@tekmidian/pai 0.66.6 → 0.66.8

package/docs/commands/memory.md

@@ -20,6 +20,8 @@ pai memory <subcommand> [options]
 | [`pai memory status [project-slug]`](#pai-memory-status-project-slug) | Show memory index statistics |
 | [`pai memory settings [key] [value]`](#pai-memory-settings-key-value) | View or modify search settings in the PAI config file (`pai config path`) |
 | [`pai memory sources`](#pai-memory-sources) | Show what the indexer has taken in: composition by source, which roots |
+| [`pai memory backend`](#pai-memory-backend) | Embedding backends: detect, use, provision (an index is bound to the backend that embedded it) |
+| [`pai memory reembed`](#pai-memory-reembed) | Switch the index to an embedding backend: clears all vectors (batched, resumable); `pai memory embed` refills |
 
 ### pai memory index [project-slug]
 
@@ -118,6 +120,56 @@ rewritten per day (which distinguishes a finite backlog from a treadmill).
 | `--limit <n>` | Rows per section (default 8) | `8` |
 
 
+### pai memory backend
+
+Embedding backends: detect, use, provision (an index is bound to the backend that embedded it)
+
+
+### pai memory backend detect
+
+Probe the available embedding backends (ollama, then transformers-cpu) and recommend the fastest
+
+
+### pai memory backend use <id>
+
+Write the embedding backend to config (ollama-f16 | transformers-cpu-q8); does not touch the index
+
+**Arguments**
+
+| Argument | Kind |
+|----------|------|
+| `<id>` | required |
+
+**Options**
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--model <name>` | Model name on the backend (ollama: server-side model name) |  |
+
+
+### pai memory backend provision <backend>
+
+Provision a backend's model. ollama: download the F16 GGUF of arctic-embed-m-v1.5 and `ollama create` it
+
+**Arguments**
+
+| Argument | Kind |
+|----------|------|
+| `<backend>` | required |
+
+
+### pai memory reembed
+
+Switch the index to an embedding backend: clears all vectors (batched, resumable); `pai memory embed` refills
+
+**Options**
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--backend <id>` | Target backend (default: the configured one); also written to config |  |
+| `--yes` | Confirm; without it only the plan is printed |  |
+
+
 ## Examples
 
 ```bash

package/docs/commands/worker.md

@@ -31,6 +31,7 @@ pai worker <subcommand> [options]
 | [`pai worker handoff <json>`](#pai-worker-handoff-json) | From inside a worker: append a handoff to the parent's inbox and (when it runs) say it to the parent. |
 | [`pai worker merge <id>`](#pai-worker-merge-id) | Merge a worker's worktree branch (worker/<id>) into the original checkout, then remove the worktree and delete the branch |
 | [`pai worker verify <id>`](#pai-worker-verify-id) | Compare a worker's committed changes with the working tree (or --against <ref>); exit 0 when every file is identical, so discarding is safe. Also reads an archived worker (refs/pai-archive/<id>) |
+| [`pai worker wait-on <pid>`](#pai-worker-wait-on-pid) | Wait at most --max seconds (default 110, cap 115) for a detached job's pid; exit 0 gone, 3 still running, 2 never existed. |
 | [`pai worker wait <ids...>`](#pai-worker-wait-ids) | Poll workers until they finish; prints each result as one JSON line, exit 1 on failure or timeout |
 | [`pai worker discard <id>`](#pai-worker-discard-id) | Drop a worker's worktree and branch, keeping nothing |
 | [`pai worker gc`](#pai-worker-gc) | Archive leftover worker worktrees (state kept under refs/pai-archive/<id>; gitignored files are not kept) |
@@ -276,6 +277,27 @@ Compare a worker's committed changes with the working tree (or --against <ref>);
 | `--json` | print the result as JSON |  |
 
 
+### pai worker wait-on <pid>
+
+Wait at most --max seconds (default 110, cap 115) for a detached job's pid; exit 0 gone, 3 still running, 2 never existed.
+
+Recipe: nohup sh -c 'CMD; echo $? > /tmp/job.rc' > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid ; then repeat `pai worker wait-on $(cat /tmp/job.pid) --log /tmp/job.log` until exit 0.
+
+**Arguments**
+
+| Argument | Kind |
+|----------|------|
+| `<pid>` | required |
+
+**Options**
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--log <file>` | Log file whose last lines are printed on return; <file>.rc holds the exit code |  |
+| `--max <secs>` | Maximum seconds to block (default 110, hard cap 115) |  |
+| `--tail <n>` | Log lines printed on return (default 20) |  |
+
+
 ### pai worker wait <ids...>
 
 Poll workers until they finish; prints each result as one JSON line, exit 1 on failure or timeout

package/docs/install-linux.md

@@ -24,6 +24,7 @@ pai setup --yes --storage sqlite
 sudo apt install -y docker.io docker-compose-v2
 sudo usermod -aG docker "$USER"                  # then log out and in, or prefix the next command with: sg docker -c "…"
 export PAI_PG_SHARED_BUFFERS=256MB               # only on small machines; the default 1GB must fit in RAM
+export PAI_PG_SHM_SIZE=3g                        # optional; shared memory for parallel vector index builds (3g is the default)
 pai setup --yes --storage postgres
 ```
 

package/docs/memory.md

@@ -94,3 +94,72 @@ Every chunk row carries a `last_accessed_at` timestamp updated on each `memory_g
 ### Multi-Tenant Support
 
 PAI isolates memory by project. Every chunk, entity, and observation row carries a `project_id` foreign key. Searches default to the current project; the `all_projects: true` flag (or `--all` CLI option) lifts the filter. Knowledge-graph triples carry a `project_id` as well, so cross-project tunnels (`memory_tunnels`) are detected explicitly rather than accidentally.
+
+## Embedding Backends
+
+Semantic search needs vectors. PAI embeds with `Snowflake/snowflake-arctic-embed-m-v1.5` (768 dims, CLS pooling, L2-normalized, 512-token context) and can run it on two backends:
+
+| id | what it is | speed (Apple M5) |
+|----|------------|------------------|
+| `transformers-cpu-q8` | in-process transformers.js, q8, CPU. Default, no server. | ~8 chunks/s |
+| `ollama-f16` | local Ollama server (Metal GPU), F16 GGUF of the same model | ~50 chunks/s |
+
+Both live behind one contract (`src/memory/backends/types.ts`: `id`, `model`, `dims`, `maxTokens`, `available()`, `embed()`); the daemon embed pass, `pai memory embed [--background]` and query embedding in search all go through the configured backend. A remote `http` backend (for example an MLX server) is a future addition behind the same contract.
+
+### Commands
+
+```
+pai memory backend detect                 # probe ollama, then transformers-cpu; recommend the fastest available
+pai memory backend provision ollama       # download the F16 GGUF from Hugging Face and `ollama create` it
+pai memory backend use <id> [--model <n>] # write embedding.backend (and embedding.model) to config
+pai memory reembed [--backend <id>] [--yes]
+```
+
+`pai setup` runs the same detection (also with `--yes`). A fresh install adopts the fastest available backend; an existing install is only told what is available.
+
+- **provision** is idempotent (skipped when the model exists on the server), needs no sudo, verifies the download's size and SHA-256, and imports it under the configured model name (default `arctic-embed-m-v1.5-f16`).
+- **reembed** prints the chunk count and an ETA from a quick throughput probe and refuses without `--yes`. It sets every stored vector to NULL in bounded batches (never one giant transaction; an interrupted run is resumed by running it again), then records the new binding. `pai memory embed` or the daemon pass refills the vectors; keyword search keeps working meanwhile.
+
+Config (`pai config get embedding`):
+
+```yaml
+embedding:
+  backend: ollama-f16            # default: transformers-cpu-q8
+  model: arctic-embed-m-v1.5-f16 # model name on the Ollama server
+  ollama:
+    baseUrl: http://127.0.0.1:11434
+```
+
+### Why vectors cannot be mixed
+
+Vectors from different backends of the "same" model differ: q8-CPU against F16/fp32 vectors has a cosine of only about 0.97, so a query embedded by one backend ranks an index embedded by the other noticeably worse, and nothing signals it. The index is therefore bound to the backend that produced its vectors: backend id, model and dimensions are stored with the index (SQLite table `embedding_binding`, Postgres `pai_embedding_binding`), set on the first embed. An index that holds vectors but no binding is treated as `transformers-cpu-q8`.
+
+When the configured backend differs from the recorded one, PAI does not embed and does not query with it. It reports `index embedded with X, configured Y: run pai memory reembed to switch`, the embed pass pauses, and searches fall back to keyword-only with that note. It never silently falls back to another backend.
+
+When the configured backend is unavailable (for example Ollama is not running), embedding pauses with the chunks left unembedded and is retried by the next pass; queries go keyword-only with a visible note.
+
+### Token cap
+
+Ollama cuts inputs longer than 510 tokens differently from the model itself (cosine about 0.45 against the reference). For `ollama-f16`, each text is therefore cut to 510 content tokens with the model's own tokenizer at embed time (the count is logged). Chunk boundaries in the database are not changed.
+
+## Status Dashboard
+
+The daemon serves a read-only status page so unattended embedding and index passes can be watched, also from a phone on the tailnet. It is on by default and uses only `node:http`, with no external assets.
+
+```yaml
+dashboard:
+  enabled: true        # default
+  port: 8770           # default
+  bind: 127.0.0.1      # default; add the tailnet IP to reach it from other devices
+```
+
+`pai daemon status` prints the URL. `GET /` is the page (refreshes every 10 s), `GET /api/status` the JSON behind it. Requests whose `Host` header is not the bound address, `localhost`, or this machine's tailnet name or IP (from `tailscale status --json`) get 403, which blocks DNS rebinding. Only GET and HEAD are accepted; the default bind is never `0.0.0.0`.
+
+The page shows, with green/amber/red status:
+
+- **Index**: files, chunks and embedding coverage, the recorded index binding against the configured backend, and the `pai memory reembed` hint on a mismatch (red).
+- **Jobs** (table `pai_embedding_jobs`): phase, done/total as a bar, rate over the last minutes, ETA, and `STALLED` (red) when `done` has not moved for 5 min.
+- **Backend**: the configured backend's availability (red when unavailable) and, for Ollama, the loaded models with their GPU share (`size_vram` / `size`).
+- **Passes**: index, embed and vault pass state, last success, the failure with its error and next retry (red), and the next scheduled time.
+
+Counts come from catalog statistics (`pg_class.reltuples`, `pg_stats`) and are marked "est."; real counts are refreshed in the background at most every 5 min (20 s statement timeout, estimate kept on failure). Nothing is computed per request.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekmidian/pai",
-  "version": "0.66.6",
+  "version": "0.66.8",
   "description": "PAI Knowledge OS — Personal AI Infrastructure with federated memory and project management",
   "type": "module",
   "main": "dist/index.mjs",

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

@@ -51,7 +51,7 @@ 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("pai worker wait-on $(cat /tmp/job.pid)");
     expect(out.permissionDecisionReason).not.toContain("run_in_background: true");
   });
 
@@ -71,7 +71,7 @@ describe("sleep-poll gate", () => {
   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(out.permissionDecisionReason).toContain("detached");
     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

@@ -12,6 +12,7 @@
  */
 
 import { SLEEP_FLOOR_SECS, totalSleepSecs } from "../../../workers/status.js";
+import { WAIT_RECIPE } from "../../../workers/wait-on.js";
 
 export interface SleepPollGateInput {
   tool_name?: string;
@@ -32,8 +33,7 @@ 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 " +
-        "and split longer jobs into steps; run_in_background is denied here."
+      `In a worker, run a long job detached: ${WAIT_RECIPE}. run_in_background is denied here.`
     );
   }
   return (
@@ -50,8 +50,8 @@ export function denyReason(secs: number, isWorker: boolean): string {
  */
 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.";
+  "there is no completion notification. Run a long job detached: " +
+  WAIT_RECIPE + ".";
 
 export function decideSleepPollGate(
   input: SleepPollGateInput,

package/src/hooks/ts/lib/worker-guard-longwait.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+import { decideWorkerGuard, type WorkerGuardContext } from "./worker-guard.js";
+
+const WT = "/work/wt/abc";
+const ctx: WorkerGuardContext = {
+  cwd: WT,
+  home: "/home/u",
+  worktreeRoot: WT,
+  inWorktree: true,
+  mainCheckout: "/work/main",
+  testScript: () => "vitest",
+};
+const WORKER = { PAI_WORKER: "1" };
+const run = (command: string, timeout?: number, env: Record<string, string> = WORKER) =>
+  decideWorkerGuard({ tool_name: "Bash", tool_input: { command, timeout } }, env, () => ctx);
+
+const RECIPE = "nohup sh -c 'timeout 590 make; sleep 300; echo $? > /tmp/job.rc' > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid";
+
+describe("long foreground waits", () => {
+  it.each([
+    ["tool timeout 300000", "npm test", 300000],
+    ["the real w37274 command", "timeout 590 zsh rounds.sh | tail -40", undefined],
+    ["timeout with signal flag", "timeout -s KILL 590 make", undefined],
+    ["sleep 300", "sleep 300", undefined],
+    ["while + sleep 90", "while true; do sleep 90; done", undefined],
+    ["gtimeout 10m", "gtimeout 10m make", undefined],
+    ["inside bash -c", "bash -c 'sleep 300'", undefined],
+  ])("denies: %s", (_n, cmd, to) => {
+    const d = run(cmd, to);
+    expect(d.decision).toBe("deny");
+    const reason = (d as { reason: string }).reason;
+    expect(reason).toContain("pai worker wait-on $(cat /tmp/job.pid) --log /tmp/job.log");
+    expect(reason).toContain("block operator messages and supervision");
+  });
+
+  it.each([
+    ["timeout 100", "timeout 100 npm test", 120000],
+    ["wait-on", "pai worker wait-on 123 --log x", undefined],
+    ["nohup recipe", RECIPE, undefined],
+    ["sleep 30", "sleep 30", undefined],
+  ])("allows: %s", (_n, cmd, to) => {
+    expect(run(cmd, to).decision).toBe("allow");
+  });
+
+  it("allows long waits in an interactive session", () => {
+    expect(run("timeout 590 make", 600000, {}).decision).toBe("allow");
+  });
+});

package/src/hooks/ts/lib/worker-guard.ts

@@ -20,11 +20,13 @@ import { dirname, resolve } from "node:path";
 import { type GateDecision } from "./sleep-poll-gate.js";
 import { decideWorkerGitGuard } from "./worker-git-guard.js";
 import { isBrowserTool } from "../../../workers/browser-tools.js";
+import { totalSleepSecs } from "../../../workers/status.js";
+import { WAIT_RECIPE } from "../../../workers/wait-on.js";
 
 export interface WorkerGuardInput {
   tool_name?: string;
   cwd?: string;
-  tool_input?: { command?: string; file_path?: string; path?: string };
+  tool_input?: { command?: string; file_path?: string; path?: string; timeout?: number };
 }
 
 export interface WorkerGuardContext {
@@ -200,7 +202,7 @@ const PATTERN_KILL_REASON =
   "`kill $(cat /tmp/x.pid)`), never by name or pattern; other workers' command lines contain your spec text";
 
 /** Decide one segment; `st.cwd` is the tracked working directory. */
-function decideSegment(seg: Segment, st: { cwd: string; raw: string }, ctx: WorkerGuardContext): GateDecision {
+function decideSegment(seg: Segment, st: { cwd: string; raw: string }, ctx: WorkerGuardContext, detached = false): GateDecision {
   const words = stripPrefix(seg.words);
   const [cmd, ...args] = words;
   const boundary = ctx.worktreeRoot ?? ctx.cwd;
@@ -213,7 +215,7 @@ function decideSegment(seg: Segment, st: { cwd: string; raw: string }, ctx: Work
   if (!cmd) return ALLOW;
 
   if ((cmd === "bash" || cmd === "sh" || cmd === "zsh") && args[0] === "-c" && args[1]) {
-    return decideCommand(args[1], { ...ctx, cwd: st.cwd });
+    return decideCommand(args[1], { ...ctx, cwd: st.cwd }, detached);
   }
 
   const pos = args.filter((a) => !isFlag(a));
@@ -292,10 +294,49 @@ function decideSegment(seg: Segment, st: { cwd: string; raw: string }, ctx: Work
   return ALLOW;
 }
 
-function decideCommand(command: string, ctx: WorkerGuardContext): GateDecision {
+const MAX_FOREGROUND_SECS = 120;
+const WAIT_REASON_TAIL =
+  "calls longer than 2 min block operator messages and supervision; long jobs run fine detached: " + WAIT_RECIPE + ".";
+
+const unitSecs = (u: string): number => (u === "m" ? 60 : u === "h" ? 3600 : u === "d" ? 86_400 : 1);
+
+/** Longest `timeout N` (timeout/gtimeout, any flags) among the segments, in seconds. */
+function longestTimeoutSecs(segs: Segment[]): number {
+  let longest = 0;
+  for (const seg of segs) {
+    const [cmd, ...args] = stripPrefix(seg.words);
+    if (cmd !== "timeout" && cmd !== "gtimeout") continue;
+    for (let i = 0; i < args.length; i++) {
+      if (/^-[sk]$/.test(args[i])) i++;
+      else if (!isFlag(args[i])) {
+        const m = /^(\d+(?:\.\d+)?)([smhd]?)$/.exec(args[i]);
+        if (m) longest = Math.max(longest, Number(m[1]) * unitSecs(m[2]));
+        break;
+      }
+    }
+  }
+  return longest;
+}
+
+/** Deny a foreground command that would block longer than 2 min; `nohup …` segments are the detached launch and exempt. */
+function longWaitReason(command: string, segs: Segment[]): string | null {
+  const fg = segs.filter((s) => s.words[0] !== "nohup");
+  const t = longestTimeoutSecs(fg);
+  if (t > MAX_FOREGROUND_SECS) return `timeout ${t}s blocked: ${WAIT_REASON_TAIL}`;
+  // Quoted text and nohup launches are not foreground sleeps; loops count at least one sleep floor (one parser: totalSleepSecs).
+  const bare = command.replace(/'[^']*'|"[^"]*"/g, "''").replace(/\bnohup\b[^;&|\n]*/g, "");
+  const s = totalSleepSecs(bare);
+  if (s > MAX_FOREGROUND_SECS) return `sleep ${s}s blocked: ${WAIT_REASON_TAIL}`;
+  return null;
+}
+
+function decideCommand(command: string, ctx: WorkerGuardContext, detached = false): GateDecision {
   const st = { cwd: ctx.cwd, raw: command };
-  for (const seg of parseCommand(command)) {
-    const d = decideSegment(seg, st, ctx);
+  const segs = parseCommand(command);
+  const long = detached ? null : longWaitReason(command, segs);
+  if (long) return deny(long);
+  for (const seg of segs) {
+    const d = decideSegment(seg, st, ctx, seg.words[0] === "nohup");
     if (d.decision === "deny") return d;
   }
   return ALLOW;
@@ -314,6 +355,9 @@ export function decideWorkerGuard(
     return deny(`${tool} blocked: this worker runs with --no-browser`);
   }
   if (tool === "Bash") {
+    if (typeof ti.timeout === "number" && ti.timeout > MAX_FOREGROUND_SECS * 1000) {
+      return deny(`Bash timeout ${ti.timeout} ms blocked: ${WAIT_REASON_TAIL}`);
+    }
     return typeof ti.command === "string" ? decideCommand(ti.command, ctx()) : ALLOW;
   }
   if (tool === "Edit" || tool === "Write" || tool === "MultiEdit" || tool === "NotebookEdit") {

package/src/hooks/ts/pre-tool-use/block-sleep-poll.test.ts

@@ -31,7 +31,7 @@ describe("block-sleep-poll", () => {
     const out = runHook("sleep 590", {}, { PAI_WORKER: "1" });
     const parsed = JSON.parse(out).hookSpecificOutput;
     expect(parsed.permissionDecision).toBe("deny");
-    expect(parsed.permissionDecisionReason).toContain("FOREGROUND with a Bash timeout up to 600000 ms");
+    expect(parsed.permissionDecisionReason).toContain("pai worker wait-on $(cat /tmp/job.pid)");
   });
 
   it("allows a short sleep (prints nothing)", () => {

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

@@ -4,10 +4,12 @@
  * load-core-context.ts
  *
  * Automatically loads your CORE skill context at session start by reading and injecting
- * the CORE SKILL.md file contents directly into Claude's context as a system-reminder.
+ * the core SKILL.md contents directly into Claude's context as a system-reminder.
+ * The file is the first existing of skills/CORE/SKILL.md, skills/PAI/SKILL.md
+ * (the latter is what `pai setup` installs); neither = silent no-op.
  *
  * Purpose:
- * - Read CORE SKILL.md file content
+ * - Read core SKILL.md file content
  * - Output content as system-reminder for Claude to process
  * - Ensure complete context (contacts, preferences, security, identity) available at session start
  * - Bypass skill activation logic by directly injecting context
@@ -52,13 +54,14 @@ async function main() {
       process.exit(0);
     }
 
-    // Get CORE skill path using PAI paths library
-    const coreSkillPath = join(SKILLS_DIR, 'CORE/SKILL.md');
+    // CORE wins; PAI/SKILL.md is where `pai setup` installs the core skill
+    const coreSkillPath = [join(SKILLS_DIR, 'CORE/SKILL.md'), join(SKILLS_DIR, 'PAI/SKILL.md')]
+      .find(existsSync);
 
     // CORE is an optional, user-provided skill (PAI ships none): absent = silent no-op
-    if (!existsSync(coreSkillPath)) process.exit(0);
+    if (!coreSkillPath) process.exit(0);
 
-    console.error('Reading CORE context from skill file...');
+    console.error(`Reading CORE context from ${coreSkillPath}...`);
 
     // Read the CORE SKILL.md file content
     let coreContent = readFileSync(coreSkillPath, 'utf-8');
@@ -75,7 +78,7 @@ async function main() {
       .replace(/\{\{DA_COLOR\}\}/g, daColor)
       .replace(/\{\{ENGINEER_NAME\}\}/g, engineerName);
 
-    console.error(`Read ${coreContent.length} characters from CORE SKILL.md (Personalized for ${engineerName} & ${daName})`);
+    console.error(`Read ${coreContent.length} characters from ${coreSkillPath} (Personalized for ${engineerName} & ${daName})`);
 
     // Output the CORE content as a system-reminder, minus the frontmatter
     // (catalogue metadata the session already has from its skill list) —
@@ -98,7 +101,7 @@ ${stripFrontmatter(coreContent)}
       `<system-reminder>\n` +
         `Edit/Write on code files is denied in this session by policy (only .md/.txt and Notes/ are editable). ` +
         `For any code change: write a spec file, then ` +
-        `\`pai worker run --provider anthropic --class implement -p "$(cat <spec>)"\`.\n` +
+        `\`pai worker run --class implement -p "$(cat <spec>)"\`.\n` +
         `</system-reminder>`
     );
 

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { execFileSync, spawnSync } from "node:child_process";
-import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -41,7 +41,8 @@ describe("session-start hooks: worker sessions get no injected context", () => {
     // whose ambient env would otherwise leak into the child and short-circuit it.
     const stdout = runHook("src/hooks/ts/session-start/load-core-context.ts", { PAI_WORKER: "" });
     expect(stdout).toContain("Edit/Write on code files is denied in this session by policy");
-    expect(stdout).toContain("pai worker run --provider anthropic --class implement");
+    expect(stdout).toContain("pai worker run --class implement");
+    expect(stdout).not.toContain("--provider anthropic");
   });
 
   it("load-core-context.ts omits the edit-gate notice when PAI_WORKER=1", () => {
@@ -68,4 +69,35 @@ describe("load-core-context.ts: CORE is optional", () => {
       rmSync(home, { recursive: true, force: true });
     }
   });
+
+  function runWithSkills(skills: Record<string, string>) {
+    const home = mkdtempSync(join(tmpdir(), "pai-core-"));
+    try {
+      for (const [name, marker] of Object.entries(skills)) {
+        mkdirSync(join(home, ".claude", "skills", name), { recursive: true });
+        writeFileSync(join(home, ".claude", "skills", name, "SKILL.md"), marker);
+      }
+      return 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: "" },
+      });
+    } finally {
+      rmSync(home, { recursive: true, force: true });
+    }
+  }
+
+  it("falls back to skills/PAI/SKILL.md (the `pai setup` layout) when CORE is absent", () => {
+    const r = runWithSkills({ PAI: "PAI-ONLY-MARKER" });
+    expect(r.status).toBe(0);
+    expect(r.stdout).toContain("PAI CORE CONTEXT");
+    expect(r.stdout).toContain("PAI-ONLY-MARKER");
+  });
+
+  it("prefers CORE over PAI when both exist", () => {
+    const r = runWithSkills({ CORE: "CORE-WINS-MARKER", PAI: "PAI-LOSES-MARKER" });
+    expect(r.stdout).toContain("CORE-WINS-MARKER");
+    expect(r.stdout).not.toContain("PAI-LOSES-MARKER");
+  });
 });

package/dist/auto-route-D6fW1Q8z.mjs

@@ -1,3 +0,0 @@
-import { n as formatAutoRouteJson, t as autoRoute } from "./auto-route-BnizyALK.mjs";
-
-export { autoRoute, formatAutoRouteJson };