greprag 5.75.0 → 5.77.0

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);
@@ -267,7 +268,7 @@ function buildStatus(cwd, platform = 'all') {
                 skill_path: grokSkillPath,
                 skill_installed: fs.existsSync(grokSkillPath),
                 hooks: grokHookStatus,
-                note: 'Grok recap is a sidecar + ~/.grok/rules (SessionStart stdout is ignored). Idle inbox: Grok monitor + quiet watch. Stop drain injects unread mail.',
+                note: 'Grok recap is a sidecar + ~/.grok/rules (SessionStart stdout is ignored). Idle inbox: Grok monitor + quiet watch. Stop drain injects unread mail only when unarmed.',
             },
         },
         project: {

package/dist/hook.js

@@ -1334,7 +1334,7 @@ function grokSidecarHead(short, full) {
     return (0, session_id_1.buildSessionIdContext)(short, (0, session_id_1.readIdentityAlias)())
         + `\n\nARM (Grok monitor persistent:true): \`${arm}\`\n`
         + `Send with --from-session ${full || short} (full UUID or 16-hex, never 8-hex).\n`
-        + 'Second session: spawn_subagent background=true; child arms its own quiet watch; parent keeps ONE watch.\n'
+        + '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';
 }
 function writeRecapOutput(text, mode, grokShort, grokFull) {
@@ -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,
@@ -2023,7 +2043,9 @@ async function collisionCheck(input) {
  *  poll live-tails with no double-delivery. Closes the dead-window gap where a
  *  session-directed message that lands between watcher death and re-arm sits
  *  unread until a manual `greprag inbox`. Inbound-only — the front desk (cold
- *  opens + email) stays with the human-scoped `mail` hook. All real logic lives
+ *  opens + email) stays with the human-scoped `mail` hook. Injects only when
+ *  unarmed (`isLocallyArmed`); a live watcher already delivered the body.
+ *  Grok also wires this on Stop as the unarmed floor. All real logic lives
  *  in ./commands/inbox-drain (pure + tested). Best-effort: any miss → silent,
  *  never blocks SessionStart. adr: adr/monitor-resilience.md */
 async function drain(input) {
@@ -2034,7 +2056,10 @@ async function drain(input) {
     const short = (0, session_id_1.truncateSessionId)(input.session_id);
     if (!short)
         return; // no session id → silent
-    const result = await (0, inbox_drain_1.runInboxDrain)({ session: short, apiUrl: cfg.apiUrl, apiKey: cfg.apiKey });
+    const result = await (0, inbox_drain_1.runInboxDrain)({
+        session: short, apiUrl: cfg.apiUrl, apiKey: cfg.apiKey,
+        armed: (0, watcher_registry_1.isLocallyArmed)(short),
+    });
     if (result.context) {
         (0, hook_runtime_1.writeAdditionalContext)(input.hook_event_name || 'SessionStart', result.context);
         if ((0, harness_1.inferCurrentHarness)() === 'grok')
@@ -2259,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' });
@@ -2417,10 +2445,11 @@ async function main() {
         // best-effort state stash. docs/ingress-trigger-bridge.md
         await store(input, harness === 'grok' ? 'grok' : 'claude-code');
         if (harness === 'grok') {
-            // Floor: inject unread mail. Do NOT nag UNARMED here — Grok Stop
-            // fires every turn, and a pidfile-alias miss made that a re-arm loop
-            // (watch already live → singleton-guard exits instantly → model arms
-            // again). Arm teaching is sidecar + rules. adr: adr/grok-platform.md
+            // Floor: inject unread mail only when unarmed. Do NOT nag UNARMED here —
+            // Grok Stop fires every turn, and a pidfile-alias miss made that a
+            // re-arm loop (watch already live → singleton-guard exits instantly →
+            // model arms again). Arm teaching is sidecar + rules.
+            // adr: adr/grok-platform.md
             await drain(input);
         }
         stateUpdate(input);

package/dist/index.js

@@ -43,6 +43,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const init_1 = require("./commands/init");
 const status_1 = require("./commands/status");
 const doctor_1 = require("./commands/doctor");
@@ -65,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");
@@ -77,6 +79,7 @@ const crush_1 = require("./commands/crush");
 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 inbox_attachments_1 = require("./inbox-attachments");
 const discord_1 = require("./commands/discord");
 const project_anchor_1 = require("./project-anchor");
@@ -272,6 +275,23 @@ undici error, OS kill); and it SELF-TERMINATES when its Monitor consumer's pipe
 breaks (session reload/end) so it never orphans. Within-session robustness only;
 a watcher cannot survive session reload / --resume / /compact.
 adr: adr/monitor-resilience.md`;
+function readProjectRegistry() {
+    try {
+        const file = path.join(os.homedir(), '.greprag', 'projects.json');
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+            if (typeof v === 'string' && v)
+                out[k] = v;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
 /** greprag inbox [--all] [--session <id>] | inbox keep <id> | inbox delete <id> | inbox watch */
 /** greprag desk — the machine's desk-line (reverse-RPC relay to the cloud).
  *    desk run      hold the line open and answer cloud questions (long-running)
@@ -405,8 +425,13 @@ async function inbox(args) {
         }
         const res = await apiGet(`${cfg.apiUrl}/v1/inbox/watchers`, cfg.apiKey);
         const watchers = (res.watchers || []);
+        const repos = readProjectRegistry();
+        const decorated = watchers.map(w => ({
+            ...w,
+            repo: w.repo || (w.project_name && repos[w.project_name]) || null,
+        }));
         if (json) {
-            console.log(JSON.stringify({ watchers }, null, 2));
+            console.log(JSON.stringify({ watchers: decorated }, null, 2));
             return;
         }
         if (watchers.length === 0) {
@@ -415,13 +440,17 @@ async function inbox(args) {
         }
         console.log(`${watchers.length} live watcher(s):\n`);
         // Label = project · title — both resolved from the session's memory (the
-        // auto-armed watcher carries neither on its WS tag). The 8-hex session id
+        // auto-armed watcher carries neither on its WS tag). The session short
         // rides in parens; orchestrator mode reads it back to address sends.
-        for (const w of watchers) {
+        // Platform + local repo path (from ~/.greprag/projects.json) say which
+        // harness armed it and which checkout it's in.
+        for (const w of decorated) {
             const proj = w.project_name ? w.project_name : (w.wide ? '(tenant-wide)' : '(no project)');
             const label = w.title ? `${proj} · ${w.title}` : proj;
             const sess = w.session_id ? `  (${w.session_id})` : '';
-            console.log(`  ${label}${sess}`);
+            const plat = w.platform ? `  [${w.platform}]` : '';
+            const repo = w.repo ? `  ${w.repo}` : '';
+            console.log(`  ${label}${sess}${plat}${repo}`);
         }
         return;
     }
@@ -666,7 +695,7 @@ function parseFileFlag(raw) {
  *  is a session id; anything else is a project name. Project names that
  *  look like UUIDs are rejected at registration time so this is unambiguous.
  *  adr: adr/session-id-awareness.md, adr/address-grammar.md */
-const SESSION_ID_PATTERN = /^([0-9a-f]{8}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+const SESSION_ID_PATTERN = /^([0-9a-f]{8}|[0-9a-f]{16}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
 /** Parse a send address under the v0.12 grammar:
  *    <handle>@greprag.com[/<target>]
  *  where <target> is exactly one segment — a session UUID (or 8-hex short form)
@@ -719,7 +748,7 @@ function parseSendAddress(addr) {
     if (!target) {
         return { ok: false, error: `address "${addr}" has an empty target segment.` };
     }
-    const kind = SESSION_ID_PATTERN.test(target) ? 'session' : 'project';
+    const kind = ((0, session_id_1.isSessionAddressTarget)(target) || SESSION_ID_PATTERN.test(target)) ? 'session' : 'project';
     return { ok: true, targetKind: kind, target };
 }
 /** Internal (self-desk) message types — KEEP IN SYNC with
@@ -1267,6 +1296,10 @@ Commands:
                                   Configure lifecycle hooks + anchor for Codex
   init --grok [--api-key <key>] [--tenant-id <handle>]
                                   Configure Grok Build hooks + skill + rules
+  grok spawn [--cwd <path>] [--prompt "<text>"]
+                                  Open a fresh Grok TUI in a new terminal
+                                  (Windows schtasks bootloader — survives the
+                                  tool Job Object; child arms its own watch)
   init --all [--root <path>]       Standard init for cwd, then bulk-register every
                                    other git repo at depth 1 under <path> (default:
                                    parent of repo root). Each becomes inbox-addressable.
@@ -1306,11 +1339,12 @@ Inbox (email-style messaging across tenants):
                                 --session scopes to one specific session's view.
                                 --project filters by project name.
                                 --peek: NON-MUTATING — does not mark any message read.
-  inbox watchers [--json]       List currently-attached live GrepRAG/Claude/OpenCode
-                                watchers under this tenant. Each row: project ·
-                                title (session_id) — project + nano title resolved
-                                from session memory. Codex task and repo/workspace
-                                discovery uses codex_app.list_threads.
+  inbox watchers [--json]       List currently-attached live watchers
+                                (Claude / Codex / OpenCode / Grok). Each row:
+                                project · title (session_id) [platform] repo —
+                                project + nano title from session memory, repo
+                                from ~/.greprag/projects.json. Codex task
+                                discovery also uses codex_app.list_threads.
   inbox watch                   Long-lived SSE stream — prints each message as it lands.
                                 Self-supervising by default: a parent process
                                 respawns the SSE loop (via CreateProcess) on any
@@ -1535,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.
@@ -1606,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],
@@ -1893,8 +1936,10 @@ 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);
         default:
             console.error(`Unknown command: ${command}\n`);
             console.log(HELP);