@hienlh/ppm 0.9.81 → 0.9.82

package/src/services/slash-items.service.ts

@@ -1,184 +1,6 @@
-import { resolve, basename, relative, sep } from "node:path";
-import { homedir } from "node:os";
-import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
-import yaml from "js-yaml";
-
-export interface SlashItem {
-  type: "skill" | "command";
-  /** Slash name, e.g. "review", "devops/deploy", "ck:research" */
-  name: string;
-  description: string;
-  argumentHint?: string;
-  /** Where the item comes from */
-  scope: "project" | "user";
-}
-
-/** Safely coerce a frontmatter value to string, returns undefined if not a scalar. */
-function str(val: unknown): string | undefined {
-  if (typeof val === "string") return val;
-  if (typeof val === "number" || typeof val === "boolean") return String(val);
-  return undefined;
-}
-
 /**
- * Parse YAML frontmatter from a Markdown file.
+ * Thin re-export wrapper — actual discovery logic lives in slash-discovery/.
+ * Kept for backward compatibility with existing imports.
  */
-function parseFrontmatter(content: string): { meta: Record<string, unknown>; body: string } {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match || !match[1]) return { meta: {}, body: content };
-  try {
-    const meta = yaml.load(match[1]) as Record<string, unknown>;
-    const body = content.slice(match[0]!.length).trim();
-    return { meta: meta ?? {}, body };
-  } catch {
-    return { meta: {}, body: content };
-  }
-}
-
-/**
- * Recursively walk a directory tree, calling `visitor` for every file.
- * Ignores unreadable dirs/files silently.
- */
-function walkDir(dir: string, visitor: (filePath: string) => void): void {
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const full = resolve(dir, entry);
-    try {
-      const stat = statSync(full);
-      if (stat.isDirectory()) {
-        walkDir(full, visitor);
-      } else if (stat.isFile()) {
-        visitor(full);
-      }
-    } catch { /* skip */ }
-  }
-}
-
-/**
- * Collect commands from a commands directory (recursive).
- * `commands/devops/deploy.md` → name `devops/deploy`
- */
-function collectCommands(commandsDir: string, scope: "project" | "user"): SlashItem[] {
-  const items: SlashItem[] = [];
-  if (!existsSync(commandsDir)) return items;
-  walkDir(commandsDir, (filePath) => {
-    if (!filePath.endsWith(".md")) return;
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      const { meta } = parseFrontmatter(content);
-      const rel = relative(commandsDir, filePath);
-      const name = rel.replace(/\.md$/, "").split(sep).join("/");
-      items.push({
-        type: "command",
-        name: str(meta.name) ?? name,
-        description: str(meta.description) ?? "",
-        argumentHint: str(meta["argument-hint"]),
-        scope,
-      });
-    } catch { /* skip */ }
-  });
-  return items;
-}
-
-/**
- * Collect skills from a skills directory.
- *
- * @param skillsDir    Root skills directory to scan
- * @param scope        "project" or "user"
- * @param strictMode   When true, ONLY pick up SKILL.md files (used for user-global
- *                     which can have many supporting .md files per skill).
- *                     When false, also pick up loose .md files outside SKILL.md dirs
- *                     (used for project-local where flat layout is common).
- */
-function collectSkills(skillsDir: string, scope: "project" | "user", strictMode: boolean): SlashItem[] {
-  const items: SlashItem[] = [];
-  if (!existsSync(skillsDir)) return items;
-
-  const dirsWithSkillMd = new Set<string>();
-
-  // Pass 1: SKILL.md files (directory-based skills)
-  walkDir(skillsDir, (filePath) => {
-    if (basename(filePath) !== "SKILL.md") return;
-    try {
-      const content = readFileSync(filePath, "utf-8");
-      const { meta } = parseFrontmatter(content);
-      const skillDir = resolve(filePath, "..");
-      dirsWithSkillMd.add(skillDir);
-      const rel = relative(skillsDir, skillDir);
-      const pathName = rel.split(sep).join("/");
-      const name = str(meta.name) ?? pathName;
-      if (!name) return;
-      items.push({
-        type: "skill",
-        name,
-        description: str(meta.description) ?? "",
-        scope,
-      });
-    } catch { /* skip */ }
-  });
-
-  // Pass 2 (only in relaxed mode): loose .md files not inside a SKILL.md directory
-  if (!strictMode) {
-    walkDir(skillsDir, (filePath) => {
-      if (!filePath.endsWith(".md")) return;
-      if (basename(filePath) === "SKILL.md") return;
-      const dir = resolve(filePath, "..");
-      // Skip supporting files inside a skill dir (or any ancestor)
-      let ancestor = dir;
-      while (ancestor.startsWith(skillsDir) && ancestor !== skillsDir) {
-        if (dirsWithSkillMd.has(ancestor)) return;
-        ancestor = resolve(ancestor, "..");
-      }
-      try {
-        const content = readFileSync(filePath, "utf-8");
-        const { meta } = parseFrontmatter(content);
-        const rel = relative(skillsDir, filePath);
-        const pathName = rel.replace(/\.md$/, "").split(sep).join("/");
-        const name = str(meta.name) ?? pathName;
-        if (!name) return;
-        items.push({
-          type: "skill",
-          name,
-          description: str(meta.description) ?? "",
-          scope,
-        });
-      } catch { /* skip */ }
-    });
-  }
-
-  return items;
-}
-
-/**
- * Scan for available slash commands and skills.
- *
- * Sources (merged, project overrides user if same name):
- *   1. User-global:   ~/.claude/commands/  and  ~/.claude/skills/   (strict: SKILL.md only)
- *   2. Project-local:  <projectPath>/.claude/commands/  and  .claude/skills/  (relaxed: also loose .md)
- */
-export function listSlashItems(projectPath: string): SlashItem[] {
-  const home = homedir();
-  const globalClaude = resolve(home, ".claude");
-
-  // Collect from both scopes (user-global uses strict mode)
-  const userCommands = collectCommands(resolve(globalClaude, "commands"), "user");
-  const userSkills = collectSkills(resolve(globalClaude, "skills"), "user", true);
-  const projectCommands = collectCommands(resolve(projectPath, ".claude", "commands"), "project");
-  const projectSkills = collectSkills(resolve(projectPath, ".claude", "skills"), "project", false);
-
-  // Merge: project items override user items with the same name
-  const map = new Map<string, SlashItem>();
-  for (const item of [...userCommands, ...userSkills]) {
-    map.set(`${item.type}:${item.name}`, item);
-  }
-  for (const item of [...projectCommands, ...projectSkills]) {
-    map.set(`${item.type}:${item.name}`, item);
-  }
-
-  return Array.from(map.values());
-}
+export { listSlashItems, searchSlashItems } from "./slash-discovery/index.ts";
+export type { SlashItem } from "./slash-discovery/types.ts";

package/src/services/supervisor-state.ts

@@ -3,17 +3,16 @@
  * Extracted from supervisor.ts to keep the orchestrator lean.
  */
 import { resolve } from "node:path";
-import { homedir } from "node:os";
 import {
   readFileSync, writeFileSync, existsSync, unlinkSync, renameSync, openSync, closeSync,
 } from "node:fs";
 import { constants } from "node:fs";
+import { getPpmDir } from "./ppm-dir.ts";
 
-const PPM_DIR = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"));
-export const CMD_FILE = resolve(PPM_DIR, ".supervisor-cmd");
-export const STATUS_FILE = resolve(PPM_DIR, "status.json");
-export const PID_FILE = resolve(PPM_DIR, "ppm.pid");
-export const LOCK_FILE = resolve(PPM_DIR, ".start-lock");
+export const CMD_FILE = () => resolve(getPpmDir(), ".supervisor-cmd");
+export const STATUS_FILE = () => resolve(getPpmDir(), "status.json");
+export const PID_FILE = () => resolve(getPpmDir(), "ppm.pid");
+export const LOCK_FILE = () => resolve(getPpmDir(), ".start-lock");
 
 // ─── State ─────────────────────────────────────────────────────────────
 export type SupervisorState = "running" | "paused" | "stopped" | "upgrading";
@@ -47,7 +46,7 @@ function atomicWriteJson(filePath: string, data: unknown) {
 
 export function readStatus(): Record<string, unknown> {
   try {
-    if (existsSync(STATUS_FILE)) return JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+    if (existsSync(STATUS_FILE())) return JSON.parse(readFileSync(STATUS_FILE(), "utf-8"));
   } catch {}
   return {};
 }
@@ -55,7 +54,7 @@ export function readStatus(): Record<string, unknown> {
 export function updateStatus(patch: Record<string, unknown>) {
   try {
     const data = { ...readStatus(), ...patch };
-    atomicWriteJson(STATUS_FILE, data);
+    atomicWriteJson(STATUS_FILE(), data);
   } catch {}
 }
 
@@ -64,9 +63,9 @@ export type CmdAction = "soft_stop" | "resume";
 
 /** Atomically claim + read command file (rename to .claimed, read, delete) */
 export function readAndDeleteCmd(): { action: CmdAction } | null {
-  const claimed = CMD_FILE + ".claimed";
+  const claimed = CMD_FILE() + ".claimed";
   try {
-    renameSync(CMD_FILE, claimed); // atomic claim — second caller gets ENOENT
+    renameSync(CMD_FILE(), claimed); // atomic claim — second caller gets ENOENT
     const cmd = JSON.parse(readFileSync(claimed, "utf-8"));
     unlinkSync(claimed);
     return cmd;
@@ -78,31 +77,31 @@ export function readAndDeleteCmd(): { action: CmdAction } | null {
 }
 
 export function writeCmd(action: CmdAction) {
-  writeFileSync(CMD_FILE, JSON.stringify({ action }));
+  writeFileSync(CMD_FILE(), JSON.stringify({ action }));
 }
 
 // ─── Lockfile ──────────────────────────────────────────────────────────
 export function acquireLock(): boolean {
   try {
     // Try exclusive create — fails if file already exists (atomic)
-    const fd = openSync(LOCK_FILE, "wx");
+    const fd = openSync(LOCK_FILE(), "wx");
     writeFileSync(fd, String(process.pid));
     closeSync(fd);
     return true;
   } catch {
     // File exists — check if holding process is alive
     try {
-      const pid = parseInt(readFileSync(LOCK_FILE, "utf-8").trim(), 10);
+      const pid = parseInt(readFileSync(LOCK_FILE(), "utf-8").trim(), 10);
       if (!isNaN(pid)) {
         try { process.kill(pid, 0); return false; } catch {} // stale lock
       }
       // Stale lock — overwrite
-      writeFileSync(LOCK_FILE, String(process.pid));
+      writeFileSync(LOCK_FILE(), String(process.pid));
       return true;
     } catch { return false; }
   }
 }
 
 export function releaseLock() {
-  try { unlinkSync(LOCK_FILE); } catch {}
+  try { unlinkSync(LOCK_FILE()); } catch {}
 }

package/src/services/supervisor-stopped-page.ts

@@ -4,13 +4,11 @@
  */
 import { appendFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { homedir } from "node:os";
-
-const LOG_FILE = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"), "ppm.log");
+import { getPpmDir } from "./ppm-dir.ts";
 
 function log(level: string, msg: string) {
   const ts = new Date().toISOString();
-  try { appendFileSync(LOG_FILE, `[${ts}] [${level}] [stopped-page] ${msg}\n`); } catch {}
+  try { appendFileSync(resolve(getPpmDir(), "ppm.log"), `[${ts}] [${level}] [stopped-page] ${msg}\n`); } catch {}
 }
 
 const STOPPED_HTML = `<!DOCTYPE html>

package/src/services/supervisor.ts

@@ -6,11 +6,11 @@
  */
 import type { Subprocess } from "bun";
 import { resolve } from "node:path";
-import { homedir } from "node:os";
 import {
   readFileSync, writeFileSync, existsSync, mkdirSync, openSync, appendFileSync,
   unlinkSync,
 } from "node:fs";
+import { getPpmDir } from "./ppm-dir.ts";
 import { isCompiledBinary } from "./autostart-generator.ts";
 import {
   type SupervisorState,
@@ -34,9 +34,8 @@ const UPGRADE_CHECK_INTERVAL_MS = 900_000;  // 15min
 const UPGRADE_SKIP_INITIAL_MS = 300_000;    // 5min delay before first check
 const SELF_REPLACE_TIMEOUT_MS = 30_000;     // 30s to wait for new supervisor
 
-const PPM_DIR = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"));
-const LOG_FILE = resolve(PPM_DIR, "ppm.log");
-const RESTARTING_FLAG = resolve(PPM_DIR, ".restarting");
+const logFile = () => resolve(getPpmDir(), "ppm.log");
+const restartingFlag = () => resolve(getPpmDir(), ".restarting");
 
 // ─── State ─────────────────────────────────────────────────────────────
 let serverChild: Subprocess | null = null;
@@ -75,7 +74,7 @@ let originalArgv: string[] = [];
 function log(level: string, msg: string) {
   const ts = new Date().toISOString();
   const line = `[${ts}] [${level}] [supervisor] ${msg}\n`;
-  try { appendFileSync(LOG_FILE, line); } catch {}
+  try { appendFileSync(logFile(), line); } catch {}
   if (level === "ERROR" || level === "FATAL") {
     process.stderr.write(line);
   }
@@ -103,7 +102,7 @@ export async function spawnServer(
 
   const childPid = serverChild.pid;
   updateStatus({ pid: childPid });
-  writeFileSync(PID_FILE, String(process.pid)); // supervisor PID for stop
+  writeFileSync(PID_FILE(), String(process.pid)); // supervisor PID for stop
   log("INFO", `Server started (PID: ${childPid})`);
 
   const exitCode = await serverChild.exited;
@@ -413,7 +412,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     updateStatus({ state: "upgrading" });
 
     // Set restarting flag so server child's stopTunnel() skips killing the tunnel
-    try { writeFileSync(RESTARTING_FLAG, ""); } catch {}
+    try { writeFileSync(restartingFlag(), ""); } catch {}
 
     // Clear probe timer FIRST to prevent race between flush check and queued callback
     if (tunnelProbeTimer) { clearInterval(tunnelProbeTimer); tunnelProbeTimer = null; }
@@ -439,7 +438,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
 
     // Spawn new supervisor using saved argv
     const cmd = originalArgv.slice();
-    const logFd = openSync(LOG_FILE, "a");
+    const logFd = openSync(logFile(), "a");
     const child = Bun.spawn({
       cmd,
       stdio: ["ignore", logFd, logFd],
@@ -452,7 +451,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     while (Date.now() - start < SELF_REPLACE_TIMEOUT_MS) {
       await Bun.sleep(1000);
       try {
-        const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+        const data = JSON.parse(readFileSync(STATUS_FILE(), "utf-8"));
         if (data.supervisorPid && data.supervisorPid !== currentSupervisorPid) {
           log("INFO", `New supervisor detected (PID: ${data.supervisorPid}), old exiting`);
           // Children already killed, just clear remaining timers and exit
@@ -467,7 +466,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     // Timeout — new supervisor didn't start, restore old supervisor
     log("ERROR", "Self-replace timeout: new supervisor did not start");
     try { child.kill(); } catch {}
-    try { unlinkSync(RESTARTING_FLAG); } catch {}
+    try { unlinkSync(restartingFlag()); } catch {}
     shuttingDown = false;
     notifyStateChange("upgrading", "running", "upgrade_failed");
     setState("running");
@@ -475,7 +474,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     return { success: false, error: "New supervisor failed to start within 30s" };
   } catch (e) {
     log("ERROR", `Self-replace error: ${e}`);
-    try { unlinkSync(RESTARTING_FLAG); } catch {}
+    try { unlinkSync(restartingFlag()); } catch {}
     shuttingDown = false;
     notifyStateChange("upgrading", "running", "upgrade_failed");
     setState("running");
@@ -741,15 +740,16 @@ export async function runSupervisor(opts: {
   profile?: string;
   share: boolean;
 }) {
-  if (!existsSync(PPM_DIR)) mkdirSync(PPM_DIR, { recursive: true });
+  const ppmDir = getPpmDir();
+  if (!existsSync(ppmDir)) mkdirSync(ppmDir, { recursive: true });
 
   // Clean up restarting flag from previous upgrade/restart
-  try { unlinkSync(RESTARTING_FLAG); } catch {}
+  try { unlinkSync(restartingFlag()); } catch {}
 
   // Save original argv for self-replace
   originalArgv = [...process.argv];
 
-  const logFd = openSync(LOG_FILE, "a");
+  const logFd = openSync(logFile(), "a");
   log("INFO", `Supervisor started (PID: ${process.pid}, port: ${opts.port}, share: ${opts.share})`);
 
   // Global exception handlers — supervisor must never crash
@@ -761,7 +761,7 @@ export async function runSupervisor(opts: {
   });
 
   // Write supervisor PID + clear stale availableVersion from previous run
-  writeFileSync(PID_FILE, String(process.pid));
+  writeFileSync(PID_FILE(), String(process.pid));
   updateStatus({
     supervisorPid: process.pid, port: opts.port, host: opts.host, availableVersion: null,
     state: "running", pausedAt: null, pauseReason: null, lastCrashError: null,

package/src/services/tunnel.service.ts

@@ -1,12 +1,11 @@
 import type { Subprocess } from "bun";
 import { resolve } from "node:path";
-import { homedir } from "node:os";
 import { existsSync, unlinkSync, readFileSync, writeFileSync, renameSync } from "node:fs";
 import { ensureCloudflared } from "./cloudflared.service.ts";
+import { getPpmDir } from "./ppm-dir.ts";
 
 const TUNNEL_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
 const decoder = new TextDecoder();
-const RESTARTING_FLAG = resolve(homedir(), ".ppm", ".restarting");
 
 /** Extract tunnel URL from cloudflared stderr output */
 export function extractTunnelUrl(text: string): string | null {
@@ -98,7 +97,7 @@ class TunnelService {
       this.cleanupHandler = null;
     }
     // If server is restarting, keep tunnel alive
-    if (existsSync(RESTARTING_FLAG)) {
+    if (existsSync(resolve(getPpmDir(), ".restarting"))) {
       this.childProcess = null;
       this.externalPid = null;
       this.url = null;
@@ -136,7 +135,7 @@ class TunnelService {
   private syncFromStatusFile(): void {
     if (this.url) return; // already have a URL
     try {
-      const statusFile = resolve(homedir(), ".ppm", "status.json");
+      const statusFile = resolve(getPpmDir(), "status.json");
       const status = JSON.parse(readFileSync(statusFile, "utf-8"));
       if (status.shareUrl) {
         this.url = status.shareUrl;
@@ -166,7 +165,7 @@ class TunnelService {
 
   /** Persist shareUrl + tunnelPid to status.json (atomic write to avoid cross-process races) */
   private persistToStatusFile(): void {
-    const statusFile = resolve(homedir(), ".ppm", "status.json");
+    const statusFile = resolve(getPpmDir(), "status.json");
     if (!existsSync(statusFile)) return;
     try {
       const data = JSON.parse(readFileSync(statusFile, "utf-8"));

package/src/services/upgrade.service.ts

@@ -3,14 +3,13 @@
  * detects install method, runs install command.
  */
 import { resolve } from "node:path";
-import { homedir } from "node:os";
 import { readFileSync } from "node:fs";
 import { VERSION } from "../version.ts";
 import { isCompiledBinary } from "./autostart-generator.ts";
+import { getPpmDir } from "./ppm-dir.ts";
 
 const NPM_REGISTRY_URL = "https://registry.npmjs.org/@hienlh/ppm/latest";
 const FETCH_TIMEOUT_MS = 10_000;
-const STATUS_FILE = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"), "status.json");
 
 export type InstallMethod = "bun" | "npm" | "binary";
 
@@ -103,7 +102,7 @@ export async function applyUpgrade(): Promise<{
 /** Send SIGUSR1 to supervisor to trigger self-replace after upgrade */
 export function signalSupervisorUpgrade(): { sent: boolean; error?: string } {
   try {
-    const data = JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+    const data = JSON.parse(readFileSync(resolve(getPpmDir(), "status.json"), "utf-8"));
     const pid = data.supervisorPid;
     if (!pid) return { sent: false, error: "No supervisor PID" };
     process.kill(pid, 0); // check alive

package/src/types/chat.ts

@@ -116,7 +116,7 @@ export type ChatEvent =
   | { type: "tool_result"; output: string; isError?: boolean; toolUseId?: string; parentToolUseId?: string }
   | { type: "approval_request"; requestId: string; tool: string; input: unknown }
   | { type: "error"; message: string }
-  | { type: "done"; sessionId: string; resultSubtype?: ResultSubtype; numTurns?: number; contextWindowPct?: number }
+  | { type: "done"; sessionId: string; resultSubtype?: ResultSubtype; numTurns?: number; contextWindowPct?: number; lastMessageUuid?: string }
   | { type: "account_info"; accountId: string; accountLabel: string }
   | { type: "account_retry"; reason: string; accountId?: string; accountLabel?: string }
   | { type: "status_update"; phase: "routing" | "refreshing" | "switching"; message: string; accountLabel?: string }
@@ -139,4 +139,6 @@ export interface ChatMessage {
   /** Account used to generate this assistant message */
   accountId?: string;
   accountLabel?: string;
+  /** SDK message UUID — used for fork/rewind (maps to JSONL message IDs) */
+  sdkUuid?: string;
 }

package/src/web/components/chat/chat-tab.tsx

@@ -36,6 +36,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
   const [slashItems, setSlashItems] = useState<SlashItem[]>([]);
   const [showSlashPicker, setShowSlashPicker] = useState(false);
   const [slashFilter, setSlashFilter] = useState("");
+  const [slashRanked, setSlashRanked] = useState(false);
   const [slashSelected, setSlashSelected] = useState<SlashItem | null>(null);
 
   // File picker state
@@ -243,6 +244,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
   const handleSlashStateChange = useCallback((visible: boolean, filter: string) => {
     setShowSlashPicker(visible);
     setSlashFilter(filter);
+    if (!visible || !filter) setSlashRanked(false);
   }, []);
 
   const handleSlashSelect = useCallback((item: SlashItem) => {
@@ -383,6 +385,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
           onSelect={handleSlashSelect}
           onClose={handleSlashClose}
           visible={showSlashPicker}
+          ranked={slashRanked}
         />
         <FilePicker
           items={fileItems}
@@ -404,7 +407,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
           initialValue={forkDraft}
           projectName={projectName}
           onSlashStateChange={handleSlashStateChange}
-          onSlashItemsLoaded={setSlashItems}
+          onSlashItemsLoaded={(items, ranked) => { setSlashItems(items); if (ranked !== undefined) setSlashRanked(ranked); }}
           slashSelected={slashSelected}
           onFileStateChange={handleFileStateChange}
           onFileItemsLoaded={setFileItems}

package/src/web/components/chat/message-input.tsx

@@ -32,7 +32,7 @@ interface MessageInputProps {
   projectName?: string;
   /** Slash picker state change */
   onSlashStateChange?: (visible: boolean, filter: string) => void;
-  onSlashItemsLoaded?: (items: SlashItem[]) => void;
+  onSlashItemsLoaded?: (items: SlashItem[], ranked?: boolean) => void;
   slashSelected?: SlashItem | null;
   /** File picker state change */
   onFileStateChange?: (visible: boolean, filter: string) => void;
@@ -83,6 +83,9 @@ export const MessageInput = memo(function MessageInput({
   const mobileTextareaRef = useRef<HTMLTextAreaElement>(null);
   const fileInputRef = useRef<HTMLInputElement>(null);
   const slashItemsRef = useRef<SlashItem[]>([]);
+  const slashRankedRef = useRef(false);
+  const slashDebounceRef = useRef<ReturnType<typeof setTimeout>>(undefined);
+  const slashSearchIdRef = useRef(0);
   const fileItemsRef = useRef<FileNode[]>([]);
 
   // Voice input (Web Speech API)
@@ -147,21 +150,29 @@ export const MessageInput = memo(function MessageInput({
   useEffect(() => {
     if (!projectName) {
       slashItemsRef.current = [];
-      onSlashItemsLoaded?.([]);
+      onSlashItemsLoaded?.([], false);
       return;
     }
     api
       .get<SlashItem[]>(`${projectUrl(projectName)}/chat/slash-items`)
       .then((items) => {
         slashItemsRef.current = items;
-        onSlashItemsLoaded?.(items);
+        slashRankedRef.current = false;
+        onSlashItemsLoaded?.(items, false);
       })
       .catch(() => {
         slashItemsRef.current = [];
-        onSlashItemsLoaded?.([]);
+        onSlashItemsLoaded?.([], false);
       });
   }, [projectName]); // eslint-disable-line react-hooks/exhaustive-deps
 
+  // Cleanup debounce timer on unmount
+  useEffect(() => {
+    return () => {
+      if (slashDebounceRef.current) clearTimeout(slashDebounceRef.current);
+    };
+  }, []);
+
   // Fetch file tree when projectName changes
   useEffect(() => {
     if (!projectName) {
@@ -387,6 +398,30 @@ export const MessageInput = memo(function MessageInput({
     [handleSend, permissionMode, onModeChange],
   );
 
+  /** Debounced server-side fuzzy search for slash items */
+  const fetchSlashSearch = useCallback(
+    (query: string) => {
+      if (slashDebounceRef.current) clearTimeout(slashDebounceRef.current);
+      if (!projectName || !query) return;
+      const requestId = ++slashSearchIdRef.current;
+      slashDebounceRef.current = setTimeout(() => {
+        api
+          .get<SlashItem[]>(`${projectUrl(projectName)}/chat/slash-items?q=${encodeURIComponent(query)}`)
+          .then((items) => {
+            if (requestId !== slashSearchIdRef.current) return; // stale response
+            slashItemsRef.current = items;
+            slashRankedRef.current = true;
+            onSlashItemsLoaded?.(items, true);
+          })
+          .catch(() => {
+            if (requestId !== slashSearchIdRef.current) return;
+            slashRankedRef.current = false;
+          });
+      }, 150);
+    },
+    [projectName, onSlashItemsLoaded],
+  );
+
   const updatePickerState = useCallback(
     (text: string, cursorPos: number) => {
       const textBefore = text.slice(0, cursorPos);
@@ -394,11 +429,18 @@ export const MessageInput = memo(function MessageInput({
       // Check for slash anywhere in text (after whitespace or at start)
       const slashMatch = textBefore.match(/(?:^|\s)\/(\S*)$/);
       if (slashMatch && slashItemsRef.current.length > 0) {
-        onSlashStateChange?.(true, slashMatch[1] ?? "");
+        const filter = slashMatch[1] ?? "";
+        onSlashStateChange?.(true, filter);
         onFileStateChange?.(false, "");
+        // Trigger server-side search for non-empty filter
+        if (filter) fetchSlashSearch(filter);
         return;
       }
 
+      // Cancel pending search when slash picker closes
+      if (slashDebounceRef.current) clearTimeout(slashDebounceRef.current);
+      if (slashRankedRef.current) slashRankedRef.current = false;
+
       // Check for @ anywhere in text (after whitespace or at start)
       const atMatch = textBefore.match(/@(\S*)$/);
       if (atMatch && fileItemsRef.current.length > 0) {
@@ -411,7 +453,7 @@ export const MessageInput = memo(function MessageInput({
       onSlashStateChange?.(false, "");
       onFileStateChange?.(false, "");
     },
-    [onSlashStateChange, onFileStateChange],
+    [onSlashStateChange, onFileStateChange, fetchSlashSearch],
   );
 
   const handleChange = useCallback(

package/src/web/components/chat/message-list.tsx

@@ -105,9 +105,9 @@ export function MessageList({
                 isStreaming={isStreaming && msg.id.startsWith("streaming-")}
                 projectName={projectName}
                 onFork={msg.role === "user" && onFork ? () => {
-                  // Pass the previous message ID so the fork includes history up to (but not including) this user message
+                  // Pass the SDK UUID of the previous assistant message for fork (JSONL-level message ID)
                   const prevMsg = idx > 0 ? filtered[idx - 1] : undefined;
-                  onFork(msg.content, prevMsg?.id);
+                  onFork(msg.content, prevMsg?.sdkUuid ?? prevMsg?.id);
                 } : undefined}
               />
             ))}