projecta-rrr 1.22.1 → 1.22.3

package/CHANGELOG.md

@@ -4,6 +4,67 @@ All notable changes to RRR will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [1.22.3] - 2026-04-19
+
+**Patch: postinstall full provision + tool-disallow real-payload subagent detection + hook wiring.**
+
+### Fixed
+- **`bin/install.js` postinstall now full-provisions** (was `--hud-only`). Fresh `npm install -g projecta-rrr` lands 47 commands, 13 agents, 18 hooks, plus settings.json with v1.22 hooks pre-wired (default-safe). Previously users had to run `npx projecta-rrr install` separately to get commands/agents.
+- **v1.22 hooks now auto-wired** into `~/.claude/settings.json` on install:
+  - `PreToolUse` matcher `Task|Agent` → `hooks/model-router.js`
+  - `PreToolUse` matcher `Read|Grep|Glob` → `hooks/tool-disallow.js`
+  - `PostToolUse` matcher `Edit|MultiEdit` → `hooks/edit-batching-nudge.js`
+  - Defaults seeded: `settings.rrr.model_router: "static"` (v1.21 behavior), `settings.rrr.tok_disallow: false` (opt-in).
+  - Idempotent — re-install does not duplicate entries.
+  - Previously hook files copied but not wired (only `runHostedInstallOrchestrator()` wired them, which only runs with `--enable-hosted`).
+- **`hooks/tool-disallow.js` subagent detection** now uses real Claude Code payload schema. Previous heuristic checked `input.agent_name` which does NOT exist in PreToolUse payloads (UAT-verified schema: `{session_id, transcript_path, cwd, permission_mode, hook_event_name, tool_name, tool_input, tool_use_id}`). New mechanism: read tail of `transcript_path` and check `isSidechain: true` to detect subagent context. Fallback: legacy `agent_name` field for forward-compat. Fail-CLOSED if transcript unreadable (over-block better than under-block when goal is token discipline).
+
+### Operator data populated this session
+- **`installations` table**: 5 rows (was 0) — populated from existing `repos.installation_id` data.
+- **`repos.github_repo_id` backfill**: 24 of 59 real repos populated via `gh api /repos/PA-Ai-Team/<slug>`. Remaining 35 are inaccessible to the user PAT (likely deleted, archived, or upstream forks like OpenHands/letta — webhook routing for them is unreachable anyway, so NULL is correct).
+
+### Verified in UAT
+- Fresh `HOME=tmp npm install -g projecta-rrr@1.22.3 --prefix=tmp` lands 47 commands + 13 agents + 18 hooks + 3 wired hook entries with safe defaults. Re-install is idempotent (no duplicate entries).
+- `tool-disallow`: main-thread Read with synthetic transcript (`isSidechain:false`) → BLOCK exit 2; subagent Read with `isSidechain:true` → ALLOW exit 0.
+- 239/239 tests pass; `prepublish:check` clean.
+
+### Known followups
+- 35 repos with NULL `github_repo_id` (private/deleted) — operator can run via App-installation token (broader scope) if needed; for now webhook safely skips them with `{"skipped":"unindexed-repo"}`.
+
+## [1.22.2] - 2026-04-19
+
+**Patch: dynamic routing now actually fires in Claude Code (Opus 4.7+).**
+
+### Fixed
+- **Phase 83 model-router matcher**: Claude Code (Opus 4.7+) emits subagent dispatches as `tool_name: "Agent"`, not `"Task"`. v1.22.0/.1 hardcoded `"Task"` in both:
+  1. `hooks/model-router.js` internal gate (`if (toolName !== "Task") return emitAllow()`)
+  2. `rrr/lib/install-hooks-wiring.js` matcher (`{ matcher: "Task", ... }`)
+  Result: hook never fired for any Agent dispatch in Opus 4.7+ sessions, so dynamic routing was a no-op even with `settings.rrr.model_router: "dynamic"`.
+
+  v1.22.2 accepts both `Task` and `Agent`. Live UAT verified end-to-end:
+  ```
+  {"ts":"2026-04-19T05:46:21Z","event":"dispatch","tool_name":"Agent",
+   "agent_name":"rrr-explore","tier":"haiku","reason":"dispatch"}
+  ```
+  Token usage on rrr-explore call: ~10.4k (haiku) vs ~13.2k baseline (general-purpose, sonnet/inherit) — ~21% reduction from tier downgrade alone, on a single dispatch.
+
+### Verified in UAT (v1.21 hosted webhook + Phase 80 App-level)
+- **Hosted Fly app redeployed** with v1.22 code (was running pre-Phase-80 image — `/webhooks/github-app` returned 404 until `fly deploy`).
+- **Phase 80 webhook end-to-end**:
+  - Ping: 200 OK
+  - Valid HMAC push (with `installation_id` lookup): 202 + `{queued:true, job_id}`
+  - Replay (same delivery_id): 200 + `{duplicate:true}` ✓ dedup
+  - Bad signature: 401 `signature_invalid`
+  - Non-default branch: 200 `{skipped:"non-default-branch"}`
+  - Unindexed repo (NULL `github_repo_id`): 200 `{skipped:"unindexed-repo"}`
+- **Neon migration 014 applied**: `installations` table populated with 5 rows from existing `repos.installation_id` data.
+- **`installations` table**: 5 rows under `team_id=pa-ai-team`. Largest installation: 125117864 (29 repos).
+
+### Known followups
+- **Backfill `repos.github_repo_id`** for all 62 repos via `gh api /repos/<full_name>`. Without this, App-level webhook deliveries hit "unindexed-repo" skip path. Operator-actionable.
+- **Postinstall `--hud-only`** still requires separate `npx projecta-rrr install` for full provision. v1.22.x followup.
+- **`tool-disallow` subagent exemption heuristic** uses `input.agent_name` — this field is NOT present in real Claude Code PreToolUse payload (UAT-verified payload schema has `tool_name`, `tool_input`, `session_id`, `transcript_path`, `cwd`, `permission_mode`, `tool_use_id`). Subagent context detection needs different mechanism.
+
 ## [1.22.1] - 2026-04-19
 
 **Patch: fixes v1.22.0 fresh install regression.**

package/bin/install.js

@@ -1730,6 +1730,47 @@ function install(isGlobal) {
     console.log(`  ${green}✓${reset} Installed hooks`);
   }
 
+  // v1.22.3: wire Phase 83 (model-router), Phase 85 (tool-disallow + edit-batching-nudge)
+  // PreToolUse/PostToolUse hooks. Idempotent — checks for existing entries before
+  // adding. Defaults are SAFE (settings.rrr.tok_disallow=false; model_router=static).
+  // Previously these were only wired when --enable-hosted ran the hosted orchestrator,
+  // so users got the hooks on disk but no settings.json registration.
+  if (bashStatus.available && fs.existsSync(path.join(claudeDir, 'hooks', 'model-router.js'))) {
+    settings.hooks = settings.hooks || {};
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse || [];
+    settings.hooks.PostToolUse = settings.hooks.PostToolUse || [];
+    settings.rrr = settings.rrr || {};
+
+    const wireOnce = (chain, matcher, hookCmd, label) => {
+      const exists = chain.some((entry) =>
+        entry && Array.isArray(entry.hooks) && entry.hooks.some(
+          (h) => h && typeof h.command === 'string' && h.command.includes(label)
+        )
+      );
+      if (!exists) {
+        chain.push({ matcher, hooks: [{ type: 'command', command: hookCmd }] });
+        return true;
+      }
+      return false;
+    };
+
+    let wiredCount = 0;
+    if (wireOnce(settings.hooks.PreToolUse, 'Task|Agent', '$HOME/.claude/hooks/model-router.js', 'model-router.js')) wiredCount++;
+    if (fs.existsSync(path.join(claudeDir, 'hooks', 'tool-disallow.js'))) {
+      if (wireOnce(settings.hooks.PreToolUse, 'Read|Grep|Glob', 'node $HOME/.claude/hooks/tool-disallow.js', 'tool-disallow.js')) wiredCount++;
+    }
+    if (fs.existsSync(path.join(claudeDir, 'hooks', 'edit-batching-nudge.js'))) {
+      if (wireOnce(settings.hooks.PostToolUse, 'Edit|MultiEdit', 'node $HOME/.claude/hooks/edit-batching-nudge.js', 'edit-batching-nudge.js')) wiredCount++;
+    }
+    if (settings.rrr.model_router === undefined) settings.rrr.model_router = 'static';
+    if (settings.rrr.tok_disallow === undefined) settings.rrr.tok_disallow = false;
+    if (wiredCount > 0) {
+      console.log(`  ${green}✓${reset} Wired ${wiredCount} v1.22 hook(s) (settings.rrr.model_router=static, tok_disallow=false — opt-in)`);
+    } else {
+      console.log(`  ${dim}✓${reset} v1.22 hooks already wired`);
+    }
+  }
+
   const statuslineCommand = isGlobal
     ? '$HOME/.claude/hooks/statusline.sh'
     : `${localDirName}/hooks/statusline.sh`;

package/hooks/model-router.js

@@ -85,9 +85,12 @@ function main() {
   try { input = JSON.parse(raw); }
   catch (_e) { return emitAllow('router: stdin not JSON'); }
 
-  // Only act on the Task tool — every other tool is pass-through.
+  // Only act on the subagent-dispatch tool — every other tool is pass-through.
+  // Claude Code uses either "Task" (Anthropic API name, most builds) or "Agent"
+  // (Opus 4.7+ builds) for subagent dispatch. Accept both — confirmed via
+  // v1.22.2 UAT live-session capture (/tmp/uat-hook-log.jsonl).
   const toolName = input.tool_name;
-  if (toolName !== 'Task') return emitAllow();
+  if (toolName !== 'Task' && toolName !== 'Agent') return emitAllow();
 
   const toolInput = (input.tool_input && typeof input.tool_input === 'object') ? input.tool_input : {};
 

package/hooks/tool-disallow.js

@@ -18,9 +18,16 @@
  *     and scripts/test-install-smoke.js).
  *   - env RRR_TOK_DISALLOW=off    → kill-switch override.
  *
- * Subagent exemption:
- *   - PreToolUse JSON payload includes `agent_name` for subagent calls.
- *     Empty/missing = main thread.
+ * Subagent exemption (v1.22.3 fix — UAT-verified payload schema):
+ *   - Real Claude Code PreToolUse payload does NOT include `agent_name`.
+ *     Schema is: {session_id, transcript_path, cwd, permission_mode,
+ *                 hook_event_name, tool_name, tool_input, tool_use_id}
+ *   - Subagent context is detected by reading the LAST line of
+ *     `transcript_path` and checking `isSidechain: true`. Sidechain entries
+ *     are subagent calls; main thread is `isSidechain: false`.
+ *   - Fallback: if transcript can't be read or parsed, treat as main thread
+ *     (fail-CLOSED for the BLOCK case — better to over-block than under-block
+ *     when the goal is token discipline).
  *
  * Settings location (read-only): ~/.claude/settings.json (then project
  * .claude/settings.json — project wins). Never modified here; wiring is
@@ -66,6 +73,43 @@ function isAgentExempt(agentName, exemptList) {
   return true;
 }
 
+/**
+ * Detect subagent context by reading the tail of the Claude Code transcript
+ * and checking for `isSidechain: true` on recent entries.
+ *
+ * Real Claude Code PreToolUse payload includes `transcript_path` but NOT
+ * `agent_name`. The transcript JSONL has one entry per turn with isSidechain
+ * marking subagent context (UAT-verified in v1.22.3).
+ *
+ * Returns: 'subagent' | 'main' | 'unknown'
+ */
+function detectThreadFromTranscript(transcriptPath) {
+  if (!transcriptPath || typeof transcriptPath !== 'string') return 'unknown';
+  try {
+    if (!fs.existsSync(transcriptPath)) return 'unknown';
+    // Read last ~64KB only (transcripts can be large; we only need recent context).
+    const stat = fs.statSync(transcriptPath);
+    const fd = fs.openSync(transcriptPath, 'r');
+    const tailSize = Math.min(stat.size, 65536);
+    const buf = Buffer.alloc(tailSize);
+    fs.readSync(fd, buf, 0, tailSize, Math.max(0, stat.size - tailSize));
+    fs.closeSync(fd);
+    const lines = buf.toString('utf8').split('\n').filter(Boolean);
+    // Walk backward — the most recent non-tool-result entry is the current turn.
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const e = JSON.parse(lines[i]);
+        if (typeof e.isSidechain === 'boolean') {
+          return e.isSidechain ? 'subagent' : 'main';
+        }
+      } catch { /* skip malformed line */ }
+    }
+    return 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
 function decideMode(settings) {
   // Env kill-switch wins.
   if ((process.env.RRR_TOK_DISALLOW || '').toLowerCase() === 'off') return 'off';
@@ -98,12 +142,18 @@ function main() {
   // a misconfigured settings.json never breaks the installer.
   if (process.env.RRR_INTERNAL_TOOL === '1') { process.exit(0); }
 
-  // Subagent exemption — agent_name set = subagent context.
-  const agentName = input.agent_name || (input.session && input.session.agent_name) || '';
+  // Subagent exemption — v1.22.3: detect via transcript_path + isSidechain.
+  // Real Claude Code payload schema does NOT include input.agent_name.
+  // Fallback to legacy input.agent_name field for forward-compat with future
+  // Claude Code versions that may add it.
+  const legacyAgentName = input.agent_name || (input.session && input.session.agent_name) || '';
+  const thread = legacyAgentName ? 'subagent' : detectThreadFromTranscript(input.transcript_path);
   const settings = loadSettings();
   const exemptList = settings.tok_disallow_exempt;
 
-  if (isAgentExempt(agentName, exemptList)) { process.exit(0); }
+  // Subagent (sidechain) → always exempt. Unknown → treat as main (fail-CLOSED).
+  if (thread === 'subagent') { process.exit(0); }
+  if (legacyAgentName && isAgentExempt(legacyAgentName, exemptList)) { process.exit(0); }
 
   // Explicit per-name allow (rare: when main-thread invocation of a
   // specific named context should still be permitted).
@@ -127,5 +177,6 @@ module.exports = {
   BLOCKED_TOOLS,
   decideMode,
   isAgentExempt,
+  detectThreadFromTranscript,
   buildMessage,
 };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "projecta-rrr",
-  "version": "1.22.1",
+  "version": "1.22.3",
   "description": "A meta-prompting, context engineering and spec-driven development system for Claude Code by Projecta.ai",
   "bin": {
     "projecta-rrr": "bin/install.js",
     "projecta-rrr-hosted-setup": "bin/hosted-setup.js"
   },
   "scripts": {
-    "postinstall": "node bin/install.js --hud-only --global && node scripts/register-mcp.js",
+    "postinstall": "node bin/install.js --global --yes --skip-optimization && node scripts/register-mcp.js",
     "watch": "node watcher/index.js",
     "watch:verbose": "node watcher/index.js --verbose",
     "watch:claude-code": "node watcher/watchers/claude-code.js --verbose",

package/rrr/lib/install-hooks-wiring.js

@@ -210,7 +210,10 @@ function wireToolRedirect({ repoHooksDir, userHooksDir, userSettingsPath, dryRun
  */
 function buildModelRouterEntry(hookAbsPath) {
   return {
-    matcher: 'Task',
+    // Claude Code uses either "Task" (most builds) or "Agent" (Opus 4.7+) as
+    // the subagent dispatch tool name. Match both via regex alternation —
+    // confirmed via v1.22.2 UAT live-session capture.
+    matcher: 'Task|Agent',
     hooks: [
       { type: 'command', command: `node ${hookAbsPath}` },
     ],