@tekmidian/pai 0.42.4 → 0.42.6

package/src/hooks/ts/session-end/capture-session-summary.ts

@@ -9,7 +9,7 @@
 
 import { writeFileSync, mkdirSync, existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { PAI_DIR, HISTORY_DIR } from '../lib/pai-paths';
+import { historyDir } from '../lib/pai-paths';
 
 interface SessionData {
   conversation_id: string;
@@ -62,7 +62,7 @@ async function main() {
     const filename = `${timestamp}_SESSION_${sessionInfo.focus}.md`;
 
     // Ensure directory exists
-    const sessionDir = join(HISTORY_DIR, 'sessions', yearMonth);
+    const sessionDir = join(historyDir(), 'sessions', yearMonth);
     if (!existsSync(sessionDir)) {
       mkdirSync(sessionDir, { recursive: true });
     }
@@ -87,7 +87,7 @@ async function main() {
 
 async function analyzeSession(conversationId: string, yearMonth: string): Promise<any> {
   // Try to read raw outputs for this session
-  const rawOutputsDir = join(HISTORY_DIR, 'raw-outputs', yearMonth);
+  const rawOutputsDir = join(historyDir(), 'raw-outputs', yearMonth);
 
   let filesChanged: string[] = [];
   let commandsExecuted: string[] = [];
@@ -196,7 +196,7 @@ ${info.commandsExecuted.length > 0 ? '```bash\n' + info.commandsExecuted.join('\
 
 This session summary was automatically generated by the UOCS SessionEnd hook.
 
-For detailed tool outputs, see: \`\${PAI_DIR}/History/raw-outputs/${timestamp.substring(0, 7)}/\`
+For detailed tool outputs, see: \`${join(historyDir(), 'raw-outputs', timestamp.substring(0, 7))}/\`
 
 ---
 

package/src/hooks/ts/session-start/initialize-session.ts

@@ -14,7 +14,7 @@
  * Setup:
  * 1. Set environment variables in settings.json:
  *    - DA: Your AI's name (e.g., "Kai", "Nova", "Assistant")
- *    - PAI_DIR: Path to your PAI directory (defaults to $HOME/.claude)
+ *    - ADAPTER_DIR: Path to your Claude Code harness adapter dir (defaults to $HOME/.claude)
  * 2. Ensure load-core-context.ts exists in hooks/session-start/ directory
  * 3. Add all three SessionStart hooks to settings.json in this order:
  *    initialize-session.ts, load-core-context.ts, load-project-context.ts
@@ -24,7 +24,7 @@ import { isWorkerSession } from "../lib/worker-session.js";
 import { existsSync, statSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
-import { PAI_DIR } from '../lib/pai-paths';
+import { ADAPTER_DIR } from '../lib/pai-paths';
 import { sendNtfyNotification, isWhatsAppEnabled, isProbeSession } from '../lib/project-utils';
 
 // Debounce duration in milliseconds (prevents duplicate SessionStart events)
@@ -61,7 +61,7 @@ function shouldDebounce(): boolean {
 }
 
 async function testStopHook() {
-  const stopHookPath = join(PAI_DIR, 'hooks/stop-hook.ts');
+  const stopHookPath = join(ADAPTER_DIR, 'hooks/stop-hook.ts');
 
   console.error('\nTesting stop-hook configuration...');
 

package/src/hooks/ts/session-start/inject-observations.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import { formatContext, isNoiseEntry } from "./inject-observations.js";
+
+function row(id: number, title: string, minutesAgo = 0) {
+  return {
+    id,
+    session_id: `s${id}`,
+    project_id: 1,
+    project_slug: "pai",
+    type: "discovery",
+    title,
+    narrative: null,
+    created_at: new Date(Date.now() - minutesAgo * 60_000).toISOString(),
+  };
+}
+
+describe("isNoiseEntry", () => {
+  it("flags Ran: and MCP: prefixed titles", () => {
+    expect(isNoiseEntry("Ran: ls -la")).toBe(true);
+    expect(isNoiseEntry("MCP: memory_search")).toBe(true);
+    expect(isNoiseEntry("Modified foo.ts")).toBe(false);
+  });
+});
+
+describe("formatContext", () => {
+  it("caps the timeline at 6 entries and drops noise entries", () => {
+    const observations = [
+      ...Array.from({ length: 10 }, (_, i) => row(i, `Ran: cmd ${i}`)),
+      ...Array.from({ length: 8 }, (_, i) => row(100 + i, `Modified file${i}.ts`)),
+    ];
+    const context = formatContext("pai", observations);
+    const timelineLines = context
+      .split("\n")
+      .filter(l => l.startsWith("- ["));
+    expect(timelineLines).toHaveLength(6);
+    expect(timelineLines.every(l => !l.includes("Ran:"))).toBe(true);
+  });
+
+  it("falls back to unfiltered entries when fewer than 3 non-noise entries remain", () => {
+    const observations = [
+      row(1, "Ran: cmd 1"),
+      row(2, "Ran: cmd 2"),
+      row(3, "Modified file.ts"),
+    ];
+    const context = formatContext("pai", observations);
+    const timelineLines = context.split("\n").filter(l => l.startsWith("- ["));
+    expect(timelineLines).toHaveLength(3);
+  });
+
+  it("truncates each timeline line to 80 characters", () => {
+    const longTitle = "Modified " + "x".repeat(200) + ".ts";
+    const context = formatContext("pai", [row(1, longTitle)]);
+    const timelineLine = context.split("\n").find(l => l.startsWith("- ["))!;
+    expect(timelineLine.length).toBeLessThanOrEqual(80);
+  });
+});

package/src/hooks/ts/session-start/inject-observations.ts

@@ -20,6 +20,16 @@
 import { connect } from 'net';
 import { randomUUID } from 'crypto';
 import { isProbeSession } from '../lib/project-utils.js';
+import { isWorkerSession } from '../lib/worker-session.js';
+
+// ---------------------------------------------------------------------------
+// Tuning
+// ---------------------------------------------------------------------------
+
+const MAX_TIMELINE_ENTRIES = 6;
+const MAX_ENTRY_LENGTH = 80;
+const MIN_FILTERED_ENTRIES = 3;
+const NOISE_PREFIXES = ['Ran:', 'MCP:'];
 
 // ---------------------------------------------------------------------------
 // Types
@@ -134,11 +144,15 @@ function truncate(s: string, maxLen: number): string {
   return s.length > maxLen ? s.slice(0, maxLen - 1) + '\u2026' : s;
 }
 
+export function isNoiseEntry(title: string): boolean {
+  return NOISE_PREFIXES.some(prefix => title.startsWith(prefix));
+}
+
 // ---------------------------------------------------------------------------
 // Format observations as progressive disclosure context
 // ---------------------------------------------------------------------------
 
-function formatContext(
+export function formatContext(
   projectSlug: string,
   observations: ObservationRow[]
 ): string {
@@ -152,19 +166,22 @@ function formatContext(
   const newest = new Date(observations[0].created_at);
   const lastActivity = timeAgo(newest);
 
-  // Timeline: show most recent 15, keep titles to 80 chars
-  const timelineObs = observations.slice(0, 15);
+  // Drop low-signal "Ran:"/"MCP:" entries, unless that leaves too few to show.
+  const filtered = observations.filter(o => !isNoiseEntry(o.title));
+  const source = filtered.length >= MIN_FILTERED_ENTRIES ? filtered : observations;
+
+  // Timeline: show at most MAX_TIMELINE_ENTRIES, each line capped to MAX_ENTRY_LENGTH.
+  const timelineObs = source.slice(0, MAX_TIMELINE_ENTRIES);
   const timeline = timelineObs
     .map(o => {
       const t = timeAgo(new Date(o.created_at));
       const label = typeLabel(o.type);
-      const title = truncate(o.title, 80);
-      return `- [${t}] ${label} ${title}`;
+      return truncate(`- [${t}] ${label} ${o.title}`, MAX_ENTRY_LENGTH);
     })
     .join('\n');
 
-  const showingNote = observations.length > 15
-    ? `(showing most recent 15 of ${observations.length}, use observation_search for more)`
+  const showingNote = observations.length > timelineObs.length
+    ? `(showing ${timelineObs.length} most recent of ${observations.length}, use observation_search for more)`
     : `(showing ${observations.length} observation${observations.length !== 1 ? 's' : ''})`;
 
   const lines: string[] = [
@@ -188,6 +205,7 @@ function formatContext(
 // ---------------------------------------------------------------------------
 
 async function main() {
+  if (isWorkerSession()) return; // disposable worker: no per-session bookkeeping
   try {
     // Skip probe/health-check sessions
     if (isProbeSession()) {
@@ -251,4 +269,6 @@ async function main() {
   }
 }
 
-main();
+if (!process.env.VITEST) {
+  main();
+}

package/src/hooks/ts/session-start/load-core-context.ts

@@ -13,9 +13,9 @@
  * - Bypass skill activation logic by directly injecting context
  *
  * Setup:
- * 1. Customize your ${PAI_DIR}/skills/CORE/SKILL.md with your personal context
+ * 1. Customize your ${ADAPTER_DIR}/skills/CORE/SKILL.md with your personal context
  * 2. Add this hook to settings.json SessionStart hooks
- * 3. Ensure PAI_DIR environment variable is set (defaults to $HOME/.claude)
+ * 3. Ensure ADAPTER_DIR environment variable is set (defaults to $HOME/.claude)
  *
  * How it works:
  * - Runs at the start of every Claude Code session
@@ -28,7 +28,7 @@
 import { isWorkerSession } from "../lib/worker-session.js";
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
-import { PAI_DIR, SKILLS_DIR } from '../lib/pai-paths';
+import { SKILLS_DIR } from '../lib/pai-paths';
 import { isProbeSession } from '../lib/project-utils';
 
 async function main() {
@@ -57,7 +57,7 @@ async function main() {
     // Verify CORE skill file exists
     if (!existsSync(coreSkillPath)) {
       console.error(`CORE skill not found at: ${coreSkillPath}`);
-      console.error(`Ensure CORE/SKILL.md exists or check PAI_DIR environment variable`);
+      console.error(`Ensure CORE/SKILL.md exists or check ADAPTER_DIR environment variable`);
       process.exit(1);
     }
 

package/src/hooks/ts/session-start/load-project-context.ts

@@ -23,8 +23,8 @@ import { homedir } from 'os';
 import { execSync } from 'child_process';
 import { buildWakeupContext } from '../../../memory/wakeup.js';
 import { readContinueCheckpoint } from '../../../session/checkpoint-block.js';
+import { sessionRoutingPath } from '../lib/pai-paths.js';
 import {
-  PAI_DIR,
   findNotesDir,
   getProjectDir,
   getCurrentNotePath,
@@ -62,7 +62,7 @@ function findPaiBinary(): string {
  * Returns the routed Notes path if set, or null to use default behavior.
  */
 function getRoutedNotesPath(): string | null {
-  const routingFile = join(PAI_DIR, 'session-routing.json');
+  const routingFile = sessionRoutingPath();
   if (!existsSync(routingFile)) return null;
 
   try {

package/src/hooks/ts/session-start/mcp-deferred-reminder.ts

@@ -16,8 +16,10 @@
  */
 
 import { decideMcpDeferredReminder, type ReminderHookInput } from "../lib/mcp-deferred-reminder.js";
+import { isWorkerSession } from "../lib/worker-session.js";
 
 async function main() {
+  if (isWorkerSession()) return; // disposable worker: no per-session bookkeeping
   let input: ReminderHookInput = {};
 
   try {

package/src/hooks/ts/session-start/session-commands.ts

@@ -10,6 +10,10 @@
  * even when the full CORE skill gets truncated.
  */
 
+import { isWorkerSession } from "../lib/worker-session.js";
+
+if (isWorkerSession()) process.exit(0); // disposable worker: no per-session bookkeeping
+
 const commands = `<system-reminder>
 SESSION COMMANDS (always available):
 

package/src/hooks/ts/session-start/session-start-worker-guard.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { execFileSync } from "node:child_process";
+
+// Every SessionStart hook entrypoint calls main() unconditionally at module
+// scope and (for most of them) blocks reading fd 0 — importing them in-process
+// would run that read against the test runner's own stdin and hang the suite.
+// Each case below runs the entrypoint as a real subprocess with its own piped
+// stdin and env, exactly like production invocation (see
+// user-prompt/whisper-rules.test.ts for the same pattern).
+describe("session-start hooks: worker sessions get no injected context", () => {
+  const HOOKS = [
+    "src/hooks/ts/session-start/initialize-session.ts",
+    "src/hooks/ts/session-start/inject-observations.ts",
+    "src/hooks/ts/session-start/load-core-context.ts",
+    "src/hooks/ts/session-start/load-project-context.ts",
+    "src/hooks/ts/session-start/mcp-deferred-reminder.ts",
+    "src/hooks/ts/session-start/post-compact-inject.ts",
+    "src/hooks/ts/session-start/session-commands.ts",
+  ];
+
+  function runHook(entrypoint: string, env: NodeJS.ProcessEnv): string {
+    return execFileSync("bun", [entrypoint], {
+      input: JSON.stringify({ session_id: "t", hook_event_name: "SessionStart", source: "startup" }),
+      encoding: "utf8",
+      timeout: 15_000,
+      env: { ...process.env, ...env },
+    });
+  }
+
+  for (const entrypoint of HOOKS) {
+    it(`${entrypoint} prints nothing when PAI_WORKER=1`, () => {
+      const stdout = runHook(entrypoint, { PAI_WORKER: "1" });
+      expect(stdout).toBe("");
+    });
+  }
+});

package/src/hooks/ts/stop/stop-hook.ts

@@ -16,6 +16,7 @@ import {
   updateTodoContinue, sessionIdFromTranscript,
   WorkItem
 } from '../lib/project-utils';
+import { paiHomePath, sessionStateDir } from '../../../config/pai-files.js';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -57,20 +58,13 @@ const AUTO_SAVE_INTERVAL = (() => {
 // Session-state helpers (mid-session auto-save)
 // ---------------------------------------------------------------------------
 
-const SESSION_STATE_DIR = join(
-  process.env.HOME ?? '/tmp',
-  '.config',
-  'pai',
-  'session-state'
-);
-
 interface SessionState {
   humanMessageCount: number;
 }
 
 function readSessionState(sessionId: string): SessionState {
   try {
-    const stateFile = join(SESSION_STATE_DIR, `${sessionId}.json`);
+    const stateFile = join(sessionStateDir(), `${sessionId}.json`);
     if (!existsSync(stateFile)) return { humanMessageCount: 0 };
     const raw = readFileSync(stateFile, 'utf-8');
     const parsed = JSON.parse(raw) as Partial<SessionState>;
@@ -84,8 +78,9 @@ function readSessionState(sessionId: string): SessionState {
 
 function writeSessionState(sessionId: string, state: SessionState): void {
   try {
-    mkdirSync(SESSION_STATE_DIR, { recursive: true });
-    const stateFile = join(SESSION_STATE_DIR, `${sessionId}.json`);
+    const dir = paiHomePath('session-state');
+    mkdirSync(dir, { recursive: true });
+    const stateFile = join(dir, `${sessionId}.json`);
     writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf-8');
   } catch (e) {
     console.error(`STOP-HOOK: Could not write session state: ${e}`);
@@ -94,7 +89,7 @@ function writeSessionState(sessionId: string, state: SessionState): void {
 
 function deleteSessionState(sessionId: string): void {
   try {
-    const stateFile = join(SESSION_STATE_DIR, `${sessionId}.json`);
+    const stateFile = join(sessionStateDir(), `${sessionId}.json`);
     if (existsSync(stateFile)) {
       unlinkSync(stateFile);
     }

package/src/hooks/ts/user-prompt/whisper-rules.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from "vitest";
+import { execFileSync } from "node:child_process";
+
+// whisper-rules.ts calls main() unconditionally at module scope (it's a hook
+// entrypoint, always run as a subprocess) — including a blocking read of fd 0.
+// Importing it in-process here would run that read against the test runner's
+// own stdin and hang the suite, so every case below goes through a real
+// subprocess with its own piped stdin, exactly like production invocation.
+describe("user-prompt/whisper-rules entrypoint", () => {
+  const ENTRYPOINT = "src/hooks/ts/user-prompt/whisper-rules.ts";
+
+  function runHook(stdin: string): string {
+    return execFileSync("bun", [ENTRYPOINT], {
+      input: stdin,
+      encoding: "utf8",
+      timeout: 15_000,
+    });
+  }
+
+  it("emits nothing for a worker-completion relay prompt", () => {
+    const stdout = runHook(JSON.stringify({ prompt: "[Session:x] worker y finished" }));
+    expect(stdout).toBe("");
+  });
+
+  it("emits nothing for a clickr control-handover line", () => {
+    const stdout = runHook(JSON.stringify({ prompt: "your controls." }));
+    expect(stdout).toBe("");
+  });
+
+  it("emits nothing for a harness [SYSTEM NOTIFICATION preamble", () => {
+    const stdout = runHook(
+      JSON.stringify({ prompt: "[SYSTEM NOTIFICATION - NOT USER INPUT]\nfoo" })
+    );
+    expect(stdout).toBe("");
+  });
+
+  it("emits nothing for a background task completion carrying <task-notification>", () => {
+    const stdout = runHook(
+      JSON.stringify({ prompt: "foo <task-notification>x</task-notification>" })
+    );
+    expect(stdout).toBe("");
+  });
+
+  it("still injects the system-reminder block for a normal prompt", () => {
+    const stdout = runHook(JSON.stringify({ prompt: "please fix the login bug" }));
+    expect(stdout).toContain("<system-reminder>");
+    expect(stdout).toContain("CURRENT LOCAL TIME");
+  });
+});

package/src/hooks/ts/user-prompt/whisper-rules.ts

@@ -4,8 +4,8 @@
  * whisper-rules.ts
  *
  * UserPromptSubmit hook that injects:
- * 1. User-defined whisper rules from ~/.claude/whisper-rules.md
- * 2. Budget-aware model tiering guidance from ~/.claude/advisor-mode.json
+ * 1. User-defined whisper rules from ~/.claude/pai/whisper-rules.md
+ * 2. Budget-aware model tiering guidance from ~/.claude/pai/advisor-mode.json
  *
  * The advisor mode implements the "advisor strategy" pattern:
  * - Normal (budget < 70%): use any model freely
@@ -13,16 +13,25 @@
  * - Strict (85-95%): haiku only for subagents, main context stays on current model
  * - Critical (>95%): minimize all subagent spawning, essential work only
  *
- * Budget percentage is written by the statusline or manually to advisor-mode.json.
- * If the file doesn't exist, no advisor guidance is injected.
+ * Budget percentage is written by the statusline or manually to advisor-mode.json,
+ * stamped with the epoch second it was read. If the file doesn't exist, or its
+ * reading is too old to still describe the current window, no advisor guidance
+ * is injected — see lib/advisor-budget.ts for why that direction is the safe one.
  */
 
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { homedir, tmpdir } from "node:os";
+import { tmpdir } from "node:os";
+import { resolveAdvisorMode, type AdvisorConfig } from "../lib/advisor-budget.js";
+import { whisperRulesPath, advisorModePath } from "../../../config/pai-files.js";
 
-const WHISPER_FILE = join(homedir(), ".claude", "whisper-rules.md");
-const ADVISOR_FILE = join(homedir(), ".claude", "advisor-mode.json");
+const WHISPER_FILE = whisperRulesPath();
+const ADVISOR_FILE = advisorModePath();
+
+/** A "# N. TITLE" section header: the start of a new section, tag reset. */
+function isSectionHeader(line: string): boolean {
+  return /^#\s*\d+\.\s/.test(line);
+}
 
 /**
  * Read the rule file, dropping everything that is there for the author rather
@@ -35,28 +44,42 @@ const ADVISOR_FILE = join(homedir(), ".claude", "advisor-mode.json");
  * maintainable, and none of it reaches the prompt. Only the rules do.
  *
  * A line whose rule text legitimately starts with "#" can be escaped as "\\#".
+ *
+ * Section tags: this file is injected into every claude process, spawned
+ * workers included, and some rules (e.g. "delegate to workers") are true only
+ * for the interactive orchestrating session. A comment line "# @orchestrator"
+ * marks every following rule as orchestrator-only, "# @worker" marks
+ * worker-only, until the next "# N. TITLE" section header resets the tag (a
+ * section's own header/divider box, which the tag line sits inside, does not
+ * count as the next section). An untagged section reaches both. `isWorker`
+ * selects which side of the tag this process is on — see PAI_WORKER in
+ * run-env.ts.
  */
-function getWhisperRules(): string {
+function getWhisperRules(isWorker: boolean): string {
   if (!existsSync(WHISPER_FILE)) return "";
   try {
-    return readFileSync(WHISPER_FILE, "utf-8")
-      .split("\n")
-      .map((l) => l.trim())
-      .filter((l) => l.length > 0 && !l.startsWith("#"))
-      .map((l) => (l.startsWith("\\#") ? l.slice(1) : l))
-      .join("\n")
-      .trim();
+    const lines = readFileSync(WHISPER_FILE, "utf-8").split("\n");
+    const out: string[] = [];
+    let tag: "orchestrator" | "worker" | null = null;
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (line.length === 0) continue;
+      if (line.startsWith("#")) {
+        if (isSectionHeader(line)) tag = null;
+        else if (line === "# @orchestrator") tag = "orchestrator";
+        else if (line === "# @worker") tag = "worker";
+        continue;
+      }
+      if (tag === "orchestrator" && isWorker) continue;
+      if (tag === "worker" && !isWorker) continue;
+      out.push(line.startsWith("\\#") ? line.slice(1) : line);
+    }
+    return out.join("\n").trim();
   } catch {
     return "";
   }
 }
 
-interface AdvisorConfig {
-  weeklyBudgetPercent?: number;  // 0-100, written by statusline or manually
-  mode?: "normal" | "conservative" | "strict" | "critical" | "auto";
-  forceModel?: string;  // override: always use this model for subagents
-}
-
 function getAdvisorGuidance(): string {
   if (!existsSync(ADVISOR_FILE)) return "";
 
@@ -67,24 +90,12 @@ function getAdvisorGuidance(): string {
     return "";
   }
 
-  // Determine mode.
-  //
-  // `??` only substitutes on null/undefined, so a config written as
-  // {"mode": ""} — which is what the statusline produces when it has no manual
-  // override — left mode as the empty string. That matched no case below, so
-  // the advisor silently returned nothing regardless of budget. A budget guard
-  // that quietly does nothing is worse than none, because you believe you have
-  // one. Treat anything that is not a recognised mode as "auto".
-  const VALID = ["normal", "conservative", "strict", "critical", "auto"] as const;
-  let mode: string =
-    config.mode && (VALID as readonly string[]).includes(config.mode) ? config.mode : "auto";
-  if (mode === "auto" && typeof config.weeklyBudgetPercent === "number") {
-    const pct = config.weeklyBudgetPercent;
-    if (pct < 60) mode = "normal";
-    else if (pct < 80) mode = "conservative";
-    else if (pct < 92) mode = "strict";
-    else mode = "critical";
-  }
+  // Determine mode: the manual one if set, else derived from a budget reading
+  // that is current. No current reading and no manual mode means say nothing —
+  // guessing is how a wrong number gets obeyed for a day and a half. See
+  // lib/advisor-budget.ts.
+  const { mode, percent: pct } = resolveAdvisorMode(config, Math.floor(Date.now() / 1000));
+  if (mode === undefined) return "";
 
   // Force model override
   if (config.forceModel) {
@@ -97,7 +108,7 @@ function getAdvisorGuidance(): string {
 
     case "conservative":
       return [
-        `ADVISOR MODE (conservative — weekly budget at ${config.weeklyBudgetPercent ?? "?"}%):`,
+        `ADVISOR MODE (conservative — weekly budget at ${pct ?? "?"}%):`,
         "Main context is opus (most expensive — 20x haiku, 5x sonnet). Delegate aggressively to subagents.",
         "Default subagents to SONNET (Agent tool, model: sonnet). Use haiku for simple lookups/verification.",
         "For substantial tasks, use swarm mode: spawn a sonnet orchestrator that delegates to haiku workers.",
@@ -106,7 +117,7 @@ function getAdvisorGuidance(): string {
 
     case "strict":
       return [
-        `ADVISOR MODE (strict — weekly budget at ${config.weeklyBudgetPercent ?? "?"}%):`,
+        `ADVISOR MODE (strict — weekly budget at ${pct ?? "?"}%):`,
         "Main context is opus (most expensive — 20x haiku, 5x sonnet). Minimize work done here.",
         "Default subagents to SONNET (Agent tool, model: sonnet) for implementation and research. Use haiku for simple tasks.",
         "For any substantial task, use swarm mode: spawn ONE sonnet orchestrator that delegates to haiku workers.",
@@ -116,7 +127,7 @@ function getAdvisorGuidance(): string {
 
     case "critical":
       return [
-        `ADVISOR MODE (critical — weekly budget at ${config.weeklyBudgetPercent ?? "?"}%):`,
+        `ADVISOR MODE (critical — weekly budget at ${pct ?? "?"}%):`,
         "MINIMIZE ALL TOKEN USAGE. Main context is opus — the most expensive model (20x haiku, 5x sonnet).",
         "For ANY non-trivial task, immediately spawn a sonnet orchestrator agent and let it handle everything.",
         "Main context should only send the task and receive the final result — do not do work here.",
@@ -153,24 +164,54 @@ function currentLocalTime(): string {
  * true after the first turn — a reminder that misstates its own trigger is one
  * the reader learns to discount.
  */
-function resetReinjectCounter(): void {
+function resetReinjectCounter(sessionId: string): void {
   try {
-    const raw = readFileSync(0, "utf-8");
-    const sessionId = raw.trim() ? (JSON.parse(raw) as { session_id?: string }).session_id ?? "" : "";
     const safe = sessionId.replace(/[^A-Za-z0-9_-]/g, "") || "nosession";
     const f = join(tmpdir(), "pai-whisper-reinject", `${safe}.count`);
     if (existsSync(f)) unlinkSync(f);
   } catch { /* best effort — a stale count is not worth failing the hook over */ }
 }
 
+/**
+ * True for prompts this hook never authored a human at the keyboard: a
+ * worker-completion relay ("[Session: …] worker … finished …"), a clickr
+ * control-handover line ("your controls." / "my controls."), or a harness
+ * notification (a "[SYSTEM NOTIFICATION" preamble, or a background task
+ * completion carrying a <task-notification> block). All of these fire
+ * several times per turn during worker-heavy work, so injecting the ~5KB rule
+ * block on each one was landing it 3-5 times in a single turn.
+ */
+export function isRelayedPrompt(prompt: string): boolean {
+  return (
+    /^\s*\[Session:[^\]]+\]/.test(prompt) ||
+    /^\s*(your|my) controls\b/i.test(prompt) ||
+    /^\s*\[SYSTEM NOTIFICATION/.test(prompt) ||
+    prompt.includes("<task-notification>")
+  );
+}
+
 function main() {
-  resetReinjectCounter();
+  let sessionId = "";
+  let prompt = "";
+  try {
+    const raw = readFileSync(0, "utf-8");
+    if (raw.trim()) {
+      const input = JSON.parse(raw) as { session_id?: string; prompt?: string };
+      sessionId = input.session_id ?? "";
+      prompt = input.prompt ?? "";
+    }
+  } catch { /* malformed/empty stdin — treat as no session, no prompt */ }
+
+  resetReinjectCounter(sessionId);
+
+  if (isRelayedPrompt(prompt)) return;
 
+  const isWorker = process.env.PAI_WORKER === "1";
   const parts: string[] = [];
 
   parts.push(`CURRENT LOCAL TIME: ${currentLocalTime()} — use this verbatim for any [YYYY-MM-DD HH:MM] stamp; never estimate or increment it.`);
 
-  const rules = getWhisperRules();
+  const rules = getWhisperRules(isWorker);
   if (rules) parts.push(rules);
 
   const advisor = getAdvisorGuidance();