@ganglion/xacpx 0.17.0-beta.0 → 0.17.0-beta.2

package/dist/cli.js

@@ -25585,6 +25585,9 @@ function terminalIdleTimeoutSeconds(config4) {
   const v = config4.terminal?.idleTimeoutSeconds;
   return typeof v === "number" && v > 0 ? v : 900;
 }
+function filesWriteEnabled(config4) {
+  return config4.files?.writeEnabled === true;
+}
 
 // src/orchestration/orchestration-server.ts
 import { chmod as chmod4, rm as rm8 } from "node:fs/promises";
@@ -33681,11 +33684,11 @@ async function readNativeSessionHistory(opts) {
 var init_native_session_history = () => {};
 
 // src/control/workspace-fs.ts
-import { execFile } from "node:child_process";
+import { execFile, spawn as spawn11 } from "node:child_process";
 import { promisify } from "node:util";
 import { homedir as homedir12 } from "node:os";
-import { readdir as readdir4, realpath, stat as stat3, open as open5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, relative, resolve as resolve3, sep } from "node:path";
+import { readdir as readdir4, realpath, stat as stat3, open as open5, readFile as readFile15, writeFile as writeFile8, mkdir as mkdir9, rename as fsRename, cp, rm as rm10 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname12, isAbsolute as isAbsolute3, relative, resolve as resolve3, sep } from "node:path";
 function expandHome2(p) {
   if (p === "~")
     return homedir12();
@@ -33723,8 +33726,93 @@ class WorkspaceFs {
     const rel = abs === root ? "" : relative(root, abs).split(sep).join("/");
     return { root, abs, rel };
   }
-  async listDirectory(workspace3, relPath) {
+  async resolveParent(workspace3, relPath) {
+    if (relPath && isAbsolute3(relPath))
+      throw new Error("path-must-be-relative");
+    const trimmed = (relPath ?? "").replace(/\/+$/, "");
+    if (!trimmed)
+      throw new Error("bad-target");
+    const name = basename3(trimmed);
+    if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\\")) {
+      throw new Error("bad-target");
+    }
+    const parentRel = dirname12(trimmed);
+    const { root, abs: parentAbs, rel: parentRelNorm } = await this.resolve(workspace3, parentRel === "." ? undefined : parentRel);
+    const targetAbs = resolve3(parentAbs, name);
+    const rel = parentRelNorm ? `${parentRelNorm}/${name}` : name;
+    return { root, parentAbs, name, targetAbs, rel };
+  }
+  async createFile(workspace3, relPath) {
+    const { targetAbs, rel } = await this.resolveParent(workspace3, relPath);
+    try {
+      await writeFile8(targetAbs, "", { flag: "wx" });
+    } catch (e) {
+      if (e.code === "EEXIST")
+        throw new Error("already-exists");
+      throw e;
+    }
+    return { path: rel };
+  }
+  async createDir(workspace3, relPath) {
+    const { targetAbs, rel } = await this.resolveParent(workspace3, relPath);
+    try {
+      await mkdir9(targetAbs);
+    } catch (e) {
+      if (e.code === "EEXIST")
+        throw new Error("already-exists");
+      throw e;
+    }
+    return { path: rel };
+  }
+  async rename(workspace3, relPath, newName) {
+    const src = await this.resolve(workspace3, relPath);
+    if (!src.rel)
+      throw new Error("bad-target");
+    if (newName.includes("/") || newName.includes("\\"))
+      throw new Error("bad-target");
+    const destRelInput = src.rel.includes("/") ? `${src.rel.slice(0, src.rel.lastIndexOf("/"))}/${newName}` : newName;
+    const dest = await this.resolveParent(workspace3, destRelInput);
+    try {
+      await stat3(dest.targetAbs);
+      throw new Error("already-exists");
+    } catch (e) {
+      if (e.message === "already-exists")
+        throw e;
+    }
+    await fsRename(src.abs, dest.targetAbs);
+    return { path: dest.rel };
+  }
+  async duplicate(workspace3, relPath) {
+    const src = await this.resolve(workspace3, relPath);
+    if (!src.rel)
+      throw new Error("bad-target");
+    const parent = await this.resolveParent(workspace3, src.rel);
+    const siblings = new Set(await readdir4(parent.parentAbs));
+    const newBase = copyName(siblings, parent.name);
+    const destAbs = resolve3(parent.parentAbs, newBase);
+    await cp(src.abs, destAbs, { recursive: true });
+    const destRel = parent.rel.includes("/") ? `${parent.rel.slice(0, parent.rel.lastIndexOf("/"))}/${newBase}` : newBase;
+    return { path: destRel };
+  }
+  async remove(workspace3, relPath) {
     const { abs, rel } = await this.resolve(workspace3, relPath);
+    if (!rel)
+      throw new Error("refuse-delete-root");
+    await rm10(abs, { recursive: true, force: false });
+    return { path: rel };
+  }
+  async readFileBytes(workspace3, relPath) {
+    const { abs, rel } = await this.resolve(workspace3, relPath);
+    const info = await stat3(abs);
+    if (!info.isFile())
+      throw new Error("not-a-file");
+    if (info.size > DOWNLOAD_MAX)
+      throw new Error("file-too-large");
+    const buf = await readFile15(abs);
+    return { path: rel, base64: buf.toString("base64"), size: info.size, mimeType: mimeForName(basename3(abs)) };
+  }
+  async listDirectory(workspace3, relPath) {
+    const { root, abs, rel } = await this.resolve(workspace3, relPath);
     const dirents = await readdir4(abs, { withFileTypes: true });
     const entries = [];
     for (const d of dirents.slice(0, MAX_ENTRIES)) {
@@ -33741,7 +33829,49 @@ class WorkspaceFs {
       }
     }
     entries.sort((a, b) => a.type !== b.type ? a.type === "dir" ? -1 : 1 : a.name.localeCompare(b.name));
-    return { workspace: workspace3, path: rel, entries };
+    const relOf = (name, isDir) => (rel ? `${rel}/${name}` : name) + (isDir ? "/" : "");
+    const ignoredSet = await this.gitCheckIgnore(root, entries.map((e) => relOf(e.name, e.type === "dir")));
+    for (const e of entries) {
+      if (ignoredSet.has(relOf(e.name, e.type === "dir")))
+        e.ignored = true;
+    }
+    return { workspace: workspace3, path: rel, entries, root, sep };
+  }
+  gitCheckIgnore(root, relPaths) {
+    return new Promise((resolvePromise) => {
+      if (!relPaths.length)
+        return resolvePromise(new Set);
+      const ignored = new Set;
+      let out = "";
+      let child;
+      try {
+        child = spawn11("git", ["-C", root, "check-ignore", "-z", "--stdin"], { stdio: ["pipe", "pipe", "ignore"] });
+      } catch {
+        return resolvePromise(ignored);
+      }
+      const killer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {}
+      }, GIT_TIMEOUT_MS);
+      child.on("error", () => {
+        clearTimeout(killer);
+        resolvePromise(ignored);
+      });
+      child.stdout.on("data", (b) => {
+        out += b.toString();
+      });
+      child.on("close", () => {
+        clearTimeout(killer);
+        for (const p of out.split("\x00")) {
+          if (p)
+            ignored.add(p);
+        }
+        resolvePromise(ignored);
+      });
+      child.stdin.on("error", () => {});
+      child.stdin.end(relPaths.join("\x00") + "\x00");
+    });
   }
   async readFile(workspace3, relPath) {
     const { abs, rel } = await this.resolve(workspace3, relPath);
@@ -33766,16 +33896,28 @@ class WorkspaceFs {
       await fh.close();
     }
   }
-  async search(workspace3, query) {
-    const { root } = await this.resolve(workspace3, undefined);
-    const needle = query.trim().toLowerCase();
+  async search(workspace3, opts) {
+    const { root, abs: base, rel: scopeRel } = await this.resolve(workspace3, opts.path);
+    const query = opts.query.trim();
+    const empty = { workspace: workspace3, query, matches: [], hits: [], truncated: false };
+    if (!query)
+      return empty;
+    if ((opts.mode ?? "name") === "content") {
+      return this.contentGrep(workspace3, root, base, scopeRel, opts, query);
+    }
+    const matcher = buildMatcher(query, opts);
+    const inc = opts.include ? globToRegExp(opts.include) : null;
+    const exc = opts.exclude ? globToRegExp(opts.exclude) : null;
     const matches = [];
-    if (!needle)
-      return { workspace: workspace3, query, matches, truncated: false };
     let scanned = 0;
     let truncated = false;
-    const queue = [root];
+    const deadline = Date.now() + SEARCH_DEADLINE_MS;
+    const queue = [base];
     while (queue.length) {
+      if (Date.now() > deadline) {
+        truncated = true;
+        break;
+      }
       const dir = queue.shift();
       let dirents;
       try {
@@ -33784,6 +33926,10 @@ class WorkspaceFs {
         continue;
       }
       for (const d of dirents) {
+        if (Date.now() > deadline) {
+          truncated = true;
+          break;
+        }
         if (++scanned > SEARCH_MAX_SCAN) {
           truncated = true;
           break;
@@ -33795,7 +33941,11 @@ class WorkspaceFs {
             queue.push(resolve3(dir, d.name));
         } else if (d.isFile()) {
           const rel = relative(root, resolve3(dir, d.name)).split(sep).join("/");
-          if (rel.toLowerCase().includes(needle)) {
+          if (inc && !inc.test(rel))
+            continue;
+          if (exc && exc.test(rel))
+            continue;
+          if (matcher(rel)) {
             matches.push(rel);
             if (matches.length >= SEARCH_MAX_RESULTS) {
               truncated = true;
@@ -33808,18 +33958,199 @@ class WorkspaceFs {
         break;
     }
     matches.sort();
-    return { workspace: workspace3, query, matches, truncated };
+    return { workspace: workspace3, query, matches, hits: [], truncated };
+  }
+  async contentGrep(workspace3, root, base, scopeRel, opts, query) {
+    const inc = opts.include ? globToRegExp(opts.include) : null;
+    const exc = opts.exclude ? globToRegExp(opts.exclude) : null;
+    const inGit = await execFileAsync("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" }).then(() => true).catch(() => false);
+    if (inGit) {
+      const args = ["-C", root, "grep", "-n", "--column", "-I", "--no-color", "--untracked"];
+      if (!opts.matchCase)
+        args.push("-i");
+      if (opts.wholeWord)
+        args.push("-w");
+      args.push(opts.regex ? "-E" : "-F");
+      args.push("-e", query, "--", scopeRel || ".");
+      let stdout2 = "";
+      let killed = false;
+      try {
+        stdout2 = (await execFileAsync("git", args, { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
+      } catch (e) {
+        killed = e.killed === true || e.signal === "SIGKILL";
+        const code = e.code;
+        if (code === 1)
+          stdout2 = "";
+        else {
+          const out = e.stdout;
+          stdout2 = typeof out === "string" ? out : "";
+        }
+      }
+      const hits2 = [];
+      let truncated2 = killed;
+      for (const raw of stdout2.split(`
+`)) {
+        if (!raw)
+          continue;
+        const m = raw.match(/^(.*?):(\d+):(\d+):(.*)$/);
+        if (!m)
+          continue;
+        const p = m[1].split(sep).join("/");
+        if (inc && !inc.test(p))
+          continue;
+        if (exc && exc.test(p))
+          continue;
+        hits2.push({ path: p, line: Number(m[2]), text: m[4].slice(0, 400) });
+        if (hits2.length >= SEARCH_CONTENT_MAX_HITS) {
+          truncated2 = true;
+          break;
+        }
+      }
+      return { workspace: workspace3, query, matches: [], hits: hits2, truncated: truncated2 };
+    }
+    try {
+      const args = ["grep", "--no-index", "-n", "--column", "-I", "--no-color"];
+      if (!opts.matchCase)
+        args.push("-i");
+      if (opts.wholeWord)
+        args.push("-w");
+      args.push(opts.regex ? "-E" : "-F");
+      args.push("-e", query, "--", ".", ":(exclude)node_modules/", ":(exclude).git/");
+      let stdout2 = "";
+      let killed = false;
+      try {
+        stdout2 = (await execFileAsync("git", args, { cwd: base, maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
+      } catch (e) {
+        if (e.code === "ENOENT")
+          throw e;
+        killed = e.killed === true || e.signal === "SIGKILL";
+        const code = e.code;
+        if (code === 1)
+          stdout2 = "";
+        else {
+          const out = e.stdout;
+          stdout2 = typeof out === "string" ? out : "";
+        }
+      }
+      const hits2 = [];
+      let truncated2 = killed;
+      for (const raw of stdout2.split(`
+`)) {
+        if (!raw)
+          continue;
+        const m = raw.match(/^(.*?):(\d+):(\d+):(.*)$/);
+        if (!m)
+          continue;
+        const relToBase = m[1].split(sep).join("/");
+        const p = scopeRel ? `${scopeRel}/${relToBase}` : relToBase;
+        if (inc && !inc.test(p))
+          continue;
+        if (exc && exc.test(p))
+          continue;
+        hits2.push({ path: p, line: Number(m[2]), text: m[4].slice(0, 400) });
+        if (hits2.length >= SEARCH_CONTENT_MAX_HITS) {
+          truncated2 = true;
+          break;
+        }
+      }
+      return { workspace: workspace3, query, matches: [], hits: hits2, truncated: truncated2 };
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        return { workspace: workspace3, query, matches: [], hits: [], truncated: false };
+      }
+    }
+    const matcher = buildLineMatcher(query, opts);
+    const hits = [];
+    let scanned = 0;
+    let truncated = false;
+    const deadline = Date.now() + SEARCH_DEADLINE_MS;
+    const queue = [base];
+    while (queue.length) {
+      if (Date.now() > deadline) {
+        truncated = true;
+        break;
+      }
+      const dir = queue.shift();
+      let dirents;
+      try {
+        dirents = await readdir4(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const d of dirents) {
+        if (Date.now() > deadline) {
+          truncated = true;
+          break;
+        }
+        if (++scanned > SEARCH_MAX_SCAN) {
+          truncated = true;
+          break;
+        }
+        if (d.isSymbolicLink())
+          continue;
+        const full = resolve3(dir, d.name);
+        if (d.isDirectory()) {
+          if (!SEARCH_SKIP_DIRS.has(d.name))
+            queue.push(full);
+          continue;
+        }
+        if (!d.isFile())
+          continue;
+        const rel = relative(root, full).split(sep).join("/");
+        if (inc && !inc.test(rel))
+          continue;
+        if (exc && exc.test(rel))
+          continue;
+        let info;
+        try {
+          info = await stat3(full);
+        } catch {
+          continue;
+        }
+        if (info.size > SEARCH_CONTENT_MAX_FILE)
+          continue;
+        let text;
+        try {
+          text = await readFile15(full, "utf8");
+        } catch {
+          continue;
+        }
+        if (text.includes("\x00"))
+          continue;
+        const lines = text.split(`
+`);
+        for (let i = 0;i < lines.length; i++) {
+          if (Date.now() > deadline) {
+            truncated = true;
+            break;
+          }
+          const line = lines[i];
+          if (matcher(line.length > LINE_MATCH_CAP ? line.slice(0, LINE_MATCH_CAP) : line)) {
+            hits.push({ path: rel, line: i + 1, text: line.slice(0, 400) });
+            if (hits.length >= SEARCH_CONTENT_MAX_HITS) {
+              truncated = true;
+              break;
+            }
+          }
+        }
+        if (truncated)
+          break;
+      }
+      if (truncated)
+        break;
+    }
+    return { workspace: workspace3, query, matches: [], hits, truncated };
   }
   async gitDiff(workspace3, relPath) {
     const { root, rel } = await this.resolve(workspace3, relPath);
     try {
-      await execFileAsync("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { maxBuffer: GIT_MAX_BUFFER });
+      await execFileAsync("git", ["-C", root, "rev-parse", "--is-inside-work-tree"], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" });
     } catch {
       throw new Error("not-a-git-repo");
     }
     const files = [];
     try {
-      const { stdout: stdout2 } = await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "status", "--porcelain", "-z"], { maxBuffer: GIT_MAX_BUFFER });
+      const { stdout: stdout2 } = await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "status", "--porcelain", "-z"], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" });
       const fields = stdout2.split("\x00");
       for (let i = 0;i < fields.length; i++) {
         const field = fields[i];
@@ -33835,17 +34166,17 @@ class WorkspaceFs {
     const diffArgs = (base) => ["-C", root, ...base, ...rel ? ["--", rel] : []];
     let diff = "";
     try {
-      diff = (await execFileAsync("git", diffArgs(["diff", "HEAD"]), { maxBuffer: GIT_MAX_BUFFER })).stdout;
+      diff = (await execFileAsync("git", diffArgs(["diff", "HEAD"]), { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
     } catch {
       try {
-        diff = (await execFileAsync("git", diffArgs(["diff"]), { maxBuffer: GIT_MAX_BUFFER })).stdout;
+        diff = (await execFileAsync("git", diffArgs(["diff"]), { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
       } catch {
         diff = "";
       }
     }
     if (rel && !diff) {
       try {
-        diff = (await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "diff", "--no-index", "--", "/dev/null", rel], { maxBuffer: GIT_MAX_BUFFER })).stdout;
+        diff = (await execFileAsync("git", ["-C", root, "-c", "core.quotePath=false", "diff", "--no-index", "--", "/dev/null", rel], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout;
       } catch (e) {
         const out = e.stdout;
         if (typeof out === "string")
@@ -33858,7 +34189,7 @@ class WorkspaceFs {
   async gitContext(root) {
     const run = async (...args) => {
       try {
-        return (await execFileAsync("git", ["-C", root, ...args], { maxBuffer: GIT_MAX_BUFFER })).stdout.trim();
+        return (await execFileAsync("git", ["-C", root, ...args], { maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, killSignal: "SIGKILL" })).stdout.trim();
       } catch {
         return null;
       }
@@ -33878,17 +34209,106 @@ class WorkspaceFs {
     return ctx;
   }
 }
-var execFileAsync, MAX_ENTRIES = 2000, FILE_READ_CAP, DIFF_CAP, GIT_MAX_BUFFER, SEARCH_MAX_RESULTS = 200, SEARCH_MAX_SCAN = 20000, SEARCH_SKIP_DIRS;
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function copyName(existing, name) {
+  const dot = name.lastIndexOf(".");
+  const hasExt = dot > 0;
+  const base = hasExt ? name.slice(0, dot) : name;
+  const ext = hasExt ? name.slice(dot) : "";
+  let candidate = `${base} copy${ext}`;
+  let n = 2;
+  while (existing.has(candidate))
+    candidate = `${base} copy ${n++}${ext}`;
+  return candidate;
+}
+function mimeForName(name) {
+  const dot = name.lastIndexOf(".");
+  const ext = dot > 0 ? name.slice(dot).toLowerCase() : "";
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+function buildMatcher(query, opts) {
+  return buildLineMatcher(query, opts);
+}
+function buildLineMatcher(query, opts) {
+  const flags = opts.matchCase ? "" : "i";
+  let pattern;
+  if (opts.regex)
+    pattern = query;
+  else
+    pattern = escapeRe(query);
+  if (opts.wholeWord)
+    pattern = `\\b${pattern}\\b`;
+  let re = null;
+  try {
+    re = new RegExp(pattern, flags);
+  } catch {
+    re = null;
+  }
+  if (!re) {
+    const needle = opts.matchCase ? query : query.toLowerCase();
+    return (s) => (opts.matchCase ? s : s.toLowerCase()).includes(needle);
+  }
+  return (s) => re.test(s);
+}
+function globToRegExp(glob) {
+  let re = "^";
+  for (let i = 0;i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (glob[i + 1] === "/")
+          i++;
+      } else
+        re += "[^/]*";
+    } else if (c === "?")
+      re += "[^/]";
+    else
+      re += escapeRe(c);
+  }
+  re += "$";
+  try {
+    return new RegExp(re);
+  } catch {
+    return /$^/;
+  }
+}
+var execFileAsync, MAX_ENTRIES = 2000, FILE_READ_CAP, DIFF_CAP, GIT_MAX_BUFFER, SEARCH_MAX_RESULTS = 200, SEARCH_MAX_SCAN = 20000, SEARCH_SKIP_DIRS, SEARCH_CONTENT_MAX_HITS = 500, SEARCH_CONTENT_MAX_FILE, LINE_MATCH_CAP = 2000, DOWNLOAD_MAX, GIT_TIMEOUT_MS = 1e4, SEARCH_DEADLINE_MS = 4000, MIME_BY_EXT;
 var init_workspace_fs = __esm(() => {
   execFileAsync = promisify(execFile);
   FILE_READ_CAP = 256 * 1024;
   DIFF_CAP = 512 * 1024;
   GIT_MAX_BUFFER = 32 * 1024 * 1024;
   SEARCH_SKIP_DIRS = new Set([".git", "node_modules"]);
+  SEARCH_CONTENT_MAX_FILE = 1024 * 1024;
+  DOWNLOAD_MAX = 5 * 1024 * 1024;
+  MIME_BY_EXT = {
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".json": "application/json",
+    ".js": "text/javascript",
+    ".ts": "text/plain",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".csv": "text/csv",
+    ".xml": "application/xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".pdf": "application/pdf",
+    ".zip": "application/zip"
+  };
 });
 
 // src/control/control-service.ts
 import path15 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 class ControlService {
   deps;
@@ -33905,8 +34325,31 @@ class ControlService {
   workspaceGitDiff(workspace3, path16) {
     return this.workspaceFs.gitDiff(workspace3, path16);
   }
-  searchWorkspace(workspace3, query) {
-    return this.workspaceFs.search(workspace3, query);
+  searchWorkspace(workspace3, opts) {
+    return this.workspaceFs.search(workspace3, opts);
+  }
+  async fsCreate(workspace3, path16, kind) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return kind === "dir" ? this.workspaceFs.createDir(workspace3, path16) : this.workspaceFs.createFile(workspace3, path16);
+  }
+  async fsRename(workspace3, path16, newName) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return this.workspaceFs.rename(workspace3, path16, newName);
+  }
+  async fsDelete(workspace3, path16) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return this.workspaceFs.remove(workspace3, path16);
+  }
+  async fsCopy(workspace3, path16) {
+    if (!this.deps.filesWriteEnabled())
+      throw new Error("files-write-disabled");
+    return this.workspaceFs.duplicate(workspace3, path16);
+  }
+  async fsDownload(workspace3, path16) {
+    return this.workspaceFs.readFileBytes(workspace3, path16);
   }
   async uploadFile(input) {
     return this.deps.uploadStore.save(input.filename, input.content, input.mimeType);
@@ -34056,12 +34499,23 @@ class ControlService {
     return task;
   }
   inFlight = new Map;
+  queues = new Map;
+  draining = new Set;
+  emitQueueUpdated(chatKey, sessionAlias) {
+    const items = (this.queues.get(turnKey(chatKey, sessionAlias)) ?? []).map((q) => ({
+      id: q.id,
+      textPreview: q.text.length > QUEUE_PREVIEW_MAX ? q.text.slice(0, QUEUE_PREVIEW_MAX) : q.text,
+      enqueuedAt: q.enqueuedAt
+    }));
+    this.deps.events.emit({ type: "queue-updated", chatKey, sessionAlias, items });
+  }
   async prompt(input) {
     return this.executeTurn({
       chatKey: input.chatKey,
       sessionAlias: input.sessionAlias,
       text: input.text,
       senderId: input.senderId,
+      queueable: true,
       ...input.isOwner !== undefined ? { isOwner: input.isOwner } : {},
       ...input.accountId !== undefined ? { accountId: input.accountId } : {},
       ...input.media !== undefined ? { media: input.media } : {}
@@ -34081,14 +34535,34 @@ class ControlService {
   }
   async executeTurn(params) {
     const key = turnKey(params.chatKey, params.sessionAlias);
-    const existing = this.inFlight.get(key);
-    if (existing) {
-      if (!existing.controller.signal.aborted) {
+    if (!params.drained) {
+      const existing = this.inFlight.get(key);
+      const busy = this.draining.has(key) || existing !== undefined && !existing.controller.signal.aborted;
+      if (busy) {
+        if (params.queueable) {
+          const id = randomUUID3();
+          const item = {
+            id,
+            text: params.text,
+            enqueuedAt: new Date().toISOString(),
+            senderId: params.senderId,
+            ...params.isOwner !== undefined ? { isOwner: params.isOwner } : {},
+            ...params.accountId !== undefined ? { accountId: params.accountId } : {},
+            ...params.media !== undefined ? { media: params.media } : {}
+          };
+          const q = this.queues.get(key) ?? [];
+          q.push(item);
+          this.queues.set(key, q);
+          this.emitQueueUpdated(params.chatKey, params.sessionAlias);
+          return { ok: true, queued: true, queueItemId: id };
+        }
         return { ok: false, errorMessage: "turn-already-running" };
       }
-      await raceWithTimeout(existing.settled, CANCEL_DRAIN_TIMEOUT_MS);
-      if (this.inFlight.has(key)) {
-        return { ok: false, errorMessage: "turn-already-running" };
+      if (existing) {
+        await raceWithTimeout(existing.settled, CANCEL_DRAIN_TIMEOUT_MS);
+        if (this.inFlight.has(key)) {
+          return { ok: false, errorMessage: "turn-already-running" };
+        }
       }
     }
     const controller = new AbortController;
@@ -34103,6 +34577,9 @@ class ControlService {
       resolveSettled = resolve4;
     });
     this.inFlight.set(key, { controller, settled });
+    if (params.drained) {
+      this.draining.delete(key);
+    }
     let internalAlias;
     let wasArchived = false;
     let priorTransportSession;
@@ -34115,8 +34592,8 @@ class ControlService {
     try {
       await this.deps.sessions.useSession(params.chatKey, params.sessionAlias);
     } catch (error2) {
-      this.inFlight.delete(key);
       resolveSettled();
+      this.advanceQueue(key, params.chatKey, params.sessionAlias);
       return { ok: false, errorMessage: toErrorMessage(error2) };
     }
     if (wasArchived) {
@@ -34127,7 +34604,8 @@ class ControlService {
       chatKey: params.chatKey,
       sessionAlias: params.sessionAlias,
       ...params.turnStarted?.prompt ? { prompt: params.turnStarted.prompt } : {},
-      ...params.turnStarted?.scheduled ? { scheduled: params.turnStarted.scheduled } : {}
+      ...params.turnStarted?.scheduled ? { scheduled: params.turnStarted.scheduled } : {},
+      ...params.turnStarted?.queueItemId ? { queueItemId: params.turnStarted.queueItemId } : {}
     });
     let streamMode = false;
     try {
@@ -34251,8 +34729,9 @@ ${chunk}` : chunk
       });
       return { ok: false, errorMessage };
     } finally {
-      this.inFlight.delete(key);
-      resolveSettled();
+      if ((this.queues.get(key)?.length ?? 0) > 0) {
+        this.draining.add(key);
+      }
       if (internalAlias && priorTransportSession) {
         try {
           const after = await this.deps.sessions.getSession(internalAlias);
@@ -34261,6 +34740,33 @@ ${chunk}` : chunk
           }
         } catch {}
       }
+      resolveSettled();
+      this.advanceQueue(key, params.chatKey, params.sessionAlias);
+    }
+  }
+  advanceQueue(key, chatKey, sessionAlias) {
+    const q = this.queues.get(key);
+    const next = q?.shift();
+    if (q && q.length === 0)
+      this.queues.delete(key);
+    if (next) {
+      this.draining.add(key);
+      this.emitQueueUpdated(chatKey, sessionAlias);
+      this.executeTurn({
+        chatKey,
+        sessionAlias,
+        text: next.text,
+        senderId: next.senderId,
+        queueable: true,
+        drained: true,
+        ...next.isOwner !== undefined ? { isOwner: next.isOwner } : {},
+        ...next.accountId !== undefined ? { accountId: next.accountId } : {},
+        ...next.media !== undefined ? { media: next.media } : {},
+        turnStarted: { queueItemId: next.id }
+      });
+    } else {
+      this.draining.delete(key);
+      this.inFlight.delete(key);
     }
   }
   cancelTurn(chatKey, sessionAlias) {
@@ -34271,6 +34777,20 @@ ${chunk}` : chunk
     entry.controller.abort();
     return true;
   }
+  cancelQueuedItem(chatKey, sessionAlias, itemId) {
+    const key = turnKey(chatKey, sessionAlias);
+    const q = this.queues.get(key);
+    if (!q)
+      return { cancelled: false };
+    const i = q.findIndex((x) => x.id === itemId);
+    if (i < 0)
+      return { cancelled: false };
+    q.splice(i, 1);
+    if (q.length === 0)
+      this.queues.delete(key);
+    this.emitQueueUpdated(chatKey, sessionAlias);
+    return { cancelled: true };
+  }
   async executeCommand(input) {
     const chunks = [];
     const response = await this.deps.agent.chat({
@@ -34332,7 +34852,7 @@ function buildControlMetadata(senderId, isOwner) {
     ...isOwner === undefined ? {} : { isOwner }
   };
 }
-var CANCEL_DRAIN_TIMEOUT_MS = 5000;
+var CANCEL_DRAIN_TIMEOUT_MS = 5000, QUEUE_PREVIEW_MAX = 120;
 var init_control_service = __esm(() => {
   init_channel_scope();
   init_native_session_history();
@@ -34340,7 +34860,7 @@ var init_control_service = __esm(() => {
 });
 
 // src/control/terminal-service.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { createRequire as createRequire6 } from "node:module";
 import { spawn as spawnPty2 } from "node-pty";
 function scrubEnv() {
@@ -34367,7 +34887,7 @@ function realPtySpawn(file, args, opts) {
   return spawnPty2(file, args, opts);
 }
 function createTerminalService(deps) {
-  const spawn11 = deps.spawn ?? realPtySpawn;
+  const spawn12 = deps.spawn ?? realPtySpawn;
   const platform = deps.platform ?? process.platform;
   const sessions = new Map;
   const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
@@ -34392,8 +34912,8 @@ function createTerminalService(deps) {
     create({ cwd, cols, rows }) {
       if (platform === "win32")
         throw new Error("terminal-unsupported-platform");
-      const terminalId = randomUUID3();
-      const handle = spawn11(defaultShell(platform), [], { name: "xterm-256color", cols, rows, cwd, env: scrubEnv() });
+      const terminalId = randomUUID4();
+      const handle = spawn12(defaultShell(platform), [], { name: "xterm-256color", cols, rows, cwd, env: scrubEnv() });
       const session3 = { handle, seq: 0, idleTimer: null };
       sessions.set(terminalId, session3);
       handle.onData((data) => {
@@ -34467,7 +34987,7 @@ var init_terminal_service = __esm(() => {
 });
 
 // src/control/upload-store.ts
-import { mkdtemp as mkdtemp2, readdir as readdir5, rm as rm10, stat as stat4, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdtemp as mkdtemp2, readdir as readdir5, rm as rm11, stat as stat4, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
 import path16 from "node:path";
 function defaultRootDir() {
@@ -34503,11 +35023,11 @@ class UploadStore {
     if (bytes.byteLength > this.maxBytes)
       throw new Error("file-too-large");
     const safeName = sanitizeUploadFilename(filename);
-    const { mkdir: mkdir9 } = await import("node:fs/promises");
-    await mkdir9(this.rootDir, { recursive: true });
+    const { mkdir: mkdir10 } = await import("node:fs/promises");
+    await mkdir10(this.rootDir, { recursive: true });
     const dir = await mkdtemp2(path16.join(this.rootDir, "u-"));
     const filePath = path16.join(dir, safeName);
-    await writeFile8(filePath, bytes);
+    await writeFile9(filePath, bytes);
     return {
       id: path16.basename(dir),
       path: filePath,
@@ -34530,7 +35050,7 @@ class UploadStore {
       try {
         const info = await stat4(dir);
         if (info.mtimeMs < cutoff) {
-          await rm10(dir, { recursive: true, force: true });
+          await rm11(dir, { recursive: true, force: true });
           removed += 1;
         }
       } catch {}
@@ -34588,12 +35108,12 @@ var init_agent_catalog = __esm(() => {
 
 // src/config/config-watcher.ts
 import { watch } from "node:fs";
-import { basename as basename3, dirname as dirname12 } from "node:path";
+import { basename as basename4, dirname as dirname13 } from "node:path";
 function startConfigWatcher(options) {
   const { configPath, onChange, debounceMs = 250, logger: logger2 } = options;
   const watchFactory = options.watchFactory ?? watch;
-  const dir = dirname12(configPath);
-  const target = basename3(configPath);
+  const dir = dirname13(configPath);
+  const target = basename4(configPath);
   let timer;
   let watcher;
   const fire = () => {
@@ -34608,7 +35128,7 @@ function startConfigWatcher(options) {
   };
   try {
     watcher = watchFactory(dir, { persistent: false }, (_event, filename) => {
-      if (filename !== null && basename3(filename.toString()) !== target)
+      if (filename !== null && basename4(filename.toString()) !== target)
         return;
       if (timer)
         clearTimeout(timer);
@@ -34646,9 +35166,9 @@ __export(exports_main, {
   main: () => main,
   buildApp: () => buildApp
 });
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { homedir as homedir14 } from "node:os";
-import { dirname as dirname13, join as join23 } from "node:path";
+import { dirname as dirname14, join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function startProgressHeartbeat(orchestration3, config4, logger2, channel) {
   const thresholdSeconds = config4.orchestration.progressHeartbeatSeconds;
@@ -35026,7 +35546,7 @@ async function buildApp(paths, deps = {}) {
   };
   orchestration3 = new OrchestrationService({
     now: deps.loggerNow ?? (() => new Date),
-    createId: () => randomUUID4(),
+    createId: () => randomUUID5(),
     config: config4,
     loadState: async () => JSON.parse(JSON.stringify(state)),
     saveState: async (nextState) => {
@@ -35193,7 +35713,8 @@ async function buildApp(paths, deps = {}) {
     },
     uploadStore,
     terminal: terminalService,
-    terminalEnabled: () => terminalEnabled(config4)
+    terminalEnabled: () => terminalEnabled(config4),
+    filesWriteEnabled: () => filesWriteEnabled(config4)
   });
   const workspaceSignature = (cfg) => JSON.stringify(Object.keys(cfg.workspaces).sort().map((name) => {
     const ws = cfg.workspaces[name];
@@ -35346,7 +35867,7 @@ async function main() {
   }
 }
 async function prepareChannelMedia(configPath, config4) {
-  const runtimeDir = join23(dirname13(configPath), "runtime");
+  const runtimeDir = join23(dirname14(configPath), "runtime");
   const mediaRootDir = join23(runtimeDir, "media");
   const mediaStore = new RuntimeMediaStore({ rootDir: mediaRootDir });
   await mediaStore.cleanupExpired().catch((error2) => {
@@ -35361,7 +35882,7 @@ function resolveRuntimePaths() {
     throw new Error("Unable to resolve the current user home directory");
   }
   const configPath = coreEnv("CONFIG") ?? join23(coreHomeDir(home), "config.json");
-  const runtimeDir = join23(dirname13(configPath), "runtime");
+  const runtimeDir = join23(dirname14(configPath), "runtime");
   return {
     configPath,
     statePath: coreEnv("STATE") ?? join23(coreHomeDir(home), "state.json"),
@@ -35376,12 +35897,12 @@ function resolveBridgeEntryPath() {
   return fileURLToPath5(new URL("./bridge/bridge-main.ts", import.meta.url));
 }
 function resolveAppLogPath(configPath) {
-  const rootDir = dirname13(configPath);
+  const rootDir = dirname14(configPath);
   const runtimeDir = join23(rootDir, "runtime");
   return join23(runtimeDir, "app.log");
 }
 function resolvePerfLogPath(configPath) {
-  const rootDir = dirname13(configPath);
+  const rootDir = dirname14(configPath);
   const runtimeDir = join23(rootDir, "runtime");
   return join23(runtimeDir, "perf.log");
 }
@@ -35439,7 +35960,7 @@ var init_main = __esm(async () => {
 });
 
 // src/doctor/checks/acpx-check.ts
-import { spawn as spawn11 } from "node:child_process";
+import { spawn as spawn12 } from "node:child_process";
 async function checkAcpx(options = {}) {
   const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
   try {
@@ -35486,7 +36007,7 @@ function buildDetails(metadata, version2, verbose) {
 async function defaultRunVersion(command) {
   const spawnSpec = resolveSpawnCommand(command, ["--version"]);
   return await new Promise((resolve4, reject) => {
-    const child = spawn11(spawnSpec.command, spawnSpec.args, {
+    const child = spawn12(spawnSpec.command, spawnSpec.args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout2 = "";
@@ -35624,7 +36145,7 @@ var init_config_check = __esm(async () => {
 });
 
 // src/doctor/checks/daemon-check.ts
-import { readdir as readdir6, readFile as readFile15, rm as rm11 } from "node:fs/promises";
+import { readdir as readdir6, readFile as readFile16, rm as rm12 } from "node:fs/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { homedir as homedir15 } from "node:os";
 import { join as join24 } from "node:path";
@@ -35770,7 +36291,7 @@ async function defaultListConsumerLocks(runtimeDir) {
 }
 async function defaultReadConsumerLock(path17) {
   try {
-    const raw = await readFile15(path17, "utf8");
+    const raw = await readFile16(path17, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.pid === "number" ? { pid: parsed.pid } : null;
   } catch {
@@ -35778,7 +36299,7 @@ async function defaultReadConsumerLock(path17) {
   }
 }
 async function defaultRemoveConsumerLock(path17) {
-  await rm11(path17, { force: true });
+  await rm12(path17, { force: true });
 }
 function resolveCliEntryPath() {
   return process.argv[1] ?? fileURLToPath6(import.meta.url);
@@ -35794,7 +36315,7 @@ var init_daemon_check = __esm(() => {
 
 // src/doctor/checks/logs-check.ts
 import { stat as stat5, readdir as readdir7 } from "node:fs/promises";
-import { basename as basename4, join as join25 } from "node:path";
+import { basename as basename5, join as join25 } from "node:path";
 import { homedir as homedir16 } from "node:os";
 async function checkLogs(options = {}) {
   const home = options.home ?? process.env.HOME ?? homedir16();
@@ -35824,7 +36345,7 @@ async function checkLogs(options = {}) {
       `error: ${formatError6(error2)}`
     ]);
   }
-  const baseNames = [basename4(paths.appLog), basename4(paths.stdoutLog), basename4(paths.stderrLog)];
+  const baseNames = [basename5(paths.appLog), basename5(paths.stdoutLog), basename5(paths.stderrLog)];
   const tracked = new Set(baseNames);
   const matched = entries.filter((entry) => isTrackedLogName(entry, tracked));
   const files = [];
@@ -36155,7 +36676,7 @@ var init_plugin_check = __esm(async () => {
 // src/doctor/checks/runtime-check.ts
 import { constants } from "node:fs";
 import { access as access4, stat as stat6 } from "node:fs/promises";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 import { homedir as homedir18 } from "node:os";
 async function checkRuntime(options = {}) {
   const home = options.home ?? process.env.HOME ?? homedir18();
@@ -36311,7 +36832,7 @@ async function checkFileCreatable(label, path17, probe, platform) {
         detail: `${label}: ${path17} (unusable: ${formatError9(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(dirname14(path17), probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(dirname15(path17), probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
@@ -36347,7 +36868,7 @@ async function checkCreatableAncestorDirectory(path17, probe, platform) {
         blockingPath: path17
       };
     }
-    const parent = dirname14(path17);
+    const parent = dirname15(path17);
     if (parent === path17) {
       return {
         ok: false,
@@ -37130,9 +37651,9 @@ var init_doctor2 = __esm(async () => {
 
 // src/cli.ts
 init_core_home();
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { homedir as homedir20 } from "node:os";
-import { dirname as dirname15, join as join27, sep as sep2 } from "node:path";
+import { dirname as dirname16, join as join27, sep as sep2 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // src/runtime/migrate-core-home.ts
@@ -52806,7 +53327,7 @@ async function prepareMcpCoordinatorStartup(input) {
   return { kind: "external-coordinator" };
 }
 function createMcpStdioIdentityResolver(input) {
-  const instanceId = randomUUID5().slice(0, 8);
+  const instanceId = randomUUID6().slice(0, 8);
   return async (context) => {
     const parsedCoordinatorSession = input.parsedCoordinatorSession?.trim() || null;
     const workspace3 = input.workspace?.trim() || null;
@@ -53761,7 +54282,7 @@ function safeDaemonLogPaths() {
     const configPath = resolveConfigPathForCurrentEnv();
     const paths = resolveDaemonPathsForCurrentConfig();
     return {
-      appLog: join27(dirname15(configPath), "runtime", "app.log"),
+      appLog: join27(dirname16(configPath), "runtime", "app.log"),
       stderrLog: paths.stderrLog
     };
   } catch {

package/dist/config/types.d.ts

@@ -48,6 +48,11 @@ export interface TerminalConfig {
     /** Idle seconds before a terminal PTY is auto-killed. Defaults to 900 (15 min). */
     idleTimeoutSeconds?: number;
 }
+export interface FilesConfig {
+    /** Default false. When false, all fs write ops (new/rename/delete/copy) are rejected
+     *  before touching disk. Download is a read and stays available regardless. */
+    writeEnabled: boolean;
+}
 export type LoggingLevel = "error" | "info" | "debug";
 export interface PerfLogConfig {
     enabled: boolean;
@@ -110,6 +115,8 @@ export interface AppConfig {
     later?: LaterConfig;
     language?: Locale;
     terminal?: TerminalConfig;
+    files?: FilesConfig;
 }
 export declare function terminalEnabled(config: AppConfig): boolean;
 export declare function terminalIdleTimeoutSeconds(config: AppConfig): number;
+export declare function filesWriteEnabled(config: AppConfig): boolean;

package/dist/control/control-event-bus.d.ts

@@ -6,6 +6,13 @@ export interface ScheduledOrigin {
     taskId: string;
     executeAt: string;
 }
+/** A single pending item in the per-session server-side prompt queue, as surfaced on
+ *  the wire by `queue-updated`. `textPreview` is truncated server-side (~120 chars). */
+export interface QueuedItemInfo {
+    id: string;
+    textPreview: string;
+    enqueuedAt: string;
+}
 export type ControlEvent = {
     type: "turn-output";
     chatKey: string;
@@ -17,6 +24,12 @@ export type ControlEvent = {
     sessionAlias: string;
     prompt?: string;
     scheduled?: ScheduledOrigin;
+    queueItemId?: string;
+} | {
+    type: "queue-updated";
+    chatKey: string;
+    sessionAlias: string;
+    items: QueuedItemInfo[];
 } | {
     type: "tool-event";
     chatKey: string;

package/dist/control/control-service.d.ts

@@ -8,7 +8,7 @@ import type { CancelTaskInput, OrchestrationService, OrchestrationTaskFilter } f
 import type { OrchestrationTaskRecord } from "../orchestration/orchestration-types";
 import type { ControlEventBus } from "./control-event-bus";
 import type { AgentCatalogEntry } from "../config/agent-catalog";
-import { type DirListing, type FileContent, type SearchResult, type WorkspaceDiff } from "./workspace-fs";
+import { type DirListing, type FileContent, type SearchOptions, type SearchResult, type WorkspaceDiff } from "./workspace-fs";
 import type { PromptAttachmentRef } from "@ganglion/xacpx-relay-protocol";
 import type { UploadStore } from "./upload-store.js";
 export interface ControlSessionInfo {
@@ -79,6 +79,7 @@ export interface ControlServiceDeps {
     uploadStore: UploadStore;
     terminal: import("./terminal-service").TerminalService;
     terminalEnabled: () => boolean;
+    filesWriteEnabled: () => boolean;
 }
 export interface ControlPromptInput {
     chatKey: string;
@@ -93,6 +94,23 @@ export interface ControlPromptResult {
     ok: boolean;
     text?: string;
     errorMessage?: string;
+    /** True when this prompt did not run immediately and was instead appended to the
+     *  per-session server-side queue (a turn was already in flight). */
+    queued?: boolean;
+    /** Id of the queued item, present only when `queued` is true. Used to cancel it via
+     *  `cancelQueuedItem` before it drains. */
+    queueItemId?: string;
+}
+/** A prompt held in the per-session server-side queue while a turn is in flight.
+ *  Runs through the same `executeTurn` machinery as a manual prompt once drained. */
+export interface QueuedPrompt {
+    id: string;
+    text: string;
+    enqueuedAt: string;
+    senderId: string;
+    isOwner?: boolean;
+    accountId?: string;
+    media?: PromptAttachmentRef[];
 }
 /** A turn started by a fired scheduled task. Runs through the same agent + turn-event
  *  machinery as a normal prompt, so it streams live and persists to history — but it
@@ -121,7 +139,25 @@ export declare class ControlService {
     listDirectory(workspace: string, path?: string): Promise<DirListing>;
     readWorkspaceFile(workspace: string, path: string): Promise<FileContent>;
     workspaceGitDiff(workspace: string, path?: string): Promise<WorkspaceDiff>;
-    searchWorkspace(workspace: string, query: string): Promise<SearchResult>;
+    searchWorkspace(workspace: string, opts: SearchOptions): Promise<SearchResult>;
+    fsCreate(workspace: string, path: string, kind: "file" | "dir"): Promise<{
+        path: string;
+    }>;
+    fsRename(workspace: string, path: string, newName: string): Promise<{
+        path: string;
+    }>;
+    fsDelete(workspace: string, path: string): Promise<{
+        path: string;
+    }>;
+    fsCopy(workspace: string, path: string): Promise<{
+        path: string;
+    }>;
+    fsDownload(workspace: string, path: string): Promise<{
+        path: string;
+        base64: string;
+        size: number;
+        mimeType: string;
+    }>;
     uploadFile(input: {
         filename: string;
         content: string;
@@ -173,6 +209,9 @@ export declare class ControlService {
     getOrchestrationTask(taskId: string): Promise<OrchestrationTaskRecord | null>;
     cancelOrchestrationTask(input: CancelTaskInput): Promise<OrchestrationTaskRecord>;
     private readonly inFlight;
+    private readonly queues;
+    private readonly draining;
+    private emitQueueUpdated;
     prompt(input: ControlPromptInput): Promise<ControlPromptResult>;
     /** Run a fired scheduled task as a real turn through the same machinery as a manual
      *  prompt — so it streams live and persists to history — while tagging turn-started
@@ -180,7 +219,15 @@ export declare class ControlService {
      *  the web can badge it. Owner-authorized: the task was owner-gated at creation. */
     runScheduledTurn(input: ControlScheduledTurnInput): Promise<ControlPromptResult>;
     private executeTurn;
+    private advanceQueue;
     cancelTurn(chatKey: string, sessionAlias: string): boolean;
+    /** Remove a pending queued prompt (by id) before it drains. No-ops (returns
+     *  `{ cancelled: false }`) when the queue or the id is absent/already drained —
+     *  e.g. a race where the item drained into a running turn just before the cancel
+     *  arrived. Does NOT touch a turn that is already running (use `cancelTurn`). */
+    cancelQueuedItem(chatKey: string, sessionAlias: string, itemId: string): {
+        cancelled: boolean;
+    };
     executeCommand(input: ControlExecuteCommandInput): Promise<string>;
     /** Open an interactive terminal in the session's workspace cwd. Rejected when terminal is disabled. */
     createTerminal(chatKey: string, sessionAlias: string, cols: number, rows: number): Promise<{

package/dist/control/workspace-fs.d.ts

@@ -2,11 +2,17 @@ export interface FsEntry {
     name: string;
     type: "dir" | "file";
     size?: number;
+    /** True when git check-ignore matches this entry (omitted in non-git workspaces). */
+    ignored?: boolean;
 }
 export interface DirListing {
     workspace: string;
     path: string;
     entries: FsEntry[];
+    /** Absolute realpath'd workspace root on the connector host. */
+    root: string;
+    /** Host path separator, so the client can render an absolute host path. */
+    sep: "/" | "\\";
 }
 export interface FileContent {
     workspace: string;
@@ -20,12 +26,31 @@ export interface DiffFile {
     path: string;
     status: string;
 }
+export interface SearchHit {
+    path: string;
+    line: number;
+    text: string;
+}
 export interface SearchResult {
     workspace: string;
     query: string;
     matches: string[];
+    hits: SearchHit[];
     truncated: boolean;
 }
+export interface SearchOptions {
+    query: string;
+    mode?: "name" | "content";
+    matchCase?: boolean;
+    wholeWord?: boolean;
+    regex?: boolean;
+    /** Glob to restrict matches (relative to workspace root). */
+    include?: string;
+    /** Glob to drop matches. */
+    exclude?: string;
+    /** Base directory (relative) to scope the search; defaults to the whole workspace. */
+    path?: string;
+}
 export interface WorkspaceDiff {
     workspace: string;
     files: DiffFile[];
@@ -51,14 +76,57 @@ export declare class WorkspaceFs {
     /** Resolve `relPath` within a named workspace, symlink-safe and contained. Throws
      *  on unknown workspace, missing target, or any path that escapes the root. */
     private resolve;
+    /** Resolve the PARENT directory of a to-be-created/renamed target. Parent must exist
+     *  and be contained; the final segment is validated (non-empty, no separators, not
+     *  "."/".."). Because parent is realpath'd+contained and name has no separator, the
+     *  join target stays inside the workspace root. */
+    private resolveParent;
+    createFile(workspace: string, relPath: string): Promise<{
+        path: string;
+    }>;
+    createDir(workspace: string, relPath: string): Promise<{
+        path: string;
+    }>;
+    rename(workspace: string, relPath: string, newName: string): Promise<{
+        path: string;
+    }>;
+    duplicate(workspace: string, relPath: string): Promise<{
+        path: string;
+    }>;
+    remove(workspace: string, relPath: string): Promise<{
+        path: string;
+    }>;
+    readFileBytes(workspace: string, relPath: string): Promise<{
+        path: string;
+        base64: string;
+        size: number;
+        mimeType: string;
+    }>;
     listDirectory(workspace: string, relPath?: string): Promise<DirListing>;
+    /** Return the subset of the given root-relative paths that git considers ignored.
+     *  Uses `check-ignore -z --stdin` (bounded by the caller's MAX_ENTRIES listing).
+     *  Any git error (not a repo, git missing) yields an empty set — callers degrade to
+     *  "nothing ignored". Never throws. */
+    private gitCheckIgnore;
     readFile(workspace: string, relPath: string): Promise<FileContent>;
-    /** Find files whose relative path contains `query` (case-insensitive). Walks the
-     *  tree breadth-first, skipping `.git`/`node_modules` and never following symlinks
-     *  (so it stays contained), bounded by a scan budget and a result cap. */
-    search(workspace: string, query: string): Promise<SearchResult>;
+    /** Find files by name (default) or content. Name mode walks relative paths
+     *  breadth-first, skipping `.git`/`node_modules` and never following symlinks (so it
+     *  stays contained), applying the query plus any include/exclude globs. Content mode
+     *  delegates to `contentGrep`. Both are bounded by a scan budget and a result cap. */
+    search(workspace: string, opts: SearchOptions): Promise<SearchResult>;
+    /** Content grep: `git grep` when the workspace root is a git repo (fast, respects
+     *  .gitignore), else a bounded manual walk that scans each file line by line. Never
+     *  throws on git absence/failure or an invalid user regex — both degrade gracefully.
+     *  `scopeRel` is the already-resolved (canonicalized, containment-checked) scope from
+     *  `resolve()`; include/exclude are applied as a post-filter on the parsed hits rather
+     *  than as extra git pathspecs — git ORs multiple positive pathspecs together, so a
+     *  scope pathspec plus an include pathspec would leak matches from outside the scope. */
+    private contentGrep;
     gitDiff(workspace: string, relPath?: string): Promise<WorkspaceDiff>;
     /** Branch + worktree context for a repo root. Best-effort: any git hiccup just
      *  omits the fields so the diff itself still returns. */
     private gitContext;
 }
+/** First free "NAME copy", "NAME copy 2"… inserting before the extension. Dotfiles
+ *  (leading dot, no other dot) and extension-less names get no split. */
+export declare function copyName(existing: Set<string>, name: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/xacpx",
-  "version": "0.17.0-beta.0",
+  "version": "0.17.0-beta.2",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",