greprag 5.76.0 → 5.77.0

package/dist/commands/codex-doctor.js

@@ -113,5 +113,6 @@ async function doctorCodex(args, deps) {
     console.log(`    PermissionRequest ctx:    ${hasHook(hooks, 'PermissionRequest', 'codex-permission-context') ? 'yes' : 'no'}`);
     console.log(`    SubagentStart metadata:   ${hasHook(hooks, 'SubagentStart', 'codex-subagent-start') ? 'yes' : 'no'}`);
     console.log(`    Stop store:               ${hasHook(hooks, 'Stop', 'codex-store') ? 'yes' : 'no'}`);
+    console.log(`    PostCompact re-announce:  ${hasHook(hooks, 'PostCompact', 'recompact') ? 'yes' : 'no'}`);
     console.log(`    PostCompact session-id:   ${hasHook(hooks, 'PostCompact', 'session-id') ? 'yes' : 'no'}`);
 }

package/dist/commands/delivery-reminder.js

@@ -12,15 +12,15 @@ exports.buildDeliveryAnnounce = buildDeliveryAnnounce;
 // adr: adr/delivery-announce-pilot.md
 function coordinationLine(platform) {
     if (platform === 'codex') {
-        return 'Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, then use codex_app.send_message_to_thread once for ready or overlapping work. Delivery owner: rename this task `DEPLOY: <existing title>`; transfer the prefix on handoff; remove the prefix when delivery is done.';
+        return 'Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, and inspect their current summaries/status. Use codex_app.send_message_to_thread only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups. Delivery owner: rename this task `DEPLOY: <existing title>` for operator visibility only; transfer the prefix on handoff; remove it before reporting delivery complete or abandoned.';
     }
     if (platform === 'claude-code') {
-        return 'Claude Code: at the merge/deploy gate, discover peers in the same repo and send one concise delivery notice to peers with ready or overlapping work.';
+        return 'Claude Code: at the merge/deploy gate, inspect peers in the same repo and send one concise delivery notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
     }
     if (platform === 'opencode') {
-        return 'OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise delivery notice to peers with ready or overlapping work.';
+        return 'OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
     }
-    return 'At the merge/deploy gate, coordinate once with peers in the same repo who have ready or overlapping work.';
+    return 'At the merge/deploy gate, inspect peers in the same repo and send one concise notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.';
 }
 function buildDeliveryAnnounce(env) {
     if (!env.deliveryRepo)
@@ -30,7 +30,7 @@ function buildDeliveryAnnounce(env) {
         `[DELIVERY — ${project}]`,
         'Commit useful, passing work.',
         coordinationLine(env.platform),
-        'Include ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Missing replies and unfinished peer work do not block delivery.',
+        'Include visible ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Silence means nothing actionable and does not block delivery.',
         'Use this repo\'s delivery profile and verify production.',
     ].join('\n');
 }

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,6 +3,7 @@ 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");
 /** The opencode registry is DERIVED from the canon, never hand-whitelisted.
@@ -44,11 +45,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];
 }
+/** 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, exports.opencodeRegistry.filter((m) => m.id === 'persona-announce'));
+}
 function getOpenCodeReminders(env) {
     return (0, reminder_registry_1.collectReminders)(env, 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

@@ -1613,11 +1613,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 +1643,7 @@ async function recap(input, mode = 'plain', opts = {}) {
         skillGainsPromise,
         mirroredSkillsPromise,
         loadoutStatePromise,
+        personaPromise,
         updateAvailablePromise,
         bodyPromise,
     ]);
@@ -1704,6 +1723,7 @@ async function recap(input, mode = 'plain', opts = {}) {
         mirroredSkills,
         procedureAnnounces,
         equippedLoadouts,
+        personaAnnounce,
         updateAvailable,
         activeCommandDrift: activeCommandDrift(),
         loadoutUpdateRequired,
@@ -2264,7 +2284,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");
@@ -1568,6 +1569,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.
@@ -1639,6 +1648,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],
@@ -1926,6 +1936,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);

package/dist/opencode-plugin.bundle.js

@@ -2438,15 +2438,15 @@ var loadoutRegistrarModule = {
 // src/commands/delivery-reminder.ts
 function coordinationLine(platform) {
   if (platform === "codex") {
-    return "Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, then use codex_app.send_message_to_thread once for ready or overlapping work. Delivery owner: rename this task `DEPLOY: <existing title>`; transfer the prefix on handoff; remove the prefix when delivery is done.";
+    return "Codex: at the merge/deploy gate, call codex_app.list_threads unfiltered, filter to peers in the same repo, and inspect their current summaries/status. Use codex_app.send_message_to_thread only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups. Delivery owner: rename this task `DEPLOY: <existing title>` for operator visibility only; transfer the prefix on handoff; remove it before reporting delivery complete or abandoned.";
   }
   if (platform === "claude-code") {
-    return "Claude Code: at the merge/deploy gate, discover peers in the same repo and send one concise delivery notice to peers with ready or overlapping work.";
+    return "Claude Code: at the merge/deploy gate, inspect peers in the same repo and send one concise delivery notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.";
   }
   if (platform === "opencode") {
-    return "OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise delivery notice to peers with ready or overlapping work.";
+    return "OpenCode: at the merge/deploy gate, use the GrepRAG project/session registry and send one concise notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.";
   }
-  return "At the merge/deploy gate, coordinate once with peers in the same repo who have ready or overlapping work.";
+  return "At the merge/deploy gate, inspect peers in the same repo and send one concise notice only for visible evidence of an unlanded ready commit, overlapping integration, or a concrete blocker. Peers with nothing actionable stay silent; do not solicit or send negative acknowledgements or routine completion follow-ups.";
 }
 function buildDeliveryAnnounce(env) {
   if (!env.deliveryRepo)
@@ -2456,7 +2456,7 @@ function buildDeliveryAnnounce(env) {
     `[DELIVERY \u2014 ${project}]`,
     "Commit useful, passing work.",
     coordinationLine(env.platform),
-    "Include ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Missing replies and unfinished peer work do not block delivery.",
+    "Include visible ready peer commits and clear known blockers, then merge to the default branch and deploy immediately. Silence means nothing actionable and does not block delivery.",
     "Use this repo's delivery profile and verify production."
   ].join("\n");
 }
@@ -2467,6 +2467,14 @@ var deliveryControlModule = {
   reminder: () => null
 };
 
+// src/commands/persona-reminder.ts
+var personaAnnounceModule = {
+  id: "persona-announce",
+  detect: () => ({ tier: "silent" }),
+  announce: (env) => env.personaAnnounce || null,
+  reminder: () => null
+};
+
 // src/commands/reminder-registry.ts
 var REGISTRY = [
   osPrimerModule,
@@ -2488,6 +2496,8 @@ var REGISTRY = [
   // active project procedures, rendered generically from operator-owned installs
   deliveryControlModule,
   // repo-scoped announce-first Delivery System pilot (all harnesses)
+  personaAnnounceModule,
+  // tenant-scoped Persona, shared across projects/harnesses
   loadoutRegistrarModule,
   // equipped loadouts: one advisor announce each + per-turn keyword Match (docs/loadout.md)
   setupWarningModule,
@@ -2591,12 +2601,16 @@ function buildOpenCodeEnv(params) {
     corpusApiDocs: params.corpusApiDocs ?? [],
     updateAvailable: params.updateAvailable ?? null,
     procedureAnnounces: params.procedureAnnounces ?? [],
-    mirroredSkills: params.mirroredSkills
+    mirroredSkills: params.mirroredSkills,
+    personaAnnounce: params.personaAnnounce ?? null
   };
 }
 function getOpenCodeAnnounces(env) {
   return [...collectAnnounces(env, opencodeRegistry), OPENCODE_QUOTA_WAITLIST_ANNOUNCE];
 }
+function getOpenCodePersistentAnnounces(env) {
+  return collectAnnounces(env, opencodeRegistry.filter((m) => m.id === "persona-announce"));
+}
 function getOpenCodeReminders(env) {
   return collectReminders(env, opencodeRegistry);
 }
@@ -4296,6 +4310,8 @@ async function fetchRecapInbox(anchor) {
 }
 var relayArmedBySession = /* @__PURE__ */ new Set();
 var announcedBySession = /* @__PURE__ */ new Set();
+var personaAnnounceBySession = /* @__PURE__ */ new Map();
+var PERSONA_SESSION_CACHE_MAX = 100;
 var turnCountBySession = /* @__PURE__ */ new Map();
 var procedurePromptKeyBySession = /* @__PURE__ */ new Map();
 var cachedRecap = null;
@@ -4333,6 +4349,32 @@ async function fetchSkillActivation(apiKey, cwd) {
     return void 0;
   }
 }
+async function fetchPersonaAnnounce(apiKey) {
+  try {
+    const response = await fetch(`${API_URL}/v1/persona`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return typeof data.announce === "string" && data.announce.length > 0 ? data.announce : null;
+  } catch {
+    return null;
+  }
+}
+async function personaAnnounceForSession(sessionId, apiKey) {
+  if (personaAnnounceBySession.has(sessionId)) {
+    return personaAnnounceBySession.get(sessionId) ?? null;
+  }
+  const announce = await fetchPersonaAnnounce(apiKey);
+  if (personaAnnounceBySession.size >= PERSONA_SESSION_CACHE_MAX) {
+    const oldest = personaAnnounceBySession.keys().next().value;
+    if (oldest)
+      personaAnnounceBySession.delete(oldest);
+  }
+  personaAnnounceBySession.set(sessionId, announce);
+  return announce;
+}
 function startSessionRelay(sessionId, serverUrl) {
   if (process.env.GREPRAG_OPENCODE_RELAY === "0")
     return;
@@ -4667,6 +4709,7 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
       if (sid8) {
         const turnCount = (turnCountBySession.get(sid8) ?? 0) + 1;
         turnCountBySession.set(sid8, turnCount);
+        const firstAnnounce = !announcedBySession.has(sid8);
         const env = buildOpenCodeEnv({
           short: sid8,
           turnCount,
@@ -4682,9 +4725,12 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
               return [];
             }
           })(),
-          mirroredSkills: !announcedBySession.has(sid8) ? await fetchSkillActivation(apiKey, workingDir) : void 0
+          mirroredSkills: firstAnnounce ? await fetchSkillActivation(apiKey, workingDir) : void 0,
+          // output.system is fresh on EVERY transform call. Resolve Persona
+          // once/session, then replay the cached shared-registry announce.
+          personaAnnounce: await personaAnnounceForSession(sid8, apiKey)
         });
-        if (!announcedBySession.has(sid8)) {
+        if (firstAnnounce) {
           announcedBySession.add(sid8);
           const announces = getOpenCodeAnnounces(env);
           if (announces.length > 0) {
@@ -4693,6 +4739,13 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
             }
             dlog(`interrupt: pushed ${announces.length} announce(s) for sid=${sid8}`);
           }
+        } else {
+          const persistent = getOpenCodePersistentAnnounces(env);
+          for (const line of persistent)
+            pushSystemPrompt(output, line);
+          if (persistent.length > 0) {
+            dlog(`interrupt: replayed ${persistent.length} persistent announce(s) for sid=${sid8}`);
+          }
         }
         const reminders = getOpenCodeReminders(env);
         if (reminders.length > 0) {

package/dist/opencode-plugin.js

@@ -548,6 +548,8 @@ async function fetchRecapInbox(anchor) {
 // ============================================================================
 const relayArmedBySession = new Set();
 const announcedBySession = new Set();
+const personaAnnounceBySession = new Map();
+const PERSONA_SESSION_CACHE_MAX = 100;
 const turnCountBySession = new Map();
 const procedurePromptKeyBySession = new Map();
 /** Cached recap body per projectId. opencode fires
@@ -596,6 +598,35 @@ async function fetchSkillActivation(apiKey, cwd) {
         return undefined;
     }
 }
+async function fetchPersonaAnnounce(apiKey) {
+    try {
+        const response = await fetch(`${API_URL}/v1/persona`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        return typeof data.announce === 'string' && data.announce.length > 0
+            ? data.announce
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function personaAnnounceForSession(sessionId, apiKey) {
+    if (personaAnnounceBySession.has(sessionId)) {
+        return personaAnnounceBySession.get(sessionId) ?? null;
+    }
+    const announce = await fetchPersonaAnnounce(apiKey);
+    if (personaAnnounceBySession.size >= PERSONA_SESSION_CACHE_MAX) {
+        const oldest = personaAnnounceBySession.keys().next().value;
+        if (oldest)
+            personaAnnounceBySession.delete(oldest);
+    }
+    personaAnnounceBySession.set(sessionId, announce);
+    return announce;
+}
 // ============================================================================
 // Per-session relay spawner — "anytime opencode is opened and being used"
 // ============================================================================
@@ -1002,6 +1033,7 @@ const GrepRAGMemoryPlugin = async (ctx) => {
             if (sid8) {
                 const turnCount = (turnCountBySession.get(sid8) ?? 0) + 1;
                 turnCountBySession.set(sid8, turnCount);
+                const firstAnnounce = !announcedBySession.has(sid8);
                 // Build env — only populate what's available in the opencode context
                 const env = (0, opencode_interrupt_1.buildOpenCodeEnv)({
                     short: sid8,
@@ -1019,12 +1051,15 @@ const GrepRAGMemoryPlugin = async (ctx) => {
                             return [];
                         }
                     })(),
-                    mirroredSkills: !announcedBySession.has(sid8)
+                    mirroredSkills: firstAnnounce
                         ? await fetchSkillActivation(apiKey, workingDir)
                         : undefined,
+                    // output.system is fresh on EVERY transform call. Resolve Persona
+                    // once/session, then replay the cached shared-registry announce.
+                    personaAnnounce: await personaAnnounceForSession(sid8, apiKey),
                 });
                 // Announces: inject on first fire per session (static primers)
-                if (!announcedBySession.has(sid8)) {
+                if (firstAnnounce) {
                     announcedBySession.add(sid8);
                     const announces = (0, opencode_interrupt_1.getOpenCodeAnnounces)(env);
                     if (announces.length > 0) {
@@ -1034,6 +1069,14 @@ const GrepRAGMemoryPlugin = async (ctx) => {
                         dlog(`interrupt: pushed ${announces.length} announce(s) for sid=${sid8}`);
                     }
                 }
+                else {
+                    const persistent = (0, opencode_interrupt_1.getOpenCodePersistentAnnounces)(env);
+                    for (const line of persistent)
+                        pushSystemPrompt(output, line);
+                    if (persistent.length > 0) {
+                        dlog(`interrupt: replayed ${persistent.length} persistent announce(s) for sid=${sid8}`);
+                    }
+                }
                 // Reminders: inject every turn (dynamic nudges)
                 const reminders = (0, opencode_interrupt_1.getOpenCodeReminders)(env);
                 if (reminders.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greprag",
-  "version": "5.76.0",
+  "version": "5.77.0",
   "description": "GrepRAG — agent memory for Claude Code, Codex, OpenCode, and Grok Build.",
   "main": "dist/index.js",
   "bin": {