@tekmidian/pai 0.42.5 → 0.43.0

package/src/hooks/ts/pre-tool-use/route-edits-to-worker.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+/**
+ * route-edits-to-worker.ts — PreToolUse (Edit|MultiEdit|Write)
+ *
+ * The outer orchestrator session does not edit code files; code changes go
+ * through `pai worker run`. Allowed through silently:
+ *   - worker sessions (the runner sets PAI_WORKER=1)
+ *   - paths outside any git work tree
+ *   - the exempt scratch prefixes (.claude incl. memory dirs, the local
+ *     notes/tasks/scratchpad dirs, the OS temp dir)
+ *   - prose: notes, session logs, handovers — see lib/edit-gate.ts isProseEdit
+ * Everything else inside a git work tree is blocked with the worker command.
+ *
+ * This file is only I/O: read stdin, resolve the path, ask lib/edit-gate for
+ * the decision, print it. The decision itself lives in lib/edit-gate.ts and
+ * is tested there.
+ */
+
+import { existsSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { decideEditGate, type EditGateContext } from "../lib/edit-gate.js";
+
+function isUnder(p: string, prefix: string): boolean {
+  return p === prefix || p.startsWith(prefix + sep);
+}
+
+// A .git entry in any ancestor marks a git work tree (.git is a directory in
+// a normal repo, a file in a linked worktree — existsSync covers both).
+function inGitWorkTree(p: string): boolean {
+  let dir = resolve(p);
+  for (;;) {
+    if (existsSync(join(dir, ".git"))) return true;
+    const parent = dirname(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+
+function exemptPrefixes(): string[] {
+  const home = homedir();
+  return [
+    join(home, ".claude"),
+    join(home, "colibri", "Notes"),
+    join(home, "colibri", "tasks"),
+    join(home, "colibri", "scratchpad"),
+    tmpdir(),
+    "/tmp",
+  ];
+}
+
+function allow(): void {
+  process.exit(0);
+}
+
+function block(reason: string): void {
+  process.stdout.write(JSON.stringify({ decision: "block", reason }) + "\n");
+  process.exit(0);
+}
+
+async function main(): Promise<void> {
+  let text = "";
+  try {
+    for await (const chunk of process.stdin) text += chunk;
+  } catch {
+    return allow();
+  }
+  if (!text.trim()) return allow();
+
+  let input: { cwd?: string; tool_input?: { file_path?: string } };
+  try {
+    input = JSON.parse(text);
+  } catch {
+    return allow();
+  }
+
+  const filePath =
+    input.tool_input && typeof input.tool_input.file_path === "string" ? input.tool_input.file_path : "";
+  if (!filePath) return allow();
+
+  const abs = resolve(input.cwd ?? process.cwd(), filePath);
+
+  const ctx: EditGateContext = {
+    filePath: abs,
+    isPaiWorker: process.env.PAI_WORKER === "1",
+    isExemptPrefix: exemptPrefixes().some((p) => isUnder(abs, p)),
+    isGitWorkTree: inGitWorkTree(abs),
+  };
+
+  const decision = decideEditGate(ctx);
+  if (decision.decision === "block") return block(decision.reason);
+  return allow();
+}
+
+main().catch(() => process.exit(0));

package/src/hooks/ts/pre-tool-use/security-validator.ts

@@ -19,6 +19,7 @@
 
 import { appendFileSync, mkdirSync, existsSync } from 'fs';
 import { dirname } from 'path';
+import { securityEventsPath } from '../lib/pai-paths.js';
 
 // ============================================================================
 // ATTACK PATTERNS - CUSTOMIZE THESE FOR YOUR ENVIRONMENT
@@ -130,7 +131,7 @@ function detectAttack(content: string): DetectionResult {
 // ============================================================================
 
 function logSecurityEvent(event: Record<string, unknown>): void {
-  const logPath = `${process.env.PAI_DIR || '~/.claude'}/history/security/security-events.jsonl`;
+  const logPath = securityEventsPath();
   const entry = JSON.stringify({ timestamp: new Date().toISOString(), ...event }) + '\n';
 
   try {

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");
+  });
+});