greprag 5.76.0 → 5.78.0

package/dist/opencode-plugin.bundle.js

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/opencode-plugin.ts
 var crypto5 = __toESM(require("crypto"));
-var fs7 = __toESM(require("fs"));
-var os2 = __toESM(require("os"));
-var path7 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var os3 = __toESM(require("os"));
+var path8 = __toESM(require("path"));
 
 // src/opencode-plugin-helpers.ts
 var crypto = __toESM(require("crypto"));
@@ -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,
@@ -2562,6 +2572,216 @@ function collectAnnounces(env, registry = REGISTRY) {
   return out;
 }
 
+// src/app-settings.ts
+var fs3 = __toESM(require("node:fs"));
+var os2 = __toESM(require("node:os"));
+var path3 = __toESM(require("node:path"));
+
+// src/project-anchor.ts
+var path2 = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var crypto2 = __toESM(require("crypto"));
+var os = __toESM(require("os"));
+var ANCHOR_DIR = ".greprag";
+var ANCHOR_FILE = "project.json";
+var LEGACY_ANCHOR_DIR = ".claude";
+function anchorPathIn(dir) {
+  return path2.join(dir, ANCHOR_DIR, ANCHOR_FILE);
+}
+function legacyAnchorPathIn(dir) {
+  return path2.join(dir, LEGACY_ANCHOR_DIR, ANCHOR_FILE);
+}
+function globalAnchorPath() {
+  return anchorPathIn(os.homedir());
+}
+function legacyGlobalAnchorPath() {
+  return legacyAnchorPathIn(os.homedir());
+}
+function findExistingAnchor(startDir) {
+  const homeAnchor = globalAnchorPath();
+  const legacyHomeAnchor = legacyGlobalAnchorPath();
+  let dir = path2.resolve(startDir);
+  while (true) {
+    const candidate = anchorPathIn(dir);
+    if (candidate !== homeAnchor && fs2.existsSync(candidate))
+      return candidate;
+    const legacyCandidate = legacyAnchorPathIn(dir);
+    if (legacyCandidate !== legacyHomeAnchor && fs2.existsSync(legacyCandidate))
+      return legacyCandidate;
+    const parent = path2.dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function isEphemeralCwd2(cwd) {
+  const norm = path2.resolve(cwd).replace(/\\/g, "/").toLowerCase();
+  if (norm.includes("/appdata/roaming/claude/local-agent-mode-sessions/"))
+    return true;
+  if (norm.includes("/appdata/local/claude/local-agent-mode-sessions/"))
+    return true;
+  if (norm.startsWith("/tmp/"))
+    return true;
+  if (norm.startsWith("/var/tmp/"))
+    return true;
+  if (norm.startsWith("/private/tmp/"))
+    return true;
+  return false;
+}
+function computeGitDerivedProjectId2(workingDir) {
+  try {
+    const out = safeExecSync("git rev-list --max-parents=0 HEAD", {
+      cwd: workingDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const roots = out.trim().split(/\s+/).filter(Boolean).sort();
+    if (roots.length === 0)
+      return null;
+    const hash = crypto2.createHash("sha256").update(roots.join("\n")).digest("hex");
+    return [
+      hash.slice(0, 8),
+      hash.slice(8, 12),
+      "4" + hash.slice(13, 16),
+      // version 4 nibble
+      "8" + hash.slice(17, 20),
+      // variant nibble
+      hash.slice(20, 32)
+    ].join("-");
+  } catch {
+    return null;
+  }
+}
+function deterministicProjectId2(workingDir) {
+  const normalized = path2.resolve(workingDir).toLowerCase();
+  const hash = crypto2.createHash("sha256").update(normalized).digest("hex");
+  return [
+    hash.slice(0, 8),
+    hash.slice(8, 12),
+    "4" + hash.slice(13, 16),
+    // version 4 nibble
+    "8" + hash.slice(17, 20),
+    // variant nibble
+    hash.slice(20, 32)
+  ].join("-");
+}
+function tryReadAnchorFileContents(filePath) {
+  try {
+    const raw = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    const notifyRaw = raw.inbox_notify;
+    const inboxNotify = notifyRaw === "off" || notifyRaw === "session_start_only" ? notifyRaw : "every_turn";
+    return {
+      projectId: raw.project_id,
+      projectName: raw.project_name,
+      created: raw.created,
+      memoryCapture: raw.memory_capture !== false,
+      sessionStartRecap: raw.session_start_recap !== false,
+      inboxNotify,
+      emailDir: typeof raw.email_dir === "string" ? raw.email_dir : void 0,
+      emailAutosave: raw.email_autosave === true,
+      role: typeof raw.role === "string" ? raw.role : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function readAnchor2(cwd) {
+  const existingPath = findExistingAnchor(cwd);
+  const fileContents = existingPath ? tryReadAnchorFileContents(existingPath) : null;
+  if (existingPath && fileContents && fileContents.projectId && fileContents.projectName) {
+    return {
+      projectId: fileContents.projectId,
+      projectName: fileContents.projectName,
+      initialized: true,
+      source: "file",
+      anchorPath: existingPath,
+      created: fileContents.created,
+      memoryCapture: fileContents.memoryCapture,
+      sessionStartRecap: fileContents.sessionStartRecap,
+      inboxNotify: fileContents.inboxNotify,
+      emailDir: fileContents.emailDir,
+      emailAutosave: fileContents.emailAutosave,
+      role: fileContents.role
+    };
+  }
+  const gitId = computeGitDerivedProjectId2(cwd);
+  if (gitId) {
+    const root2 = path2.resolve(cwd);
+    return {
+      projectId: gitId,
+      projectName: fileContents?.projectName || path2.basename(root2).toLowerCase(),
+      initialized: true,
+      source: "git",
+      anchorPath: existingPath || anchorPathIn(root2),
+      created: fileContents?.created,
+      memoryCapture: fileContents?.memoryCapture ?? true,
+      sessionStartRecap: fileContents?.sessionStartRecap ?? true,
+      inboxNotify: fileContents?.inboxNotify ?? "every_turn",
+      emailDir: fileContents?.emailDir,
+      emailAutosave: fileContents?.emailAutosave,
+      role: fileContents?.role
+    };
+  }
+  if (isEphemeralCwd2(cwd)) {
+    const globalPath = fs2.existsSync(globalAnchorPath()) ? globalAnchorPath() : legacyGlobalAnchorPath();
+    const globalContents = tryReadAnchorFileContents(globalPath);
+    if (globalContents && globalContents.projectId && globalContents.projectName) {
+      return {
+        projectId: globalContents.projectId,
+        projectName: globalContents.projectName,
+        initialized: true,
+        source: "global",
+        anchorPath: globalPath,
+        created: globalContents.created,
+        memoryCapture: globalContents.memoryCapture,
+        sessionStartRecap: globalContents.sessionStartRecap,
+        inboxNotify: globalContents.inboxNotify,
+        emailDir: globalContents.emailDir,
+        emailAutosave: globalContents.emailAutosave,
+        role: globalContents.role
+      };
+    }
+  }
+  const root = path2.resolve(cwd);
+  return {
+    projectId: deterministicProjectId2(root),
+    projectName: fileContents?.projectName || path2.basename(root).toLowerCase(),
+    initialized: false,
+    source: "hash",
+    anchorPath: existingPath || anchorPathIn(root),
+    created: fileContents?.created,
+    memoryCapture: fileContents?.memoryCapture ?? true,
+    sessionStartRecap: fileContents?.sessionStartRecap ?? true,
+    inboxNotify: fileContents?.inboxNotify ?? "every_turn",
+    emailDir: fileContents?.emailDir,
+    emailAutosave: fileContents?.emailAutosave,
+    role: fileContents?.role
+  };
+}
+
+// src/app-settings.ts
+function readJson(file) {
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(file, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function localAppSettingsPath(homeDir = os2.homedir()) {
+  return path3.join(homeDir, ".greprag", "settings.json");
+}
+function readLocalAppSettings(homeDir = os2.homedir()) {
+  const raw = readJson(localAppSettingsPath(homeDir));
+  const interrupts = raw.interrupts && typeof raw.interrupts === "object" ? raw.interrupts : {};
+  const disabled = Array.isArray(interrupts.disabled) ? [...new Set(interrupts.disabled.filter((id) => typeof id === "string" && /^[a-z0-9-]{1,80}$/.test(id)))] : [];
+  return { version: 1, interrupts: { disabled } };
+}
+function filterEnabledInterrupts(modules, settings = readLocalAppSettings()) {
+  const disabled = new Set(settings.interrupts.disabled);
+  return modules.filter((module2) => !disabled.has(module2.id));
+}
+
 // src/commands/opencode-interrupt.ts
 var opencodeRegistry = harnessModules("opencode");
 var OPENCODE_QUOTA_WAITLIST_ANNOUNCE = [
@@ -2591,19 +2811,23 @@ 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];
+  return [...collectAnnounces(env, filterEnabledInterrupts(opencodeRegistry)), OPENCODE_QUOTA_WAITLIST_ANNOUNCE];
+}
+function getOpenCodePersistentAnnounces(env) {
+  return collectAnnounces(env, filterEnabledInterrupts(opencodeRegistry.filter((m) => m.id === "persona-announce")));
 }
 function getOpenCodeReminders(env) {
-  return collectReminders(env, opencodeRegistry);
+  return collectReminders(env, filterEnabledInterrupts(opencodeRegistry));
 }
 
 // src/procedure.ts
-var path2 = __toESM(require("path"));
-var fs2 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
 
 // src/delivery-lifecycle.ts
 var DELIVERY_LIFECYCLE_VERBS = [
@@ -2622,14 +2846,14 @@ function isDeliveryLifecycleVerb(verb) {
 var PROCEDURE_STORE_VERSION = "2";
 function stateDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path2.join(home, ".greprag", "state");
+  return path4.join(home, ".greprag", "state");
 }
 function procedureStorePath(projectId) {
-  return path2.join(stateDir(), `procedures-${projectId}.json`);
+  return path4.join(stateDir(), `procedures-${projectId}.json`);
 }
 function readProcedureStore(projectId) {
   try {
-    const raw = fs2.readFileSync(procedureStorePath(projectId), "utf-8");
+    const raw = fs4.readFileSync(procedureStorePath(projectId), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && Array.isArray(parsed.procedures)) {
       return normalizeProcedureStore({
@@ -2862,191 +3086,9 @@ function activeProcedureAnnounces(store) {
 // src/procedure-runtime.ts
 var crypto4 = __toESM(require("crypto"));
 
-// src/project-anchor.ts
-var path3 = __toESM(require("path"));
-var fs3 = __toESM(require("fs"));
-var crypto2 = __toESM(require("crypto"));
-var os = __toESM(require("os"));
-var ANCHOR_DIR = ".greprag";
-var ANCHOR_FILE = "project.json";
-var LEGACY_ANCHOR_DIR = ".claude";
-function anchorPathIn(dir) {
-  return path3.join(dir, ANCHOR_DIR, ANCHOR_FILE);
-}
-function legacyAnchorPathIn(dir) {
-  return path3.join(dir, LEGACY_ANCHOR_DIR, ANCHOR_FILE);
-}
-function globalAnchorPath() {
-  return anchorPathIn(os.homedir());
-}
-function legacyGlobalAnchorPath() {
-  return legacyAnchorPathIn(os.homedir());
-}
-function findExistingAnchor(startDir) {
-  const homeAnchor = globalAnchorPath();
-  const legacyHomeAnchor = legacyGlobalAnchorPath();
-  let dir = path3.resolve(startDir);
-  while (true) {
-    const candidate = anchorPathIn(dir);
-    if (candidate !== homeAnchor && fs3.existsSync(candidate))
-      return candidate;
-    const legacyCandidate = legacyAnchorPathIn(dir);
-    if (legacyCandidate !== legacyHomeAnchor && fs3.existsSync(legacyCandidate))
-      return legacyCandidate;
-    const parent = path3.dirname(dir);
-    if (parent === dir)
-      return null;
-    dir = parent;
-  }
-}
-function isEphemeralCwd2(cwd) {
-  const norm = path3.resolve(cwd).replace(/\\/g, "/").toLowerCase();
-  if (norm.includes("/appdata/roaming/claude/local-agent-mode-sessions/"))
-    return true;
-  if (norm.includes("/appdata/local/claude/local-agent-mode-sessions/"))
-    return true;
-  if (norm.startsWith("/tmp/"))
-    return true;
-  if (norm.startsWith("/var/tmp/"))
-    return true;
-  if (norm.startsWith("/private/tmp/"))
-    return true;
-  return false;
-}
-function computeGitDerivedProjectId2(workingDir) {
-  try {
-    const out = safeExecSync("git rev-list --max-parents=0 HEAD", {
-      cwd: workingDir,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const roots = out.trim().split(/\s+/).filter(Boolean).sort();
-    if (roots.length === 0)
-      return null;
-    const hash = crypto2.createHash("sha256").update(roots.join("\n")).digest("hex");
-    return [
-      hash.slice(0, 8),
-      hash.slice(8, 12),
-      "4" + hash.slice(13, 16),
-      // version 4 nibble
-      "8" + hash.slice(17, 20),
-      // variant nibble
-      hash.slice(20, 32)
-    ].join("-");
-  } catch {
-    return null;
-  }
-}
-function deterministicProjectId2(workingDir) {
-  const normalized = path3.resolve(workingDir).toLowerCase();
-  const hash = crypto2.createHash("sha256").update(normalized).digest("hex");
-  return [
-    hash.slice(0, 8),
-    hash.slice(8, 12),
-    "4" + hash.slice(13, 16),
-    // version 4 nibble
-    "8" + hash.slice(17, 20),
-    // variant nibble
-    hash.slice(20, 32)
-  ].join("-");
-}
-function tryReadAnchorFileContents(filePath) {
-  try {
-    const raw = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
-    const notifyRaw = raw.inbox_notify;
-    const inboxNotify = notifyRaw === "off" || notifyRaw === "session_start_only" ? notifyRaw : "every_turn";
-    return {
-      projectId: raw.project_id,
-      projectName: raw.project_name,
-      created: raw.created,
-      memoryCapture: raw.memory_capture !== false,
-      sessionStartRecap: raw.session_start_recap !== false,
-      inboxNotify,
-      emailDir: typeof raw.email_dir === "string" ? raw.email_dir : void 0,
-      emailAutosave: raw.email_autosave === true,
-      role: typeof raw.role === "string" ? raw.role : void 0
-    };
-  } catch {
-    return null;
-  }
-}
-function readAnchor2(cwd) {
-  const existingPath = findExistingAnchor(cwd);
-  const fileContents = existingPath ? tryReadAnchorFileContents(existingPath) : null;
-  if (existingPath && fileContents && fileContents.projectId && fileContents.projectName) {
-    return {
-      projectId: fileContents.projectId,
-      projectName: fileContents.projectName,
-      initialized: true,
-      source: "file",
-      anchorPath: existingPath,
-      created: fileContents.created,
-      memoryCapture: fileContents.memoryCapture,
-      sessionStartRecap: fileContents.sessionStartRecap,
-      inboxNotify: fileContents.inboxNotify,
-      emailDir: fileContents.emailDir,
-      emailAutosave: fileContents.emailAutosave,
-      role: fileContents.role
-    };
-  }
-  const gitId = computeGitDerivedProjectId2(cwd);
-  if (gitId) {
-    const root2 = path3.resolve(cwd);
-    return {
-      projectId: gitId,
-      projectName: fileContents?.projectName || path3.basename(root2).toLowerCase(),
-      initialized: true,
-      source: "git",
-      anchorPath: existingPath || anchorPathIn(root2),
-      created: fileContents?.created,
-      memoryCapture: fileContents?.memoryCapture ?? true,
-      sessionStartRecap: fileContents?.sessionStartRecap ?? true,
-      inboxNotify: fileContents?.inboxNotify ?? "every_turn",
-      emailDir: fileContents?.emailDir,
-      emailAutosave: fileContents?.emailAutosave,
-      role: fileContents?.role
-    };
-  }
-  if (isEphemeralCwd2(cwd)) {
-    const globalPath = fs3.existsSync(globalAnchorPath()) ? globalAnchorPath() : legacyGlobalAnchorPath();
-    const globalContents = tryReadAnchorFileContents(globalPath);
-    if (globalContents && globalContents.projectId && globalContents.projectName) {
-      return {
-        projectId: globalContents.projectId,
-        projectName: globalContents.projectName,
-        initialized: true,
-        source: "global",
-        anchorPath: globalPath,
-        created: globalContents.created,
-        memoryCapture: globalContents.memoryCapture,
-        sessionStartRecap: globalContents.sessionStartRecap,
-        inboxNotify: globalContents.inboxNotify,
-        emailDir: globalContents.emailDir,
-        emailAutosave: globalContents.emailAutosave,
-        role: globalContents.role
-      };
-    }
-  }
-  const root = path3.resolve(cwd);
-  return {
-    projectId: deterministicProjectId2(root),
-    projectName: fileContents?.projectName || path3.basename(root).toLowerCase(),
-    initialized: false,
-    source: "hash",
-    anchorPath: existingPath || anchorPathIn(root),
-    created: fileContents?.created,
-    memoryCapture: fileContents?.memoryCapture ?? true,
-    sessionStartRecap: fileContents?.sessionStartRecap ?? true,
-    inboxNotify: fileContents?.inboxNotify ?? "every_turn",
-    emailDir: fileContents?.emailDir,
-    emailAutosave: fileContents?.emailAutosave,
-    role: fileContents?.role
-  };
-}
-
 // src/procedure-watch.ts
-var path4 = __toESM(require("path"));
-var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
 var TIER1_LEARN_TRIGGERS = [
   { verb: "deploy", triggers: ["deploy", "deploy the api", "deploy the worker", "redeploy"], steps: "", status: "seeded" },
   { verb: "push", triggers: ["push", "git push", "push to remote", "push it up", "push upstream"], steps: "", status: "seeded", destructive: true },
@@ -3079,24 +3121,24 @@ function openWatch(verb, phase, openedAt, shadowRunId) {
 }
 function stateDir2() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path4.join(home, ".greprag", "state");
+  return path5.join(home, ".greprag", "state");
 }
 function procedureWatchPath(projectId) {
-  return path4.join(stateDir2(), `procedure-watch-${projectId}.json`);
+  return path5.join(stateDir2(), `procedure-watch-${projectId}.json`);
 }
 function hasProcedureWatch(projectId) {
   try {
-    return fs4.existsSync(procedureWatchPath(projectId));
+    return fs5.existsSync(procedureWatchPath(projectId));
   } catch {
     return false;
   }
 }
 function writeProcedureWatch(projectId, watch) {
   const file = procedureWatchPath(projectId);
-  const dir = path4.dirname(file);
-  if (!fs4.existsSync(dir))
-    fs4.mkdirSync(dir, { recursive: true });
-  fs4.writeFileSync(file, JSON.stringify(watch, null, 2) + "\n");
+  const dir = path5.dirname(file);
+  if (!fs5.existsSync(dir))
+    fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(file, JSON.stringify(watch, null, 2) + "\n");
 }
 function openWatchIfIdle(projectId, verb, phase, shadowRunId) {
   if (hasProcedureWatch(projectId))
@@ -3107,20 +3149,20 @@ function openWatchIfIdle(projectId, verb, phase, shadowRunId) {
 
 // src/procedure-shadow.ts
 var crypto3 = __toESM(require("crypto"));
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 function stateDir3() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path5.join(home, ".greprag", "state");
+  return path6.join(home, ".greprag", "state");
 }
 function procedureShadowPath(projectId) {
-  return path5.join(stateDir3(), `procedure-shadow-${projectId}.jsonl`);
+  return path6.join(stateDir3(), `procedure-shadow-${projectId}.jsonl`);
 }
 function appendShadowEvent(projectId, event) {
   try {
     const file = procedureShadowPath(projectId);
-    fs5.mkdirSync(path5.dirname(file), { recursive: true });
-    fs5.appendFileSync(file, JSON.stringify(event) + "\n");
+    fs6.mkdirSync(path6.dirname(file), { recursive: true });
+    fs6.appendFileSync(file, JSON.stringify(event) + "\n");
   } catch {
   }
 }
@@ -3840,29 +3882,29 @@ function recodeMessagesToPng(messages, opts) {
 }
 
 // src/skill-activation-manifest.ts
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 var MAX_NATIVE_SKILL_FILES = 1500;
 var MAX_SCAN_DEPTH = 7;
 function homeRoots(homeDir, platform) {
   if (platform === "claude-code") {
-    return [path6.join(homeDir, ".claude", "skills")];
+    return [path7.join(homeDir, ".claude", "skills")];
   }
   if (platform === "codex") {
     return [
-      path6.join(homeDir, ".codex", "skills"),
-      path6.join(homeDir, ".agents", "skills"),
-      path6.join(homeDir, ".codex", "plugins", "cache")
+      path7.join(homeDir, ".codex", "skills"),
+      path7.join(homeDir, ".agents", "skills"),
+      path7.join(homeDir, ".codex", "plugins", "cache")
     ];
   }
-  return [path6.join(homeDir, ".config", "opencode", "skills")];
+  return [path7.join(homeDir, ".config", "opencode", "skills")];
 }
 function ancestorDirs(cwd) {
   const dirs = [];
-  let current = path6.resolve(cwd);
+  let current = path7.resolve(cwd);
   for (let depth = 0; depth < 16; depth++) {
     dirs.push(current);
-    const parent = path6.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current)
       break;
     current = parent;
@@ -3872,11 +3914,11 @@ function ancestorDirs(cwd) {
 function repoRoots(cwd, platform) {
   return ancestorDirs(cwd).flatMap((dir) => {
     if (platform === "claude-code")
-      return [path6.join(dir, ".claude", "skills")];
+      return [path7.join(dir, ".claude", "skills")];
     if (platform === "codex") {
-      return [path6.join(dir, ".codex", "skills"), path6.join(dir, ".agents", "skills")];
+      return [path7.join(dir, ".codex", "skills"), path7.join(dir, ".agents", "skills")];
     }
-    return [path6.join(dir, ".opencode", "skills")];
+    return [path7.join(dir, ".opencode", "skills")];
   });
 }
 function frontmatterName(content) {
@@ -3892,14 +3934,14 @@ function readNativeSkillNames(params) {
       return;
     let entries;
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (visited >= MAX_NATIVE_SKILL_FILES)
         return;
-      const full = path6.join(dir, entry.name);
+      const full = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full, depth + 1);
         continue;
@@ -3907,9 +3949,9 @@ function readNativeSkillNames(params) {
       if (!entry.isFile() || entry.name.toLowerCase() !== "skill.md")
         continue;
       visited++;
-      names.add(path6.basename(path6.dirname(full)).toLowerCase());
+      names.add(path7.basename(path7.dirname(full)).toLowerCase());
       try {
-        const declared = frontmatterName(fs6.readFileSync(full, "utf8"));
+        const declared = frontmatterName(fs7.readFileSync(full, "utf8"));
         if (declared)
           names.add(declared.toLowerCase());
       } catch {
@@ -3941,14 +3983,14 @@ function activationFromApiRows(params) {
 }
 
 // src/opencode-plugin.ts
-var DEBUG_LOG_PATH = path7.join(os2.homedir(), ".greprag", "opencode-plugin-debug.log");
+var DEBUG_LOG_PATH = path8.join(os3.homedir(), ".greprag", "opencode-plugin-debug.log");
 var _debugLogReady = false;
 function dlogInit() {
   if (_debugLogReady)
     return;
   _debugLogReady = true;
   try {
-    fs7.writeFileSync(DEBUG_LOG_PATH, "");
+    fs8.writeFileSync(DEBUG_LOG_PATH, "");
   } catch {
   }
 }
@@ -3957,7 +3999,7 @@ function dlog(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [greprag-memory] ${msg}
 `;
   try {
-    fs7.appendFileSync(DEBUG_LOG_PATH, line);
+    fs8.appendFileSync(DEBUG_LOG_PATH, line);
   } catch {
   }
 }
@@ -3965,9 +4007,9 @@ dlog(`module top reached: pid=${process.pid} argv0=${process.argv[0]} distPath=$
 var API_URL = "https://api.greprag.com";
 function loadEnvFile(filePath) {
   try {
-    if (!fs7.existsSync(filePath))
+    if (!fs8.existsSync(filePath))
       return;
-    const raw = fs7.readFileSync(filePath, "utf-8");
+    const raw = fs8.readFileSync(filePath, "utf-8");
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#"))
@@ -3987,12 +4029,12 @@ function loadEnvFile(filePath) {
   }
 }
 function loadGrepragEnv() {
-  loadEnvFile(path7.join(HOME, ".greprag", ".env"));
+  loadEnvFile(path8.join(HOME, ".greprag", ".env"));
   try {
-    const p = path7.join(HOME, ".claude", "settings.json");
-    if (!fs7.existsSync(p))
+    const p = path8.join(HOME, ".claude", "settings.json");
+    if (!fs8.existsSync(p))
       return;
-    const data = JSON.parse(fs7.readFileSync(p, "utf-8"));
+    const data = JSON.parse(fs8.readFileSync(p, "utf-8"));
     if (data && data.env && typeof data.env === "object") {
       for (const [key, val] of Object.entries(data.env)) {
         if (!process.env[key] && typeof val === "string") {
@@ -4005,11 +4047,11 @@ function loadGrepragEnv() {
 }
 loadGrepragEnv();
 dlog(`env loaded: MEMORY_HOOK_ENABLED=${process.env.MEMORY_HOOK_ENABLED || "<unset>"} GREPRAG_API_KEY=${process.env.GREPRAG_API_KEY ? "set" : "<unset>"} GREPRAG_OPENCODE_CAPTURE=${process.env.GREPRAG_OPENCODE_CAPTURE || "<unset>"}`);
-var WATCHER_LOCK = path7.join(HOME || os2.homedir(), ".greprag", "opencode-watch.lock");
+var WATCHER_LOCK = path8.join(HOME || os3.homedir(), ".greprag", "opencode-watch.lock");
 var WATCHER_STALE_MS = 3e4;
 function findGrepragBinary() {
   const override = process.env.GREPRAG_BIN;
-  if (override && fs7.existsSync(override))
+  if (override && fs8.existsSync(override))
     return override;
   const binaryName = process.platform === "win32" ? "greprag.cmd" : "greprag";
   try {
@@ -4018,14 +4060,14 @@ function findGrepragBinary() {
       const candidate = line.trim();
       if (!candidate)
         continue;
-      if (!fs7.existsSync(candidate))
+      if (!fs8.existsSync(candidate))
         continue;
       if (process.platform === "win32") {
-        const ext = path7.extname(candidate).toLowerCase();
+        const ext = path8.extname(candidate).toLowerCase();
         if (ext === ".cmd" || ext === ".exe" || ext === ".bat")
           return candidate;
         const cmdSibling = candidate + ".cmd";
-        if (fs7.existsSync(cmdSibling))
+        if (fs8.existsSync(cmdSibling))
           return cmdSibling;
         continue;
       }
@@ -4034,19 +4076,19 @@ function findGrepragBinary() {
   } catch {
   }
   const candidates = process.platform === "win32" ? [
-    path7.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
-    path7.join(HOME, "AppData", "Roaming", "npm", "greprag"),
-    path7.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
-    path7.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
+    path8.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
+    path8.join(HOME, "AppData", "Roaming", "npm", "greprag"),
+    path8.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
+    path8.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
   ] : [
     "/usr/local/bin/greprag",
     "/opt/homebrew/bin/greprag",
-    path7.join(HOME || "", ".local", "bin", "greprag"),
-    path7.join(HOME || "", ".yarn", "bin", "greprag")
+    path8.join(HOME || "", ".local", "bin", "greprag"),
+    path8.join(HOME || "", ".yarn", "bin", "greprag")
   ];
   for (const c of candidates) {
     try {
-      if (c && fs7.existsSync(c))
+      if (c && fs8.existsSync(c))
         return c;
     } catch {
     }
@@ -4055,18 +4097,18 @@ function findGrepragBinary() {
 }
 function tryClaimWatcherLock() {
   try {
-    const fd = fs7.openSync(WATCHER_LOCK, "wx");
+    const fd = fs8.openSync(WATCHER_LOCK, "wx");
     return { ok: true, fd };
   } catch (err) {
     if (err.code !== "EEXIST") {
       return { ok: false, reason: "lock-create-failed" };
     }
     try {
-      const stat = fs7.statSync(WATCHER_LOCK);
+      const stat = fs8.statSync(WATCHER_LOCK);
       const ageMs = Date.now() - stat.mtimeMs;
       let pidAlive = false;
       try {
-        const pid = parseInt(fs7.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
+        const pid = parseInt(fs8.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
         pidAlive = pid > 0 && isPidAlive(pid);
       } catch {
       }
@@ -4074,10 +4116,10 @@ function tryClaimWatcherLock() {
         return { ok: false, reason: "busy" };
       }
       try {
-        fs7.unlinkSync(WATCHER_LOCK);
+        fs8.unlinkSync(WATCHER_LOCK);
       } catch {
       }
-      const fd = fs7.openSync(WATCHER_LOCK, "wx");
+      const fd = fs8.openSync(WATCHER_LOCK, "wx");
       return { ok: true, fd };
     } catch (err2) {
       return { ok: false, reason: "lock-stale-replace-failed" };
@@ -4118,11 +4160,11 @@ function startCaptureWatcher() {
     return;
   }
   try {
-    fs7.writeSync(claim.fd, String(process.pid));
-    fs7.closeSync(claim.fd);
+    fs8.writeSync(claim.fd, String(process.pid));
+    fs8.closeSync(claim.fd);
   } catch {
     try {
-      fs7.unlinkSync(WATCHER_LOCK);
+      fs8.unlinkSync(WATCHER_LOCK);
     } catch {
     }
     return;
@@ -4138,11 +4180,11 @@ function startCaptureWatcher() {
     const claim2 = tryClaimWatcherLock();
     if (claim2.ok) {
       try {
-        fs7.writeSync(claim2.fd, String(process.pid));
-        fs7.closeSync(claim2.fd);
+        fs8.writeSync(claim2.fd, String(process.pid));
+        fs8.closeSync(claim2.fd);
       } catch {
         try {
-          fs7.unlinkSync(WATCHER_LOCK);
+          fs8.unlinkSync(WATCHER_LOCK);
         } catch {
         }
         return false;
@@ -4185,7 +4227,7 @@ function startCaptureWatcher() {
     childStartTime = Date.now();
     dlog(`startCaptureWatcher: spawned 'greprag opencode watch' pid=${child.pid ?? "<none>"}`);
     try {
-      fs7.writeFileSync(WATCHER_LOCK, String(child.pid));
+      fs8.writeFileSync(WATCHER_LOCK, String(child.pid));
     } catch {
     }
     child.stderr?.on("data", (chunk2) => {
@@ -4197,9 +4239,9 @@ function startCaptureWatcher() {
     child.on("exit", (code, signal) => {
       dlog(`startCaptureWatcher: child pid=${child.pid ?? "<none>"} exited code=${code} signal=${signal || "none"}`);
       try {
-        const current = fs7.readFileSync(WATCHER_LOCK, "utf-8").trim();
+        const current = fs8.readFileSync(WATCHER_LOCK, "utf-8").trim();
         if (current === String(child.pid))
-          fs7.unlinkSync(WATCHER_LOCK);
+          fs8.unlinkSync(WATCHER_LOCK);
       } catch {
       }
       currentChild = null;
@@ -4228,7 +4270,7 @@ function startCaptureWatcher() {
 `
       );
       try {
-        fs7.unlinkSync(WATCHER_LOCK);
+        fs8.unlinkSync(WATCHER_LOCK);
       } catch {
       }
       return;
@@ -4260,7 +4302,7 @@ function startCaptureWatcher() {
       }, 2e3).unref();
     }
     try {
-      fs7.unlinkSync(WATCHER_LOCK);
+      fs8.unlinkSync(WATCHER_LOCK);
     } catch {
     }
   };
@@ -4296,6 +4338,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 +4377,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;
@@ -4369,11 +4439,11 @@ function startSessionRelay(sessionId, serverUrl) {
     return;
   }
   try {
-    fs7.writeSync(claim.fd, String(process.pid));
-    fs7.closeSync(claim.fd);
+    fs8.writeSync(claim.fd, String(process.pid));
+    fs8.closeSync(claim.fd);
   } catch {
     try {
-      fs7.unlinkSync(lockPath);
+      fs8.unlinkSync(lockPath);
     } catch {
     }
     return;
@@ -4388,11 +4458,11 @@ function startSessionRelay(sessionId, serverUrl) {
     const claim2 = tryClaimRelayLock(lockPath);
     if (claim2.ok) {
       try {
-        fs7.writeSync(claim2.fd, String(process.pid));
-        fs7.closeSync(claim2.fd);
+        fs8.writeSync(claim2.fd, String(process.pid));
+        fs8.closeSync(claim2.fd);
       } catch {
         try {
-          fs7.unlinkSync(lockPath);
+          fs8.unlinkSync(lockPath);
         } catch {
         }
         return false;
@@ -4428,7 +4498,7 @@ function startSessionRelay(sessionId, serverUrl) {
     childStartTime = Date.now();
     dlog(`startSessionRelay: spawned 'greprag opencode relay' pid=${child.pid ?? "<none>"}`);
     try {
-      fs7.writeFileSync(lockPath, String(child.pid));
+      fs8.writeFileSync(lockPath, String(child.pid));
     } catch {
     }
     child.stderr?.on("data", (chunk2) => {
@@ -4439,9 +4509,9 @@ function startSessionRelay(sessionId, serverUrl) {
     });
     child.on("exit", (code, signal) => {
       try {
-        const current = fs7.readFileSync(lockPath, "utf-8").trim();
+        const current = fs8.readFileSync(lockPath, "utf-8").trim();
         if (current === String(child.pid))
-          fs7.unlinkSync(lockPath);
+          fs8.unlinkSync(lockPath);
       } catch {
       }
       currentChild = null;
@@ -4468,7 +4538,7 @@ function startSessionRelay(sessionId, serverUrl) {
 `
       );
       try {
-        fs7.unlinkSync(lockPath);
+        fs8.unlinkSync(lockPath);
       } catch {
       }
       return;
@@ -4500,7 +4570,7 @@ function startSessionRelay(sessionId, serverUrl) {
       }, 2e3).unref();
     }
     try {
-      fs7.unlinkSync(lockPath);
+      fs8.unlinkSync(lockPath);
     } catch {
     }
   };
@@ -4667,6 +4737,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 +4753,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 +4767,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) {