greprag 5.83.1 → 5.84.0

package/dist/commands/app-model.js

@@ -72,7 +72,6 @@ const INTERRUPT_COPY = {
     'memory-primer': { label: 'Memory guidance', description: 'Teaches agents how and when to retrieve project memory.', group: 'Memory' },
     'watcher-arm': { label: 'Live inbox checks', description: 'Reminds Claude Code to keep live message delivery connected.', group: 'Communication' },
     'mechanic-friction': { label: 'Automatic repair prompts', description: 'Surfaces repeated harness friction for durable repair.', group: 'Automation' },
-    collision: { label: 'Collision warnings', description: 'Warns before shared Git actions when another session is active.', group: 'Delegation' },
 };
 function readObject(file) {
     try {
@@ -293,7 +292,7 @@ async function buildAppModel(cwd, requestedProjectId, homeDir = os.homedir()) {
                     group: 'Other',
                 }),
                 enabled: !disabled.has(module.id),
-                surface: module.source === 'command' ? 'Before sensitive actions' : 'Agent guidance',
+                surface: 'Agent guidance',
                 harnesses: module.harnesses || ['claude-code', 'codex', 'opencode', 'grok'],
             })),
         },

package/dist/commands/collision-check.js

@@ -1,12 +1,23 @@
 "use strict";
-/** Collision schematic — detect another live session working in the SAME repo
- *  and inject a directive telling the agent to coordinate (message the peer +
- *  work in a worktree). The operator does this by hand today; this makes it a
- *  reflex. adr: docs/schematic-triggers.md, docs/stateful-injection.md
+/** Collision schematic — detect another session with an armed greprag watcher
+ *  working in the SAME repo and inject a directive telling the agent to
+ *  coordinate (message the peer + work in a worktree). The operator does this by
+ *  hand today; this makes it a reflex. adr: docs/schematic-triggers.md,
+ *  docs/stateful-injection.md
  *
- *  WHERE IT FIRES: wired as a SessionStart hook (startup + resume + compact).
- *  Because BOTH sides run it at their own start, whichever session starts LAST
- *  detects the overlap and pings the other — mutual coverage with no polling.
+ *  WHERE IT FIRES: nowhere since 2026-10-06. It was hand-wired as a Claude Code
+ *  SessionStart hook (startup + resume + compact), which Grok also ran through
+ *  its Claude-hook compatibility, until the operator removed it
+ *  (docs/collision-schematic.md).
+ *
+ *  WHAT IT SEES: only sessions that arm a greprag watcher — OpenCode (its relay)
+ *  and Grok (its monitor). Claude Code has armed none since 2026-09-04 and Codex
+ *  never did, so the hook never detects a Claude Code or Codex peer: two Claude
+ *  Code sessions in one repo get nothing from it, whichever starts last. That is
+ *  the design, not a gap to close here. The harness owns Claude Code discovery,
+ *  and Claude Code peers get no heads-up: each works in its own worktree and Git
+ *  reconciles the overlap at landing (adr/delivery-announce-pilot.md). Silence
+ *  from this hook is never evidence that the repo has no other session.
  *
  *  THE SIGNAL: `GET /v1/inbox/watchers` (the cloud registry) lists every armed
  *  watcher under the tenant as `{project_id, project_name, session_id, title,
@@ -16,8 +27,7 @@
  *  service watchers (receptionist / desk-line) carry a different
  *  project_id (or none), so they never match a working session's repo and are
  *  excluded for free. (`wide` is NOT a usable filter — observed true on ordinary
- *  session-scoped watchers, not just tenant-wide ones.) Liveness here depends on
- *  the peer having an armed (Monitor) watcher; best-effort by construction.
+ *  session-scoped watchers, not just tenant-wide ones.)
  *
  *  AI NEVER AUTO-ACTS: the hook injects a directive naming the peers; the AGENT
  *  composes and sends the contextual heads-up. The hook never sends.
@@ -117,20 +127,24 @@ function dedupePeers(peers, announced) {
 // adr: adr/delivery-announce-pilot.md
 /** The LOUD directive — same `additionalContext` shape as the arm directive,
  *  naming each peer + instructing message-then-worktree. PURE.
+ *  Only Claude Code runs this hook (Grok too, through its Claude-hook
+ *  compatibility), and every peer it names is a watcher row, so the heads-up
+ *  goes by `greprag send` alone; neither harness has Codex's native tools.
  *  It asks no heads-up of Claude Code peers: Claude Code holds a message to a
  *  session in another permission mode for that session's user and may let it
  *  expire, and the sender cannot see modes, so silence there is not approval.
- *  Delivery is the per-harness Delivery announce's alone, so step 3 defers. */
+ *  Delivery is the per-harness Delivery announce's alone, so step 3 defers.
+ *  The count is of watcher sessions, never of every session in the repo: a
+ *  Claude Code or Codex peer is never a registry row. */
 function buildCollisionDirective(peers, myShort, alias) {
     const handle = alias || '<handle>';
     const lines = peers.map(p => `  · ${p.short}${p.title ? ` — "${p.title}"` : ''}`);
     const plural = peers.length === 1 ? '' : 's';
-    return (`COLLISION DETECTED — ${peers.length} other live session${plural} working in this same repo right now:\n`
+    return (`COLLISION DETECTED — ${peers.length} greprag watcher session${plural} working in this same repo right now:\n`
         + lines.join('\n') + '\n'
-        + `Coordinate BEFORE touching shared files: (1) message each peer above now with a contextual heads-up — `
-        + `Codex peers: use \`codex_app.list_threads\` to find the task and its repo/workspace, then \`codex_app.send_message_to_thread\` to send the heads-up; `
-        + `peers OUTSIDE this harness (opencode / Grok / another tenant): \`greprag send "…what you're about to touch…" --to ${handle}@greprag.com/<their-8hex> --from-session ${myShort}\` `
-        + `(YOU compose and send it — this is a notice, not an auto-send; recipients reply only for a concrete conflict, silence is approval, and you never poll or wait; watcher rows are not the Codex peer source of truth); `
+        + `Coordinate BEFORE touching shared files: (1) message each peer above now with a contextual heads-up: `
+        + `\`greprag send "…what you're about to touch…" --to ${handle}@greprag.com/<their-8hex> --from-session ${myShort}\` `
+        + `(YOU compose and send it — this is a notice, not an auto-send; recipients reply only for a concrete conflict, silence is approval, and you never poll or wait); `
         + `(2) do your code work in a worktree on its own branch (\`git worktree add .claude/worktrees/<slug> -b <branch>\`), never in the shared default checkout; `
         + `(3) at delivery, notify peers only as this harness's Delivery announce says.`);
 }
@@ -165,7 +179,7 @@ function buildRosterWhisper(sessions) {
         return null;
     const parts = sessions.map(s => `${s.short}@${s.projectName}${s.title ? ` ("${s.title}")` : ''}`);
     const plural = sessions.length === 1 ? '' : 's';
-    return `[Live elsewhere — ${sessions.length} other session${plural} active in your tenant `
+    return `[Live elsewhere — ${sessions.length} greprag watcher session${plural} active in your tenant `
         + `(cross-repo, FYI only): ${parts.join(' · ')}]`;
 }
 /** Only-on-change gate for the whisper: emit iff the cross-repo session SET

package/dist/commands/delivery-reminder.js

@@ -50,7 +50,7 @@ function buildDeliveryAnnounce(env) {
         `[DELIVERY — ${project}]`,
         'Commit useful, passing work. Only committed state delivers; ignore uncommitted and untracked work in every checkout.',
         coordinationLine(env.platform),
-        'Land every ready same-repo commit: update the default branch, rebase your worktree onto its tip, retest there, take greprag merge-lock in the canonical checkout, recheck the tip, merge --ff-only, release --landed. Tip moved? Free the lock and prepare again. Never rebase a shared default branch.',
+        'Land every ready same-repo commit: update the default branch, rebase your worktree onto its tip, retest there, take greprag merge-lock in the canonical checkout, recheck the tip, merge --ff-only, release --landed. Tip moved? Free the lock and prepare again. A chip\'s branch arrives rebased by the chip: only fast-forward it; refused, free the lock and send it back. Never rebase in another session\'s worktree or a shared default branch.',
         'Deploy through this repo\'s delivery profile, from its canonical primary checkout unless the profile says otherwise. Worktrees build; they do not deploy. Then verify production serves the commit you shipped.',
         'THE GOAL ALREADY AUTHORIZES ALL OF THIS. Do not stop to ask permission to commit, merge, or deploy. Separate approval is for effects outside code delivery: destructive data, secrets, money, customer-facing messages.',
         'Why each rule, and the details: `greprag load delivery`.',

package/dist/commands/discord.js

@@ -1,21 +1,21 @@
 "use strict";
-/** greprag discord <pair|unpair|me|handoff|unhandoff> — Discord bot CLI.
+/** greprag discord <pair|unpair|me|typing> — Discord bot CLI.
  *
  *  pair        POSTs /v1/discord/pair with the current project anchor; prints
  *              the 6-char code + DM-the-bot instructions.
  *  unpair      DELETEs /v1/discord/pair.
- *  me          GETs /v1/discord/me — pairing + handoff state.
- *  handoff     POSTs /v1/discord/handoff — pins DMs to (current project,
- *              current session) for a TTL window. Bot DMs a confirmation.
- *  unhandoff   DELETEs /v1/discord/handoff.
+ *  me          GETs /v1/discord/me — pairing state.
+ *  typing      POSTs /v1/discord/typing — refreshes the typing indicator.
+ *
+ *  Sessions DM the operator with `greprag send --to discord:<snowflake>`.
+ *  Nothing reads DMs sent to the bot: the Front Desk and the handoff pin were
+ *  retired 2026-10-06, so the bot answers each one with a fixed line.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DISCORD_HELP = void 0;
 exports.callDiscordPair = callDiscordPair;
 exports.callDiscordUnpair = callDiscordUnpair;
 exports.callDiscordMe = callDiscordMe;
-exports.callDiscordHandoff = callDiscordHandoff;
-exports.callDiscordUnhandoff = callDiscordUnhandoff;
 exports.callDiscordTyping = callDiscordTyping;
 async function callDiscordPair(deps, projectId) {
     const f = deps.fetchImpl ?? fetch;
@@ -45,30 +45,6 @@ async function callDiscordMe(deps) {
     });
     return (await res.json());
 }
-async function callDiscordHandoff(deps, args) {
-    const f = deps.fetchImpl ?? fetch;
-    const res = await f(`${deps.apiUrl}/v1/discord/handoff`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${deps.apiKey}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            project_id: args.projectId,
-            session_id: args.sessionId,
-            ttl_minutes: args.ttlMinutes,
-        }),
-    });
-    return (await res.json());
-}
-async function callDiscordUnhandoff(deps) {
-    const f = deps.fetchImpl ?? fetch;
-    const res = await f(`${deps.apiUrl}/v1/discord/handoff`, {
-        method: 'DELETE',
-        headers: { 'Authorization': `Bearer ${deps.apiKey}` },
-    });
-    return (await res.json());
-}
 async function callDiscordTyping(deps) {
     const f = deps.fetchImpl ?? fetch;
     const res = await f(`${deps.apiUrl}/v1/discord/typing`, {
@@ -78,44 +54,19 @@ async function callDiscordTyping(deps) {
     return (await res.json());
 }
 exports.DISCORD_HELP = `
-greprag discord — Discord DM bridge to your greprag inbox.
+greprag discord — let your sessions DM you on Discord.
 
-Pair once, then DM the bot to talk to the agents listening in your project.
-Handoff temporarily redirects DMs to a specific session (e.g. while you step
-away from the desk and want to keep the same thread alive on your phone).
+Pair once; then any session can message you (see Outbound below). The bot does
+not read DMs you send it: the Front Desk was retired 2026-10-06.
 
 Subcommands:
   greprag discord pair                  Generate a 15-min code; DM @greprag-bot
                                         /pair <code> to link this Discord account
                                         to the current project.
   greprag discord unpair                Remove the pairing.
-  greprag discord me                    Show current pairing + handoff state.
-  greprag discord handoff [--ttl N]     Pin DMs to (current project, current
-                                        session) for N minutes (default 60,
-                                        max 1440). Bot DMs you a confirmation,
-                                        then this command BLOCKS and streams
-                                        inbound DMs to stdout (one per line)
-                                        until killed. Run it under Claude's
-                                        Monitor tool: each line = one
-                                        notification right back into the
-                                        agent's turn. Sliding TTL: each
-                                        inbound DM extends the pin by >=30 min.
-    [--session <8-hex>]                 Override session id (default: CLAUDE_SESSION_ID).
-    [--project <name>]                  Override project (default: cwd anchor).
-    [--orchestrator]                    Tenant-wide watcher — sees inbox traffic
-                                        from any project under this tenant. The
-                                        DM pin still routes here, but the agent
-                                        has portfolio-wide eyes. Use when this
-                                        session is the user's orchestrator
-                                        (/business-advisor loaded, etc.).
-    [--json]                            Emit raw JSON per line (for Monitor).
-    [--no-watch]                        Pin and exit — skip the inline watcher.
-                                        For scripted use; loses the live DM stream.
-  greprag discord unhandoff             Clear the active handoff — DMs revert
-                                        to default project.
+  greprag discord me                    Show current pairing state.
   greprag discord typing                Refresh the "typing..." indicator on
-                                        Discord for ~10s. Auto-fires on every
-                                        inbound DM; call manually during long
+                                        Discord for ~10s. Call it during long
                                         agent turns so the user sees activity
                                         instead of silence.
 

package/dist/commands/inbox-primer-reminder.js

@@ -46,7 +46,7 @@ function buildInboxPrimer(env) {
                 ? '[CODEX INBOX — greprag is your agent-to-agent mesh. Codex-to-Codex: discover tasks and their repo/workspace with `codex_app.list_threads`, then coordinate with `codex_app.send_message_to_thread`. Reaching ANY non-Codex peer (Claude Code / opencode / Grok / another tenant\'s agent): `greprag send` IS the live primary path — native Codex messaging cannot reach them.]'
                 : opencode
                     ? '[OPENCODE INBOX — greprag is your agent-to-agent mesh. Inbound delivery is AUTOMATIC here: the greprag plugin arms a relay for this session (nothing to arm or re-arm) and inbound peer messages arrive as injected turns.]'
-                    : '[CLAUDE CODE INBOX — greprag is how the world OUTSIDE this harness reaches you: Codex / opencode / Grok peers, the operator by DM, inbound email. Inbound delivery is AUTOMATIC and TURN-BASED: unread mail is injected at the top of your turn, plus a drain at session start. There is NOTHING to arm — the Monitor inbox watcher is RETIRED here (2026-09-04). Reply to those on the same greprag rail they arrived on. Another CLAUDE CODE session is NEVER reached through greprag — use your own harness\'s session list + send tools, which know each peer\'s working directory. Every 8-hex id greprag shows you is a GREPRAG address: those tools do not accept it, and passing one to them is the usual way a peer notice fails to address. Idle mail waits for the next turn instead of waking you.]',
+                    : '[CLAUDE CODE INBOX — greprag is how the world OUTSIDE this harness reaches you: Codex / opencode / Grok peers, the operator by DM, inbound email. Inbound delivery is AUTOMATIC and TURN-BASED: unread mail is injected at the top of your turn, plus a drain at session start. There is NOTHING to arm — the Monitor inbox watcher is RETIRED here (2026-09-04). Reply to those on the same greprag rail they arrived on. Another CLAUDE CODE session is NEVER reached through greprag — use your own harness\'s session list + send tools, which know each peer\'s working directory. Every 8-hex id greprag shows you is a GREPRAG address: those tools do not accept it. Idle mail waits for the next turn instead of waking you.]',
         grok
             ? `ARM (idle wake): Grok \`monitor\` tool, persistent:true, description:"greprag inbox ${env.short}", command: \`${arm}\`. \`--quiet\` is REQUIRED — Grok treats stderr as wake events; the Claude bash wrapper is PowerShell-invalid. Use full UUID / 16-hex, never 8-hex. A chip → \`greprag load grok-chip-spawn\` then \`greprag grok spawn\` (child arms its own watch; parent keeps ONE). A helper → spawn_subagent. Floor: Stop-hook drain injects unread mail even if you never arm. Then \`greprag inbox\`.`
             : codex

package/dist/commands/inbox-watch.js

@@ -251,19 +251,6 @@ function printMessage(msg) {
 function emitDmReplyDirective(msg, session) {
     if (!session)
         return;
-    // Front Desk Switchboard relay: the operator reached THIS session through the
-    // receptionist and `references.reply_to` is the rail to answer on. Fires for
-    // ANY message_type (the relay uses plain 'message'), and takes precedence over
-    // the legacy Discord-DM path. Without this the session falls back to the bare
-    // sender handle (travis@greprag.com) — the reply lands in MAIN, never reaching
-    // the operator on Discord/SMS. Live failure 2026-06-08. spec:
-    // docs/front-desk-switchboard.md §4 (return leg).
-    const replyTo = msg.references?.reply_to;
-    if (replyTo) {
-        console.log(`[greprag] Operator via front desk — answer now, even mid-task: greprag send --to ${replyTo} "…" ` +
-            `(exact addr; bare handle is lost). If they reply inline here, don't echo to Discord/SMS.`);
-        return;
-    }
     if (msg.message_type !== 'discord_dm')
         return;
     const snowflake = msg.references?.discord?.snowflake ?? '<snowflake>';

package/dist/commands/load.js

@@ -453,9 +453,11 @@ async function printMirroredSkill(name, args) {
         const identityArg = args.skillId ? ` --skill-id ${args.skillId}` : '';
         console.error(`Mirrored skill "${name}" has no canonical body — the mirror is holding the generated adapter.\n` +
             `Refusing to serve it: the adapter is the launcher that sent you here, not the skill.\n\n` +
-            `Restore the real body from the pre-adoption snapshot:\n` +
+            `Restore the real body from an earlier revision or the pre-adoption snapshot:\n` +
+            `  greprag skill history ${name}${identityArg}\n` +
+            `  greprag skill revert ${name} --to <rev>${identityArg} --reason "<why>" --expected-hash <current-hash>\n` +
             `  greprag skill mirror snapshot list ${name}${identityArg}\n` +
-            `  greprag skill mirror snapshot promote ${name} --name <snapshot>${identityArg} --expected-hash <current-hash>\n`);
+            `  greprag skill mirror snapshot promote ${name} --name <snapshot>${identityArg} --expected-hash <current-hash> --reason "<why>"\n`);
         process.exitCode = 1;
         return true;
     }

package/dist/commands/merge-guard.js

@@ -302,7 +302,7 @@ function buildMergeGuardReason(held, ownership) {
         'merges into it are serialised the way deploys already are.',
         '  greprag merge-lock acquire --label "<what you are merging>"',
         '  git merge --ff-only <rebased branch>',
-        '  greprag merge-lock release --landed <the merge sha> --label "<what it was>"',
+        '  greprag merge-lock release --landed <rebased branch> --label "<what it was>"',
         'One call works too when the acquire comes first and failure stops the merge:',
         'use an `&&` chain, or in PowerShell a try/finally block with an immediate',
         '`if ($LASTEXITCODE -ne 0) { throw ... }` after acquire. Bare `;` and `||`',

package/dist/commands/merge-lock.js

@@ -7,7 +7,7 @@ const HELP = `greprag merge-lock — serialise merges into a shared canonical ch
 
 Usage:
   greprag merge-lock acquire [--label <text>] [--json]
-  greprag merge-lock release [--landed <sha>] [--label <text>] [--json]
+  greprag merge-lock release [--landed <branch>] [--label <text>] [--json]
   greprag merge-lock status [--json]
   greprag merge-lock claim [--drop <sha>] [--json]
 
@@ -28,9 +28,14 @@ serves HEAD — never that HEAD contains your work. On 2026-09-04 a session's me
 redone by a peer under a new sha, its deploy exited 0 honestly, and it reported
 shipping work that was on no branch.
 
+Name the branch you merged, never HEAD. Release exits 1 when that commit is not on
+the integration branch, or was already its tip when you took the lock: on 2026-10-06
+a refused fast-forward piped through tail left HEAD unmoved, and \`--landed HEAD\`
+claimed a peer's commit as this session's work.
+
 Options:
   --label <text>  What this merge is, shown to whoever is blocked by it
-  --landed <sha>  Record this commit as merged, to be verified at deploy time
+  --landed <rev>  The branch you merged; verified now and again at deploy time
   --drop <sha>    (claim) Forget a claim you have confirmed by hand
   --json          Machine-readable result`;
 /** Resolve to a full sha, so a claim never depends on an abbreviation staying unique. */
@@ -67,7 +72,9 @@ function runMergeLock(args) {
     if (sub === 'acquire') {
         // Session-held, so never pid-checked: the process running this command exits
         // immediately and a pid check would mark the lock stale the moment it is taken.
-        const result = (0, deploy_locks_1.acquireLock)(file, flagValue(args, '--label') || 'merge', deploy_locks_1.MERGE_STALE_MS, { checkPid: false });
+        const result = (0, deploy_locks_1.acquireLock)(file, flagValue(args, '--label') || 'merge', deploy_locks_1.MERGE_STALE_MS, {
+            checkPid: false, base: (0, deploy_locks_1.refTip)(cwd, (0, deploy_locks_1.integrationRef)(cwd)),
+        });
         if (json)
             console.log(JSON.stringify(result));
         else if (result.ok) {
@@ -104,10 +111,29 @@ function runMergeLock(args) {
                 process.exitCode = 1;
                 return;
             }
+            // Checked here, not trusted: the exit code is what stops `release && deploy`
+            // even when a pipe swallowed the merge's own refusal.
+            const verdict = (0, deploy_locks_1.landedVerdict)(cwd, resolved, (0, deploy_locks_1.readMergeLock)(cwd)?.record.base);
+            if (verdict === 'nothing-new') {
+                (0, deploy_locks_1.releaseLock)(file);
+                console.error(`merge-lock: released, nothing claimed. ${resolved.slice(0, 10)} was already the tip of the integration branch`
+                    + ' when you took the lock, so nothing landed under it. A refused merge leaves exactly this state.'
+                    + '\n  Name the branch you merged: --landed <branch>. It passes only once that branch is in.'
+                    + '\n  If someone else already landed it before you took the lock, release without --landed.');
+                process.exitCode = 1;
+                return;
+            }
             try {
                 const claim = (0, deploy_locks_1.recordLandedClaim)(cwd, resolved, flagValue(args, '--label') || 'merged work');
-                console.log(`merge-lock: released; claimed ${claim.sha.slice(0, 10)} as landed`);
-                console.log('  The deploy gate will refuse until that commit is in what ships.');
+                if (verdict === 'not-landed') {
+                    console.error(`merge-lock: released, but ${claim.sha.slice(0, 10)} is NOT on the integration branch — your merge did not land.`);
+                    console.error('  The claim is recorded, so the deploy gate refuses until that commit is in what ships.');
+                    process.exitCode = 1;
+                }
+                else {
+                    console.log(`merge-lock: released; claimed ${claim.sha.slice(0, 10)} as landed`);
+                    console.log('  The deploy gate will refuse until that commit is in what ships.');
+                }
             }
             catch (error) {
                 console.error(`merge-lock: released, but the claim was NOT recorded: ${error instanceof Error ? error.message : String(error)}`);

package/dist/commands/reminder-registry.js

@@ -5,7 +5,7 @@
  *  PURE over ReminderEnv — the hook assembles env (i/o) and emits the returned lines;
  *  a broken module never blocks a turn (fail-open per module). */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ANNOUNCE_POINTER_RESERVE = exports.ANNOUNCE_HARNESS_CAP = exports.ANNOUNCE_INLINE_BUDGET = exports.compactReannounceModules = exports.commandModules = exports.promptModules = exports.harnessModules = exports.REGISTRY = void 0;
+exports.ANNOUNCE_POINTER_RESERVE = exports.ANNOUNCE_HARNESS_CAP = exports.ANNOUNCE_INLINE_BUDGET = exports.compactReannounceModules = exports.harnessModules = exports.REGISTRY = void 0;
 exports.collectReminders = collectReminders;
 exports.bootOrder = bootOrder;
 exports.collectAnnounces = collectAnnounces;
@@ -66,13 +66,6 @@ exports.REGISTRY = [
  *  update a parallel id list. (Root-cause repair, chip/opencode-fix-chip-system-parity.) */
 const harnessModules = (harness, registry = exports.REGISTRY) => registry.filter((m) => !m.harnesses || m.harnesses.includes(harness));
 exports.harnessModules = harnessModules;
-/** Split the registry by READ surface (docs/reminder-interrupt.md). UserPromptSubmit
- *  evaluates `prompt`-source modules (the default); PreToolUse evaluates `command`-source
- *  modules (they read env.toolCommand). Announces are always prompt-side (SessionStart). */
-const promptModules = (registry = exports.REGISTRY) => registry.filter((m) => (m.source ?? 'prompt') === 'prompt');
-exports.promptModules = promptModules;
-const commandModules = (registry = exports.REGISTRY) => registry.filter((m) => m.source === 'command');
-exports.commandModules = commandModules;
 /** PostCompact re-announce set (docs/reminder-interrupt.md). A compaction wipes the
  *  SessionStart announces from context, so the announce modules re-present afterward —
  *  by DEFAULT all of them; a module opts out with `reannounceOnCompact: false`. The

package/dist/commands/session.js

@@ -4,8 +4,8 @@
  *  retitle <session-8hex> "<title>" — force-set a session's registry title,
  *  overriding the gpt-5.4-nano auto-title. Used by the multi-chip /chip-leader
  *  convention: a chip stamps its own label-aligned title ("Chip A — …") in
- *  Block 1 so the FleetView watcher list / Discord /switch line up with the
- *  leader's chip labels. Thin HTTP client over POST /v1/memory/title. */
+ *  Block 1 so the FleetView watcher list lines up with the leader's chip
+ *  labels. Thin HTTP client over POST /v1/memory/title. */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/dist/commands/skill-mirror-reminder.js

@@ -90,7 +90,6 @@ function buildSkillMirrorAnnounce(m, platform) {
 }
 exports.skillMirrorAnnounceModule = {
     id: 'skill-mirror-announce',
-    source: 'prompt',
     dependsOn: ['load-primer'], // references `greprag load` — the primer establishes it
     detect: (_env) => ({ tier: 'silent' }), // announce-only
     announce: (env) => buildSkillMirrorAnnounce(env.mirroredSkills, env.platform),