@rol1n/pi-kit 0.1.2 → 0.1.3

package/model-vision/image.ts

@@ -0,0 +1,84 @@
+import { readFile, stat } from "node:fs/promises";
+import { extname, resolve } from "node:path";
+import { combinedSignal, readBounded, validateRemoteUrl } from "./network.ts";
+
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const MAX_REDIRECTS = 5;
+
+const MIME_MAP: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+};
+const SUPPORTED_MIMES = new Set(Object.values(MIME_MAP));
+
+function detectMime(buffer: Buffer): string | undefined {
+  if (buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) return "image/png";
+  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return "image/jpeg";
+  if (
+    buffer.subarray(0, 6).toString("ascii") === "GIF87a" ||
+    buffer.subarray(0, 6).toString("ascii") === "GIF89a"
+  ) {
+    return "image/gif";
+  }
+  if (
+    buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+    buffer.subarray(8, 12).toString("ascii") === "WEBP"
+  ) {
+    return "image/webp";
+  }
+  if (buffer.subarray(0, 2).toString("ascii") === "BM") return "image/bmp";
+  return undefined;
+}
+
+async function fetchRemoteImage(url: string, signal: AbortSignal): Promise<{ buffer: Buffer; mime: string }> {
+  let current = await validateRemoteUrl(url);
+  for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects++) {
+    const response = await fetch(current, {
+      redirect: "manual",
+      headers: { Accept: "image/png,image/jpeg,image/webp,image/gif,image/bmp" },
+      signal,
+    });
+    if ([301, 302, 303, 307, 308].includes(response.status)) {
+      const location = response.headers.get("location");
+      if (!location) throw new Error(`Image redirect missing Location header: HTTP ${response.status}`);
+      if (redirects === MAX_REDIRECTS) throw new Error("Too many image redirects.");
+      current = await validateRemoteUrl(new URL(location, current).href);
+      continue;
+    }
+    if (!response.ok) throw new Error(`Failed to fetch image: HTTP ${response.status} ${response.statusText}`);
+
+    const mime = (response.headers.get("content-type") ?? "").split(";", 1)[0].trim().toLowerCase();
+    if (!SUPPORTED_MIMES.has(mime)) throw new Error(`Unsupported remote image MIME type: ${mime || "unknown"}`);
+    return { buffer: await readBounded(response, MAX_IMAGE_BYTES), mime };
+  }
+  throw new Error("Too many image redirects.");
+}
+
+export async function readImage(image: string, cwd: string, signal?: AbortSignal): Promise<string> {
+  const trimmed = image.trim();
+  if (!trimmed) throw new Error("Image path or URL cannot be empty.");
+
+  let buffer: Buffer;
+  let mime: string;
+  if (/^https?:\/\//i.test(trimmed)) {
+    ({ buffer, mime } = await fetchRemoteImage(trimmed, combinedSignal(30_000, signal)));
+  } else {
+    const filePath = resolve(cwd, trimmed);
+    const expectedMime = MIME_MAP[extname(filePath).toLowerCase()];
+    if (!expectedMime) throw new Error(`Unsupported image file extension: ${extname(filePath) || "none"}`);
+    const fileStat = await stat(filePath);
+    if (fileStat.size > MAX_IMAGE_BYTES) throw new Error("Image file exceeds 10 MiB limit.");
+    buffer = await readFile(filePath);
+    mime = expectedMime;
+  }
+
+  const detected = detectMime(buffer);
+  if (!detected || detected !== mime) {
+    throw new Error(`Image content does not match MIME type (expected ${mime}, detected ${detected ?? "unknown"}).`);
+  }
+  return `data:${mime};base64,${buffer.toString("base64")}`;
+}

package/model-vision/index.ts

@@ -0,0 +1,124 @@
+/**
+ * model-vision — Image understanding extension for Pi.
+ *
+ * Registers the `model_vision` tool to analyze local or remote images
+ * using a vision model and return a textual description.
+ */
+
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  truncateHead,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { readImage } from "./image.ts";
+import { callOpenAICompatible, callPiNative } from "./requests.ts";
+
+/**
+ * Configure your default vision model(s) here.
+ * The first available model in the chain will be used; subsequent ones act as fallbacks.
+ * Supported protocols: "pi-native" (Antigravity/built-in) or "openai-completions".
+ */
+export const DEFAULT_VISION_MODELS: Array<{
+  provider: string;
+  model: string;
+  protocol?: "pi-native" | "openai-completions";
+}> = [
+  { provider: "antigravity", model: "gemini-3.8-flash", protocol: "pi-native" },
+  { provider: "shuaiapi", model: "gpt-6-luna", protocol: "openai-completions" },
+];
+
+export type VisionCandidate = {
+  provider: string;
+  model: string;
+  protocol?: "pi-native" | "openai-completions";
+};
+
+export function getVisionCandidates(): VisionCandidate[] {
+  const models = DEFAULT_VISION_MODELS as VisionCandidate[] | VisionCandidate;
+  const list = Array.isArray(models) ? models : [models];
+  return list.map((c) => ({
+    ...c,
+    protocol: c.protocol ?? (c.provider === "antigravity" ? "pi-native" : "openai-completions"),
+  }));
+}
+
+const DEFAULT_PROMPT =
+  "Describe this image in detail: transcribe any visible text verbatim, describe visual elements, layout, colors, and note any errors, anomalies, or important details.";
+
+export async function analyzeImage(
+  image: string,
+  promptText: string | undefined,
+  cwd: string,
+  ctx: ExtensionContext,
+  signal?: AbortSignal,
+): Promise<{ text: string; model: string; provider: string; truncated: boolean }> {
+  const candidates = getVisionCandidates();
+  if (!candidates.length) throw new Error("No vision models configured.");
+
+  const dataUri = await readImage(image, cwd, signal);
+  const prompt = promptText?.trim() || DEFAULT_PROMPT;
+  const errors: string[] = [];
+
+  for (const candidate of candidates) {
+    try {
+      const text =
+        candidate.protocol === "pi-native"
+          ? await callPiNative(ctx, candidate, dataUri, prompt, signal)
+          : await callOpenAICompatible(ctx, candidate, dataUri, prompt, signal);
+      const output = truncateHead(text, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES });
+      return {
+        text: output.content,
+        model: candidate.model,
+        provider: candidate.provider,
+        truncated: output.truncated,
+      };
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      errors.push(`${candidate.provider}/${candidate.model}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  throw new Error(`All vision models failed: ${errors.join("; ")}`);
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "model_vision",
+    label: "model_vision",
+    description:
+      "Analyze an image using a vision model and return a textual description. Supports local PNG/JPEG/WebP/GIF/BMP file paths or public http(s) URLs. Use prompt to specify OCR, error diagnosis, UI inspection, or detailed description.",
+    parameters: Type.Object({
+      image: Type.String({
+        minLength: 1,
+        description: "Local image path (relative to cwd or absolute) or public http(s) URL",
+      }),
+      prompt: Type.Optional(
+        Type.String({
+          description: "Specific question or instruction for the vision model",
+        }),
+      ),
+    }),
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const result = await analyzeImage(params.image, params.prompt, ctx.cwd, ctx, signal);
+      return {
+        content: [{ type: "text", text: result.text }],
+        details: {
+          model: result.model,
+          provider: result.provider,
+          truncated: result.truncated,
+        },
+      };
+    },
+    renderCall(args, theme, context) {
+      const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      const { image } = args as { image?: string };
+      const display = image && image.length > 50 ? "..." + image.slice(-47) : image || "";
+      text.setText(theme.fg("toolTitle", theme.bold("model_vision ")) + theme.fg("accent", display));
+      return text;
+    },
+  });
+}

package/model-vision/network.ts

@@ -0,0 +1,82 @@
+import { lookup } from "node:dns/promises";
+import net from "node:net";
+
+export function combinedSignal(timeoutMs: number, signal?: AbortSignal): AbortSignal {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+
+function isPrivateIp(address: string): boolean {
+  if (net.isIPv4(address)) {
+    const [a, b] = address.split(".").map(Number);
+    return (
+      a === 0 ||
+      a === 10 ||
+      a === 127 ||
+      (a === 169 && b === 254) ||
+      (a === 172 && b >= 16 && b <= 31) ||
+      (a === 192 && b === 168) ||
+      a >= 224
+    );
+  }
+  const norm = address.toLowerCase();
+  return (
+    norm === "::" ||
+    norm === "::1" ||
+    norm.startsWith("fc") ||
+    norm.startsWith("fd") ||
+    /^fe[89ab]/.test(norm) ||
+    norm.startsWith("::ffff:127.") ||
+    norm.startsWith("::ffff:10.") ||
+    norm.startsWith("::ffff:192.168.")
+  );
+}
+
+export async function validateRemoteUrl(raw: string): Promise<URL> {
+  const url = new URL(raw);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Only http(s) URLs are supported for remote images.");
+  }
+  if (url.username || url.password) {
+    throw new Error("Image URL must not contain username or password.");
+  }
+  const hostname = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (hostname === "localhost" || hostname.endsWith(".localhost")) {
+    throw new Error(`Access to local address is blocked: ${hostname}`);
+  }
+  const addresses = net.isIP(hostname)
+    ? [{ address: hostname }]
+    : await lookup(hostname, { all: true, verbatim: true });
+  if (!addresses.length || addresses.some(({ address }) => isPrivateIp(address))) {
+    throw new Error(`Access to private or local network address is blocked: ${hostname}`);
+  }
+  return url;
+}
+
+export async function readBounded(response: Response, maxBytes: number): Promise<Buffer> {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    throw new Error(`Content exceeds ${Math.round(maxBytes / (1024 * 1024))} MiB limit.`);
+  }
+  if (!response.body) return Buffer.alloc(0);
+
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel();
+        throw new Error(`Content exceeds ${Math.round(maxBytes / (1024 * 1024))} MiB limit.`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total);
+}

package/model-vision/requests.ts

@@ -0,0 +1,151 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { VisionCandidate } from "./index.ts";
+import { combinedSignal, readBounded } from "./network.ts";
+
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+const MAX_TOKENS = 8192;
+const REQUEST_TIMEOUT_MS = 90_000;
+
+async function parseChatResponse(response: Response): Promise<string> {
+  const raw = (await readBounded(response, MAX_RESPONSE_BYTES)).toString("utf8");
+  if (!(response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+    let json: any;
+    try {
+      json = JSON.parse(raw);
+    } catch {
+      throw new Error(`Vision model returned invalid JSON: ${raw.slice(0, 200)}`);
+    }
+    const content = json?.choices?.[0]?.message?.content;
+    if (typeof content === "string") return content.trim();
+    if (Array.isArray(content)) {
+      return content
+        .map((part) => (typeof part === "string" ? part : part?.text ?? ""))
+        .join("")
+        .trim();
+    }
+    return String(json?.choices?.[0]?.message?.reasoning_content ?? "").trim();
+  }
+
+  let text = "";
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    try {
+      const delta = JSON.parse(payload)?.choices?.[0]?.delta;
+      const content = delta?.content ?? delta?.reasoning_content;
+      if (typeof content === "string") text += content;
+    } catch {}
+  }
+  return text.trim();
+}
+
+export async function callOpenAICompatible(
+  ctx: ExtensionContext,
+  candidate: VisionCandidate,
+  dataUri: string,
+  prompt: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  const registered = ctx.modelRegistry.getProvider(candidate.provider);
+  const resolved = await ctx.modelRegistry.getProviderAuth(candidate.provider);
+  const apiKey = resolved?.auth.apiKey;
+  if (!apiKey) {
+    throw new Error(`No API key found for provider "${candidate.provider}". Run /login ${candidate.provider} first.`);
+  }
+
+  const baseUrl = (resolved.auth.baseUrl || registered?.baseUrl)?.replace(/\/+$/, "");
+  if (!baseUrl) {
+    throw new Error(`Provider "${candidate.provider}" has no base URL configured.`);
+  }
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+  };
+  for (const source of [registered?.headers, resolved.auth.headers]) {
+    for (const [key, value] of Object.entries(source ?? {})) {
+      if (typeof value === "string") headers[key] = value;
+    }
+  }
+
+  const response = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model: candidate.model,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image_url", image_url: { url: dataUri } },
+          ],
+        },
+      ],
+      max_tokens: MAX_TOKENS,
+    }),
+    signal: combinedSignal(REQUEST_TIMEOUT_MS, signal),
+  });
+
+  if (!response.ok) {
+    const errorBody = (await readBounded(response, 16 * 1024)).toString("utf8");
+    throw new Error(`HTTP ${response.status}: ${errorBody.slice(0, 300)}`);
+  }
+  const text = await parseChatResponse(response);
+  if (!text) throw new Error("Vision model returned an empty response.");
+  return text;
+}
+
+export async function callPiNative(
+  ctx: ExtensionContext,
+  candidate: VisionCandidate,
+  dataUri: string,
+  prompt: string,
+  signal?: AbortSignal,
+): Promise<string> {
+  const model = ctx.modelRegistry.find(candidate.provider, candidate.model);
+  if (!model) {
+    throw new Error(`Model ${candidate.provider}/${candidate.model} not found in modelRegistry.`);
+  }
+  const auth = await ctx.modelRegistry.getProviderAuth(candidate.provider);
+  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
+  if (!match) throw new Error("Failed to parse image data URI.");
+  const [, mimeType, base64Data] = match;
+
+  const { completeSimple } = await import("@earendil-works/pi-ai/compat");
+  const response = await completeSimple(
+    model,
+    {
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image", data: base64Data, mimeType },
+          ],
+          timestamp: Date.now(),
+        },
+      ],
+    },
+    {
+      apiKey: auth?.auth.apiKey,
+      headers: auth?.auth.headers,
+      signal: combinedSignal(REQUEST_TIMEOUT_MS, signal),
+      maxTokens: MAX_TOKENS,
+    },
+  );
+
+  if (response.stopReason === "error") {
+    throw new Error(response.errorMessage || "Vision model request failed.");
+  }
+
+  const text = response.content
+    ?.filter((c: any) => c.type === "text")
+    ?.map((c: any) => c.text)
+    ?.join("\n")
+    ?.trim();
+
+  if (!text) throw new Error("Vision model returned an empty response.");
+  return text;
+}

package/multi-harness/README.md

@@ -2,19 +2,19 @@
 
 A small delegation runtime with one tool, `multi_harness`. `pi`, `codex`, `claude`, and `opencode` are equal CLI peers. The original `subagent` extension remains a separate, lean Pi-only tool.
 
-The runtime accepts **one named worker and an existing cwd**. Those decisions belong to the caller. An independently installed `worktree-studio` skill can coordinate isolated implementations and their acceptance review.
+The runtime accepts **one named worker and an existing cwd**. Those decisions belong to the caller. The bundled [worktree-studio skill](../skills/worktree-studio/SKILL.md) can coordinate isolated implementations and their acceptance review; enable it through the kit's `skills` resource selection.
 
 ## Install
 
 ```sh
-pi install npm:@rol1n/multi-harness
+pi install npm:@rol1n/pi-kit
 ```
 
-Also included in `@rol1n/pi-kit`. Enable one copy of the extension.
+Included and loaded by default in `@rol1n/pi-kit`. See [resource selection](../README.md#resource-selection) to disable this entry or load only selected extensions. Enable one copy of the extension.
 
 ## Use
 
-Load `multi-harness` through the aggregate package, or run from this repository:
+Load `multi-harness` through `pi-kit`, or run from this repository:
 
 ```sh
 pi --no-extensions -e ./multi-harness/index.ts

package/oai-subquota/README.md

@@ -5,10 +5,10 @@ Monitor OpenAI Codex subscription quota (5-hour and 7-day windows, resets, and c
 ## Install
 
 ```sh
-pi install npm:@rol1n/oai-subquota
+pi install npm:@rol1n/pi-kit
 ```
 
-Also included in `@rol1n/pi-kit`.
+Included and loaded by default in `@rol1n/pi-kit`. See [resource selection](../README.md#resource-selection) to disable this entry or load only selected extensions.
 
 ## Commands
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rol1n/pi-kit",
-  "version": "0.1.2",
-  "description": "A selectable collection of Pi extensions and prompt templates.",
+  "version": "0.1.3",
+  "description": "A selectable collection of Pi extensions, prompt templates, and skills.",
   "author": "RoL1n_SrP",
   "license": "MIT",
   "repository": {
@@ -20,43 +20,32 @@
     "node": ">=22.19.0"
   },
   "scripts": {
-    "manifest": "node scripts/package.mjs sync",
-    "check": "node scripts/package.mjs check",
-    "prepare:extension": "node scripts/package.mjs extension",
-    "publish:ci": "node scripts/package.mjs publish",
-    "prepack": "node scripts/package.mjs check"
+    "check": "node scripts/check-package.mjs",
+    "test": "node --experimental-strip-types --test memory-log/hooks/*.test.ts memory-log/ledger/*.test.ts prompt-snipaste/*.test.ts",
+    "prepack": "npm run check"
   },
   "publishConfig": {
     "access": "public"
   },
   "files": [
     "README_zh.md",
-    "ask-u-questions/README.md",
-    "continue-signal/README.md",
-    "custom-providers/README.md",
-    "image-generate/README.md",
-    "memory-log/README.md",
-    "model-vision/README.md",
-    "multi-harness/README.md",
-    "oai-subquota/README.md",
-    "prompt-snipaste/README.md",
-    "screenshot/README.md",
-    "srp-theme/README.md",
-    "subagent/README.md",
-    "tui-asr/README.md",
-    "web-reach/README.md",
-    "windows-wheel-fix/README.md",
+    "scripts/check-package.mjs",
+    "prompts",
+    "skills",
     "ask-u-questions",
     "continue-signal",
     "custom-providers",
     "image-generate",
     "memory-log",
+    "model-vision",
     "multi-harness",
     "subagent",
     "oai-subquota",
     "prompt-snipaste",
+    "screenshot",
     "srp-theme",
     "tui-asr",
+    "web-reach",
     "windows-wheel-fix",
     "!**/test/**",
     "!**/tests/**",
@@ -78,17 +67,22 @@
       "./custom-providers/index.ts",
       "./image-generate/index.ts",
       "./memory-log/index.ts",
+      "./model-vision/index.ts",
       "./multi-harness/index.ts",
       "./oai-subquota/index.ts",
       "./prompt-snipaste/index.ts",
+      "./screenshot/index.ts",
       "./srp-theme/index.ts",
       "./subagent/index.ts",
       "./tui-asr/index.ts",
+      "./web-reach/index.ts",
       "./windows-wheel-fix/index.ts"
     ],
-    "skills": [],
+    "skills": [
+      "./skills"
+    ],
     "prompts": [
-      "./prompt-snipaste/prompts"
+      "./prompts"
     ],
     "themes": []
   }

package/prompt-snipaste/README.md

@@ -1,20 +1,32 @@
 # prompt-snipaste
 
-Select prompt snippets to prepend or append to the next user message, with live preview and a session transcript card. Bundles 7 built-in prompt snippets under `prompts/`.
+A generic composer for Pi prompt templates: select snippets to prepend or append to the next user message, with live preview and a session transcript card. It ships no private template library and requires no particular prompt names.
 
 ## Install
 
 ```sh
-pi install npm:@rol1n/prompt-snipaste
+pi install npm:@rol1n/pi-kit
 ```
 
-Also included in `@rol1n/pi-kit`.
+Included and loaded by default in `@rol1n/pi-kit`. See [resource selection](../README.md#resource-selection) to disable this entry or load only selected extensions.
 
 ## Use
 
-Open with `/snipaste` or `Alt+S`. Navigate with arrow keys, toggle with `Space`, preview with `Tab`, confirm with `Enter`, and cancel with `Escape`.
+Open with `/snipaste` or `Alt+S`. Navigate with arrow keys, toggle with `Space`, preview with `Tab`, confirm with `Enter`, and cancel with `Escape`. A confirmed selection applies once, to the next user message.
 
-## Frontmatter
+## Prompt sources and filtering
+
+Pi owns discovery and filtering. The selector reads only prompt commands exposed by `pi.getCommands()`, including templates from personal configuration, trusted projects, and other packages. It does not scan package directories, read settings itself, or fall back to disabled templates.
+
+- Ordinary Markdown and standard Pi templates work without any snippet-specific metadata.
+- Add or change prompts through Pi's normal prompt directories or settings, then run `/reload`.
+- Package `prompts` filters are respected. With no enabled templates, the menu displays a notice and injects nothing.
+- Same-named files from different sources have independent identities based on their full source paths.
+- The kit's root [`prompts/`](../prompts/) directory is a separate resource. Disabling it does not disable the selector; disabling the selector does not disable native template commands.
+
+The selector composes template bodies as text; it does **not** invoke slash commands or expand positional argument placeholders such as `$1`. Use Pi's normal `/template args` invocation when argument expansion is needed.
+
+## Optional frontmatter
 
 ```markdown
 ---
@@ -25,3 +37,5 @@ order: 100
 ---
 Check correctness, error handling, and missing validation.
 ```
+
+All fields are optional. `name` overrides the menu label, `description` describes the template, `placement` defaults to `append`, and `order` defaults to `100`. Prepend snippets come first, followed by append snippets; each group is sorted by numeric order and name.

package/prompt-snipaste/index.ts

@@ -20,11 +20,11 @@ export default function promptSnipaste(pi: ExtensionAPI) {
 			return;
 		}
 
-		snippets = loadSnippets(ctx.cwd, pi);
+		snippets = loadSnippets(pi);
 		enabled = new Set([...enabled].filter((id) => snippets.some((s) => s.id === id)));
 
 		if (snippets.length === 0) {
-			ctx.ui.notify("No Markdown files found in prompt directories", "warning");
+			ctx.ui.notify("No enabled prompt templates. Add prompts in Pi settings, then /reload.", "warning");
 			updateWidget(ctx);
 			return;
 		}
@@ -50,14 +50,14 @@ export default function promptSnipaste(pi: ExtensionAPI) {
 	pi.on("session_start", (_event, ctx) => {
 		enabled = new Set();
 		pendingTurnSnippets = null;
-		snippets = loadSnippets(ctx.cwd, pi);
+		snippets = loadSnippets(pi);
 		updateWidget(ctx);
 	});
 
 	pi.on("input", async (_event, ctx) => {
 		if (enabled.size === 0) return undefined;
 
-		snippets = loadSnippets(ctx.cwd, pi);
+		snippets = loadSnippets(pi);
 		const active = snippets.filter((s) => enabled.has(s.id));
 		enabled = new Set();
 		updateWidget(ctx);