@tekmidian/pai 0.64.0 → 0.65.0

package/src/hooks/ts/lib/pai-paths-import.test.ts

@@ -0,0 +1,25 @@
+/**
+ * Importing the shared path module must never exit the host process, even on
+ * a fresh machine with no ~/.claude — `pai setup` is what creates it.
+ */
+
+import { it, expect } from "vitest";
+import { mkdtempSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+it("importing pai-paths with an empty HOME does not exit", () => {
+  const home = mkdtempSync(join(tmpdir(), "pai-paths-import-"));
+  const env: NodeJS.ProcessEnv = { ...process.env, HOME: home };
+  delete env.PAI_DIR;
+  delete env.ADAPTER_DIR;
+  const r = spawnSync(
+    process.execPath,
+    ["--import", "tsx", "-e", "await import('./src/hooks/ts/lib/pai-paths.ts'); console.log('ok')"],
+    { env, encoding: "utf8" },
+  );
+  expect(r.stderr).not.toContain("not found");
+  expect(r.stdout.trim()).toBe("ok");
+  expect(r.status).toBe(0);
+});

package/src/hooks/ts/lib/pai-paths.ts

@@ -6,8 +6,8 @@
  * Two different things live here, and they must not be confused:
  *
  * - ADAPTER_DIR (~/.claude by default) is the Claude Code harness adapter —
- *   fixed, hardcoded paths the harness itself loads from (Hooks/, Skills/,
- *   Agents/, Commands/, settings.json, statusline-command.sh,
+ *   fixed, hardcoded paths the harness itself loads from (Hooks/, skills/,
+ *   agents/, commands/, settings.json, statusline-command.sh,
  *   tab-color-command.sh). It is harness-specific: a future harness would
  *   need its own adapter directory with its own conventions.
  * - PAI_HOME (~/.claude/pai by default — see ../../../config/pai-home.ts) is
@@ -165,32 +165,9 @@ export const PAI_DIR = ADAPTER_DIR;
  * from. These stay under ADAPTER_DIR; they are not PAI state.
  */
 export const HOOKS_DIR = join(ADAPTER_DIR, 'Hooks');
-export const SKILLS_DIR = join(ADAPTER_DIR, 'Skills');
-export const AGENTS_DIR = join(ADAPTER_DIR, 'Agents');
-export const COMMANDS_DIR = join(ADAPTER_DIR, 'Commands');
-
-/**
- * Validate PAI directory structure on first import
- * This fails fast with a clear error if PAI is misconfigured
- */
-function validatePAIStructure(): void {
-  if (!existsSync(ADAPTER_DIR)) {
-    console.error(`ADAPTER_DIR does not exist: ${ADAPTER_DIR}`);
-    console.error(`   Expected ~/.claude or set ADAPTER_DIR environment variable`);
-    process.exit(1);
-  }
-
-  if (!existsSync(HOOKS_DIR)) {
-    console.error(`PAI hooks directory not found: ${HOOKS_DIR}`);
-    console.error(`   Your ADAPTER_DIR may be misconfigured`);
-    console.error(`   Current ADAPTER_DIR: ${ADAPTER_DIR}`);
-    process.exit(1);
-  }
-}
-
-// Run validation on module import
-// This ensures any hook that imports this module will fail fast if paths are wrong
-validatePAIStructure();
+export const SKILLS_DIR = join(ADAPTER_DIR, 'skills');
+export const AGENTS_DIR = join(ADAPTER_DIR, 'agents');
+export const COMMANDS_DIR = join(ADAPTER_DIR, 'commands');
 
 // ---------------------------------------------------------------------------
 // PAI state written by hooks — resolves under PAI_HOME, falling back to the

package/src/hooks/ts/lib/sleep-poll-gate.test.ts

@@ -52,11 +52,27 @@ describe("sleep-poll gate", () => {
   it("worker session (PAI_WORKER=1): deny reason points at a foreground timeout and a kill -0 loop instead", () => {
     const out = decisionOf(bash("sleep 590"), { PAI_WORKER: "1" });
     expect(out.permissionDecisionReason).toContain("FOREGROUND with a Bash timeout up to 600000 ms");
-    expect(out.permissionDecisionReason).toContain("while kill -0 <pid> 2>/dev/null; do sleep 15; done");
     expect(out.permissionDecisionReason).not.toContain("run_in_background: true");
   });
 
   it("names the exact offending duration in the reason", () => {
     expect(decisionOf(bash("sleep 2m")).permissionDecisionReason).toContain("sleep 120s blocked");
   });
+
+  it("sums sleeps across one command", () => {
+    for (const cmd of ["sleep 58; sleep 58", "sleep 30 && sleep 30", "sleep 1m\nsleep 1", "sleep 0.5m; sleep 31", "for i in 1 2 3; do sleep 30; done", "until false; do sleep 5; done"]) {
+      expect(decisionOf(bash(cmd)).permissionDecision, cmd).toBe("deny");
+    }
+    for (const cmd of ["sleep 30; sleep 20", "for i in 1 2; do sleep 20; done", "for i in {1..3}; do sleep 10; done", "while kill -0 123 2>/dev/null; do sleep 15; done"]) {
+      expect(decisionOf(bash(cmd)).permissionDecision, cmd).toBe("allow");
+    }
+  });
+
+  it("worker: run_in_background is denied with foreground advice; interactive keeps it", () => {
+    const out = decisionOf(bash("npm test", true), { PAI_WORKER: "1" });
+    expect(out.permissionDecision).toBe("deny");
+    expect(out.permissionDecisionReason).toContain("FOREGROUND");
+    expect(decisionOf(bash("npm test", true), {}).permissionDecision).toBe("allow");
+    expect(decisionOf(bash("npm test", false), { PAI_WORKER: "1" }).permissionDecision).toBe("allow");
+  });
 });

package/src/hooks/ts/lib/sleep-poll-gate.ts

@@ -6,12 +6,12 @@
  * same split as lib/agent-gate.ts and lib/edit-gate.ts.
  *
  * CLAUDE.md already says "never sleep-poll"; prose does not enforce it, a
- * PreToolUse deny does. `run_in_background: true` is always allowed — a
+ * PreToolUse deny does. `run_in_background: true` is allowed in an interactive session (denied in a worker) — a
  * backgrounded sleep blocks nothing, it is the harness's own long-command
  * pattern.
  */
 
-import { longestSleepSecs } from "../../../workers/status.js";
+import { SLEEP_FLOOR_SECS, totalSleepSecs } from "../../../workers/status.js";
 
 export interface SleepPollGateInput {
   tool_name?: string;
@@ -32,9 +32,8 @@ export function denyReason(secs: number, isWorker: boolean): string {
   if (isWorker) {
     return (
       lead +
-      "In a worker, run the long command in the FOREGROUND with a Bash timeout up to 600000 ms. " +
-      "If it can run longer, start it in the background and wait with a foreground loop that ends " +
-      "when the job ends: while kill -0 <pid> 2>/dev/null; do sleep 15; done"
+      "In a worker, run the long command in the FOREGROUND with a Bash timeout up to 600000 ms " +
+        "and split longer jobs into steps; run_in_background is denied here."
     );
   }
   return (
@@ -44,20 +43,33 @@ export function denyReason(secs: number, isWorker: boolean): string {
   );
 }
 
+/**
+ * A headless worker (`claude -p`) has no re-invocation: ending its turn ends
+ * the process and kills the background job, whatever it says about waiting for
+ * a completion notification.
+ */
+const BACKGROUND_WORKER_REASON =
+  "run_in_background is blocked in a worker: ending your turn ends this process and kills the job, " +
+  "there is no completion notification. Run the command in the FOREGROUND with a Bash timeout up to " +
+  "600000 ms, and split a longer job into steps that each fit in that.";
+
 export function decideSleepPollGate(
   input: SleepPollGateInput,
   env: Record<string, string | undefined>
 ): GateDecision {
   if (input.tool_name && input.tool_name !== "Bash") return { decision: "allow" };
-  if (input.tool_input?.run_in_background === true) return { decision: "allow" };
+  const isWorker = env.PAI_WORKER === "1";
+  if (input.tool_input?.run_in_background === true) {
+    return isWorker ? { decision: "deny", reason: BACKGROUND_WORKER_REASON } : { decision: "allow" };
+  }
 
   const command = input.tool_input?.command;
   if (typeof command !== "string") return { decision: "allow" };
 
-  const secs = longestSleepSecs(command);
-  if (secs === null) return { decision: "allow" };
+  const secs = totalSleepSecs(command);
+  if (secs < SLEEP_FLOOR_SECS) return { decision: "allow" };
 
-  return { decision: "deny", reason: denyReason(secs, env.PAI_WORKER === "1") };
+  return { decision: "deny", reason: denyReason(secs, isWorker) };
 }
 
 /** Render a decision as the JSON the harness reads on the hook's stdout. */

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

@@ -55,12 +55,8 @@ async function main() {
     // Get CORE skill path using PAI paths library
     const coreSkillPath = join(SKILLS_DIR, 'CORE/SKILL.md');
 
-    // 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 ADAPTER_DIR environment variable`);
-      process.exit(1);
-    }
+    // CORE is an optional, user-provided skill (PAI ships none): absent = silent no-op
+    if (!existsSync(coreSkillPath)) process.exit(0);
 
     console.error('Reading CORE context from skill file...');
 

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

@@ -1,5 +1,8 @@
 import { describe, it, expect } from "vitest";
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 // Every SessionStart hook entrypoint calls main() unconditionally at module
 // scope and (for most of them) blocks reading fd 0 — importing them in-process
@@ -46,3 +49,23 @@ describe("session-start hooks: worker sessions get no injected context", () => {
     expect(stdout).not.toContain("Edit/Write on code files is denied");
   });
 });
+
+describe("load-core-context.ts: CORE is optional", () => {
+  it("exits 0 with empty stdout/stderr when ~/.claude/skills/CORE/SKILL.md is absent", () => {
+    const home = mkdtempSync(join(tmpdir(), "pai-core-"));
+    try {
+      mkdirSync(join(home, ".claude", "skills"), { recursive: true });
+      const r = spawnSync("bun", ["src/hooks/ts/session-start/load-core-context.ts"], {
+        input: JSON.stringify({ session_id: "t", hook_event_name: "SessionStart", source: "startup" }),
+        encoding: "utf8",
+        timeout: 15_000,
+        env: { ...process.env, HOME: home, ADAPTER_DIR: "", PAI_DIR: "", PAI_WORKER: "" },
+      });
+      expect(r.status).toBe(0);
+      expect(r.stdout).toBe("");
+      expect(r.stderr).not.toContain("CORE skill not found");
+    } finally {
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+});