pi-cloud 2.0.0 → 2.0.2

package/server/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { randomBytes as randomBytes3 } from "node:crypto";
+import { randomBytes as randomBytes4 } from "node:crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "node:fs";
 import { spawn as spawn3 } from "node:child_process";
 import * as os9 from "node:os";
@@ -14,7 +14,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/routes/sessions.ts
 import * as os3 from "os";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute2 } from "path";
 
 // src/services/project-mover.ts
 import { access as access2, rename, stat } from "fs/promises";
@@ -53,8 +53,8 @@ function configuredAllowedRoots() {
   return raw.split(",").map((root) => root.trim()).filter(Boolean);
 }
 function isInsideRoot(candidate, root) {
-  const relative3 = path2.relative(root, candidate);
-  return relative3 === "" || !relative3.startsWith("..") && !path2.isAbsolute(relative3);
+  const relative4 = path2.relative(root, candidate);
+  return relative4 === "" || !relative4.startsWith("..") && !path2.isAbsolute(relative4);
 }
 async function realpathIfExists(candidate) {
   try {
@@ -101,6 +101,23 @@ async function resolveAllowedPath(requestedPath) {
   }
   return resolvedPath;
 }
+async function resolveAllowedExistingPath(requestedPath) {
+  const resolvedPath = path2.resolve(expandHomePath(requestedPath));
+  if (isPathCheckDisabled()) return fs.realpath(resolvedPath);
+  const configuredRoots = configuredAllowedRoots().map((root) => path2.resolve(expandHomePath(root)));
+  const matchedRoot = configuredRoots.find((root) => isInsideRoot(resolvedPath, root));
+  if (!matchedRoot) throw new PathAccessError(resolvedPath);
+  const relativePath = path2.relative(matchedRoot, resolvedPath);
+  if (relativePath.startsWith("..") || path2.isAbsolute(relativePath)) {
+    throw new PathAccessError(resolvedPath);
+  }
+  const realPath = await fs.realpath(resolvedPath);
+  const roots = await allowedRoots();
+  if (!roots.some((root) => isInsideRoot(realPath, root))) {
+    throw new PathAccessError(resolvedPath);
+  }
+  return realPath;
+}
 
 // src/services/project-mover.ts
 var ProjectMover = class {
@@ -123,12 +140,12 @@ var ProjectMover = class {
     }
     return trimmed;
   }
-  async assertDirectory(path13, message) {
+  async assertDirectory(path13, message2) {
     try {
       const stats = await stat(path13);
-      if (!stats.isDirectory()) throw new Error(message);
+      if (!stats.isDirectory()) throw new Error(message2);
     } catch (error) {
-      if (isMissingPathError(error)) throw new Error(message);
+      if (isMissingPathError(error)) throw new Error(message2);
       throw error;
     }
   }
@@ -758,10 +775,12 @@ async function sessionRoutes(app, options = {}) {
     if (!profileId) return reply.status(400).send({ error: "profileId is required" });
     const owner = { type: "profile", id: profileId };
     const idsByGroup = options.pinStore.listSessionIdsByGroup(owner);
+    const filesByGroup = options.pinStore.listFilePathsByGroup(profileId);
     return {
       groups: options.pinStore.listGroups(owner).map((group) => ({
         ...group,
-        sessionIds: idsByGroup.get(group.id) || []
+        sessionIds: idsByGroup.get(group.id) || [],
+        filePaths: filesByGroup.get(group.id) || []
       }))
     };
   });
@@ -775,6 +794,26 @@ async function sessionRoutes(app, options = {}) {
       return reply.status(400).send({ error: error instanceof Error ? error.message : "Failed to create pin group" });
     }
   });
+  app.put("/files/pin", async (req, reply) => {
+    if (!options.pinStore) return reply.status(503).send({ error: "Session pins are not configured" });
+    const { filePath, groupId, profileId } = req.body;
+    if (!filePath || !isAbsolute2(filePath) || !groupId || !profileId) {
+      return reply.status(400).send({ error: "absolute filePath, groupId, and profileId are required" });
+    }
+    try {
+      options.pinStore.pinFile(profileId, filePath, groupId);
+      return { success: true };
+    } catch (error) {
+      return reply.status(404).send({ error: error instanceof Error ? error.message : "Pin group not found" });
+    }
+  });
+  app.delete("/files/pin", async (req, reply) => {
+    if (!options.pinStore) return reply.status(503).send({ error: "Session pins are not configured" });
+    const { filePath, profileId } = req.query;
+    if (!filePath || !profileId) return reply.status(400).send({ error: "filePath and profileId are required" });
+    options.pinStore.unpinFile(profileId, filePath);
+    return { success: true };
+  });
   app.put("/:id/pin", async (req, reply) => {
     if (!options.pinStore) return reply.status(503).send({ error: "Session pins are not configured" });
     const { id } = req.params;
@@ -806,9 +845,11 @@ async function sessionRoutes(app, options = {}) {
     }, worktreeMetadata)]));
     const owner = { type: "profile", id: profileId };
     const idsByGroup = options.pinStore.listSessionIdsByGroup(owner);
+    const filesByGroup = options.pinStore.listFilePathsByGroup(profileId);
     return {
       groups: options.pinStore.listGroups(owner).map((group) => ({
         ...group,
+        filePaths: filesByGroup.get(group.id) || [],
         sessions: (idsByGroup.get(group.id) || []).map((id) => sessionsById.get(id)).filter((session) => Boolean(session)).map(toSessionListItem)
       }))
     };
@@ -1037,9 +1078,9 @@ async function sessionRoutes(app, options = {}) {
         skippedSessionFiles: sessionResult.skipped
       };
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to move project";
-      const status = message.includes("already exists") || message.includes("streaming") ? 409 : 400;
-      return reply.status(status).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to move project";
+      const status = message2.includes("already exists") || message2.includes("streaming") ? 409 : 400;
+      return reply.status(status).send({ error: message2 });
     }
   });
   app.post("/relocate-project", async (req, reply) => {
@@ -1067,8 +1108,8 @@ async function sessionRoutes(app, options = {}) {
       sessionService.invalidateSessionListCache();
       return { success: true, moved: result.moved, skipped: result.skipped };
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to relocate project sessions";
-      return reply.status(message.includes("already exists") ? 409 : 400).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to relocate project sessions";
+      return reply.status(message2.includes("already exists") ? 409 : 400).send({ error: message2 });
     }
   });
   app.post("/:id/relocate", async (req, reply) => {
@@ -1104,8 +1145,8 @@ async function sessionRoutes(app, options = {}) {
       sessionService.invalidateSessionListCache();
       return { success: true, path: result.destinationPath, cwd: newCwd };
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to move session";
-      return reply.status(message.includes("already exists") ? 409 : 400).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to move session";
+      return reply.status(message2.includes("already exists") ? 409 : 400).send({ error: message2 });
     }
   });
   app.post("/:id/resume", async (req) => {
@@ -1162,8 +1203,8 @@ async function sessionRoutes(app, options = {}) {
     try {
       return await sessionService.updateSessionSkillPolicy(clientId, id, mode, skills || []);
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to update session skills";
-      return reply.status(message.includes("streaming") ? 409 : 404).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to update session skills";
+      return reply.status(message2.includes("streaming") ? 409 : 404).send({ error: message2 });
     }
   });
   app.post("/:id/model", async (req, reply) => {
@@ -1175,8 +1216,8 @@ async function sessionRoutes(app, options = {}) {
     try {
       return await sessionService.setSessionModel(clientId, id, provider, modelId);
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to change model";
-      return reply.status(message.includes("streaming") ? 409 : 400).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to change model";
+      return reply.status(message2.includes("streaming") ? 409 : 400).send({ error: message2 });
     }
   });
   app.post("/:id/thinking-level", async (req, reply) => {
@@ -1188,8 +1229,8 @@ async function sessionRoutes(app, options = {}) {
     try {
       return await sessionService.setSessionThinkingLevel(clientId, id, level);
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to change thinking level";
-      return reply.status(message.includes("streaming") ? 409 : 400).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to change thinking level";
+      return reply.status(message2.includes("streaming") ? 409 : 400).send({ error: message2 });
     }
   });
   app.get("/:id/summary", async (req, reply) => {
@@ -1313,6 +1354,7 @@ async function sessionRoutes(app, options = {}) {
         model: foundSession.model,
         thinkingLevel: foundSession.thinkingLevel,
         isStreaming: foundSession.isStreaming,
+        streamingStartedAt: sessionService.getSessionStreamingStartedAt(foundSession.sessionId),
         activity: options.activityStore?.listForSession(foundSession.sessionId) || []
       }, worktreeMetadata);
     }
@@ -1389,8 +1431,8 @@ async function sessionRoutes(app, options = {}) {
       const result = await sessionService.renameSession(clientId, id, name);
       return result;
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to rename session";
-      return reply.status(message.includes("not found") ? 404 : 400).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to rename session";
+      return reply.status(message2.includes("not found") ? 404 : 400).send({ error: message2 });
     }
   });
   app.delete("/:id", async (req, reply) => {
@@ -1423,8 +1465,8 @@ var MEMORY_CATEGORIES = ["rule", "preference", "decision", "fact", "pitfall"];
 var MEMORY_STATUSES = ["active", "pending", "archived"];
 var PINNED_APPLICABILITY_MODES = ["always", "matched"];
 var MemoryRouteError = class extends Error {
-  constructor(statusCode, message) {
-    super(message);
+  constructor(statusCode, message2) {
+    super(message2);
     this.statusCode = statusCode;
   }
   statusCode;
@@ -1544,7 +1586,10 @@ async function memoryRoutes(app) {
   app.post("/extractions/:id/clear", async (req, reply) => {
     try {
       const body = requestBody(req.body);
-      const context = await resolveContext(app, body);
+      const context = await resolveContext(app, {
+        clientId: body.clientId,
+        projectPath: body.projectPath
+      });
       const { id } = req.params;
       requireAccessibleRun(app, context, id);
       app.memoryRuntime.store.clearFailedRun(id);
@@ -1750,23 +1795,23 @@ function clampNumber(value, min, max, fallback) {
   return Math.min(max, Math.max(min, Math.trunc(parsed)));
 }
 function sendError(reply, error) {
-  const message = error instanceof Error ? error.message : "Memory request failed";
-  if (error instanceof MemoryRouteError) return reply.status(error.statusCode).send({ error: message });
-  if (/not found/i.test(message)) return reply.status(404).send({ error: message });
-  if (/modified|already exists|not pending|not failed|not completed|cannot be requeued|superseded/i.test(message)) {
-    return reply.status(409).send({ error: message });
+  const message2 = error instanceof Error ? error.message : "Memory request failed";
+  if (error instanceof MemoryRouteError) return reply.status(error.statusCode).send({ error: message2 });
+  if (/not found/i.test(message2)) return reply.status(404).send({ error: message2 });
+  if (/modified|already exists|not pending|not failed|not completed|cannot be requeued|superseded/i.test(message2)) {
+    return reply.status(409).send({ error: message2 });
   }
-  return reply.status(400).send({ error: message });
+  return reply.status(400).send({ error: message2 });
 }
 
 // src/routes/files.ts
 import { spawn } from "child_process";
 import { isUtf8 } from "buffer";
-import { createReadStream as createReadStream2 } from "fs";
+import { constants as fsConstants, createReadStream as createReadStream2 } from "fs";
 import * as fs2 from "fs/promises";
 import * as path3 from "path";
 import { ZipArchive } from "archiver";
-import { glob } from "glob";
+import { globIterate } from "glob";
 
 // src/utils/archive-preview.ts
 import { createReadStream } from "node:fs";
@@ -1882,6 +1927,13 @@ function listTarEntries(filePath, gzipped) {
 }
 
 // src/routes/files.ts
+var MAX_FILE_TREE_DEPTH = 10;
+var MAX_FILE_TREE_NODES = 5e3;
+var FILE_TREE_TIMEOUT_MS = 5e3;
+var MAX_TEXT_FILE_BYTES = 10 * 1024 * 1024;
+var MAX_FILE_SEARCH_RESULTS = 5e3;
+var FILE_SEARCH_TIMEOUT_MS = 5e3;
+var FILE_SEARCH_IGNORES = ["**/.git/**", "**/node_modules/**"];
 var imageMimeTypes = /* @__PURE__ */ new Map([
   [".apng", "image/apng"],
   [".avif", "image/avif"],
@@ -1995,7 +2047,7 @@ async function createTreeNode(dirPath, entry) {
     const rawTarget = await fs2.readlink(fullPath);
     linkTarget = path3.isAbsolute(rawTarget) ? rawTarget : path3.resolve(dirPath, rawTarget);
     try {
-      const targetStats = await fs2.stat(fullPath);
+      const targetStats = await fs2.stat(await resolveAllowedExistingPath(fullPath));
       if (targetStats.isDirectory()) {
         isDirectory = true;
         targetType = "directory";
@@ -2020,29 +2072,41 @@ async function createTreeNode(dirPath, entry) {
   }
   return node;
 }
-async function buildFileTree(dirPath, depth, currentDepth = 0, options = {
-  includeHidden: false,
-  excludeNames: /* @__PURE__ */ new Set(["node_modules"]),
-  filterType: "all",
-  sort: "name"
-}) {
+async function buildFileTree(dirPath, depth, currentDepth, options, budget) {
   if (currentDepth >= depth) return [];
-  const entries = await fs2.readdir(dirPath, { withFileTypes: true });
   const nodes = [];
-  for (const entry of entries) {
-    if (!options.includeHidden && entry.name.startsWith(".")) continue;
-    if (options.excludeNames.has(entry.name)) continue;
-    const node = await createTreeNode(dirPath, entry);
-    if (options.sort === "modified") {
-      node.mtime = (await fs2.lstat(node.path)).mtimeMs;
-    }
-    if (options.filterType !== "all" && options.filterType !== node.type) {
-      continue;
-    }
-    if (node.type === "directory" && !node.isSymlink) {
-      node.children = await buildFileTree(node.path, depth, currentDepth + 1, options);
+  const accessDirPath = await resolveAllowedExistingPath(dirPath);
+  const directory = await fs2.opendir(accessDirPath);
+  try {
+    let entry = await directory.read();
+    while (entry !== null) {
+      if (budget.remainingNodes <= 0 || Date.now() >= budget.deadline) {
+        budget.truncated = true;
+        break;
+      }
+      if (!options.includeHidden && entry.name.startsWith(".")) {
+        entry = await directory.read();
+        continue;
+      }
+      if (options.excludeNames.has(entry.name)) {
+        entry = await directory.read();
+        continue;
+      }
+      const node = await createTreeNode(dirPath, entry);
+      if (options.sort === "modified") {
+        node.mtime = (await fs2.lstat(path3.join(accessDirPath, entry.name))).mtimeMs;
+      }
+      if (options.filterType === "all" || options.filterType === node.type) {
+        budget.remainingNodes--;
+        if (node.type === "directory" && !node.isSymlink) {
+          node.children = await buildFileTree(node.path, depth, currentDepth + 1, options, budget);
+        }
+        nodes.push(node);
+      }
+      entry = await directory.read();
     }
-    nodes.push(node);
+  } finally {
+    await directory.close();
   }
   return nodes.sort((a, b) => {
     if (options.sort === "modified") {
@@ -2053,7 +2117,7 @@ async function buildFileTree(dirPath, depth, currentDepth = 0, options = {
   });
 }
 async function fileRoutes(app) {
-  app.get("/tree", async (req) => {
+  app.get("/tree", async (req, reply) => {
     const {
       path: dirPath,
       depth,
@@ -2062,21 +2126,31 @@ async function fileRoutes(app) {
       exclude,
       sort
     } = req.query;
+    const requestedDepth = depth === void 0 ? 3 : Number(depth);
+    if (!Number.isInteger(requestedDepth) || requestedDepth < 1 || requestedDepth > MAX_FILE_TREE_DEPTH) {
+      return reply.code(400).send({ error: `depth must be an integer between 1 and ${MAX_FILE_TREE_DEPTH}` });
+    }
     const resolvedPath = await resolveAllowedPath(dirPath);
     const excludeNames = new Set(
       (exclude === void 0 ? "node_modules" : exclude).split(",").map((name) => name.trim()).filter(Boolean)
     );
-    const tree = await buildFileTree(resolvedPath, parseInt(depth || "3"), 0, {
+    const budget = {
+      remainingNodes: MAX_FILE_TREE_NODES,
+      deadline: Date.now() + FILE_TREE_TIMEOUT_MS,
+      truncated: false
+    };
+    const tree = await buildFileTree(resolvedPath, requestedDepth, 0, {
       includeHidden: parseBoolean(hidden, false),
       excludeNames,
       filterType: parseFilterType(type),
       sort: parseTreeSort(sort)
-    });
+    }, budget);
     const parentPath = path3.dirname(resolvedPath);
     return {
       path: resolvedPath,
       parentPath: parentPath === resolvedPath ? null : parentPath,
-      tree
+      tree,
+      truncated: budget.truncated
     };
   });
   app.get("/download", async (req, reply) => {
@@ -2119,9 +2193,11 @@ async function fileRoutes(app) {
   app.get("/read", async (req, reply) => {
     const { path: filePath } = req.query;
     const resolvedPath = await resolveAllowedPath(filePath);
+    let accessPath;
     let stats;
     try {
-      stats = await fs2.stat(resolvedPath);
+      accessPath = await resolveAllowedExistingPath(resolvedPath);
+      stats = await fs2.stat(accessPath);
     } catch (error) {
       if (error.code === "ENOENT") {
         return reply.code(404).send({ error: "File not found", path: resolvedPath });
@@ -2133,14 +2209,14 @@ async function fileRoutes(app) {
       try {
         return {
           path: resolvedPath,
-          content: await archivePreview(resolvedPath),
+          content: await archivePreview(accessPath),
           kind: "archive",
           mtime: stats.mtimeMs
         };
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown archive error";
+        const message2 = error instanceof Error ? error.message : "Unknown archive error";
         return reply.code(415).send({
-          error: `Archive preview failed: ${message}`,
+          error: `Archive preview failed: ${message2}`,
           kind: "binary",
           path: resolvedPath,
           mtime: stats.mtimeMs
@@ -2165,24 +2241,52 @@ async function fileRoutes(app) {
         mtime: stats.mtimeMs
       });
     }
-    let content;
+    let handle;
     try {
-      content = await fs2.readFile(resolvedPath);
+      handle = await fs2.open(accessPath, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0));
+      const openedStats = await handle.stat();
+      if (openedStats.size > MAX_TEXT_FILE_BYTES) {
+        return reply.code(413).send({
+          error: "File is too large to open as text",
+          maxBytes: MAX_TEXT_FILE_BYTES,
+          path: resolvedPath
+        });
+      }
+      const chunks = [];
+      let totalBytes = 0;
+      while (true) {
+        const remainingBytes = MAX_TEXT_FILE_BYTES + 1 - totalBytes;
+        const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, remainingBytes));
+        const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, null);
+        if (bytesRead === 0) break;
+        totalBytes += bytesRead;
+        if (totalBytes > MAX_TEXT_FILE_BYTES) {
+          return reply.code(413).send({
+            error: "File is too large to open as text",
+            maxBytes: MAX_TEXT_FILE_BYTES,
+            path: resolvedPath
+          });
+        }
+        chunks.push(buffer.subarray(0, bytesRead));
+      }
+      const content = Buffer.concat(chunks, totalBytes);
+      if (isBinaryFile(resolvedPath, content)) {
+        return reply.code(415).send({
+          error: "Unsupported file type",
+          kind: "binary",
+          path: resolvedPath,
+          mtime: openedStats.mtimeMs
+        });
+      }
+      return { path: resolvedPath, content: content.toString("utf-8"), mtime: openedStats.mtimeMs };
     } catch (error) {
       if (error.code === "ENOENT") {
         return reply.code(404).send({ error: "File not found", path: resolvedPath });
       }
       throw error;
+    } finally {
+      await handle?.close();
     }
-    if (isBinaryFile(resolvedPath, content)) {
-      return reply.code(415).send({
-        error: "Unsupported file type",
-        kind: "binary",
-        path: resolvedPath,
-        mtime: stats.mtimeMs
-      });
-    }
-    return { path: resolvedPath, content: content.toString("utf-8"), mtime: stats.mtimeMs };
   });
   app.get("/preview-asset", async (req, reply) => {
     const { root, path: relativePath } = req.query;
@@ -2223,14 +2327,22 @@ async function fileRoutes(app) {
     if (!imageMimeType && !isPdf) {
       return reply.code(415).send({ error: "Unsupported file type" });
     }
-    if (isPdf) {
-      return reply.type("application/pdf").send(createReadStream2(resolvedPath));
-    }
-    const content = await fs2.readFile(resolvedPath);
-    if (imageMimeType === "image/svg+xml") {
-      reply.header("Content-Security-Policy", "sandbox; default-src 'none'");
+    let handle;
+    try {
+      const accessPath = await resolveAllowedExistingPath(resolvedPath);
+      handle = await fs2.open(accessPath, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0));
+      const stream = handle.createReadStream();
+      handle = void 0;
+      if (isPdf) {
+        return reply.type("application/pdf").send(stream);
+      }
+      if (imageMimeType === "image/svg+xml") {
+        reply.header("Content-Security-Policy", "sandbox; default-src 'none'");
+      }
+      return reply.type(imageMimeType).send(stream);
+    } finally {
+      await handle?.close();
     }
-    return reply.type(imageMimeType).send(content);
   });
   app.post("/write", async (req) => {
     const { path: filePath, content } = req.body;
@@ -2384,11 +2496,45 @@ async function fileRoutes(app) {
     });
     return { success: true };
   });
-  app.get("/search", async (req) => {
+  app.get("/search", async (req, reply) => {
     const { pattern, path: searchPath } = req.query;
+    if (!pattern?.trim()) {
+      return reply.code(400).send({ error: "Search pattern is required" });
+    }
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    const patternSegments = normalizedPattern.split("/");
+    const unsafeMagic = ["{", "}", "[", "]"].some((character) => normalizedPattern.includes(character)) || /[?*+@!]\(/.test(normalizedPattern);
+    const unsafeDotSegment = patternSegments.some((segment) => segment === ".." || segment.includes(".") && /^[.*?]+$/.test(segment));
+    if (path3.isAbsolute(pattern) || unsafeMagic || unsafeDotSegment) {
+      return reply.code(400).send({ error: "Search pattern must stay within the requested path" });
+    }
     const resolvedSearchPath = await resolveAllowedPath(searchPath || ".");
-    const files = await glob(pattern, { cwd: resolvedSearchPath });
-    return { files };
+    const files = [];
+    const signal = AbortSignal.timeout(FILE_SEARCH_TIMEOUT_MS);
+    try {
+      for await (const file of globIterate(normalizedPattern, {
+        cwd: resolvedSearchPath,
+        root: resolvedSearchPath,
+        ignore: FILE_SEARCH_IGNORES,
+        nodir: true,
+        signal
+      })) {
+        const relativePath = path3.relative(resolvedSearchPath, path3.resolve(resolvedSearchPath, file));
+        if (relativePath.startsWith("..") || path3.isAbsolute(relativePath)) {
+          return reply.code(400).send({ error: "Search pattern must stay within the requested path" });
+        }
+        if (files.length === MAX_FILE_SEARCH_RESULTS) {
+          return { files, truncated: true };
+        }
+        files.push(file);
+      }
+    } catch (error) {
+      if (signal.aborted) {
+        return reply.code(408).send({ error: "File search timed out" });
+      }
+      throw error;
+    }
+    return { files, truncated: false };
   });
 }
 
@@ -2674,6 +2820,205 @@ async function changelogRoutes(app) {
   });
 }
 
+// src/services/speech-to-text.ts
+var DEFAULT_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_MODEL = "gpt-4o-mini-transcribe";
+var MAX_TRANSCRIPTION_ATTEMPTS = 3;
+var RETRY_DELAY_MS = 500;
+var MAX_AUDIO_BYTES = 25 * 1024 * 1024;
+function audioExtension(contentType) {
+  if (contentType.includes("amr")) return "amr";
+  if (contentType.includes("mp4")) return "m4a";
+  if (contentType.includes("mpeg")) return "mp3";
+  if (contentType.includes("ogg")) return "ogg";
+  if (contentType.includes("wav")) return "wav";
+  return "webm";
+}
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+function wait(ms) {
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
+}
+function isSpeechToTextConfigured() {
+  return Boolean(process.env.PI_CLOUD_STT_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim());
+}
+async function transcribeAudio(audio, contentType, options = {}) {
+  const apiKey = process.env.PI_CLOUD_STT_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim();
+  if (!apiKey) throw new Error("Speech-to-text is not configured.");
+  const baseUrl = (process.env.PI_CLOUD_STT_BASE_URL?.trim() || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const model = process.env.PI_CLOUD_STT_MODEL?.trim() || DEFAULT_MODEL;
+  const language = process.env.PI_CLOUD_STT_LANGUAGE?.trim();
+  const fetchImpl = options.fetch ?? fetch;
+  const retryDelayMs = options.retryDelayMs ?? RETRY_DELAY_MS;
+  const form = new FormData();
+  form.append("file", new Blob([audio], { type: contentType }), `recording.${audioExtension(contentType)}`);
+  form.append("model", model);
+  if (language) form.append("language", language);
+  for (let attempt = 1; attempt <= MAX_TRANSCRIPTION_ATTEMPTS; attempt += 1) {
+    let response;
+    try {
+      response = await fetchImpl(`${baseUrl}/audio/transcriptions`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}` },
+        body: form
+      });
+    } catch (error) {
+      if (attempt === MAX_TRANSCRIPTION_ATTEMPTS) {
+        throw new Error("Unable to reach the speech-to-text provider.", { cause: error });
+      }
+      await wait(retryDelayMs * attempt);
+      continue;
+    }
+    const result = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      if (isRetryableStatus(response.status) && attempt < MAX_TRANSCRIPTION_ATTEMPTS) {
+        await wait(retryDelayMs * attempt);
+        continue;
+      }
+      throw new Error(typeof result.error?.message === "string" ? result.error.message : "Transcription failed.");
+    }
+    if (typeof result.text !== "string") throw new Error("The speech-to-text provider returned an invalid response.");
+    return result.text;
+  }
+  throw new Error("Unable to reach the speech-to-text provider.");
+}
+
+// src/services/text-to-speech.ts
+var DEFAULT_MODEL2 = "mlx-community/Kokoro-82M-bf16";
+var DEFAULT_VOICE = "af_heart";
+var DEFAULT_FORMAT = "wav";
+var MAX_SYNTHESIS_ATTEMPTS = 3;
+var RETRY_DELAY_MS2 = 500;
+var MAX_TTS_TEXT_LENGTH = 1e5;
+var FORMAT_CONTENT_TYPES = {
+  aac: "audio/aac",
+  flac: "audio/flac",
+  mp3: "audio/mpeg",
+  ogg: "audio/ogg",
+  opus: "audio/ogg",
+  pcm: "audio/L16",
+  wav: "audio/wav"
+};
+function isRetryableStatus2(status) {
+  return status === 429 || status >= 500;
+}
+function wait2(ms) {
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
+}
+function languageCode(language) {
+  if (language === "zh") return "z";
+  if (language === "en") return "a";
+  return language;
+}
+async function providerError(response) {
+  const result = await response.json().catch(() => ({}));
+  if (typeof result.error?.message === "string") return result.error.message;
+  if (typeof result.detail === "string") return result.detail;
+  return "Speech synthesis failed.";
+}
+function isTextToSpeechConfigured() {
+  return Boolean(process.env.PI_CLOUD_TTS_BASE_URL?.trim());
+}
+async function synthesizeSpeech(text, options = {}) {
+  const baseUrl = process.env.PI_CLOUD_TTS_BASE_URL?.trim().replace(/\/+$/, "");
+  if (!baseUrl) throw new Error("Text-to-speech is not configured.");
+  const model = process.env.PI_CLOUD_TTS_MODEL?.trim() || DEFAULT_MODEL2;
+  const voice = process.env.PI_CLOUD_TTS_VOICE?.trim() || DEFAULT_VOICE;
+  const language = process.env.PI_CLOUD_TTS_LANGUAGE?.trim();
+  const format = process.env.PI_CLOUD_TTS_FORMAT?.trim().toLowerCase() || DEFAULT_FORMAT;
+  const apiKey = process.env.PI_CLOUD_TTS_API_KEY?.trim();
+  const fetchImpl = options.fetch ?? fetch;
+  const retryDelayMs = options.retryDelayMs ?? RETRY_DELAY_MS2;
+  const body = {
+    model,
+    input: text,
+    voice,
+    response_format: format,
+    ...language ? { language } : {},
+    ...language ? { lang_code: languageCode(language) } : {}
+  };
+  for (let attempt = 1; attempt <= MAX_SYNTHESIS_ATTEMPTS; attempt += 1) {
+    let response;
+    try {
+      response = await fetchImpl(`${baseUrl}/audio/speech`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (error) {
+      if (attempt === MAX_SYNTHESIS_ATTEMPTS) {
+        throw new Error("Unable to reach the text-to-speech provider.", { cause: error });
+      }
+      await wait2(retryDelayMs * attempt);
+      continue;
+    }
+    if (!response.ok) {
+      const message2 = await providerError(response);
+      if (isRetryableStatus2(response.status) && attempt < MAX_SYNTHESIS_ATTEMPTS) {
+        await wait2(retryDelayMs * attempt);
+        continue;
+      }
+      throw new Error(message2);
+    }
+    const audio = Buffer.from(await response.arrayBuffer());
+    if (audio.length === 0) throw new Error("The text-to-speech provider returned an empty response.");
+    return {
+      audio,
+      contentType: response.headers.get("content-type")?.split(";")[0] || FORMAT_CONTENT_TYPES[format] || "application/octet-stream"
+    };
+  }
+  throw new Error("Unable to reach the text-to-speech provider.");
+}
+
+// src/routes/speech.ts
+async function speechRoutes(app, options = {}) {
+  app.addContentTypeParser(/^audio\//, { parseAs: "buffer", bodyLimit: MAX_AUDIO_BYTES }, (_req, body, done) => {
+    done(null, body);
+  });
+  app.get("/status", async () => ({
+    available: isSpeechToTextConfigured(),
+    ttsAvailable: isTextToSpeechConfigured()
+  }));
+  app.post("/transcribe", async (req, reply) => {
+    if (!isSpeechToTextConfigured()) {
+      return reply.status(503).send({ error: "Speech-to-text is not configured." });
+    }
+    const contentType = req.headers["content-type"]?.split(";")[0]?.trim().toLowerCase() || "";
+    if (!contentType.startsWith("audio/") || !Buffer.isBuffer(req.body) || req.body.length === 0) {
+      return reply.status(400).send({ error: "A non-empty audio request body is required." });
+    }
+    try {
+      return { text: await transcribeAudio(req.body, contentType, options) };
+    } catch (error) {
+      req.log.error({ err: error }, "Speech-to-text request failed");
+      return reply.status(502).send({ error: error instanceof Error ? error.message : "Transcription failed." });
+    }
+  });
+  app.post("/synthesize", async (req, reply) => {
+    if (!isTextToSpeechConfigured()) {
+      return reply.status(503).send({ error: "Text-to-speech is not configured." });
+    }
+    const text = req.body?.text;
+    if (typeof text !== "string" || !text.trim()) {
+      return reply.status(400).send({ error: "Non-empty text is required." });
+    }
+    if (text.length > MAX_TTS_TEXT_LENGTH) {
+      return reply.status(413).send({ error: `Text must not exceed ${MAX_TTS_TEXT_LENGTH} characters.` });
+    }
+    try {
+      const result = await synthesizeSpeech(text, options);
+      return reply.type(result.contentType).send(result.audio);
+    } catch (error) {
+      req.log.error({ err: error }, "Text-to-speech request failed");
+      return reply.status(502).send({ error: error instanceof Error ? error.message : "Speech synthesis failed." });
+    }
+  });
+}
+
 // src/routes/git.ts
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
@@ -2798,6 +3143,17 @@ async function runGit(cwd, args, maxBuffer3 = MAX_SLASH_COMMAND_OUTPUT_BYTES) {
     throw error;
   }
 }
+async function runGitNoIndex(cwd, args, maxBuffer3) {
+  try {
+    const { stdout } = await execFileAsync("git", ["diff", "--no-index", ...args], { cwd, maxBuffer: maxBuffer3 });
+    return stdout;
+  } catch (error) {
+    if (isMaxBufferError(error)) throw new OversizedGitOutputError();
+    const result = error;
+    if (result.code === 1) return result.stdout || "";
+    throw error;
+  }
+}
 async function isGitRepository(cwd) {
   try {
     return (await runGit(cwd, ["rev-parse", "--is-inside-work-tree"])).trim() === "true";
@@ -2874,12 +3230,26 @@ function parseBranchName(name, files) {
   if (!files.length) throw new Error("No git changes to suggest a branch name from");
   return sanitizeBranchName(proposeCommitMessage(files));
 }
-function textFromAssistantMessage(message) {
-  return message.content.filter((item) => item.type === "text").map((item) => item.text).join("\n").trim();
+function textFromAssistantMessage(message2) {
+  return message2.content.filter((item) => item.type === "text").map((item) => item.text).join("\n").trim();
 }
 function joinGitOutput(...parts) {
   return parts.map((part) => part.replace(/^(?:\r?\n)+|(?:\r?\n)+$/g, "")).filter((part) => part.trim()).join("\n\n");
 }
+async function appendUntrackedDiff(cwd, diff, args, path13, maxBytes) {
+  const pathArgs = path13 ? ["--", path13] : [];
+  const untracked = await runGit(cwd, ["ls-files", "--others", "--exclude-standard", "-z", ...pathArgs]);
+  const files = untracked.split("\0").filter(Boolean);
+  let output = diff;
+  for (const file of files) {
+    const separatorBytes = output.trim() ? 2 : 0;
+    const remainingBytes = maxBytes - Buffer.byteLength(output) - separatorBytes;
+    if (remainingBytes <= 0) throw new OversizedGitOutputError();
+    const fileDiff = await runGitNoIndex(cwd, [...args, "--", "/dev/null", file], remainingBytes);
+    output = joinGitOutput(output, fileDiff);
+  }
+  return output;
+}
 async function getCombinedDiff(cwd, args, maxBytes = MAX_SLASH_COMMAND_OUTPUT_BYTES) {
   const unstaged = await runGit(cwd, ["diff", ...args], maxBytes);
   const remainingBytes = maxBytes - Buffer.byteLength(unstaged);
@@ -3023,9 +3393,9 @@ async function generateCommitMessageWithAi(sessionService, clientId, cwd, status
   if (response.stopReason === "error") {
     throw new Error(response.errorMessage || "AI commit message generation failed");
   }
-  const message = textFromAssistantMessage(response).replace(/^```(?:text)?/i, "").replace(/```$/i, "").trim().replace(/^['"]|['"]$/g, "").trim();
-  if (!message) throw new Error("AI did not return a commit message");
-  return message;
+  const message2 = textFromAssistantMessage(response).replace(/^```(?:text)?/i, "").replace(/```$/i, "").trim().replace(/^['"]|['"]$/g, "").trim();
+  if (!message2) throw new Error("AI did not return a commit message");
+  return message2;
 }
 function parseChangedRanges(diff) {
   const changes = {};
@@ -3100,7 +3470,7 @@ async function gitRoutes(app, options = {}) {
     }) || { global: {}, project: {}, effective: DEFAULT_COMMIT_MESSAGE_PROMPTS };
   });
   app.get("/status", async (req, reply) => {
-    const { cwd, message, stagedOnly } = req.query;
+    const { cwd, message: message2, stagedOnly } = req.query;
     const resolvedCwd = await resolveGitCwd(cwd);
     try {
       if (!await isGitRepository(resolvedCwd)) {
@@ -3115,7 +3485,7 @@ async function gitRoutes(app, options = {}) {
         cwd: resolvedCwd,
         isRepository: true,
         files,
-        message: message?.trim() || (files.length ? proposeCommitMessage(files) : ""),
+        message: message2?.trim() || (files.length ? proposeCommitMessage(files) : ""),
         output
       };
     } catch (error) {
@@ -3152,8 +3522,8 @@ async function gitRoutes(app, options = {}) {
         commits: commits.slice(0, GIT_HISTORY_PAGE_SIZE)
       };
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to load git history";
-      return reply.status(400).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to load git history";
+      return reply.status(400).send({ error: message2 });
     }
   });
   app.get("/branches", async (req, reply) => {
@@ -3214,8 +3584,8 @@ async function gitRoutes(app, options = {}) {
         return reply.status(400).send({ error: "No git changes to generate a commit message from" });
       }
       const prompts = options.commitMessagePrompts?.get(resolvedCwd).effective || DEFAULT_COMMIT_MESSAGE_PROMPTS;
-      const message = await generateCommitMessageWithAi(app.services.sessions, clientId, resolvedCwd, status, diff, prompts);
-      return { cwd: resolvedCwd, message, files };
+      const message2 = await generateCommitMessageWithAi(app.services.sessions, clientId, resolvedCwd, status, diff, prompts);
+      return { cwd: resolvedCwd, message: message2, files };
     } catch (error) {
       const errorMessage2 = error instanceof Error ? error.message : "Failed to generate commit message";
       return reply.status(400).send({ error: errorMessage2 });
@@ -3294,8 +3664,8 @@ async function gitRoutes(app, options = {}) {
   app.post("/commit", async (req, reply) => {
     const body = req.body || {};
     const resolvedCwd = await resolveGitCwd(body.cwd);
-    const message = body.message?.trim();
-    if (!message) {
+    const message2 = body.message?.trim();
+    if (!message2) {
       return reply.status(400).send({ error: "Commit message is required" });
     }
     try {
@@ -3306,12 +3676,12 @@ async function gitRoutes(app, options = {}) {
       if (!files.length) {
         return reply.status(400).send({ error: "No changes to commit" });
       }
-      const output = await runGit(resolvedCwd, ["commit", "-m", message]);
+      const output = await runGit(resolvedCwd, ["commit", "-m", message2]);
       const commit = (await runGit(resolvedCwd, ["rev-parse", "HEAD"])).trim();
-      recordCommitActivity(options, { sessionId: body.sessionId, cwd: resolvedCwd, message, commit, files, mode: "commit" });
+      recordCommitActivity(options, { sessionId: body.sessionId, cwd: resolvedCwd, message: message2, commit, files, mode: "commit" });
       return {
         cwd: resolvedCwd,
-        message,
+        message: message2,
         files,
         commit,
         output
@@ -3322,7 +3692,7 @@ async function gitRoutes(app, options = {}) {
     }
   });
   app.get("/amend-status", async (req, reply) => {
-    const { cwd, message } = req.query;
+    const { cwd, message: message2 } = req.query;
     const resolvedCwd = await resolveGitCwd(cwd);
     try {
       await ensureHasCommit(resolvedCwd);
@@ -3333,7 +3703,7 @@ async function gitRoutes(app, options = {}) {
       return {
         cwd: resolvedCwd,
         files: parseStatusFiles(status),
-        message: message?.trim() || previousMessage.trim()
+        message: message2?.trim() || previousMessage.trim()
       };
     } catch (error) {
       const errorMessage2 = error instanceof Error ? error.message : "Failed to prepare git amend";
@@ -3343,8 +3713,8 @@ async function gitRoutes(app, options = {}) {
   app.post("/amend", async (req, reply) => {
     const body = req.body || {};
     const resolvedCwd = await resolveGitCwd(body.cwd);
-    const message = body.message?.trim();
-    if (!message) {
+    const message2 = body.message?.trim();
+    if (!message2) {
       return reply.status(400).send({ error: "Commit message is required" });
     }
     try {
@@ -3352,12 +3722,12 @@ async function gitRoutes(app, options = {}) {
       await runGit(resolvedCwd, ["add", "-A"]);
       const status = await runGit(resolvedCwd, ["status", "--porcelain"]);
       const files = parseStatusFiles(status);
-      const output = await runGit(resolvedCwd, ["commit", "--amend", "--allow-empty", "-m", message]);
+      const output = await runGit(resolvedCwd, ["commit", "--amend", "--allow-empty", "-m", message2]);
       const commit = (await runGit(resolvedCwd, ["rev-parse", "HEAD"])).trim();
-      recordCommitActivity(options, { sessionId: body.sessionId, cwd: resolvedCwd, message, commit, files, mode: "amend" });
+      recordCommitActivity(options, { sessionId: body.sessionId, cwd: resolvedCwd, message: message2, commit, files, mode: "amend" });
       return {
         cwd: resolvedCwd,
-        message,
+        message: message2,
         files,
         commit,
         output
@@ -3377,27 +3747,33 @@ async function gitRoutes(app, options = {}) {
         changes: parseChangedRanges(diff)
       };
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to run git diff";
-      return reply.status(400).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to run git diff";
+      return reply.status(400).send({ error: message2 });
     }
   });
   app.get("/diff", async (req, reply) => {
-    const { cwd, scope: rawScope, commit: rawCommit, path: path13 } = req.query;
+    const { cwd, scope: rawScope, commit: rawCommit, path: path13, includeUntracked } = req.query;
     const resolvedCwd = await resolveGitCwd(cwd);
     try {
       const commit = rawCommit ? parseCommit(rawCommit) : void 0;
       if (commit) {
         const diff2 = await runGit(resolvedCwd, ["show", "--format=", "--patch", commit]);
         const remainingBytes2 = MAX_SLASH_COMMAND_OUTPUT_BYTES - Buffer.byteLength(diff2);
-        const stat9 = remainingBytes2 > 0 ? await runGit(resolvedCwd, ["show", "--format=", "--stat", commit], remainingBytes2) : "";
-        return { cwd: resolvedCwd, scope: `commit-${commit}`, commit, stat: stat9, diff: diff2 };
+        const stat11 = remainingBytes2 > 0 ? await runGit(resolvedCwd, ["show", "--format=", "--stat", commit], remainingBytes2) : "";
+        return { cwd: resolvedCwd, scope: `commit-${commit}`, commit, stat: stat11, diff: diff2 };
       }
       const scope = parseDiffScope(rawScope);
       const pathArgs = path13 ? ["--", path13] : [];
-      const diff = await getDiff(resolvedCwd, pathArgs, scope);
+      let diff = await getDiff(resolvedCwd, pathArgs, scope);
+      if (includeUntracked === "true" && scope !== "staged") {
+        diff = await appendUntrackedDiff(resolvedCwd, diff, [], path13, MAX_SLASH_COMMAND_OUTPUT_BYTES);
+      }
       const remainingBytes = MAX_SLASH_COMMAND_OUTPUT_BYTES - Buffer.byteLength(diff);
-      const stat8 = remainingBytes > 0 ? await getDiff(resolvedCwd, ["--stat", ...pathArgs], scope, remainingBytes) : "";
-      return { cwd: resolvedCwd, scope, path: path13, stat: stat8, diff };
+      let stat10 = remainingBytes > 0 ? await getDiff(resolvedCwd, ["--stat", ...pathArgs], scope, remainingBytes) : "";
+      if (includeUntracked === "true" && scope !== "staged" && remainingBytes > 0) {
+        stat10 = await appendUntrackedDiff(resolvedCwd, stat10, ["--stat"], path13, remainingBytes);
+      }
+      return { cwd: resolvedCwd, scope, path: path13, stat: stat10, diff };
     } catch (error) {
       if (error instanceof OversizedGitOutputError) {
         return {
@@ -3408,8 +3784,8 @@ async function gitRoutes(app, options = {}) {
           message: error.message
         };
       }
-      const message = error instanceof Error ? error.message : "Failed to run git diff";
-      return reply.status(400).send({ error: message });
+      const message2 = error instanceof Error ? error.message : "Failed to run git diff";
+      return reply.status(400).send({ error: message2 });
     }
   });
 }
@@ -3587,10 +3963,10 @@ var ProjectTaskStore = class {
     if (!task) throw new ProjectTaskNotFoundError("Task not found");
     return task;
   }
-  assertChanged(id, changes, message) {
+  assertChanged(id, changes, message2) {
     if (changes) return;
     if (!this.get(id)) throw new ProjectTaskNotFoundError("Task not found");
-    throw new ProjectTaskConflictError(message);
+    throw new ProjectTaskConflictError(message2);
   }
 };
 function isProjectTaskStatus(value) {
@@ -3760,8 +4136,8 @@ async function taskRoutes(app, options) {
     }
   });
 }
-function textFromAssistantMessage2(message) {
-  return message.content.filter((item) => item.type === "text").map((item) => item.text).join("\n").trim();
+function textFromAssistantMessage2(message2) {
+  return message2.content.filter((item) => item.type === "text").map((item) => item.text).join("\n").trim();
 }
 function taskPolishPrompt(title, prompt) {
   return `Polish this project task so it is ready for an AI coding agent to execute.
@@ -3854,11 +4230,11 @@ function optionalString3(value, field) {
   return value.trim() || null;
 }
 function sendTaskError(reply, error, validationStatus = 409) {
-  const message = error instanceof Error ? error.message : "Task request failed";
-  if (error instanceof ProjectTaskNotFoundError) return reply.status(404).send({ error: message });
-  if (error instanceof ProjectTaskConflictError) return reply.status(409).send({ error: message });
-  if (error instanceof ProjectTaskValidationError) return reply.status(validationStatus).send({ error: message });
-  return reply.status(500).send({ error: message });
+  const message2 = error instanceof Error ? error.message : "Task request failed";
+  if (error instanceof ProjectTaskNotFoundError) return reply.status(404).send({ error: message2 });
+  if (error instanceof ProjectTaskConflictError) return reply.status(409).send({ error: message2 });
+  if (error instanceof ProjectTaskValidationError) return reply.status(validationStatus).send({ error: message2 });
+  return reply.status(500).send({ error: message2 });
 }
 
 // src/routes/feishu-gateway.ts
@@ -3874,8 +4250,8 @@ async function feishuGatewayRoutes(app, options) {
 function sendFeishuGatewayError(reply, error) {
   const maybeStatusCode = error?.statusCode;
   const statusCode = typeof maybeStatusCode === "number" ? maybeStatusCode : 500;
-  const message = error instanceof Error ? error.message : "Feishu gateway request failed";
-  return reply.status(statusCode).send({ error: message });
+  const message2 = error instanceof Error ? error.message : "Feishu gateway request failed";
+  return reply.status(statusCode).send({ error: message2 });
 }
 
 // src/routes/gateways.ts
@@ -3910,8 +4286,67 @@ async function gatewayRoutes(app, options) {
   });
 }
 function sendGatewayError(reply, error) {
-  const message = error instanceof Error ? error.message : "Gateway settings request failed";
-  return reply.status(400).send({ error: message });
+  const message2 = error instanceof Error ? error.message : "Gateway settings request failed";
+  return reply.status(400).send({ error: message2 });
+}
+
+// src/routes/wecom-gateway.ts
+async function wecomGatewayRoutes(app, options) {
+  app.addContentTypeParser(["application/xml", "text/xml"], { parseAs: "string" }, (_req, body, done) => done(null, body));
+  app.get("/callback", async (req, reply) => {
+    try {
+      const challenge = options.service.handleVerification(req.query);
+      return reply.type("text/plain; charset=utf-8").send(challenge);
+    } catch (error) {
+      return sendWecomError(reply, error);
+    }
+  });
+  app.post("/callback", async (req, reply) => {
+    try {
+      const acknowledgement = options.service.handleCallback(
+        req.query,
+        typeof req.body === "string" ? req.body : ""
+      );
+      return reply.type("text/plain; charset=utf-8").send(acknowledgement);
+    } catch (error) {
+      return sendWecomError(reply, error);
+    }
+  });
+  app.get("/status", async () => ({ status: options.service.status() }));
+  app.put("/configuration", async (req, reply) => {
+    try {
+      return options.service.saveConfiguration(req.body);
+    } catch (error) {
+      return sendWecomError(reply, error);
+    }
+  });
+  app.delete("/configuration", async (_req, reply) => {
+    try {
+      options.service.disconnect();
+      return { status: options.service.status() };
+    } catch (error) {
+      return sendWecomError(reply, error);
+    }
+  });
+  app.post("/callback-secrets", async (_req, reply) => {
+    try {
+      return options.service.regenerateCallbackSecrets();
+    } catch (error) {
+      return sendWecomError(reply, error);
+    }
+  });
+  app.post("/test", async (_req, reply) => {
+    try {
+      return { status: await options.service.testConnection() };
+    } catch (error) {
+      return sendWecomError(reply, error);
+    }
+  });
+}
+function sendWecomError(reply, error) {
+  const statusCode = Number(error?.statusCode) || 400;
+  const message2 = error instanceof Error ? error.message : "WeCom gateway request failed";
+  return reply.status(statusCode).send({ error: message2 });
 }
 
 // src/routes/git-hosting.ts
@@ -3953,15 +4388,15 @@ var GiteaSettingsStore = class {
     return this.get();
   }
   clear() {
-    this.db.prepare("DELETE FROM security_settings WHERE key IN (?, ?)").run(SERVER_URL_KEY, TOKEN_KEY);
+    this.db.prepare("DELETE FROM application_settings WHERE key IN (?, ?)").run(SERVER_URL_KEY, TOKEN_KEY);
   }
   value(key) {
-    const row = this.db.prepare("SELECT value FROM security_settings WHERE key = ?").get(key);
+    const row = this.db.prepare("SELECT value FROM application_settings WHERE key = ?").get(key);
     return row?.value;
   }
   set(key, value) {
     this.db.prepare(`
-      INSERT INTO security_settings (key, value, updated_at)
+      INSERT INTO application_settings (key, value, updated_at)
       VALUES (?, ?, ?)
       ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
     `).run(key, value, (/* @__PURE__ */ new Date()).toISOString());
@@ -4016,7 +4451,7 @@ var GithubSettingsStore = class {
     const value = proxyUrl.trim();
     if (value) new URL(value);
     if (value) this.set(PROXY_URL_KEY, value);
-    else this.db.prepare("DELETE FROM security_settings WHERE key = ?").run(PROXY_URL_KEY);
+    else this.db.prepare("DELETE FROM application_settings WHERE key = ?").run(PROXY_URL_KEY);
     return this.get();
   }
   proxyEnv() {
@@ -4024,15 +4459,15 @@ var GithubSettingsStore = class {
     return proxyUrl ? githubProxyEnvFromUrl(proxyUrl) : {};
   }
   clear() {
-    this.db.prepare("DELETE FROM security_settings WHERE key IN (?, ?)").run(SERVER_URL_KEY2, TOKEN_KEY2);
+    this.db.prepare("DELETE FROM application_settings WHERE key IN (?, ?)").run(SERVER_URL_KEY2, TOKEN_KEY2);
   }
   value(key) {
-    const row = this.db.prepare("SELECT value FROM security_settings WHERE key = ?").get(key);
+    const row = this.db.prepare("SELECT value FROM application_settings WHERE key = ?").get(key);
     return row?.value;
   }
   set(key, value) {
     this.db.prepare(`
-      INSERT INTO security_settings (key, value, updated_at)
+      INSERT INTO application_settings (key, value, updated_at)
       VALUES (?, ?, ?)
       ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
     `).run(key, value, (/* @__PURE__ */ new Date()).toISOString());
@@ -4055,8 +4490,8 @@ var maxDiffBuffer = 10 * 1024 * 1024;
 var githubProxyCheckArgs = ["-fsSL", "--connect-timeout", "5", "--max-time", "10", "https://www.google.com/generate_204"];
 var githubProxyCountryArgs = ["-fsSL", "--connect-timeout", "5", "--max-time", "10", "https://ipinfo.io/country"];
 var proxyEnvKeys = ["ALL_PROXY", "HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "all_proxy", "http_proxy", "https_proxy", "no_proxy"];
-function textFromAssistantMessage3(message) {
-  return message.content.filter((item) => item.type === "text").map((item) => item.text).join("\n").trim();
+function textFromAssistantMessage3(message2) {
+  return message2.content.filter((item) => item.type === "text").map((item) => item.text).join("\n").trim();
 }
 async function runGit2(cwd, args) {
   const { stdout } = await execFileAsync2("git", args, { cwd, maxBuffer: maxDiffBuffer });
@@ -4386,8 +4821,8 @@ async function gitHostingRoutes(app, options) {
 }
 function sendError2(reply, error, status = 500) {
   const maybeStatus = error?.statusCode;
-  const errorStatus2 = typeof maybeStatus === "number" ? maybeStatus : status;
-  return reply.status(errorStatus2).send({ error: error instanceof Error ? error.message : "Git integration request failed" });
+  const errorStatus3 = typeof maybeStatus === "number" ? maybeStatus : status;
+  return reply.status(errorStatus3).send({ error: error instanceof Error ? error.message : "Git integration request failed" });
 }
 
 // src/routes/review-sources.ts
@@ -4538,6 +4973,72 @@ async function reviewSourceRoutes(app, options) {
   });
 }
 
+// src/routes/model-window-kickoffs.ts
+import { stat as stat4 } from "node:fs/promises";
+var modelWindowKickoffRoutes = async (app, options) => {
+  app.get("/", async () => ({ kickoffs: options.store.list() }));
+  app.post("/", async (req, reply) => {
+    try {
+      const input = await validateInput(options.sessions, req.body);
+      return reply.status(201).send({ kickoff: options.store.create(input) });
+    } catch (error) {
+      return reply.status(errorStatus(error, 400)).send({ error: message(error) });
+    }
+  });
+  app.put("/:id", async (req, reply) => {
+    try {
+      const input = await validateInput(options.sessions, req.body);
+      return { kickoff: options.store.update(req.params.id, input) };
+    } catch (error) {
+      const fallback = message(error).includes("not found") ? 404 : 400;
+      return reply.status(errorStatus(error, fallback)).send({ error: message(error) });
+    }
+  });
+  app.delete("/:id", async (req, reply) => {
+    try {
+      options.store.delete(req.params.id);
+      return reply.status(204).send();
+    } catch (error) {
+      return reply.status(404).send({ error: message(error) });
+    }
+  });
+  app.get("/notification-channels", async () => ({ channels: options.notifications.list() }));
+  app.post("/notification-channels/wecom", async (req, reply) => {
+    try {
+      return { channel: options.notifications.saveWecom(req.body) };
+    } catch (error) {
+      return reply.status(400).send({ error: message(error) });
+    }
+  });
+  app.delete("/notification-channels/:id", async (req, reply) => {
+    try {
+      options.notifications.delete(req.params.id);
+      return reply.status(204).send();
+    } catch (error) {
+      return reply.status(404).send({ error: message(error) });
+    }
+  });
+};
+async function validateInput(sessions, input) {
+  if (!input?.profileId || !input.provider || !input.modelId) throw new Error("Profile, provider, and model are required");
+  const models = await sessions.listAgentProfileModels(input.profileId);
+  if (!models.some((model) => model.provider === input.provider && model.id === input.modelId)) {
+    throw new Error(`Unknown model: ${input.provider}/${input.modelId}`);
+  }
+  const projectPath = await resolveAllowedExistingPath(input.projectPath || "~");
+  if (!(await stat4(projectPath)).isDirectory()) throw new Error("Project path must be a directory");
+  return { ...input, projectPath };
+}
+function errorStatus(error, fallback) {
+  return typeof error === "object" && error && "statusCode" in error && typeof error.statusCode === "number" ? error.statusCode : fallback;
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/routes/auth.ts
+import rateLimit from "@fastify/rate-limit";
+
 // src/auth/request.ts
 function getRequestContext(req, trustProxy) {
   const forwardedFor = req.headers["x-forwarded-for"];
@@ -4685,17 +5186,70 @@ function mapRow2(row) {
   };
 }
 
+// src/services/user-prompt-store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var UserPromptStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  list() {
+    return this.db.prepare(`
+      SELECT id, name, content, created_at, updated_at
+      FROM user_prompts
+      ORDER BY lower(name), id
+    `).all().map(mapRow3);
+  }
+  create(input) {
+    const id = randomUUID3();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(`
+      INSERT INTO user_prompts (id, name, content, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(id, input.name.trim(), input.content.trim(), now, now);
+    return this.get(id);
+  }
+  update(id, input) {
+    const result = this.db.prepare(`
+      UPDATE user_prompts SET name = ?, content = ?, updated_at = ?
+      WHERE id = ?
+    `).run(input.name.trim(), input.content.trim(), (/* @__PURE__ */ new Date()).toISOString(), id);
+    if (!result.changes) throw new Error(`User prompt not found: ${id}`);
+    return this.get(id);
+  }
+  delete(id) {
+    this.db.prepare("DELETE FROM user_prompts WHERE id = ?").run(id);
+  }
+  get(id) {
+    const row = this.db.prepare(`
+      SELECT id, name, content, created_at, updated_at
+      FROM user_prompts WHERE id = ?
+    `).get(id);
+    return row ? mapRow3(row) : null;
+  }
+};
+function mapRow3(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    content: row.content,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
 // src/routes/auth.ts
 async function authRoutes(app, options) {
   const { config, sessions, audit, totp, rateLimiter, db } = options;
   const presetStore = new SkillPresetStore(db);
+  const userPromptStore = new UserPromptStore(db);
   function getPreferenceValue(key) {
-    const row = db.prepare("SELECT value FROM security_settings WHERE key = ?").get(key);
+    const row = db.prepare("SELECT value FROM application_settings WHERE key = ?").get(key);
     return row?.value;
   }
   function setPreferenceValue(key, value) {
     db.prepare(`
-      INSERT INTO security_settings (key, value, updated_at)
+      INSERT INTO application_settings (key, value, updated_at)
       VALUES (?, ?, ?)
       ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
     `).run(key, value, (/* @__PURE__ */ new Date()).toISOString());
@@ -4742,7 +5296,8 @@ async function authRoutes(app, options) {
       autoExtractMemory: getPreferenceValue("memory.autoExtract") === "true",
       theme: getTheme(),
       language: getLanguage(),
-      soundNotification: getSoundNotification()
+      soundNotification: getSoundNotification(),
+      autoSpeakAssistant: getPreferenceValue("ui.autoSpeakAssistant") === "true"
     };
   }
   function requireAuth(req, reply) {
@@ -4768,6 +5323,13 @@ async function authRoutes(app, options) {
     }
     return { name, mode, skills };
   }
+  function parseUserPromptBody(body) {
+    const name = typeof body.name === "string" ? body.name.trim() : "";
+    const content = typeof body.content === "string" ? body.content.trim() : "";
+    if (!name) throw new Error("name is required");
+    if (!content) throw new Error("content is required");
+    return { name, content };
+  }
   function isUniqueConstraintError(error) {
     return error instanceof Error && /unique/i.test(error.message);
   }
@@ -4777,6 +5339,12 @@ async function authRoutes(app, options) {
     }
     return reply.status(400).send({ error: error instanceof Error ? error.message : "Invalid preset payload" });
   }
+  function sendUserPromptError(reply, error) {
+    if (isUniqueConstraintError(error)) {
+      return reply.status(409).send({ error: "A prompt with that name already exists" });
+    }
+    return reply.status(400).send({ error: error instanceof Error ? error.message : "Invalid prompt payload" });
+  }
   app.get("/me", async (req, reply) => {
     const session = renewSessionFromRequest(req, reply, config, sessions);
     return {
@@ -4855,8 +5423,9 @@ async function authRoutes(app, options) {
     const hasTheme = hasPreference(body, "theme");
     const hasLanguage = hasPreference(body, "language");
     const hasSoundNotification = hasPreference(body, "soundNotification");
+    const hasAutoSpeakAssistant = hasPreference(body, "autoSpeakAssistant");
     const hasGitCloneParentPath = hasPreference(body, "gitCloneParentPath");
-    if (!hasShowHintInfo && !hasShowCodeBlockLanguageHeaders && !hasStreamingMessageBehavior && !hasEditorAutoRefresh && !hasConfirmSessionDelete && !hasNewSessionShortcut && !hasFullscreenShortcut && !hasShowGoToTopButton && !hasShowChatViewOptionsButton && !hasAutoExtractMemory && !hasTheme && !hasLanguage && !hasSoundNotification && !hasGitCloneParentPath) {
+    if (!hasShowHintInfo && !hasShowCodeBlockLanguageHeaders && !hasStreamingMessageBehavior && !hasEditorAutoRefresh && !hasConfirmSessionDelete && !hasNewSessionShortcut && !hasFullscreenShortcut && !hasShowGoToTopButton && !hasShowChatViewOptionsButton && !hasAutoExtractMemory && !hasTheme && !hasLanguage && !hasSoundNotification && !hasAutoSpeakAssistant && !hasGitCloneParentPath) {
       return reply.status(400).send({ error: "At least one preference must be provided" });
     }
     if (hasShowHintInfo && typeof body.showHintInfo !== "boolean") {
@@ -4898,6 +5467,9 @@ async function authRoutes(app, options) {
     if (hasSoundNotification && body.soundNotification !== "off" && body.soundNotification !== "beep" && body.soundNotification !== "chime" && body.soundNotification !== "ding") {
       return reply.status(400).send({ error: "soundNotification must be off, beep, chime, or ding" });
     }
+    if (hasAutoSpeakAssistant && typeof body.autoSpeakAssistant !== "boolean") {
+      return reply.status(400).send({ error: "autoSpeakAssistant must be a boolean" });
+    }
     if (hasGitCloneParentPath && (typeof body.gitCloneParentPath !== "string" || !body.gitCloneParentPath.trim())) {
       return reply.status(400).send({ error: "gitCloneParentPath must be a non-empty string" });
     }
@@ -4914,6 +5486,7 @@ async function authRoutes(app, options) {
     if (hasTheme) setPreferenceValue("ui.theme", String(body.theme));
     if (hasLanguage) setPreferenceValue("ui.language", String(body.language));
     if (hasSoundNotification) setPreferenceValue("ui.soundNotification", String(body.soundNotification));
+    if (hasAutoSpeakAssistant) setPreferenceValue("ui.autoSpeakAssistant", String(body.autoSpeakAssistant));
     if (hasGitCloneParentPath) setPreferenceValue("ui.gitCloneParentPath", String(body.gitCloneParentPath).trim());
     return getPreferences();
   });
@@ -4954,6 +5527,47 @@ async function authRoutes(app, options) {
     presetStore.delete(req.params.id, session.username);
     return { success: true };
   });
+  await app.register(async (userPromptRoutes) => {
+    await userPromptRoutes.register(rateLimit, {
+      max: 100,
+      timeWindow: "1 minute",
+      keyGenerator: (req) => getRequestContext(req, config.trustProxy).ip
+    });
+    userPromptRoutes.get("/user-prompts", async (req, reply) => {
+      const session = requireAuth(req, reply);
+      if (!session) return;
+      return { prompts: userPromptStore.list() };
+    });
+    userPromptRoutes.post("/user-prompts", async (req, reply) => {
+      const session = requireAuth(req, reply);
+      if (!session) return;
+      try {
+        return { prompt: userPromptStore.create(parseUserPromptBody(req.body || {})) };
+      } catch (error) {
+        return sendUserPromptError(reply, error);
+      }
+    });
+    userPromptRoutes.patch("/user-prompts/:id", async (req, reply) => {
+      const session = requireAuth(req, reply);
+      if (!session) return;
+      try {
+        return {
+          prompt: userPromptStore.update(
+            req.params.id,
+            parseUserPromptBody(req.body || {})
+          )
+        };
+      } catch (error) {
+        return sendUserPromptError(reply, error);
+      }
+    });
+    userPromptRoutes.delete("/user-prompts/:id", async (req, reply) => {
+      const session = requireAuth(req, reply);
+      if (!session) return;
+      userPromptStore.delete(req.params.id);
+      return { success: true };
+    });
+  });
   app.post("/2fa/setup", async (req, reply) => {
     const session = requireAuth(req, reply);
     if (!session) return;
@@ -5037,8 +5651,8 @@ function isAllowedRequestOrigin(req) {
 var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
 var MAX_IMAGE_COUNT = 4;
 var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
-function invalidImage(message = "The image could not be read. Try selecting it again.") {
-  return { ok: false, code: "image_malformed", message };
+function invalidImage(message2 = "The image could not be read. Try selecting it again.") {
+  return { ok: false, code: "image_malformed", message: message2 };
 }
 function sniffImageMimeType(bytes) {
   if (bytes.subarray(0, 3).equals(Buffer.from([255, 216, 255]))) return "image/jpeg";
@@ -5129,10 +5743,10 @@ function extensionForMimeType(mimeType) {
 }
 
 // src/ws/safe-send.ts
-function sendJson(socket, message) {
+function sendJson(socket, message2) {
   if (socket.readyState !== socket.OPEN) return;
   try {
-    socket.send(JSON.stringify(message));
+    socket.send(JSON.stringify(message2));
   } catch {
   }
 }
@@ -5205,6 +5819,7 @@ function formatCompactResult(result, status) {
 }
 async function chatWebSocket(app) {
   const sessionService = app.services.sessions;
+  const clients = /* @__PURE__ */ new Set();
   app.get("/ws/chat", { websocket: true }, (socket, req) => {
     const auth = app.authServices;
     if (!isAllowedRequestOrigin(req)) {
@@ -5232,7 +5847,17 @@ async function chatWebSocket(app) {
       return;
     }
     const safeClientId = clientId;
+    const connectedClient = { socket, watchedSessionId: void 0 };
+    clients.add(connectedClient);
     console.log(`Client connected: ${safeClientId}`);
+    sessionService.cancelCleanup(safeClientId);
+    function broadcastToSession(sessionId, message2) {
+      for (const client of clients) {
+        if (client === connectedClient || client.watchedSessionId === sessionId) {
+          sendJson(client.socket, message2);
+        }
+      }
+    }
     function sendPromptPreflight(sessionId, requestId, accepted, error, imagePaths) {
       sendJson(socket, {
         type: "prompt_preflight",
@@ -5296,10 +5921,24 @@ async function chatWebSocket(app) {
     }
     socket.on("message", async (rawData) => {
       try {
-        const message = JSON.parse(rawData.toString());
-        switch (message.type) {
+        const message2 = JSON.parse(rawData.toString());
+        switch (message2.type) {
+          case "watch": {
+            connectedClient.watchedSessionId = message2.payload?.sessionId;
+            const targetSessionId = connectedClient.watchedSessionId;
+            if (targetSessionId) {
+              const isStreaming = sessionService.isSessionStreaming(targetSessionId);
+              sendJson(socket, {
+                type: "streaming_state",
+                sessionId: targetSessionId,
+                isStreaming,
+                ...isStreaming ? { streamingStartedAt: sessionService.getSessionStreamingStartedAt(targetSessionId) } : {}
+              });
+            }
+            break;
+          }
           case "prompt": {
-            const session2 = await ensureTargetSession(message.payload?.sessionId);
+            const session2 = await ensureTargetSession(message2.payload?.sessionId);
             if (!session2) {
               sendJson(socket, {
                 type: "error",
@@ -5307,14 +5946,16 @@ async function chatWebSocket(app) {
               });
               return;
             }
-            const imageResult = validateImages(message.payload?.images, session2.model);
+            const imageResult = validateImages(message2.payload?.images, session2.model);
             if (!imageResult.ok) {
-              sendPromptPreflight(session2.sessionId, message.payload?.requestId, false, imageResult);
+              sendPromptPreflight(session2.sessionId, message2.payload?.requestId, false, imageResult);
               return;
             }
             sessionService.cancelCleanup(safeClientId);
             const sessionId = session2.sessionId;
-            const compactInstructions = parseCompactCommand(message.payload?.text || "");
+            connectedClient.watchedSessionId = sessionId;
+            const streamingStartedAt = sessionService.markSessionStreamingStarted(sessionId);
+            const compactInstructions = parseCompactCommand(message2.payload?.text || "");
             req.log?.info({
               clientId: safeClientId,
               sessionId,
@@ -5338,7 +5979,7 @@ async function chatWebSocket(app) {
                   if (recent.every((t) => t.name === recent[0].name && t.input === recent[0].input)) {
                     loopDetected = true;
                     console.warn(`[loop-detected] tool="${name}" sessionId=${sessionId}`);
-                    sendJson(socket, {
+                    broadcastToSession(sessionId, {
                       type: "loop_detected",
                       sessionId,
                       message: `Loop detected: tool "${name}" called ${MAX_REPEATED_TOOL_CALLS} times with identical input. Stopping automatically.`,
@@ -5353,10 +5994,11 @@ async function chatWebSocket(app) {
                   }
                 }
               }
-              sendJson(socket, {
+              broadcastToSession(sessionId, {
                 type: "event",
                 sessionId,
-                event
+                event,
+                streamingStartedAt
               });
             });
             try {
@@ -5370,9 +6012,9 @@ async function chatWebSocket(app) {
                     result
                   });
                 } else {
-                  const requestId = message.payload?.requestId;
+                  const requestId = message2.payload?.requestId;
                   const preparedPrompt = await promptWithUploadedImagePaths(
-                    message.payload?.text || "",
+                    message2.payload?.text || "",
                     session2,
                     imageResult
                   );
@@ -5390,24 +6032,23 @@ async function chatWebSocket(app) {
               });
             } finally {
               unsubscribe();
-              if (!loopDetected) {
-                sendJson(socket, { type: "status", sessionId, status: "idle" });
-              }
+              sessionService.markSessionStreamingFinished(sessionId);
+              broadcastToSession(sessionId, { type: "status", sessionId, status: "idle" });
             }
             break;
           }
           case "steer":
           case "followUp": {
-            const session2 = await ensureTargetSession(message.payload?.sessionId);
+            const session2 = await ensureTargetSession(message2.payload?.sessionId);
             if (!session2) break;
-            const imageResult = validateImages(message.payload?.images, session2.model);
+            const imageResult = validateImages(message2.payload?.images, session2.model);
             if (!imageResult.ok) {
-              sendPromptPreflight(session2.sessionId, message.payload?.requestId, false, imageResult);
+              sendPromptPreflight(session2.sessionId, message2.payload?.requestId, false, imageResult);
               break;
             }
-            if (!message.payload?.text && imageResult.images.length === 0) break;
-            const requestId = message.payload?.requestId;
-            const streamingBehavior = message.type === "steer" ? "steer" : "followUp";
+            if (!message2.payload?.text && imageResult.images.length === 0) break;
+            const requestId = message2.payload?.requestId;
+            const streamingBehavior = message2.type === "steer" ? "steer" : "followUp";
             req.log?.info({
               clientId: safeClientId,
               sessionId: session2.sessionId,
@@ -5417,7 +6058,7 @@ async function chatWebSocket(app) {
             }, "[ai-chat] request");
             await sessionService.runForegroundWithClientProfileProxy(safeClientId, async () => {
               const preparedPrompt = await promptWithUploadedImagePaths(
-                message.payload?.text || "",
+                message2.payload?.text || "",
                 session2,
                 imageResult
               );
@@ -5430,7 +6071,7 @@ async function chatWebSocket(app) {
             break;
           }
           case "abort": {
-            const session2 = await ensureTargetSession(message.payload?.sessionId);
+            const session2 = await ensureTargetSession(message2.payload?.sessionId);
             if (session2) {
               const aborted = await abortSessionBestEffort(session2);
               if (!aborted) {
@@ -5441,7 +6082,8 @@ async function chatWebSocket(app) {
                   message: "Request did not stop cleanly; the stuck runtime was discarded."
                 });
               }
-              sendJson(socket, { type: "status", sessionId: session2.sessionId, status: "idle" });
+              sessionService.markSessionStreamingFinished(session2.sessionId);
+              broadcastToSession(session2.sessionId, { type: "status", sessionId: session2.sessionId, status: "idle" });
             }
             break;
           }
@@ -5455,17 +6097,10 @@ async function chatWebSocket(app) {
       }
     });
     socket.on("close", () => {
+      clients.delete(connectedClient);
       console.log(`Client disconnected: ${safeClientId}`);
       unsubscribeMemoryUpdates();
       unsubscribeMemoryRecall();
-      const activeSession = sessionService.getSession(safeClientId);
-      if (activeSession?.isStreaming) {
-        abortSessionBestEffort(activeSession).then((aborted) => {
-          if (!aborted) sessionService.forceDisposeBySessionId(activeSession.sessionId);
-        }).catch((error) => {
-          console.warn("Failed to stop streaming session on disconnect:", error);
-        });
-      }
       sessionService.scheduleCleanup(safeClientId);
     });
   });
@@ -5533,16 +6168,16 @@ async function terminalWebSocket(app) {
     }));
     socket.on("message", (rawData) => {
       try {
-        const message = JSON.parse(rawData.toString());
-        switch (message.type) {
+        const message2 = JSON.parse(rawData.toString());
+        switch (message2.type) {
           case "input":
-            if (message.terminalId === terminal.id && typeof message.data === "string") {
-              terminalManager.writeTo(terminal.id, message.data);
+            if (message2.terminalId === terminal.id && typeof message2.data === "string") {
+              terminalManager.writeTo(terminal.id, message2.data);
             }
             break;
           case "resize":
-            if (message.terminalId === terminal.id && Number.isFinite(message.cols) && Number.isFinite(message.rows)) {
-              terminalManager.resize(terminal.id, message.cols, message.rows);
+            if (message2.terminalId === terminal.id && Number.isFinite(message2.cols) && Number.isFinite(message2.rows)) {
+              terminalManager.resize(terminal.id, message2.cols, message2.rows);
             }
             break;
         }
@@ -6081,11 +6716,157 @@ var projectHistorySchemaMigration = {
   }
 };
 
+// src/db/migrations/004-wecom-gateway-schema.ts
+var wecomGatewaySchemaMigration = {
+  version: 4,
+  name: "wecom-gateway-schema",
+  up(db) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS wecom_gateway_credentials (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        corp_id TEXT NOT NULL,
+        corp_secret TEXT NOT NULL,
+        agent_id TEXT NOT NULL,
+        callback_token TEXT NOT NULL,
+        encoding_aes_key TEXT NOT NULL,
+        allowed_users_json TEXT NOT NULL DEFAULT '[]',
+        callback_verified_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS wecom_gateway_sessions (
+        session_key TEXT PRIMARY KEY,
+        client_id TEXT NOT NULL,
+        pi_session_id TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS wecom_gateway_configs (
+        client_id TEXT PRIMARY KEY,
+        agent_profile TEXT,
+        default_cwd TEXT,
+        skill_mode TEXT,
+        skill_preset_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+    `);
+  }
+};
+
+// src/db/migrations/005-model-window-kickoff-schema.ts
+var modelWindowKickoffSchemaMigration = {
+  version: 5,
+  name: "model-window-kickoff-schema",
+  up(db) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS notification_channels (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        name TEXT NOT NULL,
+        config_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS model_window_kickoffs (
+        id TEXT PRIMARY KEY,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        profile_id TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model_id TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        window_duration_minutes INTEGER NOT NULL,
+        safety_buffer_seconds INTEGER NOT NULL,
+        notification_channel_id TEXT REFERENCES notification_channels(id) ON DELETE SET NULL,
+        next_run_at TEXT NOT NULL,
+        last_attempt_at TEXT,
+        last_success_at TEXT,
+        last_error TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS model_window_kickoffs_due_idx
+      ON model_window_kickoffs(enabled, next_run_at);
+    `);
+  }
+};
+
+// src/db/migrations/006-model-window-kickoff-project-path.ts
+var modelWindowKickoffProjectPathMigration = {
+  version: 6,
+  name: "model-window-kickoff-project-path",
+  up(db) {
+    db.exec(`
+      ALTER TABLE model_window_kickoffs
+      ADD COLUMN project_path TEXT NOT NULL DEFAULT '~';
+    `);
+  }
+};
+
+// src/db/migrations/007-user-prompts-schema.ts
+var userPromptsSchemaMigration = {
+  version: 7,
+  name: "user-prompts-schema",
+  up(db) {
+    db.exec(`
+      CREATE TABLE user_prompts (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        content TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+  }
+};
+
+// src/db/migrations/008-application-settings-table.ts
+var applicationSettingsTableMigration = {
+  version: 8,
+  name: "application-settings-table",
+  up(db) {
+    db.exec("ALTER TABLE security_settings RENAME TO application_settings");
+  }
+};
+
+// src/db/migrations/009-pinned-files-schema.ts
+var pinnedFilesSchemaMigration = {
+  version: 9,
+  name: "pinned-files-schema",
+  up(db) {
+    db.exec(`
+      CREATE TABLE pinned_files (
+        owner_type TEXT NOT NULL CHECK (owner_type = 'profile'),
+        owner_id TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        group_id TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (owner_type, owner_id, file_path),
+        FOREIGN KEY (owner_type, owner_id, group_id)
+          REFERENCES session_pin_groups(owner_type, owner_id, id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX pinned_files_group_idx
+        ON pinned_files(owner_type, owner_id, group_id, created_at);
+    `);
+  }
+};
+
 // src/db/migrations/index.ts
 var migrations = [
   applicationSchemaMigration,
   gatewaySchemaMigration,
-  projectHistorySchemaMigration
+  projectHistorySchemaMigration,
+  wecomGatewaySchemaMigration,
+  modelWindowKickoffSchemaMigration,
+  modelWindowKickoffProjectPathMigration,
+  userPromptsSchemaMigration,
+  applicationSettingsTableMigration,
+  pinnedFilesSchemaMigration
 ];
 function runDatabaseMigrations(db) {
   db.exec(`
@@ -6333,18 +7114,18 @@ var TotpService = class {
     this.deleteValue("totp.secret");
   }
   getValue(key) {
-    const row = this.db.prepare("SELECT value FROM security_settings WHERE key = ?").get(key);
+    const row = this.db.prepare("SELECT value FROM application_settings WHERE key = ?").get(key);
     return row?.value;
   }
   setValue(key, value) {
     this.db.prepare(`
-      INSERT INTO security_settings (key, value, updated_at)
+      INSERT INTO application_settings (key, value, updated_at)
       VALUES (?, ?, ?)
       ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
     `).run(key, value, (/* @__PURE__ */ new Date()).toISOString());
   }
   deleteValue(key) {
-    this.db.prepare("DELETE FROM security_settings WHERE key = ?").run(key);
+    this.db.prepare("DELETE FROM application_settings WHERE key = ?").run(key);
   }
 };
 
@@ -6672,6 +7453,7 @@ var PiSessionService = class {
   clientSessions = /* @__PURE__ */ new Map();
   currentClientSession = /* @__PURE__ */ new Map();
   cleanupTimers = /* @__PURE__ */ new Map();
+  streamingStartedAt = /* @__PURE__ */ new Map();
   clientProfiles = /* @__PURE__ */ new Map();
   sessionListCache = /* @__PURE__ */ new Map();
   userMessageCountCache = /* @__PURE__ */ new Map();
@@ -7419,7 +8201,7 @@ var PiSessionService = class {
         path: sessionPath || cwd,
         created: (/* @__PURE__ */ new Date()).toISOString(),
         modified: (/* @__PURE__ */ new Date()).toISOString(),
-        messageCount: activeSession.messages.filter((message) => message.role === "user").length,
+        messageCount: activeSession.messages.filter((message2) => message2.role === "user").length,
         cwd,
         firstMessage: typeof firstUserMessage === "string" ? firstUserMessage : void 0,
         isStreaming: activeSession.isStreaming
@@ -7838,12 +8620,32 @@ var PiSessionService = class {
   isSessionStreaming(sessionId) {
     return this.getSessionBySessionId(sessionId)?.isStreaming === true;
   }
+  markSessionStreamingStarted(sessionId) {
+    const startedAt = this.streamingStartedAt.get(sessionId) ?? Date.now();
+    this.streamingStartedAt.set(sessionId, startedAt);
+    return startedAt;
+  }
+  getSessionStreamingStartedAt(sessionId) {
+    const startedAt = this.streamingStartedAt.get(sessionId);
+    if (startedAt !== void 0 || !this.isSessionStreaming(sessionId)) return startedAt;
+    return this.markSessionStreamingStarted(sessionId);
+  }
+  markSessionStreamingFinished(sessionId) {
+    this.streamingStartedAt.delete(sessionId);
+  }
   isCwdStreaming(cwd) {
     return Array.from(this.sessions.values()).some((session) => session.sessionManager.getCwd() === cwd && session.isStreaming === true);
   }
   scheduleCleanup(clientId, delayMs = 5 * 60 * 1e3) {
     this.cancelCleanup(clientId);
     const timer = setTimeout(() => {
+      this.cleanupTimers.delete(clientId);
+      const sessionIds = this.clientSessions.get(clientId) || /* @__PURE__ */ new Set();
+      const isStreaming = Array.from(sessionIds).some((sessionId) => this.sessions.get(sessionId)?.isStreaming);
+      if (isStreaming) {
+        this.scheduleCleanup(clientId, delayMs);
+        return;
+      }
       this.disposeSession(clientId);
     }, delayMs);
     this.cleanupTimers.set(clientId, timer);
@@ -7863,6 +8665,7 @@ var PiSessionService = class {
       if (!session) continue;
       session.dispose();
       this.sessions.delete(sessionId);
+      this.streamingStartedAt.delete(sessionId);
     }
     this.clientSessions.delete(clientId);
     this.currentClientSession.delete(clientId);
@@ -7888,6 +8691,7 @@ var PiSessionService = class {
       session.dispose();
       this.sessions.delete(sessionId);
     }
+    this.streamingStartedAt.delete(sessionId);
     for (const [clientId, sessionIds] of this.clientSessions) {
       sessionIds.delete(sessionId);
       if (this.currentClientSession.get(clientId) === sessionId) {
@@ -8108,7 +8912,7 @@ var PiSessionService = class {
     return (await this.readSessionDirHeader(sessionDir))?.cwd;
   }
   getFirstUserMessageContent(messages) {
-    const firstUserMessage = messages.find((message) => Boolean(message) && typeof message === "object" && message.role === "user");
+    const firstUserMessage = messages.find((message2) => Boolean(message2) && typeof message2 === "object" && message2.role === "user");
     return typeof firstUserMessage?.content === "string" ? firstUserMessage.content : void 0;
   }
   async readSessionDirHeader(sessionDir) {
@@ -8224,7 +9028,7 @@ var SessionActivityStore = class {
       WHERE session_id = ?
       ORDER BY created_at ASC, id ASC
     `).all(sessionId);
-    return rows.map(mapRow3);
+    return rows.map(mapRow4);
   }
   updatePrStatus(id, status, checkedAt = this.now()) {
     const row = this.db.prepare("SELECT session_id, data_json FROM session_builtin_events WHERE id = ? AND kind = 'pr_created'").get(id);
@@ -8246,7 +9050,7 @@ var SessionActivityStore = class {
       ORDER BY created_at DESC, id DESC
     `).all(...sessionIds);
     for (const row of rows) {
-      if (!latest.has(row.session_id)) latest.set(row.session_id, mapRow3(row));
+      if (!latest.has(row.session_id)) latest.set(row.session_id, mapRow4(row));
     }
     return latest;
   }
@@ -8259,7 +9063,7 @@ var SessionActivityStore = class {
     return this.listForSession(sessionId).find((record) => record.id === Number(result.lastInsertRowid));
   }
 };
-function mapRow3(row) {
+function mapRow4(row) {
   return {
     id: row.id,
     sessionId: row.session_id,
@@ -8278,7 +9082,7 @@ function parseJson(value) {
 }
 
 // src/services/session-pin-store.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var DEFAULT_PIN_GROUP_ID = "default";
 var SessionPinStore = class {
   constructor(db) {
@@ -8299,7 +9103,7 @@ var SessionPinStore = class {
     this.ensureDefaultGroup(owner);
     const trimmed = name.trim();
     if (!trimmed) throw new Error("Group name is required");
-    const id = randomUUID3();
+    const id = randomUUID4();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     this.db.prepare(`
       INSERT INTO session_pin_groups (owner_type, owner_id, id, name, is_default, created_at)
@@ -8325,6 +9129,40 @@ var SessionPinStore = class {
       DELETE FROM session_pins WHERE owner_type = ? AND owner_id = ? AND session_id = ?
     `).run(owner.type, owner.id, sessionId);
   }
+  pinFile(profileId, filePath, groupId) {
+    const owner = { type: "profile", id: profileId };
+    this.ensureDefaultGroup(owner);
+    if (!this.db.prepare(`
+      SELECT 1 FROM session_pin_groups WHERE owner_type = 'profile' AND owner_id = ? AND id = ?
+    `).get(profileId, groupId)) {
+      throw new Error("Pin group not found");
+    }
+    this.db.prepare(`
+      INSERT INTO pinned_files (owner_type, owner_id, file_path, group_id, created_at)
+      VALUES ('profile', ?, ?, ?, ?)
+      ON CONFLICT(owner_type, owner_id, file_path) DO UPDATE SET group_id = excluded.group_id
+    `).run(profileId, filePath, groupId, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  unpinFile(profileId, filePath) {
+    this.db.prepare(`
+      DELETE FROM pinned_files WHERE owner_type = 'profile' AND owner_id = ? AND file_path = ?
+    `).run(profileId, filePath);
+  }
+  listFilePathsByGroup(profileId) {
+    const rows = this.db.prepare(`
+      SELECT group_id, file_path
+      FROM pinned_files
+      WHERE owner_type = 'profile' AND owner_id = ?
+      ORDER BY created_at, file_path
+    `).all(profileId);
+    const result = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const paths = result.get(row.group_id) || [];
+      paths.push(row.file_path);
+      result.set(row.group_id, paths);
+    }
+    return result;
+  }
   listSessionIdsByGroup(owner) {
     const rows = this.db.prepare(`
       SELECT group_id, session_id
@@ -8379,7 +9217,7 @@ var SkillPolicyStore = class {
   }
   get(sessionId) {
     const row = this.db.prepare("SELECT * FROM session_skill_policies WHERE session_id = ?").get(sessionId);
-    return row ? mapRow4(row) : null;
+    return row ? mapRow5(row) : null;
   }
   delete(sessionId) {
     this.db.prepare("DELETE FROM session_skill_policies WHERE session_id = ?").run(sessionId);
@@ -8388,7 +9226,7 @@ var SkillPolicyStore = class {
 function normalizeSkills2(skills) {
   return Array.from(new Set(skills.map((skill) => skill.trim()).filter(Boolean)));
 }
-function mapRow4(row) {
+function mapRow5(row) {
   return {
     sessionId: row.session_id,
     username: row.username,
@@ -8571,16 +9409,16 @@ function buildExtractionSource(branchEntries, startingLeafId, endingLeafId) {
   const evidence = [];
   for (const entry of branchEntries.slice(startIndex + 1, endIndex + 1)) {
     if (entry.type !== "message") continue;
-    const message = entry.message;
-    if (message.role === "user") {
-      for (const text of textBlocks(message.content)) {
+    const message2 = entry.message;
+    if (message2.role === "user") {
+      for (const text of textBlocks(message2.content)) {
         lines.push(`[User] ${text}`);
         evidence.push({ role: "user", text });
       }
       continue;
     }
-    if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
-    for (const block of message.content) {
+    if (message2.role !== "assistant" || !Array.isArray(message2.content)) continue;
+    for (const block of message2.content) {
       if (block.type === "text" && block.text.trim()) {
         const text = block.text.trim();
         lines.push(`[Assistant] ${text}`);
@@ -9020,15 +9858,15 @@ function buildExtractionSource2(branchEntries, startingLeafId, endingLeafId) {
   };
   for (const entry of branchEntries.slice(startIndex + 1, endIndex + 1)) {
     if (entry.type !== "message") continue;
-    const message = entry.message;
-    if (message.role === "user") {
-      for (const text2 of textBlocks2(message.content)) {
+    const message2 = entry.message;
+    if (message2.role === "user") {
+      for (const text2 of textBlocks2(message2.content)) {
         if (!isRawNoise(text2)) append({ role: "user", text: text2, ...textMetadata(text2) });
       }
       continue;
     }
-    if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
-    for (const block of message.content) {
+    if (message2.role !== "assistant" || !Array.isArray(message2.content)) continue;
+    for (const block of message2.content) {
       if (block.type === "text" && isConfirmedAssistantEvidence(block.text)) {
         append({ role: "assistant", text: block.text, ...textMetadata(block.text) });
         continue;
@@ -9530,8 +10368,8 @@ function buildExtractionQueries(source) {
 // src/memory/extractor.ts
 var EXTRACTION_TIMEOUT_MS = 45e3;
 var RetryableExtractionError = class extends Error {
-  constructor(kind, message) {
-    super(message);
+  constructor(kind, message2) {
+    super(message2);
     this.kind = kind;
     this.name = "RetryableExtractionError";
   }
@@ -9895,21 +10733,21 @@ function isUsage(value) {
 function isAbort(error, signal) {
   return signal.aborted || error instanceof Error && error.name === "AbortError";
 }
-function providerResponseError(message) {
-  return new Error(message?.trim() || "Memory extraction provider failed");
+function providerResponseError(message2) {
+  return new Error(message2?.trim() || "Memory extraction provider failed");
 }
 function isUnsupportedSchemaError(error) {
-  const status = errorStatus(error);
-  const message = error instanceof Error ? error.message : String(error);
-  return (status === 400 || status === 422 || status === void 0) && /(?:response[_ .-]?format|output[_ .-]?config|text\.format|json[_ .-]?schema|structured output|responseJsonSchema|unknown (?:field|parameter)).*(?:unsupported|unknown|invalid|not (?:allowed|supported))|(?:unsupported|unknown|invalid|not (?:allowed|supported)).*(?:response[_ .-]?format|output[_ .-]?config|text\.format|json[_ .-]?schema|structured output|responseJsonSchema)/i.test(message);
+  const status = errorStatus2(error);
+  const message2 = error instanceof Error ? error.message : String(error);
+  return (status === 400 || status === 422 || status === void 0) && /(?:response[_ .-]?format|output[_ .-]?config|text\.format|json[_ .-]?schema|structured output|responseJsonSchema|unknown (?:field|parameter)).*(?:unsupported|unknown|invalid|not (?:allowed|supported))|(?:unsupported|unknown|invalid|not (?:allowed|supported)).*(?:response[_ .-]?format|output[_ .-]?config|text\.format|json[_ .-]?schema|structured output|responseJsonSchema)/i.test(message2);
 }
 function isRetryableTransportError(error) {
-  const status = errorStatus(error);
+  const status = errorStatus2(error);
   if (status !== void 0) return status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
   if (!(error instanceof Error)) return false;
   return /(?:timeout|timed out|network|connection|socket|fetch failed|temporarily unavailable|rate limit|overloaded)/i.test(error.message);
 }
-function errorStatus(error) {
+function errorStatus2(error) {
   if (!error || typeof error !== "object") return void 0;
   const candidate = error;
   const status = candidate.status ?? candidate.statusCode ?? candidate.response?.status;
@@ -10543,15 +11381,15 @@ function errorName2(error) {
 }
 
 // src/memory/store.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 var MemoryStore = class {
   constructor(db) {
     this.db = db;
   }
   db;
   isAutoExtractionEnabled() {
-    const row = this.db.prepare("SELECT value FROM security_settings WHERE key = ?").get("memory.autoExtract");
-    return row?.value !== "false";
+    const row = this.db.prepare("SELECT value FROM application_settings WHERE key = ?").get("memory.autoExtract");
+    return row?.value === "true";
   }
   getOrCreateProject(profileId, canonicalPath) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -10559,7 +11397,7 @@ var MemoryStore = class {
       INSERT INTO memory_projects (id, profile_id, canonical_path, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?)
       ON CONFLICT(profile_id, canonical_path) DO NOTHING
-    `).run(randomUUID4(), profileId, canonicalPath, now, now);
+    `).run(randomUUID5(), profileId, canonicalPath, now, now);
     return this.getProjectByPath(profileId, canonicalPath);
   }
   getProjectById(id) {
@@ -10617,7 +11455,7 @@ var MemoryStore = class {
     const evidence = input.evidence ? assertMemoryContent(input.evidence) : null;
     const tags = normalizeMemoryTags(input.tags);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const id = randomUUID4();
+    const id = randomUUID5();
     try {
       this.db.prepare(`
         INSERT INTO memories (
@@ -10921,7 +11759,7 @@ var MemoryStore = class {
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'queued', ?, ?, 0, ?)
       ON CONFLICT(source_session_id, ending_leaf_id, source_kind) DO NOTHING
     `).run(
-      randomUUID4(),
+      randomUUID5(),
       input.profileId,
       input.projectId,
       input.sourceSessionId,
@@ -11431,8 +12269,8 @@ function createMemoryRuntime(options) {
 
 // src/services/worktree-manager.ts
 import { execFile as execFileCallback } from "child_process";
-import { copyFile, mkdir as mkdir5, readdir as readdir4 } from "fs/promises";
-import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute3, join as join13 } from "path";
+import { copyFile, mkdir as mkdir5, readdir as readdir3 } from "fs/promises";
+import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute4, join as join13 } from "path";
 import { promisify as promisify4 } from "util";
 var defaultExecFile = promisify4(execFileCallback);
 var WorktreeManager = class {
@@ -11460,7 +12298,7 @@ var WorktreeManager = class {
     const baseRepoPath = await this.getRepoRoot(projectPath).catch(() => void 0);
     if (!baseRepoPath) return [];
     const files = [];
-    const entries = await readdir4(baseRepoPath, { withFileTypes: true });
+    const entries = await readdir3(baseRepoPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !this.isRootFileName(entry.name)) continue;
       if (await this.isIgnored(baseRepoPath, entry.name)) files.push(entry.name);
@@ -11554,7 +12392,7 @@ var WorktreeManager = class {
     }
   }
   isRootFileName(name) {
-    return Boolean(name.trim()) && !isAbsolute3(name) && !name.includes("/") && !name.includes("\\") && basename5(name) === name;
+    return Boolean(name.trim()) && !isAbsolute4(name) && !name.includes("/") && !name.includes("\\") && basename5(name) === name;
   }
 };
 
@@ -11927,8 +12765,8 @@ function matchesNoProxy(host, entry) {
 
 // src/services/github-client.ts
 var GithubRequestError = class extends Error {
-  constructor(message, statusCode) {
-    super(message);
+  constructor(message2, statusCode) {
+    super(message2);
     this.statusCode = statusCode;
     this.name = "GithubRequestError";
   }
@@ -12027,8 +12865,8 @@ function execFileCapture(file, args, options) {
 function parseResponse2(text, ok, status) {
   const data = parseJsonObject3(text);
   if (!ok) {
-    const message = typeof data.message === "string" ? data.message : `GitHub request failed (${status})`;
-    throw new GithubRequestError(message, status);
+    const message2 = typeof data.message === "string" ? data.message : `GitHub request failed (${status})`;
+    throw new GithubRequestError(message2, status);
   }
   return data;
 }
@@ -12102,18 +12940,18 @@ var GatewaySettingsStore = class {
     else this.delete(key);
   }
   value(key) {
-    const row = this.db.prepare("SELECT value FROM security_settings WHERE key = ?").get(key);
+    const row = this.db.prepare("SELECT value FROM application_settings WHERE key = ?").get(key);
     return row?.value || "";
   }
   set(key, value) {
     this.db.prepare(`
-      INSERT INTO security_settings (key, value, updated_at)
+      INSERT INTO application_settings (key, value, updated_at)
       VALUES (?, ?, ?)
       ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
     `).run(key, value, (/* @__PURE__ */ new Date()).toISOString());
   }
   delete(key) {
-    this.db.prepare("DELETE FROM security_settings WHERE key = ?").run(key);
+    this.db.prepare("DELETE FROM application_settings WHERE key = ?").run(key);
   }
 };
 function normalizeCwdList(value) {
@@ -12235,8 +13073,8 @@ function toSessionOptions(task, cwd) {
 
 // src/services/repository-cloner.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
-import { randomUUID as randomUUID5 } from "node:crypto";
-import { rm as rm4, stat as stat5 } from "node:fs/promises";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import { rm as rm4, stat as stat6 } from "node:fs/promises";
 import { join as join14 } from "node:path";
 var GIT_PROGRESS_PATTERNS = [
   { pattern: /^Receiving objects:\s+(\d+)%/, status: "Receiving objects\u2026" },
@@ -12256,7 +13094,7 @@ var RepositoryCloner = class {
     if (!destinationPath) throw new Error("Destination path is required");
     const pathExists = this.options.pathExists || defaultPathExists;
     if (await pathExists(destinationPath)) return { status: "destination_exists", existingPath: destinationPath };
-    const job = new CloneJob(`clone_${randomUUID5()}`, remoteUrl, destinationPath, input.shallow === true);
+    const job = new CloneJob(`clone_${randomUUID6()}`, remoteUrl, destinationPath, input.shallow === true);
     this.jobs.set(job.id, job);
     await this.spawnClone(job, remoteUrl, false, input.clientId);
     return { status: "started", jobId: job.id };
@@ -12415,7 +13253,7 @@ function withToken(remoteUrl, username, token) {
   return parsed.toString();
 }
 async function defaultPathExists(path13) {
-  return stat5(path13).then(() => true, () => false);
+  return stat6(path13).then(() => true, () => false);
 }
 async function defaultRemovePath(path13) {
   await rm4(path13, { recursive: true, force: true });
@@ -12423,8 +13261,8 @@ async function defaultRemovePath(path13) {
 
 // src/services/feishu-gateway.ts
 import { createDecipheriv, createHash as createHash7 } from "node:crypto";
-import { stat as stat6 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4 } from "node:path";
+import { stat as stat7 } from "node:fs/promises";
+import { isAbsolute as isAbsolute5 } from "node:path";
 
 // src/services/gateway-command-aliases.ts
 var DEFAULT_COMMAND_PREFIX = "\u5C0F\u52A9\u7406";
@@ -12510,12 +13348,12 @@ var FeishuGatewayService = class {
     if (payload.type === "url_verification") {
       return { challenge: stringValue(payload.challenge) };
     }
-    const message = this.parseMessage(payload);
-    if (!message) return { ok: true, ignored: true };
-    if (this.markDuplicate(message.eventId) || this.markDuplicate(message.messageId)) {
+    const message2 = this.parseMessage(payload);
+    if (!message2) return { ok: true, ignored: true };
+    if (this.markDuplicate(message2.eventId) || this.markDuplicate(message2.messageId)) {
       return { ok: true, duplicate: true };
     }
-    this.enqueue(message, config);
+    this.enqueue(message2, config);
     return { ok: true };
   }
   loadConfig() {
@@ -12562,9 +13400,9 @@ var FeishuGatewayService = class {
       console.warn("[feishu-gateway] failed to decrypt encrypted callback payload", {
         reason: error instanceof Error ? error.message : "unknown error"
       });
-      const gatewayError = new Error("Invalid Feishu encrypted callback payload");
-      gatewayError.statusCode = 400;
-      throw gatewayError;
+      const gatewayError2 = new Error("Invalid Feishu encrypted callback payload");
+      gatewayError2.statusCode = 400;
+      throw gatewayError2;
     }
   }
   verifyToken(payload, config) {
@@ -12587,22 +13425,22 @@ var FeishuGatewayService = class {
     const event = asRecord(payload.event);
     const eventType = stringValue(header.event_type);
     if (eventType && eventType !== "im.message.receive_v1") return null;
-    const message = asRecord(event.message);
-    const messageType = stringValue(message.message_type);
+    const message2 = asRecord(event.message);
+    const messageType = stringValue(message2.message_type);
     if (messageType && messageType !== "text") {
-      logUnsupportedFeishuMessage(message, messageType);
+      logUnsupportedFeishuMessage(message2, messageType);
       return null;
     }
-    const text = parseFeishuTextContent(stringValue(message.content)).trim();
-    const chatId = stringValue(message.chat_id);
-    const messageId = stringValue(message.message_id);
+    const text = parseFeishuTextContent(stringValue(message2.content)).trim();
+    const chatId = stringValue(message2.chat_id);
+    const messageId = stringValue(message2.message_id);
     if (!text || !chatId || !messageId) return null;
     return {
       eventId: stringValue(header.event_id) || messageId,
       messageId,
       chatId,
-      chatType: stringValue(message.chat_type) || "p2p",
-      threadId: stringValue(message.thread_id) || stringValue(message.parent_id) || stringValue(message.root_id),
+      chatType: stringValue(message2.chat_type) || "p2p",
+      threadId: stringValue(message2.thread_id) || stringValue(message2.parent_id) || stringValue(message2.root_id),
       text
     };
   }
@@ -12616,24 +13454,24 @@ var FeishuGatewayService = class {
     this.seen.set(id, now + DEDUP_TTL_MS);
     return false;
   }
-  enqueue(message, config) {
-    const clientId = this.clientIdForMessage(message);
+  enqueue(message2, config) {
+    const clientId = this.clientIdForMessage(message2);
     const previous = this.queues.get(clientId) || Promise.resolve();
-    const next = previous.catch(() => void 0).then(() => this.processMessage(clientId, message, config)).catch((error) => console.error("[feishu-gateway] message handling failed:", error)).finally(() => {
+    const next = previous.catch(() => void 0).then(() => this.processMessage(clientId, message2, config)).catch((error) => console.error("[feishu-gateway] message handling failed:", error)).finally(() => {
       if (this.queues.get(clientId) === next) this.queues.delete(clientId);
     });
     this.queues.set(clientId, next);
   }
-  clientIdForMessage(message) {
-    const chatType = message.chatType === "p2p" ? "dm" : message.chatType || "chat";
-    const thread = message.threadId ? `:${message.threadId}` : "";
-    return `feishu:${chatType}:${message.chatId}${thread}`;
+  clientIdForMessage(message2) {
+    const chatType = message2.chatType === "p2p" ? "dm" : message2.chatType || "chat";
+    const thread = message2.threadId ? `:${message2.threadId}` : "";
+    return `feishu:${chatType}:${message2.chatId}${thread}`;
   }
-  async processMessage(clientId, message, config) {
+  async processMessage(clientId, message2, config) {
     const effectiveConfig = this.resolveChatConfig(clientId, config);
-    if (await this.handleCommand(clientId, message, config, effectiveConfig)) return;
+    if (await this.handleCommand(clientId, message2, config, effectiveConfig)) return;
     if (!effectiveConfig.defaultCwd) {
-      await this.sendReply(config, message.messageId, GATEWAY_FOLDERS_REQUIRED_MESSAGE);
+      await this.sendReply(config, message2.messageId, GATEWAY_FOLDERS_REQUIRED_MESSAGE);
       return;
     }
     const session = await this.ensureSession(clientId, effectiveConfig);
@@ -12647,13 +13485,13 @@ var FeishuGatewayService = class {
     });
     try {
       await this.sessionService.runForegroundWithClientProfileProxy(clientId, async () => {
-        await session.prompt(message.text);
+        await session.prompt(message2.text);
       });
     } finally {
       unsubscribe();
     }
     const response = chunks.join("").trim() || extractLastAssistantText(session.messages) || "(Pi finished without a text response.)";
-    await this.sendReply(config, message.messageId, response);
+    await this.sendReply(config, message2.messageId, response);
   }
   async ensureSession(clientId, config) {
     await this.sessionService.setClientAgentProfile(clientId, config.agentProfile || "default");
@@ -12668,8 +13506,8 @@ var FeishuGatewayService = class {
     this.saveSessionMapping(clientId, result.session.sessionId);
     return result.session;
   }
-  async handleCommand(clientId, message, baseConfig, effectiveConfig) {
-    const commandText = normalizeGatewayCommandText(message.text);
+  async handleCommand(clientId, message2, baseConfig, effectiveConfig) {
+    const commandText = normalizeGatewayCommandText(message2.text);
     const [command = "", ...args] = commandText.split(/\s+/);
     const normalized = command.toLowerCase();
     if (!normalized.startsWith("/")) return false;
@@ -12678,66 +13516,66 @@ var FeishuGatewayService = class {
         this.resetSession(clientId);
         await this.sendReply(
           baseConfig,
-          message.messageId,
+          message2.messageId,
           await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Reset this Feishu chat. A fresh Pi session will start with your next message.")
         );
         return true;
       }
       if (normalized === "/help") {
-        await this.sendReply(baseConfig, message.messageId, this.formatHelp());
+        await this.sendReply(baseConfig, message2.messageId, this.formatHelp());
         return true;
       }
       if (normalized === "/status") {
-        await this.sendReply(baseConfig, message.messageId, await this.formatStatus(clientId, effectiveConfig));
+        await this.sendReply(baseConfig, message2.messageId, await this.formatStatus(clientId, effectiveConfig));
         return true;
       }
       if (normalized === "/profiles") {
-        await this.sendReply(baseConfig, message.messageId, await this.formatProfiles(effectiveConfig.agentProfile || "default"));
+        await this.sendReply(baseConfig, message2.messageId, await this.formatProfiles(effectiveConfig.agentProfile || "default"));
         return true;
       }
       if (normalized === "/profile" || normalized === "/use-profile" || normalized === "/set-profile") {
         await this.setChatProfile(clientId, args[0]);
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.messageId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Profile updated."));
+        await this.sendReply(baseConfig, message2.messageId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Profile updated."));
         return true;
       }
       if (normalized === "/cwds" || normalized === "/pwds") {
-        await this.sendReply(baseConfig, message.messageId, this.formatCwdChoices(baseConfig));
+        await this.sendReply(baseConfig, message2.messageId, this.formatCwdChoices(baseConfig));
         return true;
       }
       if (normalized === "/cwd") {
         if (args.length === 0) {
-          await this.sendReply(baseConfig, message.messageId, effectiveConfig.defaultCwd || NO_GATEWAY_FOLDERS_MESSAGE);
+          await this.sendReply(baseConfig, message2.messageId, effectiveConfig.defaultCwd || NO_GATEWAY_FOLDERS_MESSAGE);
           return true;
         }
         await this.setChatCwd(clientId, args[0], baseConfig);
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.messageId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Working directory updated."));
+        await this.sendReply(baseConfig, message2.messageId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Working directory updated."));
         return true;
       }
       if (normalized === "/skillsets") {
-        await this.sendReply(baseConfig, message.messageId, this.formatSkillsets(effectiveConfig.skillPresetId));
+        await this.sendReply(baseConfig, message2.messageId, this.formatSkillsets(effectiveConfig.skillPresetId));
         return true;
       }
       if (normalized === "/skillset") {
         await this.setChatSkillset(clientId, args.join(" "));
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.messageId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Skillset updated."));
+        await this.sendReply(baseConfig, message2.messageId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Skillset updated."));
         return true;
       }
       if (normalized === "/clear-config") {
         this.clearChatConfig(clientId);
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.messageId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Feishu chat config cleared."));
+        await this.sendReply(baseConfig, message2.messageId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Feishu chat config cleared."));
         return true;
       }
     } catch (error) {
-      await this.sendReply(baseConfig, message.messageId, `Command failed: ${error instanceof Error ? error.message : "unknown error"}
+      await this.sendReply(baseConfig, message2.messageId, `Command failed: ${error instanceof Error ? error.message : "unknown error"}
 
 ${this.formatHelp()}`);
       return true;
     }
-    await this.sendReply(baseConfig, message.messageId, `Unknown command: ${command}
+    await this.sendReply(baseConfig, message2.messageId, `Unknown command: ${command}
 
 ${this.formatHelp()}`);
     return true;
@@ -12812,8 +13650,8 @@ ${this.formatHelp()}`);
     const slot = Number(slotText.trim());
     if (!Number.isInteger(slot) || slot < 1 || slot > config.cwdChoices.length) throw new Error(`Usage: /cwd <1-${config.cwdChoices.length}>`);
     const target = config.cwdChoices[slot - 1];
-    if (!isAbsolute4(target)) throw new Error(`Configured CWD ${slot} must be an absolute path`);
-    const info = await stat6(target);
+    if (!isAbsolute5(target)) throw new Error(`Configured CWD ${slot} must be an absolute path`);
+    const info = await stat7(target);
     if (!info.isDirectory()) throw new Error(`Configured CWD ${slot} must be an existing directory`);
     this.saveChatConfig(clientId, { defaultCwd: target });
   }
@@ -12974,13 +13812,13 @@ function parseFeishuTextContent(content) {
     return content;
   }
 }
-function logUnsupportedFeishuMessage(message, messageType) {
-  const content = parseJsonRecord(stringValue(message.content));
+function logUnsupportedFeishuMessage(message2, messageType) {
+  const content = parseJsonRecord(stringValue(message2.content));
   console.info("[feishu-gateway] unsupported inbound message", {
     messageType,
-    messageId: stringValue(message.message_id) || void 0,
-    chatType: stringValue(message.chat_type) || void 0,
-    messageKeys: Object.keys(message).sort(),
+    messageId: stringValue(message2.message_id) || void 0,
+    chatType: stringValue(message2.chat_type) || void 0,
+    messageKeys: Object.keys(message2).sort(),
     contentKeys: Object.keys(content).sort(),
     contentStringFields: Object.fromEntries(
       Object.entries(content).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value.length])
@@ -13004,9 +13842,9 @@ function truncateFeishuText(text) {
 function extractLastAssistantText(messages) {
   if (!Array.isArray(messages)) return "";
   for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message?.role !== "assistant") continue;
-    const content = message.content;
+    const message2 = messages[index];
+    if (message2?.role !== "assistant") continue;
+    const content = message2.content;
     if (typeof content === "string") return content.trim();
     if (Array.isArray(content)) {
       const text = content.map((part) => typeof part === "string" ? part : part?.text || part?.content || "").join("").trim();
@@ -13017,9 +13855,9 @@ function extractLastAssistantText(messages) {
 }
 
 // src/services/weixin-gateway.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { stat as stat7 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5 } from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { stat as stat8 } from "node:fs/promises";
+import { isAbsolute as isAbsolute6 } from "node:path";
 import QRCode from "qrcode";
 import { Agent, fetch as undiciFetch2 } from "undici";
 
@@ -13280,11 +14118,11 @@ var WeixinGatewayService = class {
         }
         const messages = Array.isArray(response.msgs) ? response.msgs : [];
         for (const raw of messages) {
-          const message = await this.parseMessage(asRecord2(raw), config);
-          if (!message) continue;
-          if (this.markDuplicate(message.messageId)) continue;
-          if (message.contextToken) this.saveContextToken(config.accountId, message.senderId, message.contextToken);
-          this.enqueue(message, config);
+          const message2 = await this.parseMessage(asRecord2(raw), config);
+          if (!message2) continue;
+          if (this.markDuplicate(message2.messageId)) continue;
+          if (message2.contextToken) this.saveContextToken(config.accountId, message2.senderId, message2.contextToken);
+          this.enqueue(message2, config);
         }
       } catch (error) {
         if (!this.running) break;
@@ -13296,17 +14134,17 @@ var WeixinGatewayService = class {
     }
     console.info("[weixin-gateway] stopped");
   }
-  async parseMessage(message, config) {
-    const senderId = stringValue2(message.from_user_id);
+  async parseMessage(message2, config) {
+    const senderId = stringValue2(message2.from_user_id);
     if (!senderId || senderId === config.accountId) return null;
-    const { chatType, chatId } = this.guessChat(message, config.accountId);
+    const { chatType, chatId } = this.guessChat(message2, config.accountId);
     if (chatType === "group") return null;
     if (!this.isDmAllowed(senderId, config)) return null;
-    const items = Array.isArray(message.item_list) ? message.item_list.map(asRecord2) : [];
+    const items = Array.isArray(message2.item_list) ? message2.item_list.map(asRecord2) : [];
     const text = extractText2(items).trim();
     const imageResult = await this.extractImages(config, items);
-    const messageId = stringValue2(message.message_id) || randomUUID6();
-    if (!text && imageResult.images.length === 0 && !imageResult.error) this.logUnsupportedInboundMessage(message, items, "no text or supported image item");
+    const messageId = stringValue2(message2.message_id) || randomUUID7();
+    if (!text && imageResult.images.length === 0 && !imageResult.error) this.logUnsupportedInboundMessage(message2, items, "no text or supported image item");
     if (!text && imageResult.images.length === 0 && !imageResult.error || !chatId) return null;
     return {
       messageId,
@@ -13316,15 +14154,15 @@ var WeixinGatewayService = class {
       text,
       images: imageResult.images,
       imageError: imageResult.error,
-      contextToken: stringValue2(message.context_token) || void 0
+      contextToken: stringValue2(message2.context_token) || void 0
     };
   }
-  guessChat(message, accountId) {
-    const roomId = stringValue2(message.room_id) || stringValue2(message.chat_room_id);
-    const toUserId = stringValue2(message.to_user_id);
-    const isGroup = Boolean(roomId) || Boolean(toUserId && accountId && toUserId !== accountId && Number(message.msg_type) === 1);
-    if (isGroup) return { chatType: "group", chatId: roomId || toUserId || stringValue2(message.from_user_id) };
-    return { chatType: "dm", chatId: stringValue2(message.from_user_id) };
+  guessChat(message2, accountId) {
+    const roomId = stringValue2(message2.room_id) || stringValue2(message2.chat_room_id);
+    const toUserId = stringValue2(message2.to_user_id);
+    const isGroup = Boolean(roomId) || Boolean(toUserId && accountId && toUserId !== accountId && Number(message2.msg_type) === 1);
+    if (isGroup) return { chatType: "group", chatId: roomId || toUserId || stringValue2(message2.from_user_id) };
+    return { chatType: "dm", chatId: stringValue2(message2.from_user_id) };
   }
   isDmAllowed(senderId, config) {
     if (config.dmPolicy === "disabled") return false;
@@ -13332,13 +14170,13 @@ var WeixinGatewayService = class {
     if (config.dmPolicy === "open") return parseBoolean3(process.env.PI_CLOUD_WECHAT_ALLOW_ALL_USERS || process.env.GATEWAY_ALLOW_ALL_USERS, false);
     return true;
   }
-  logUnsupportedInboundMessage(message, items, reason) {
+  logUnsupportedInboundMessage(message2, items, reason) {
     console.info("[weixin-gateway] unsupported inbound message", JSON.stringify({
       reason,
-      messageId: message.message_id,
-      msgType: message.msg_type,
-      messageType: message.message_type,
-      messageKeys: Object.keys(message).sort(),
+      messageId: message2.message_id,
+      msgType: message2.msg_type,
+      messageType: message2.message_type,
+      messageKeys: Object.keys(message2).sort(),
       itemSummaries: items.map(summarizeWeixinItem)
     }, null, 2));
   }
@@ -13426,36 +14264,36 @@ var WeixinGatewayService = class {
     this.seen.set(id, now + DEDUP_TTL_MS2);
     return false;
   }
-  enqueue(message, config) {
-    const clientId = this.clientIdForMessage(message);
+  enqueue(message2, config) {
+    const clientId = this.clientIdForMessage(message2);
     const previous = this.queues.get(clientId) || Promise.resolve();
-    const next = previous.catch(() => void 0).then(() => this.processMessage(clientId, message, config)).catch((error) => console.error("[weixin-gateway] message handling failed:", error)).finally(() => {
+    const next = previous.catch(() => void 0).then(() => this.processMessage(clientId, message2, config)).catch((error) => console.error("[weixin-gateway] message handling failed:", error)).finally(() => {
       if (this.queues.get(clientId) === next) this.queues.delete(clientId);
     });
     this.queues.set(clientId, next);
   }
-  clientIdForMessage(message) {
-    return `weixin:${message.chatType}:${message.chatId}`;
+  clientIdForMessage(message2) {
+    return `weixin:${message2.chatType}:${message2.chatId}`;
   }
-  async processMessage(clientId, message, config) {
+  async processMessage(clientId, message2, config) {
     const effectiveConfig = this.resolveChatConfig(clientId, config);
-    if (await this.handleCommand(clientId, message, config, effectiveConfig)) return;
+    if (await this.handleCommand(clientId, message2, config, effectiveConfig)) return;
     if (!effectiveConfig.defaultCwd) {
-      await this.sendReply(config, message.chatId, GATEWAY_FOLDERS_REQUIRED_MESSAGE2);
+      await this.sendReply(config, message2.chatId, GATEWAY_FOLDERS_REQUIRED_MESSAGE2);
       return;
     }
-    if (message.imageError && message.images.length === 0) {
-      await this.sendReply(config, message.chatId, message.imageError);
+    if (message2.imageError && message2.images.length === 0) {
+      await this.sendReply(config, message2.chatId, message2.imageError);
       return;
     }
     const session = await this.ensureSession(clientId, effectiveConfig);
-    const imageResult = validateImages(message.images, session.model);
+    const imageResult = validateImages(message2.images, session.model);
     if (!imageResult.ok) {
-      await this.sendReply(config, message.chatId, imageResult.message);
+      await this.sendReply(config, message2.chatId, imageResult.message);
       return;
     }
-    await this.saveInboundImages(effectiveConfig.defaultCwd, message.messageId, imageResult.images);
-    const promptText = message.text || (imageResult.images.length ? "Please analyze the attached image." : "");
+    await this.saveInboundImages(effectiveConfig.defaultCwd, message2.messageId, imageResult.images);
+    const promptText = message2.text || (imageResult.images.length ? "Please analyze the attached image." : "");
     const chunks = [];
     const unsubscribe = session.subscribe((event) => {
       if (event?.type !== "message_update") return;
@@ -13464,7 +14302,7 @@ var WeixinGatewayService = class {
         chunks.push(update.delta);
       }
     });
-    const stopTypingIndicator = this.startTypingIndicator(config, message.chatId);
+    const stopTypingIndicator = this.startTypingIndicator(config, message2.chatId);
     try {
       await this.sessionService.runForegroundWithClientProfileProxy(clientId, async () => {
         await session.prompt(promptText, imageResult.images.length ? { images: imageResult.images } : void 0);
@@ -13474,7 +14312,7 @@ var WeixinGatewayService = class {
       unsubscribe();
     }
     const response = chunks.join("").trim() || extractLastAssistantText2(session.messages) || "(Pi finished without a text response.)";
-    await this.sendReply(config, message.chatId, response);
+    await this.sendReply(config, message2.chatId, response);
   }
   async saveInboundImages(projectRoot, messageId, images) {
     if (!projectRoot || images.length === 0) return;
@@ -13505,8 +14343,8 @@ var WeixinGatewayService = class {
     this.saveSessionMapping(clientId, result.session.sessionId);
     return result.session;
   }
-  async handleCommand(clientId, message, baseConfig, effectiveConfig) {
-    const commandText = normalizeGatewayCommandText(message.text);
+  async handleCommand(clientId, message2, baseConfig, effectiveConfig) {
+    const commandText = normalizeGatewayCommandText(message2.text);
     const [command = "", ...args] = commandText.split(/\s+/);
     const normalized = command.toLowerCase();
     if (!normalized.startsWith("/")) return false;
@@ -13515,66 +14353,66 @@ var WeixinGatewayService = class {
         this.resetSession(clientId);
         await this.sendReply(
           baseConfig,
-          message.chatId,
+          message2.chatId,
           await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Reset this WeChat chat. A fresh Pi session will start with your next message.")
         );
         return true;
       }
       if (normalized === "/help") {
-        await this.sendReply(baseConfig, message.chatId, this.formatHelp());
+        await this.sendReply(baseConfig, message2.chatId, this.formatHelp());
         return true;
       }
       if (normalized === "/status") {
-        await this.sendReply(baseConfig, message.chatId, await this.formatStatus(clientId, effectiveConfig));
+        await this.sendReply(baseConfig, message2.chatId, await this.formatStatus(clientId, effectiveConfig));
         return true;
       }
       if (normalized === "/profiles") {
-        await this.sendReply(baseConfig, message.chatId, await this.formatProfiles(effectiveConfig.agentProfile || "default"));
+        await this.sendReply(baseConfig, message2.chatId, await this.formatProfiles(effectiveConfig.agentProfile || "default"));
         return true;
       }
       if (normalized === "/profile" || normalized === "/use-profile" || normalized === "/set-profile") {
         await this.setChatProfile(clientId, args[0]);
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.chatId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Profile updated."));
+        await this.sendReply(baseConfig, message2.chatId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Profile updated."));
         return true;
       }
       if (normalized === "/cwds" || normalized === "/pwds") {
-        await this.sendReply(baseConfig, message.chatId, this.formatCwdChoices(baseConfig));
+        await this.sendReply(baseConfig, message2.chatId, this.formatCwdChoices(baseConfig));
         return true;
       }
       if (normalized === "/cwd") {
         if (args.length === 0) {
-          await this.sendReply(baseConfig, message.chatId, effectiveConfig.defaultCwd || NO_GATEWAY_FOLDERS_MESSAGE2);
+          await this.sendReply(baseConfig, message2.chatId, effectiveConfig.defaultCwd || NO_GATEWAY_FOLDERS_MESSAGE2);
           return true;
         }
         await this.setChatCwd(clientId, args[0], baseConfig);
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.chatId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Working directory updated."));
+        await this.sendReply(baseConfig, message2.chatId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Working directory updated."));
         return true;
       }
       if (normalized === "/skillsets") {
-        await this.sendReply(baseConfig, message.chatId, this.formatSkillsets(effectiveConfig.skillPresetId));
+        await this.sendReply(baseConfig, message2.chatId, this.formatSkillsets(effectiveConfig.skillPresetId));
         return true;
       }
       if (normalized === "/skillset") {
         await this.setChatSkillset(clientId, args.join(" "));
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.chatId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Skillset updated."));
+        await this.sendReply(baseConfig, message2.chatId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Skillset updated."));
         return true;
       }
       if (normalized === "/clear-config") {
         this.clearChatConfig(clientId);
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.chatId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "WeChat chat config cleared."));
+        await this.sendReply(baseConfig, message2.chatId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "WeChat chat config cleared."));
         return true;
       }
     } catch (error) {
-      await this.sendReply(baseConfig, message.chatId, `Command failed: ${error instanceof Error ? error.message : "unknown error"}
+      await this.sendReply(baseConfig, message2.chatId, `Command failed: ${error instanceof Error ? error.message : "unknown error"}
 
 ${this.formatHelp()}`);
       return true;
     }
-    await this.sendReply(baseConfig, message.chatId, `Unknown command: ${command}
+    await this.sendReply(baseConfig, message2.chatId, `Unknown command: ${command}
 
 ${this.formatHelp()}`);
     return true;
@@ -13649,8 +14487,8 @@ ${this.formatHelp()}`);
     const slot = Number(slotText.trim());
     if (!Number.isInteger(slot) || slot < 1 || slot > config.cwdChoices.length) throw new Error(`Usage: /cwd <1-${config.cwdChoices.length}>`);
     const target = config.cwdChoices[slot - 1];
-    if (!isAbsolute5(target)) throw new Error(`Configured CWD ${slot} must be an absolute path`);
-    const info = await stat7(target);
+    if (!isAbsolute6(target)) throw new Error(`Configured CWD ${slot} must be an absolute path`);
+    const info = await stat8(target);
     if (!info.isDirectory()) throw new Error(`Configured CWD ${slot} must be an existing directory`);
     this.saveChatConfig(clientId, { defaultCwd: target });
   }
@@ -13821,7 +14659,7 @@ ${this.formatHelp()}`);
       msg: {
         from_user_id: "",
         to_user_id: chatId,
-        client_id: randomUUID6(),
+        client_id: randomUUID7(),
         message_type: MSG_TYPE_BOT,
         ...msg,
         ...withContextToken(this.getContextToken(config.accountId, chatId))
@@ -14066,122 +14904,820 @@ function safeId(value) {
 }
 function extractLastAssistantText2(messages) {
   for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message?.role !== "assistant") continue;
-    if (typeof message.content === "string") return message.content.trim();
-    if (Array.isArray(message.content)) {
-      const text = message.content.map((part) => typeof part === "string" ? part : part?.text || part?.content || "").join("").trim();
+    const message2 = messages[index];
+    if (message2?.role !== "assistant") continue;
+    if (typeof message2.content === "string") return message2.content.trim();
+    if (Array.isArray(message2.content)) {
+      const text = message2.content.map((part) => typeof part === "string" ? part : part?.text || part?.content || "").join("").trim();
       if (text) return text;
     }
   }
   return void 0;
 }
 
-// src/services/review-source-store.ts
-import * as os8 from "os";
-import * as path11 from "path";
+// src/services/wecom-gateway.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { stat as stat9 } from "node:fs/promises";
+import { isAbsolute as isAbsolute7 } from "node:path";
 
-// src/services/review-source-providers.ts
-import * as fs8 from "fs";
-import * as os7 from "os";
-import * as path10 from "path";
+// src/services/wecom-crypto.ts
+import { createDecipheriv as createDecipheriv3, createHash as createHash8, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+function verifyWecomSignature(input) {
+  const expected = createHash8("sha1").update([input.token, input.timestamp, input.nonce, input.encrypted].sort().join("")).digest();
+  if (!/^[0-9a-f]{40}$/i.test(input.signature)) return false;
+  const actual = Buffer.from(input.signature, "hex");
+  return timingSafeEqual2(expected, actual);
+}
+function decryptWecomPayload(encrypted, encodingAesKey, expectedReceiveId) {
+  const key = parseEncodingAesKey(encodingAesKey);
+  const ciphertext = Buffer.from(encrypted, "base64");
+  if (!ciphertext.length || ciphertext.length % 16 !== 0) throw new Error("Invalid WeCom encrypted payload");
+  const decipher = createDecipheriv3("aes-256-cbc", key, key.subarray(0, 16));
+  decipher.setAutoPadding(false);
+  const padded = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  const plaintext = removePkcs7Padding(padded);
+  if (plaintext.length < 20) throw new Error("Invalid WeCom decrypted payload");
+  const messageLength = plaintext.readUInt32BE(16);
+  const messageStart = 20;
+  const messageEnd = messageStart + messageLength;
+  if (messageEnd > plaintext.length) throw new Error("Invalid WeCom message length");
+  const receiveId = plaintext.subarray(messageEnd).toString("utf8");
+  if (receiveId !== expectedReceiveId) throw new Error("Invalid WeCom callback receive ID");
+  return plaintext.subarray(messageStart, messageEnd).toString("utf8");
+}
+function parseEncodingAesKey(value) {
+  if (!/^[A-Za-z0-9]{43}$/.test(value)) throw new Error("WeCom EncodingAESKey must contain 43 letters or digits");
+  const key = Buffer.from(`${value}=`, "base64");
+  if (key.length !== 32) throw new Error("Invalid WeCom EncodingAESKey");
+  return key;
+}
+function removePkcs7Padding(value) {
+  const padding = value[value.length - 1];
+  if (!padding || padding > 32 || padding > value.length) throw new Error("Invalid WeCom PKCS#7 padding");
+  for (let index = value.length - padding; index < value.length; index += 1) {
+    if (value[index] !== padding) throw new Error("Invalid WeCom PKCS#7 padding");
+  }
+  return value.subarray(0, value.length - padding);
+}
 
-// src/services/review-source-adapters/claude-code-adapter.ts
-import * as fs5 from "fs";
-import * as path7 from "path";
-var ClaudeCodeReviewSourceAdapter = class {
-  constructor(dataPath) {
-    this.dataPath = dataPath;
-  }
-  dataPath;
-  async list(options = {}) {
-    const items = this.readSessions().map((session) => session.item).sort((a, b) => b.modified.localeCompare(a.modified));
-    return this.applyListOptions(items, options);
-  }
-  async search(query, options = {}) {
-    const normalized = query.trim().toLowerCase();
-    if (!normalized) return this.list(options);
-    const matches = this.readSessions().filter(({ item, filePath }) => {
-      if (item.name?.toLowerCase().includes(normalized) || item.firstMessage?.toLowerCase().includes(normalized)) return true;
-      return this.readTranscript(filePath).messages.some((message) => this.messageText(message.content).toLowerCase().includes(normalized));
-    }).map((session) => session.item).sort((a, b) => b.modified.localeCompare(a.modified));
-    return this.applyListOptions(matches, options);
+// src/services/wecom-gateway.ts
+var WECOM_API_BASE_URL = "https://qyapi.weixin.qq.com";
+var TOKEN_REFRESH_SKEW_MS2 = 5 * 60 * 1e3;
+var DEDUP_TTL_MS3 = 5 * 60 * 1e3;
+var TEXT_CHUNK_MAX_BYTES = 1900;
+function generateEncodingAesKey() {
+  while (true) {
+    const key = randomBytes3(32).toString("base64").slice(0, 43);
+    if (/^[A-Za-z0-9]+$/.test(key)) return key;
   }
-  async getTranscript(sessionId) {
-    const session = this.findSession(sessionId);
-    if (!session) throw new Error(`Transcript not found for session ${sessionId}`);
-    return this.readTranscript(session.filePath);
+}
+var WecomGatewayService = class {
+  constructor(db, gatewaySettings, sessionService) {
+    this.db = db;
+    this.sessionService = sessionService;
+    this.gatewaySettings = gatewaySettings || new GatewaySettingsStore(db);
+    this.presetStore = new SkillPresetStore(db);
   }
-  async delete(_sessionId) {
-    throw new Error("Claude Code review sessions are read-only");
+  db;
+  sessionService;
+  gatewaySettings;
+  presetStore;
+  seen = /* @__PURE__ */ new Map();
+  queues = /* @__PURE__ */ new Map();
+  tokenCache;
+  environmentCallbackVerified = false;
+  status() {
+    const config = this.loadConfig();
+    const managedBy = this.isEnvironmentManaged() ? "environment" : this.loadSavedCredentials() ? "database" : "none";
+    return {
+      configured: Boolean(config.corpId && config.corpSecret && config.agentId && config.callbackToken && config.encodingAesKey),
+      managedBy,
+      ...config.corpId ? { corpId: config.corpId } : {},
+      ...config.agentId ? { agentId: config.agentId } : {},
+      allowedUsers: config.allowedUsers,
+      callbackVerified: managedBy === "database" ? Boolean(this.loadSavedCredentials()?.callbackVerified) : this.environmentCallbackVerified
+    };
   }
-  async listProjectPaths() {
-    const sessions = await this.list();
-    return Array.from(new Set(sessions.map((item) => item.cwd).filter((cwd) => Boolean(cwd))));
+  saveConfiguration(input) {
+    if (this.isEnvironmentManaged()) throw new Error("WeCom credentials are managed by environment variables");
+    const corpId = input.corpId.trim();
+    const corpSecret = input.corpSecret.trim();
+    const agentId = input.agentId.trim();
+    if (!corpId || !corpSecret || !/^\d+$/.test(agentId)) throw new Error("Corp ID, app secret, and a numeric Agent ID are required");
+    const allowedUsers = normalizeList(input.allowedUsers);
+    const existing = this.loadSavedCredentials();
+    const callbackToken = existing?.callbackToken || randomBytes3(16).toString("hex");
+    const encodingAesKey = existing?.encodingAesKey || generateEncodingAesKey();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(`
+      INSERT INTO wecom_gateway_credentials (
+        id, corp_id, corp_secret, agent_id, callback_token, encoding_aes_key,
+        allowed_users_json, callback_verified_at, created_at, updated_at
+      ) VALUES (1, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        corp_id = excluded.corp_id,
+        corp_secret = excluded.corp_secret,
+        agent_id = excluded.agent_id,
+        callback_token = excluded.callback_token,
+        encoding_aes_key = excluded.encoding_aes_key,
+        allowed_users_json = excluded.allowed_users_json,
+        callback_verified_at = NULL,
+        updated_at = excluded.updated_at
+    `).run(corpId, corpSecret, agentId, callbackToken, encodingAesKey, JSON.stringify(allowedUsers), now, now);
+    this.tokenCache = void 0;
+    return { status: this.status(), callbackToken, encodingAesKey };
+  }
+  regenerateCallbackSecrets() {
+    if (this.isEnvironmentManaged()) throw new Error("WeCom credentials are managed by environment variables");
+    const saved = this.loadSavedCredentials();
+    if (!saved) throw new Error("Save the WeCom configuration first");
+    const callbackToken = randomBytes3(16).toString("hex");
+    const encodingAesKey = generateEncodingAesKey();
+    this.db.prepare(`
+      UPDATE wecom_gateway_credentials
+      SET callback_token = ?, encoding_aes_key = ?, callback_verified_at = NULL, updated_at = ?
+      WHERE id = 1
+    `).run(callbackToken, encodingAesKey, (/* @__PURE__ */ new Date()).toISOString());
+    return { status: this.status(), callbackToken, encodingAesKey };
+  }
+  disconnect() {
+    if (this.isEnvironmentManaged()) throw new Error("WeCom credentials are managed by environment variables");
+    const clients = this.db.prepare("SELECT client_id FROM wecom_gateway_sessions").all();
+    for (const { client_id: clientId } of clients) this.sessionService.disposeSession(clientId);
+    this.db.exec("DELETE FROM wecom_gateway_sessions; DELETE FROM wecom_gateway_configs; DELETE FROM wecom_gateway_credentials;");
+    this.tokenCache = void 0;
   }
-  readSessions() {
-    return this.sessionFiles().flatMap((filePath) => {
-      try {
-        const records = this.readRecords(filePath);
-        if (!records.length) return [];
-        const stat8 = fs5.statSync(filePath);
-        const sessionRecord = records.find((record) => record.sessionId || record.session_id);
-        const sessionId = sessionRecord?.sessionId || sessionRecord?.session_id || path7.basename(filePath, ".jsonl");
-        const cwd = records.find((record) => record.cwd)?.cwd;
-        const timestamps = records.map((record) => this.timestamp(record.timestamp)).filter((value) => value !== void 0);
-        const messages = this.recordsToMessages(records);
-        const title = [...records].reverse().find((record) => typeof record.aiTitle === "string")?.aiTitle;
-        const firstUserMessage = messages.find((message) => message.role === "user");
-        return [{
-          filePath,
-          item: {
-            id: sessionId,
-            sourceId: "",
-            name: title,
-            path: filePath,
-            cwd,
-            created: new Date(timestamps.length ? Math.min(...timestamps) : stat8.birthtimeMs).toISOString(),
-            modified: new Date(timestamps.length ? Math.max(...timestamps) : stat8.mtimeMs).toISOString(),
-            messageCount: messages.length,
-            firstMessage: firstUserMessage ? this.messageText(firstUserMessage.content) : void 0
-          }
-        }];
-      } catch {
-        return [];
-      }
+  async testConnection() {
+    const config = this.requireConfig();
+    this.tokenCache = void 0;
+    await this.getAccessToken(config);
+    return this.status();
+  }
+  handleVerification(query) {
+    const config = this.requireConfig();
+    const encrypted = stringValue3(query.echostr);
+    this.verifySignature(query, encrypted, config);
+    const challenge = decryptWecomPayload(encrypted, config.encodingAesKey, config.corpId);
+    this.markCallbackVerified();
+    return challenge;
+  }
+  handleCallback(query, body) {
+    const config = this.requireConfig();
+    const encrypted = xmlValue(body, "Encrypt");
+    if (!encrypted) throw gatewayError("Invalid WeCom callback envelope", 400);
+    this.verifySignature(query, encrypted, config);
+    const message2 = parseWecomMessage(decryptWecomPayload(encrypted, config.encodingAesKey, config.corpId));
+    this.markCallbackVerified();
+    if (!message2 || message2.agentId !== config.agentId) return "success";
+    if (config.allowedUsers.length && !config.allowedUsers.includes(message2.userId)) return "success";
+    if (this.markDuplicate(message2.messageId)) return "success";
+    if (!["text", "image", "voice"].includes(message2.messageType)) {
+      void this.sendReply(config, message2.userId, "This WeCom gateway supports text, image, and voice messages only.").catch((error) => {
+        console.warn("[wecom-gateway] unsupported-message reply failed:", error instanceof Error ? error.message : error);
+      });
+      return "success";
+    }
+    this.enqueue({
+      messageId: message2.messageId,
+      userId: message2.userId,
+      text: message2.text,
+      messageType: message2.messageType,
+      mediaId: message2.mediaId,
+      picUrl: message2.picUrl
+    }, config);
+    return "success";
+  }
+  verifySignature(query, encrypted, config) {
+    const valid = encrypted && verifyWecomSignature({
+      token: config.callbackToken,
+      timestamp: stringValue3(query.timestamp),
+      nonce: stringValue3(query.nonce),
+      encrypted,
+      signature: stringValue3(query.msg_signature)
     });
+    if (!valid) throw gatewayError("Invalid WeCom callback signature", 401);
   }
-  sessionFiles() {
-    if (!fs5.existsSync(this.dataPath)) return [];
-    const files = [];
-    const addJsonlFiles = (directory) => {
-      for (const entry of fs5.readdirSync(directory, { withFileTypes: true })) {
-        if (entry.isFile() && entry.name.endsWith(".jsonl")) files.push(path7.join(directory, entry.name));
-      }
-    };
-    addJsonlFiles(this.dataPath);
-    for (const entry of fs5.readdirSync(this.dataPath, { withFileTypes: true })) {
-      if (entry.isDirectory()) addJsonlFiles(path7.join(this.dataPath, entry.name));
+  requireConfig() {
+    const config = this.loadConfig();
+    if (!config.corpId || !config.corpSecret || !config.agentId || !config.callbackToken || !config.encodingAesKey) {
+      throw gatewayError("WeCom gateway is not configured", 503);
     }
-    return files;
-  }
-  findSession(sessionId) {
-    if (!sessionId || path7.basename(sessionId) !== sessionId) throw new Error("Invalid review session ID");
-    return this.readSessions().find((session) => session.item.id === sessionId);
+    return config;
   }
-  readTranscript(filePath) {
-    const records = this.readRecords(filePath);
+  loadConfig() {
+    const gatewaySettings = this.gatewaySettings.get();
+    const saved = this.loadSavedCredentials();
+    const skillset = this.resolveSkillsetConfig(gatewaySettings.defaultSkillset);
     return {
-      messages: this.recordsToMessages(records),
-      metadata: { sessionId: path7.basename(filePath, ".jsonl"), format: "claude-code-jsonl" }
+      corpId: process.env.PI_CLOUD_WECOM_CORP_ID?.trim() || saved?.corpId || "",
+      corpSecret: process.env.PI_CLOUD_WECOM_CORP_SECRET?.trim() || saved?.corpSecret || "",
+      agentId: process.env.PI_CLOUD_WECOM_AGENT_ID?.trim() || saved?.agentId || "",
+      callbackToken: process.env.PI_CLOUD_WECOM_CALLBACK_TOKEN?.trim() || saved?.callbackToken || "",
+      encodingAesKey: process.env.PI_CLOUD_WECOM_ENCODING_AES_KEY?.trim() || saved?.encodingAesKey || "",
+      allowedUsers: process.env.PI_CLOUD_WECOM_ALLOWED_USERS !== void 0 ? parseList2(process.env.PI_CLOUD_WECOM_ALLOWED_USERS) : saved?.allowedUsers || [],
+      defaultCwd: gatewaySettings.cwds[0],
+      cwdChoices: gatewaySettings.cwds,
+      agentProfile: gatewaySettings.defaultProfile,
+      modelProvider: gatewaySettings.defaultModelProvider,
+      modelId: gatewaySettings.defaultModelId,
+      ...skillset
     };
   }
-  readRecords(filePath) {
-    return fs5.readFileSync(filePath, "utf8").split(/\r?\n/).filter(Boolean).flatMap((line) => {
-      try {
-        return [JSON.parse(line)];
-      } catch {
-        return [];
+  isEnvironmentManaged() {
+    return [
+      "PI_CLOUD_WECOM_CORP_ID",
+      "PI_CLOUD_WECOM_CORP_SECRET",
+      "PI_CLOUD_WECOM_AGENT_ID",
+      "PI_CLOUD_WECOM_CALLBACK_TOKEN",
+      "PI_CLOUD_WECOM_ENCODING_AES_KEY"
+    ].some((key) => Boolean(process.env[key]?.trim()));
+  }
+  loadSavedCredentials() {
+    const row = this.db.prepare(`
+      SELECT corp_id, corp_secret, agent_id, callback_token, encoding_aes_key,
+             allowed_users_json, callback_verified_at
+      FROM wecom_gateway_credentials WHERE id = 1
+    `).get();
+    if (!row) return null;
+    let allowedUsers = [];
+    try {
+      allowedUsers = normalizeList(JSON.parse(row.allowed_users_json));
+    } catch {
+    }
+    return {
+      corpId: row.corp_id,
+      corpSecret: row.corp_secret,
+      agentId: row.agent_id,
+      callbackToken: row.callback_token,
+      encodingAesKey: row.encoding_aes_key,
+      allowedUsers,
+      callbackVerified: Boolean(row.callback_verified_at)
+    };
+  }
+  markCallbackVerified() {
+    if (this.isEnvironmentManaged()) {
+      this.environmentCallbackVerified = true;
+      return;
+    }
+    this.db.prepare("UPDATE wecom_gateway_credentials SET callback_verified_at = ?, updated_at = ? WHERE id = 1").run((/* @__PURE__ */ new Date()).toISOString(), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  markDuplicate(id) {
+    const now = Date.now();
+    for (const [key, expiresAt] of this.seen) {
+      if (expiresAt <= now) this.seen.delete(key);
+    }
+    if (this.seen.has(id)) return true;
+    this.seen.set(id, now + DEDUP_TTL_MS3);
+    return false;
+  }
+  enqueue(message2, config) {
+    const clientId = `wecom:dm:${message2.userId}`;
+    const previous = this.queues.get(clientId) || Promise.resolve();
+    const next = previous.catch(() => void 0).then(() => this.processMessage(clientId, message2, config)).catch((error) => console.error("[wecom-gateway] message handling failed:", error)).finally(() => {
+      if (this.queues.get(clientId) === next) this.queues.delete(clientId);
+    });
+    this.queues.set(clientId, next);
+  }
+  async processMessage(clientId, message2, config) {
+    const effectiveConfig = this.resolveChatConfig(clientId, config);
+    if (await this.handleCommand(clientId, message2, config, effectiveConfig)) return;
+    if (!effectiveConfig.defaultCwd) {
+      await this.sendReply(config, message2.userId, "No gateway folders configured. Add at least one allowed folder in Web UI Settings > Gateway.");
+      return;
+    }
+    let promptText = message2.text;
+    if (message2.messageType === "voice") {
+      if (!message2.mediaId) {
+        await this.sendReply(config, message2.userId, "The WeCom voice message did not include downloadable media. Try sending it again.");
+        return;
+      }
+      try {
+        promptText = (await transcribeAudio(await this.downloadVoice(config, message2.mediaId), "audio/amr")).trim();
+      } catch (error) {
+        console.warn("[wecom-gateway] failed to transcribe inbound voice:", error instanceof Error ? error.message : error);
+        await this.sendReply(config, message2.userId, "The voice message could not be transcribed. Check the speech-to-text configuration and try again.");
+        return;
+      }
+      if (!promptText) {
+        await this.sendReply(config, message2.userId, "The voice message did not contain recognizable speech. Try sending it again.");
+        return;
+      }
+    }
+    const session = await this.ensureSession(clientId, effectiveConfig);
+    let images = [];
+    if (message2.messageType === "image") {
+      if (!message2.mediaId) {
+        await this.sendReply(config, message2.userId, "The WeCom image message did not include downloadable media. Try sending it again.");
+        return;
+      }
+      try {
+        images = [await this.downloadImage(config, message2.mediaId)];
+      } catch (error) {
+        console.warn("[wecom-gateway] failed to download inbound image:", error instanceof Error ? error.message : error);
+        await this.sendReply(config, message2.userId, "The image could not be downloaded from WeCom. Try sending it again.");
+        return;
+      }
+    }
+    const imageResult = validateImages(images, session.model);
+    if (!imageResult.ok) {
+      await this.sendReply(config, message2.userId, imageResult.message);
+      return;
+    }
+    promptText ||= imageResult.images.length ? "Please analyze the attached image." : "";
+    const chunks = [];
+    const unsubscribe = session.subscribe((event) => {
+      const update = event?.type === "message_update" ? event.assistantMessageEvent : void 0;
+      if (update?.type === "text_delta" && typeof update.delta === "string") chunks.push(update.delta);
+    });
+    try {
+      await this.sessionService.runForegroundWithClientProfileProxy(clientId, () => session.prompt(promptText, imageResult.images.length ? { images: imageResult.images } : void 0));
+    } finally {
+      unsubscribe();
+    }
+    const response = chunks.join("").trim() || extractLastAssistantText3(session.messages) || "(Pi finished without a text response.)";
+    await this.sendReply(config, message2.userId, response);
+  }
+  async ensureSession(clientId, config) {
+    await this.sessionService.setClientAgentProfile(clientId, config.agentProfile || "default");
+    const active = this.sessionService.getSession(clientId);
+    if (active) return active;
+    const mapped = this.db.prepare("SELECT pi_session_id FROM wecom_gateway_sessions WHERE client_id = ?").get(clientId);
+    if (mapped) {
+      const persisted = await this.sessionService.findPersistedSession(clientId, mapped.pi_session_id);
+      if (persisted) return this.sessionService.resumeSession(clientId, persisted.path);
+    }
+    const preset = config.skillPresetId ? this.presetStore.getById(config.skillPresetId) : null;
+    const result = await this.sessionService.createSession(clientId, {
+      cwd: config.defaultCwd,
+      modelProvider: config.modelProvider,
+      modelId: config.modelId,
+      enabledSkills: preset?.mode === "enabled" ? preset.skills : void 0,
+      disabledSkills: preset?.mode === "disabled" ? preset.skills : void 0,
+      presetId: preset?.id,
+      skillMode: preset?.mode || config.skillMode || "all"
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(`
+      INSERT INTO wecom_gateway_sessions (session_key, client_id, pi_session_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(session_key) DO UPDATE SET pi_session_id = excluded.pi_session_id, updated_at = excluded.updated_at
+    `).run(clientId, clientId, result.session.sessionId, now, now);
+    return result.session;
+  }
+  async handleCommand(clientId, message2, baseConfig, effectiveConfig) {
+    const commandText = normalizeGatewayCommandText(message2.text);
+    const [command = "", ...args] = commandText.split(/\s+/);
+    const normalized = command.toLowerCase();
+    if (!normalized.startsWith("/")) return false;
+    try {
+      if (normalized === "/new" || normalized === "/reset") {
+        this.resetSession(clientId);
+        await this.sendReply(baseConfig, message2.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Reset this WeCom chat. A fresh Pi session will start with your next message."));
+        return true;
+      }
+      if (normalized === "/help") {
+        await this.sendReply(baseConfig, message2.userId, this.formatHelp());
+        return true;
+      }
+      if (normalized === "/status") {
+        await this.sendReply(baseConfig, message2.userId, await this.formatStatus(clientId, effectiveConfig));
+        return true;
+      }
+      if (normalized === "/profiles") {
+        const profiles = await this.sessionService.listAgentProfiles();
+        await this.sendReply(baseConfig, message2.userId, ["Available profiles:", ...profiles.map((profile) => `${profile.id === (effectiveConfig.agentProfile || "default") ? "*" : " "} ${profile.id}`)].join("\n"));
+        return true;
+      }
+      if (normalized === "/profile" || normalized === "/use-profile" || normalized === "/set-profile") {
+        const profile = args[0]?.trim();
+        if (!profile) throw new Error("Usage: /profile <profile-id>");
+        const profiles = await this.sessionService.listAgentProfiles();
+        if (!profiles.some((item) => item.id === profile)) throw new Error(`Unknown profile: ${profile}`);
+        this.saveChatConfig(clientId, { agentProfile: profile });
+        this.resetSession(clientId);
+        await this.sendReply(baseConfig, message2.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Profile updated."));
+        return true;
+      }
+      if (normalized === "/cwds" || normalized === "/pwds") {
+        await this.sendReply(baseConfig, message2.userId, baseConfig.cwdChoices.length ? baseConfig.cwdChoices.map((cwd, index) => `${index + 1}: ${cwd}`).join("\n") : "No gateway folders configured.");
+        return true;
+      }
+      if (normalized === "/cwd") {
+        const slot = Number(args[0]);
+        if (!Number.isInteger(slot) || slot < 1 || slot > baseConfig.cwdChoices.length) throw new Error(`Usage: /cwd <1-${baseConfig.cwdChoices.length}>`);
+        const target = baseConfig.cwdChoices[slot - 1];
+        if (!isAbsolute7(target) || !(await stat9(target)).isDirectory()) throw new Error(`Configured CWD ${slot} must be an existing absolute directory`);
+        this.saveChatConfig(clientId, { defaultCwd: target });
+        this.resetSession(clientId);
+        await this.sendReply(baseConfig, message2.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Working directory updated."));
+        return true;
+      }
+      if (normalized === "/skillsets") {
+        await this.sendReply(baseConfig, message2.userId, this.formatSkillsets(effectiveConfig.skillPresetId));
+        return true;
+      }
+      if (normalized === "/skillset") {
+        const selected = args.join(" ").trim();
+        if (!selected) throw new Error("Usage: /skillset <all|preset-name>");
+        this.saveChatConfig(clientId, this.resolveSkillsetConfig(selected, true));
+        this.resetSession(clientId);
+        await this.sendReply(baseConfig, message2.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Skillset updated."));
+        return true;
+      }
+      if (normalized === "/clear-config") {
+        this.db.prepare("DELETE FROM wecom_gateway_configs WHERE client_id = ?").run(clientId);
+        this.resetSession(clientId);
+        await this.sendReply(baseConfig, message2.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "WeCom chat config cleared."));
+        return true;
+      }
+    } catch (error) {
+      await this.sendReply(baseConfig, message2.userId, `Command failed: ${error instanceof Error ? error.message : "unknown error"}
+
+${this.formatHelp()}`);
+      return true;
+    }
+    await this.sendReply(baseConfig, message2.userId, `Unknown command: ${command}
+
+${this.formatHelp()}`);
+    return true;
+  }
+  resolveChatConfig(clientId, base) {
+    const chat = this.loadChatConfig(clientId);
+    const useBaseModel = !chat.agentProfile || chat.agentProfile === base.agentProfile;
+    return {
+      ...base,
+      agentProfile: chat.agentProfile || base.agentProfile,
+      defaultCwd: chat.defaultCwd && base.cwdChoices.includes(chat.defaultCwd) ? chat.defaultCwd : base.defaultCwd,
+      modelProvider: useBaseModel ? base.modelProvider : void 0,
+      modelId: useBaseModel ? base.modelId : void 0,
+      skillMode: chat.skillMode || base.skillMode,
+      skillPresetId: chat.skillMode ? chat.skillPresetId : base.skillPresetId
+    };
+  }
+  loadChatConfig(clientId) {
+    const row = this.db.prepare("SELECT agent_profile, default_cwd, skill_mode, skill_preset_id FROM wecom_gateway_configs WHERE client_id = ?").get(clientId);
+    return row ? {
+      agentProfile: row.agent_profile || void 0,
+      defaultCwd: row.default_cwd || void 0,
+      skillMode: row.skill_mode || void 0,
+      skillPresetId: row.skill_preset_id
+    } : {};
+  }
+  saveChatConfig(clientId, patch) {
+    const next = { ...this.loadChatConfig(clientId), ...patch };
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare(`
+      INSERT INTO wecom_gateway_configs (client_id, agent_profile, default_cwd, skill_mode, skill_preset_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(client_id) DO UPDATE SET
+        agent_profile = excluded.agent_profile,
+        default_cwd = excluded.default_cwd,
+        skill_mode = excluded.skill_mode,
+        skill_preset_id = excluded.skill_preset_id,
+        updated_at = excluded.updated_at
+    `).run(clientId, next.agentProfile || null, next.defaultCwd || null, next.skillMode || null, next.skillPresetId || null, now, now);
+  }
+  resetSession(clientId) {
+    this.sessionService.disposeSession(clientId);
+    this.db.prepare("DELETE FROM wecom_gateway_sessions WHERE client_id = ?").run(clientId);
+  }
+  async formatStatus(clientId, config, prefix) {
+    const profiles = await this.sessionService.listAgentProfiles();
+    const profile = profiles.find((item) => item.id === (config.agentProfile || "default")) || profiles[0];
+    const active = this.sessionService.getSession(clientId);
+    return [
+      prefix,
+      "Pi session status",
+      "",
+      `- Profile: ${profile?.id || "default"}`,
+      `- CWD: ${config.defaultCwd || "(not configured)"}`,
+      `- Provider: ${active?.model?.provider || config.modelProvider || profile?.defaultProvider || "(profile default)"}`,
+      `- Model: ${active?.model?.id || config.modelId || profile?.defaultModel || "(profile default)"}`,
+      `- Skillset: ${this.formatSkillsetName(config.skillPresetId)}`,
+      `- Session: ${active ? `active (${active.sessionId})` : "not started"}`
+    ].filter((line) => line !== void 0).join("\n");
+  }
+  formatHelp() {
+    return [
+      "Pi Cloud WeCom commands",
+      "/new - reset this chat session",
+      "/status - show current configuration",
+      "/profiles - list profiles",
+      "/profile <id> - switch profile",
+      "/cwds - list allowed folders",
+      "/cwd <number> - switch folder",
+      "/skillsets - list skillsets",
+      "/skillset <name> - switch skillset",
+      "/clear-config - restore gateway defaults",
+      "/help - show this help",
+      "",
+      GATEWAY_COMMON_ALIAS_HELP
+    ].join("\n");
+  }
+  resolveSkillsetConfig(skillset, strict = false) {
+    const selected = skillset?.trim();
+    if (!selected || selected.toLowerCase() === "all") return { skillMode: "all", skillPresetId: null };
+    const preset = this.findSkillPreset(selected);
+    if (preset) return { skillMode: preset.mode, skillPresetId: preset.id };
+    if (strict) throw new Error(`Unknown skillset: ${selected}`);
+    console.warn("[wecom-gateway] default gateway skillset was not found; using all skills", { skillset: selected });
+    return { skillMode: "all", skillPresetId: null };
+  }
+  formatSkillsets(currentPresetId) {
+    const presets = this.presetStore.list();
+    return [
+      "Available skillsets:",
+      `${currentPresetId ? " " : "*"} all - use all skills`,
+      ...presets.map((preset) => `${preset.id === currentPresetId ? "*" : " "} ${preset.name} (${preset.mode}: ${preset.skills.join(", ") || "none"})`)
+    ].join("\n");
+  }
+  formatSkillsetName(presetId) {
+    if (!presetId) return "all";
+    const preset = this.presetStore.getById(presetId);
+    return preset ? `${preset.name} (${preset.mode})` : `unknown preset (${presetId})`;
+  }
+  findSkillPreset(nameOrId) {
+    const normalized = nameOrId.trim().toLowerCase();
+    return this.presetStore.list().find((preset) => preset.id === nameOrId || preset.name.toLowerCase() === normalized) || null;
+  }
+  async sendReply(config, userId, text) {
+    for (const chunk of splitUtf8Text(formatWecomMarkdown(text), TEXT_CHUNK_MAX_BYTES)) {
+      let token = await this.getAccessToken(config);
+      let data = await this.sendApplicationMarkdown(config, token, userId, chunk);
+      if ([40014, 42001].includes(Number(data.errcode))) {
+        this.tokenCache = void 0;
+        token = await this.getAccessToken(config);
+        data = await this.sendApplicationMarkdown(config, token, userId, chunk);
+      }
+      if (Number(data.errcode) !== 0) throw new Error(`WeCom send message failed: ${stringValue3(data.errmsg) || `errcode=${data.errcode}`}`);
+    }
+  }
+  async sendApplicationMarkdown(config, token, userId, text) {
+    const response = await fetch(`${WECOM_API_BASE_URL}/cgi-bin/message/send?access_token=${encodeURIComponent(token)}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        touser: userId,
+        msgtype: "markdown",
+        agentid: Number(config.agentId),
+        markdown: { content: text },
+        safe: 0,
+        enable_duplicate_check: 1,
+        duplicate_check_interval: 1800
+      })
+    });
+    return parseWecomResponse(response);
+  }
+  async downloadImage(config, mediaId) {
+    const bytes = await this.downloadMedia(config, mediaId, MAX_IMAGE_BYTES, "An image is larger than 10 MB.");
+    const mimeType = sniffImageMimeType(bytes);
+    if (!mimeType) throw new Error("WeCom media response was not a supported image");
+    return { type: "image", data: bytes.toString("base64"), mimeType };
+  }
+  downloadVoice(config, mediaId) {
+    return this.downloadMedia(config, mediaId, MAX_AUDIO_BYTES, "A voice message is larger than 25 MB.");
+  }
+  async downloadMedia(config, mediaId, maxBytes, tooLargeMessage) {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const token = await this.getAccessToken(config);
+      const response = await fetch(`${WECOM_API_BASE_URL}/cgi-bin/media/get?access_token=${encodeURIComponent(token)}&media_id=${encodeURIComponent(mediaId)}`);
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.toLowerCase().includes("application/json")) {
+        const data = await parseWecomResponse(response);
+        const errorCode = Number(data.errcode);
+        if (attempt === 0 && [40014, 42001].includes(errorCode)) {
+          this.tokenCache = void 0;
+          continue;
+        }
+        throw new Error(`WeCom media download failed: ${stringValue3(data.errmsg) || `errcode=${data.errcode}`}`);
+      }
+      if (!response.ok) throw new Error(`WeCom media download failed: HTTP ${response.status}`);
+      return readResponseBytes(response, maxBytes, tooLargeMessage);
+    }
+    throw new Error("WeCom media download failed after refreshing the access token");
+  }
+  async getAccessToken(config) {
+    const now = Date.now();
+    if (this.tokenCache && this.tokenCache.expiresAt - TOKEN_REFRESH_SKEW_MS2 > now) return this.tokenCache.token;
+    const response = await fetch(`${WECOM_API_BASE_URL}/cgi-bin/gettoken?corpid=${encodeURIComponent(config.corpId)}&corpsecret=${encodeURIComponent(config.corpSecret)}`);
+    const data = await parseWecomResponse(response);
+    const token = stringValue3(data.access_token);
+    if (Number(data.errcode) !== 0 || !token) throw new Error(`WeCom access token failed: ${stringValue3(data.errmsg) || `errcode=${data.errcode}`}`);
+    this.tokenCache = { token, expiresAt: now + (Number(data.expires_in) || 7200) * 1e3 };
+    return token;
+  }
+};
+async function readResponseBytes(response, maxBytes, tooLargeMessage) {
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    await response.body?.cancel();
+    throw new Error(tooLargeMessage);
+  }
+  if (!response.body) return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        await reader.cancel();
+        throw new Error(tooLargeMessage);
+      }
+      chunks.push(Buffer.from(value));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, totalBytes);
+}
+function parseWecomMessage(xml) {
+  const messageType = xmlValue(xml, "MsgType");
+  const userId = xmlValue(xml, "FromUserName");
+  const messageId = xmlValue(xml, "MsgId");
+  const agentId = xmlValue(xml, "AgentID");
+  if (!messageType || !userId || !messageId || !agentId) return null;
+  return {
+    messageType,
+    userId,
+    messageId,
+    agentId,
+    text: xmlValue(xml, "Content").trim(),
+    mediaId: xmlValue(xml, "MediaId") || void 0,
+    picUrl: xmlValue(xml, "PicUrl") || void 0
+  };
+}
+function xmlValue(xml, tag) {
+  const match = new RegExp(`<${tag}>(?:<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>|([\\s\\S]*?))<\\/${tag}>`, "i").exec(xml);
+  return decodeXmlEntities((match?.[1] ?? match?.[2] ?? "").trim());
+}
+function decodeXmlEntities(value) {
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function parseList2(value) {
+  return Array.from(new Set((value || "").split(",").map((item) => item.trim()).filter(Boolean)));
+}
+function normalizeList(value) {
+  return Array.from(new Set((Array.isArray(value) ? value : []).filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean)));
+}
+function stringValue3(value) {
+  return typeof value === "string" ? value : value === void 0 || value === null ? "" : String(value);
+}
+function gatewayError(message2, statusCode) {
+  const error = new Error(message2);
+  error.statusCode = statusCode;
+  return error;
+}
+async function parseWecomResponse(response) {
+  const text = await response.text();
+  let data = {};
+  try {
+    data = JSON.parse(text);
+  } catch {
+  }
+  if (!response.ok) throw new Error(`WeCom HTTP ${response.status}: ${text.slice(0, 200)}`);
+  return data;
+}
+function extractLastAssistantText3(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message2 = messages[index];
+    if (message2?.role !== "assistant") continue;
+    if (typeof message2.content === "string" && message2.content.trim()) return message2.content.trim();
+    if (!Array.isArray(message2.content)) continue;
+    const text = message2.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("").trim();
+    if (text) return text;
+  }
+  return void 0;
+}
+function formatWecomMarkdown(text) {
+  return text.replace(/^([ \t]*)[-+*][ \t]+/gm, (_match, indentation) => `${indentation}${indentation ? "\u25E6" : "\u2022"} `);
+}
+function splitUtf8Text(text, maxBytes) {
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return [text];
+  const chunks = [];
+  let current = "";
+  let currentBytes = 0;
+  for (const character of text) {
+    const characterBytes = Buffer.byteLength(character, "utf8");
+    if (current && currentBytes + characterBytes > maxBytes) {
+      chunks.push(current);
+      current = "";
+      currentBytes = 0;
+    }
+    current += character;
+    currentBytes += characterBytes;
+  }
+  if (current) chunks.push(current);
+  return chunks;
+}
+
+// src/services/review-source-store.ts
+import * as os8 from "os";
+import * as path11 from "path";
+
+// src/services/review-source-providers.ts
+import * as fs8 from "fs";
+import * as os7 from "os";
+import * as path10 from "path";
+
+// src/services/review-source-adapters/claude-code-adapter.ts
+import * as fs5 from "fs";
+import * as path7 from "path";
+var ClaudeCodeReviewSourceAdapter = class {
+  constructor(dataPath) {
+    this.dataPath = dataPath;
+  }
+  dataPath;
+  async list(options = {}) {
+    const items = this.readSessions().map((session) => session.item).sort((a, b) => b.modified.localeCompare(a.modified));
+    return this.applyListOptions(items, options);
+  }
+  async search(query, options = {}) {
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) return this.list(options);
+    const matches = this.readSessions().filter(({ item, filePath }) => {
+      if (item.name?.toLowerCase().includes(normalized) || item.firstMessage?.toLowerCase().includes(normalized)) return true;
+      return this.readTranscript(filePath).messages.some((message2) => this.messageText(message2.content).toLowerCase().includes(normalized));
+    }).map((session) => session.item).sort((a, b) => b.modified.localeCompare(a.modified));
+    return this.applyListOptions(matches, options);
+  }
+  async getTranscript(sessionId) {
+    const session = this.findSession(sessionId);
+    if (!session) throw new Error(`Transcript not found for session ${sessionId}`);
+    return this.readTranscript(session.filePath);
+  }
+  async delete(_sessionId) {
+    throw new Error("Claude Code review sessions are read-only");
+  }
+  async listProjectPaths() {
+    const sessions = await this.list();
+    return Array.from(new Set(sessions.map((item) => item.cwd).filter((cwd) => Boolean(cwd))));
+  }
+  readSessions() {
+    return this.sessionFiles().flatMap((filePath) => {
+      try {
+        const records = this.readRecords(filePath);
+        if (!records.length) return [];
+        const stat10 = fs5.statSync(filePath);
+        const sessionRecord = records.find((record) => record.sessionId || record.session_id);
+        const sessionId = sessionRecord?.sessionId || sessionRecord?.session_id || path7.basename(filePath, ".jsonl");
+        const cwd = records.find((record) => record.cwd)?.cwd;
+        const timestamps = records.map((record) => this.timestamp(record.timestamp)).filter((value) => value !== void 0);
+        const messages = this.recordsToMessages(records);
+        const title = [...records].reverse().find((record) => typeof record.aiTitle === "string")?.aiTitle;
+        const firstUserMessage = messages.find((message2) => message2.role === "user");
+        return [{
+          filePath,
+          item: {
+            id: sessionId,
+            sourceId: "",
+            name: title,
+            path: filePath,
+            cwd,
+            created: new Date(timestamps.length ? Math.min(...timestamps) : stat10.birthtimeMs).toISOString(),
+            modified: new Date(timestamps.length ? Math.max(...timestamps) : stat10.mtimeMs).toISOString(),
+            messageCount: messages.length,
+            firstMessage: firstUserMessage ? this.messageText(firstUserMessage.content) : void 0
+          }
+        }];
+      } catch {
+        return [];
+      }
+    });
+  }
+  sessionFiles() {
+    if (!fs5.existsSync(this.dataPath)) return [];
+    const files = [];
+    const addJsonlFiles = (directory) => {
+      for (const entry of fs5.readdirSync(directory, { withFileTypes: true })) {
+        if (entry.isFile() && entry.name.endsWith(".jsonl")) files.push(path7.join(directory, entry.name));
+      }
+    };
+    addJsonlFiles(this.dataPath);
+    for (const entry of fs5.readdirSync(this.dataPath, { withFileTypes: true })) {
+      if (entry.isDirectory()) addJsonlFiles(path7.join(this.dataPath, entry.name));
+    }
+    return files;
+  }
+  findSession(sessionId) {
+    if (!sessionId || path7.basename(sessionId) !== sessionId) throw new Error("Invalid review session ID");
+    return this.readSessions().find((session) => session.item.id === sessionId);
+  }
+  readTranscript(filePath) {
+    const records = this.readRecords(filePath);
+    return {
+      messages: this.recordsToMessages(records),
+      metadata: { sessionId: path7.basename(filePath, ".jsonl"), format: "claude-code-jsonl" }
+    };
+  }
+  readRecords(filePath) {
+    return fs5.readFileSync(filePath, "utf8").split(/\r?\n/).filter(Boolean).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
       }
     });
   }
@@ -14266,7 +15802,7 @@ var CodexReviewSourceAdapter = class {
     if (!normalized) return this.list(options);
     const matches = this.readSessions().filter(({ item, filePath }) => {
       if (item.name?.toLowerCase().includes(normalized) || item.firstMessage?.toLowerCase().includes(normalized)) return true;
-      return this.readTranscript(filePath).messages.some((message) => this.messageText(message.content).toLowerCase().includes(normalized));
+      return this.readTranscript(filePath).messages.some((message2) => this.messageText(message2.content).toLowerCase().includes(normalized));
     }).map((session) => session.item).sort((a, b) => b.modified.localeCompare(a.modified));
     return this.applyListOptions(matches, options);
   }
@@ -14287,11 +15823,11 @@ var CodexReviewSourceAdapter = class {
       try {
         const records = this.readRecords(filePath);
         if (!records.length) return [];
-        const stat8 = fs6.statSync(filePath);
+        const stat10 = fs6.statSync(filePath);
         const metadata = records.find((record) => record.type === "session_meta")?.payload;
         const messages = this.recordsToMessages(records);
         const timestamps = records.map((record) => this.timestamp(record.timestamp)).filter((value) => value !== void 0);
-        const firstUserMessage = messages.find((message) => message.role === "user" && !message.detailOnly);
+        const firstUserMessage = messages.find((message2) => message2.role === "user" && !message2.detailOnly);
         return [{
           filePath,
           item: {
@@ -14299,8 +15835,8 @@ var CodexReviewSourceAdapter = class {
             sourceId: "",
             path: filePath,
             cwd: this.stringValue(metadata?.cwd),
-            created: new Date(timestamps.length ? Math.min(...timestamps) : stat8.birthtimeMs).toISOString(),
-            modified: new Date(timestamps.length ? Math.max(...timestamps) : stat8.mtimeMs).toISOString(),
+            created: new Date(timestamps.length ? Math.min(...timestamps) : stat10.birthtimeMs).toISOString(),
+            modified: new Date(timestamps.length ? Math.max(...timestamps) : stat10.mtimeMs).toISOString(),
             messageCount: messages.length,
             firstMessage: firstUserMessage ? this.messageText(firstUserMessage.content) : void 0
           }
@@ -14567,15 +16103,15 @@ var DevinReviewSourceAdapter = class {
   }
   extractMessages(raw) {
     if (Array.isArray(raw.messages) && raw.messages.length > 0) {
-      return raw.messages.map((message) => ({
-        role: String(message.role || "unknown"),
-        content: message.content,
-        timestamp: typeof message.timestamp === "number" ? message.timestamp : void 0,
-        detailOnly: this.isDetailOnlyMessage(message.content)
+      return raw.messages.map((message2) => ({
+        role: String(message2.role || "unknown"),
+        content: message2.content,
+        timestamp: typeof message2.timestamp === "number" ? message2.timestamp : void 0,
+        detailOnly: this.isDetailOnlyMessage(message2.content)
       }));
     }
     const steps = Array.isArray(raw.steps) ? raw.steps : [];
-    return steps.map((step) => this.devinStepToMessage(step)).filter((message) => message.content !== "");
+    return steps.map((step) => this.devinStepToMessage(step)).filter((message2) => message2.content !== "");
   }
   devinStepToMessage(step) {
     const source = String(step.source || "unknown");
@@ -14617,16 +16153,16 @@ ${observation}
     const text = typeof content === "string" ? content.trimStart() : "";
     return text.startsWith("You are Devin, an interactive command line") || text.startsWith("You are powered by ") || /^Available subagent profiles for the\s+`?run_subagent`?\s+tool\./.test(text) || text.startsWith("The following skills can be invoked using the `skill` tool.");
   }
-  messageToText(message) {
-    if (!message) return void 0;
-    if (typeof message.content === "string") return message.content;
-    if (Array.isArray(message.content)) {
-      return message.content.map((item) => typeof item === "string" ? item : item?.text).filter(Boolean).join("\n");
+  messageToText(message2) {
+    if (!message2) return void 0;
+    if (typeof message2.content === "string") return message2.content;
+    if (Array.isArray(message2.content)) {
+      return message2.content.map((item) => typeof item === "string" ? item : item?.text).filter(Boolean).join("\n");
     }
     return void 0;
   }
   transcriptToText(transcript) {
-    return transcript.messages.map((message) => this.messageToText(message) || "").join("\n");
+    return transcript.messages.map((message2) => this.messageToText(message2) || "").join("\n");
   }
   applyListOptions(items, options) {
     let result = items;
@@ -14836,6 +16372,336 @@ var ReviewSourceService = class {
   }
 };
 
+// src/services/model-window-kickoff-store.ts
+import { randomUUID as randomUUID8 } from "node:crypto";
+var DEFAULT_KICKOFF_PROMPT = "Ping";
+var ModelWindowKickoffStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  list() {
+    return this.db.prepare("SELECT * FROM model_window_kickoffs ORDER BY created_at").all().map(toRecord);
+  }
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM model_window_kickoffs WHERE id = ?").get(id);
+    return row && toRecord(row);
+  }
+  listDue(now) {
+    return this.db.prepare(`
+      SELECT * FROM model_window_kickoffs WHERE enabled = 1 AND next_run_at <= ? ORDER BY next_run_at
+    `).all(now).map(toRecord);
+  }
+  create(input, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    const value = validateInput2(input, now);
+    const id = randomUUID8();
+    this.db.prepare(`
+      INSERT INTO model_window_kickoffs (
+        id, enabled, profile_id, provider, model_id, project_path, prompt, window_duration_minutes,
+        safety_buffer_seconds, notification_channel_id, next_run_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      id,
+      value.enabled ? 1 : 0,
+      value.profileId,
+      value.provider,
+      value.modelId,
+      value.projectPath,
+      value.prompt,
+      value.windowDurationMinutes,
+      value.safetyBufferSeconds,
+      value.notificationChannelId,
+      value.nextRunAt,
+      now,
+      now
+    );
+    return this.get(id);
+  }
+  update(id, input, now = (/* @__PURE__ */ new Date()).toISOString()) {
+    if (!this.get(id)) throw new Error("Model window kickoff not found");
+    const value = validateInput2(input, now);
+    this.db.prepare(`
+      UPDATE model_window_kickoffs SET enabled = ?, profile_id = ?, provider = ?, model_id = ?, project_path = ?, prompt = ?,
+        window_duration_minutes = ?, safety_buffer_seconds = ?, notification_channel_id = ?, next_run_at = ?, updated_at = ?
+      WHERE id = ?
+    `).run(
+      value.enabled ? 1 : 0,
+      value.profileId,
+      value.provider,
+      value.modelId,
+      value.projectPath,
+      value.prompt,
+      value.windowDurationMinutes,
+      value.safetyBufferSeconds,
+      value.notificationChannelId,
+      value.nextRunAt,
+      now,
+      id
+    );
+    return this.get(id);
+  }
+  delete(id) {
+    if (this.db.prepare("DELETE FROM model_window_kickoffs WHERE id = ?").run(id).changes !== 1) {
+      throw new Error("Model window kickoff not found");
+    }
+  }
+  recordAttempt(id, at) {
+    this.db.prepare("UPDATE model_window_kickoffs SET last_attempt_at = ?, updated_at = ? WHERE id = ?").run(at, at, id);
+  }
+  recordSuccess(id, at, nextRunAt) {
+    this.db.prepare(`UPDATE model_window_kickoffs SET last_success_at = ?, next_run_at = ?, last_error = NULL, updated_at = ? WHERE id = ?`).run(at, nextRunAt, at, id);
+  }
+  recordFailure(id, at, error, nextRunAt) {
+    this.db.prepare(`UPDATE model_window_kickoffs SET last_error = ?, next_run_at = ?, updated_at = ? WHERE id = ?`).run(error.slice(0, 2e3), nextRunAt, at, id);
+  }
+};
+function validateInput2(input, now) {
+  const profileId = input.profileId?.trim();
+  const provider = input.provider?.trim();
+  const modelId = input.modelId?.trim();
+  const projectPath = input.projectPath?.trim() || "~";
+  const prompt = (input.prompt ?? DEFAULT_KICKOFF_PROMPT).trim();
+  const windowDurationMinutes = input.windowDurationMinutes ?? 300;
+  const safetyBufferSeconds = input.safetyBufferSeconds ?? 60;
+  const nextRunAt = input.nextRunAt ?? now;
+  if (!profileId || !provider || !modelId || !prompt) {
+    throw new Error("Profile, provider, model, and prompt are required");
+  }
+  if (!Number.isInteger(windowDurationMinutes) || windowDurationMinutes < 1 || windowDurationMinutes > 43200) {
+    throw new Error("Window duration must be between 1 and 43200 minutes");
+  }
+  if (!Number.isInteger(safetyBufferSeconds) || safetyBufferSeconds < 0 || safetyBufferSeconds > 86400) {
+    throw new Error("Safety buffer must be between 0 and 86400 seconds");
+  }
+  if (!Number.isFinite(Date.parse(nextRunAt))) {
+    throw new Error("Next run time is invalid");
+  }
+  return {
+    enabled: input.enabled ?? true,
+    profileId,
+    provider,
+    modelId,
+    projectPath,
+    prompt,
+    windowDurationMinutes,
+    safetyBufferSeconds,
+    notificationChannelId: input.notificationChannelId || null,
+    nextRunAt: new Date(nextRunAt).toISOString()
+  };
+}
+function toRecord(row) {
+  return {
+    id: row.id,
+    enabled: Boolean(row.enabled),
+    profileId: row.profile_id,
+    provider: row.provider,
+    modelId: row.model_id,
+    projectPath: row.project_path,
+    prompt: row.prompt,
+    windowDurationMinutes: row.window_duration_minutes,
+    safetyBufferSeconds: row.safety_buffer_seconds,
+    notificationChannelId: row.notification_channel_id,
+    nextRunAt: row.next_run_at,
+    lastAttemptAt: row.last_attempt_at,
+    lastSuccessAt: row.last_success_at,
+    lastError: row.last_error,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// src/services/model-window-kickoff-scheduler.ts
+var POLL_INTERVAL_MS = 1 * 6e4;
+var FAILURE_RETRY_MS = 60 * 6e4;
+var ModelWindowKickoffScheduler = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+    this.now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  dependencies;
+  timer;
+  running = /* @__PURE__ */ new Set();
+  now;
+  start() {
+    if (this.timer) return;
+    void this.tick();
+    this.timer = setInterval(() => void this.tick(), this.dependencies.pollIntervalMs ?? POLL_INTERVAL_MS);
+    this.timer.unref();
+  }
+  async stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    while (this.running.size) await new Promise((resolve10) => setTimeout(resolve10, 10));
+  }
+  async tick() {
+    const due = this.dependencies.store.listDue(this.now().toISOString());
+    await Promise.allSettled(due.map((kickoff) => this.run(kickoff)));
+  }
+  async run(kickoff) {
+    if (this.running.has(kickoff.id)) return;
+    this.running.add(kickoff.id);
+    const attemptedAt = this.now();
+    this.dependencies.store.recordAttempt(kickoff.id, attemptedAt.toISOString());
+    try {
+      const profile = await this.dependencies.resolveProfile(kickoff.profileId);
+      if (!profile) throw new Error("Agent profile not found");
+      const response = this.dependencies.probe ? await this.dependencies.probe(kickoff, profile) : await probeModel(kickoff, this.dependencies.sessions);
+      const successfulAt = this.now();
+      const next = new Date(successfulAt.getTime() + kickoff.windowDurationMinutes * 6e4 + kickoff.safetyBufferSeconds * 1e3);
+      this.dependencies.store.recordSuccess(kickoff.id, successfulAt.toISOString(), next.toISOString());
+      if (kickoff.notificationChannelId) {
+        try {
+          await this.dependencies.notifications.send(
+            kickoff.notificationChannelId,
+            formatSuccessNotification(kickoff, profile, response, attemptedAt, next)
+          );
+        } catch (error) {
+          this.dependencies.log?.error(error, "Model window kickoff notification failed");
+        }
+      }
+    } catch (error) {
+      const failedAt = this.now();
+      const failure = error instanceof Error ? error.message : String(error);
+      const retryAt = new Date(failedAt.getTime() + FAILURE_RETRY_MS);
+      this.dependencies.store.recordFailure(kickoff.id, failedAt.toISOString(), failure, retryAt.toISOString());
+      if (kickoff.notificationChannelId) {
+        try {
+          await this.dependencies.notifications.send(
+            kickoff.notificationChannelId,
+            formatFailureNotification(kickoff, failure, attemptedAt, retryAt)
+          );
+        } catch (notificationError) {
+          this.dependencies.log?.error(notificationError, "Model window kickoff failure notification failed");
+        }
+      }
+    } finally {
+      this.running.delete(kickoff.id);
+    }
+  }
+};
+function formatSuccessNotification(kickoff, profile, response, startedAt, next) {
+  return [
+    "\u2705Model window started",
+    markdownField("Profile", profile.label || profile.id),
+    markdownField("Model", `${kickoff.provider}/${kickoff.modelId}`),
+    ...response ? [markdownField("Response", response)] : [],
+    markdownField("Started time", formatLocalDateTime(startedAt), "warning"),
+    markdownField("Next kickoff", formatLocalDateTime(next))
+  ].join("\n");
+}
+function formatFailureNotification(kickoff, failure, startedAt, retryAt) {
+  return [
+    "\u274CModel window kickoff failed",
+    markdownField("Profile", kickoff.profileId),
+    markdownField("Model", `${kickoff.provider}/${kickoff.modelId}`),
+    markdownField("Error", failure, "warning"),
+    markdownField("Started time", formatLocalDateTime(startedAt), "warning"),
+    markdownField("Retry", formatLocalDateTime(retryAt))
+  ].join("\n");
+}
+function markdownField(label, value, color = "comment") {
+  return `>${label}: <font color="${color}">${value}</font>`;
+}
+function formatLocalDateTime(value) {
+  const pad = (part) => String(part).padStart(2, "0");
+  return `${value.getFullYear()}-${pad(value.getMonth() + 1)}-${pad(value.getDate())} ${pad(value.getHours())}:${pad(value.getMinutes())}:${pad(value.getSeconds())}`;
+}
+async function probeModel(kickoff, sessions) {
+  const clientId = `model-window-kickoff:${kickoff.id}`;
+  const sessionName = `Model window kickoff: ${kickoff.provider}/${kickoff.modelId} (${kickoff.id.slice(0, 8)})`;
+  await sessions.setClientAgentProfile(clientId, kickoff.profileId);
+  const persisted = (await sessions.listSessions(clientId, kickoff.projectPath)).find((item) => item.name === sessionName);
+  let activeSession;
+  if (persisted) {
+    activeSession = await sessions.resumeSession(clientId, persisted.path);
+  } else {
+    activeSession = (await sessions.createSession(clientId, {
+      cwd: kickoff.projectPath,
+      agentProfileId: kickoff.profileId,
+      modelProvider: kickoff.provider,
+      modelId: kickoff.modelId,
+      memoryEnabled: false
+    })).session;
+    await sessions.renameSession(clientId, activeSession.sessionId, sessionName);
+  }
+  await sessions.setSessionModel(clientId, activeSession.sessionId, kickoff.provider, kickoff.modelId);
+  await sessions.runForegroundWithClientProfileProxy(clientId, () => activeSession.prompt(kickoff.prompt));
+  const response = [...activeSession.messages].reverse().find((message2) => message2.role === "assistant" && "stopReason" in message2);
+  if (!response || !("stopReason" in response)) throw new Error("Model kickoff finished without an assistant response");
+  if (response.stopReason === "error" || response.stopReason === "aborted") {
+    throw new Error(response.errorMessage || `Model kickoff ${response.stopReason}`);
+  }
+  return extractAssistantText(response.content);
+}
+function extractAssistantText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.filter((part) => typeof part === "object" && part !== null && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string").map((part) => part.text).join("").trim();
+}
+
+// src/services/notification-channel.ts
+import { randomUUID as randomUUID9 } from "node:crypto";
+var NotificationChannelService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  list() {
+    return this.db.prepare("SELECT id, type, name, config_json FROM notification_channels ORDER BY created_at").all().map(publicChannel);
+  }
+  saveWecom(input) {
+    const existing = input.id ? this.getRow(input.id) : void 0;
+    const botKey = input.botKey?.trim() || readBotKey(existing);
+    if (!botKey) throw new Error("WeCom bot key is required");
+    const id = existing?.id ?? randomUUID9();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const name = input.name?.trim() || existing?.name || "WeCom";
+    this.db.prepare(`
+      INSERT INTO notification_channels (id, type, name, config_json, created_at, updated_at)
+      VALUES (?, 'wecom', ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET name = excluded.name, config_json = excluded.config_json, updated_at = excluded.updated_at
+    `).run(id, name, JSON.stringify({ botKey }), now, now);
+    return publicChannel(this.getRow(id));
+  }
+  delete(id) {
+    if (this.db.prepare("DELETE FROM notification_channels WHERE id = ?").run(id).changes !== 1) {
+      throw new Error("Notification channel not found");
+    }
+  }
+  async send(id, message2) {
+    const row = this.getRow(id);
+    if (!row) throw new Error("Notification channel not found");
+    if (row.type !== "wecom") throw new Error(`Unsupported notification channel: ${row.type}`);
+    const botKey = readBotKey(row);
+    if (!botKey) throw new Error("WeCom bot key is not configured");
+    const response = await fetch(`https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=${encodeURIComponent(botKey)}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ msgtype: "markdown", markdown: { content: message2 } }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) throw new Error(`WeCom returned HTTP ${response.status}`);
+    const result = await response.json();
+    if (result.errcode !== 0) throw new Error(`WeCom notification failed: ${result.errmsg || result.errcode}`);
+  }
+  getRow(id) {
+    return this.db.prepare("SELECT id, type, name, config_json FROM notification_channels WHERE id = ?").get(id);
+  }
+};
+function readBotKey(row) {
+  if (!row) {
+    return "";
+  }
+  try {
+    return JSON.parse(row.config_json).botKey || "";
+  } catch {
+    return "";
+  }
+}
+function publicChannel(row) {
+  return { id: row.id, type: "wecom", name: row.name, configured: Boolean(readBotKey(row)) };
+}
+
 // src/index.ts
 var __filename = fileURLToPath2(import.meta.url);
 var __dirname = path12.dirname(__filename);
@@ -14866,7 +16732,7 @@ function createDefaultConfig() {
   if (process.env.NODE_ENV === "test") return;
   if (process.env.PI_CLOUD_AUTH_USERNAME || process.env.PI_CLOUD_AUTH_PASSWORD || process.env.PI_CLOUD_AUTH_PASSWORD_HASH) return;
   const username = "admin";
-  const password = randomBytes3(6).toString("base64url");
+  const password = randomBytes4(6).toString("base64url");
   const samplePath = path12.resolve(__dirname, "../../.env.example");
   const content = renderDefaultConfig(readFileSync4(samplePath, "utf8"), username, password);
   mkdirSync2(userConfigDir, { recursive: true, mode: 448 });
@@ -14887,6 +16753,7 @@ var CONTENT_SECURITY_POLICY = [
   "object-src 'none'",
   "frame-ancestors 'none'",
   "img-src 'self' data: blob:",
+  "media-src 'self' blob:",
   "font-src 'self' data:",
   "style-src 'self' 'unsafe-inline'",
   "script-src 'self'",
@@ -14909,6 +16776,7 @@ function isPublicRoute(req) {
   if (url === "/api/health") return true;
   if (url.startsWith("/api/auth")) return true;
   if (url === "/api/gateways/feishu/events") return true;
+  if (url === "/api/gateways/wecom/callback") return true;
   if (req.method === "GET" && !url.startsWith("/api/")) return true;
   return false;
 }
@@ -14922,8 +16790,8 @@ function isSpaRoute(req) {
   if (path12.extname(url)) return false;
   return true;
 }
-function getSecuritySetting(db, key) {
-  const row = db.prepare("SELECT value FROM security_settings WHERE key = ?").get(key);
+function getApplicationSetting(db, key) {
+  const row = db.prepare("SELECT value FROM application_settings WHERE key = ?").get(key);
   return row?.value || "";
 }
 function formatServerTimestamp() {
@@ -14981,6 +16849,16 @@ async function buildApp() {
   const skillPresetStore = new SkillPresetStore(db);
   const reviewSourceStore = new ReviewSourceStore(db);
   const reviewSourceService = new ReviewSourceService(reviewSourceStore);
+  const modelWindowKickoffStore = new ModelWindowKickoffStore(db);
+  const notificationChannels = new NotificationChannelService(db);
+  const modelWindowKickoffScheduler = new ModelWindowKickoffScheduler({
+    store: modelWindowKickoffStore,
+    notifications: notificationChannels,
+    sessions: piSessionService,
+    resolveProfile: async (profileId) => (await piSessionService.listAgentProfiles()).find((profile) => profile.id === profileId),
+    log: app.log
+  });
+  modelWindowKickoffScheduler.start();
   const sessionActivityStore = new SessionActivityStore(db);
   const sessionPinStore = new SessionPinStore(db);
   projectTaskStore.restoreAllStarting();
@@ -14989,6 +16867,7 @@ async function buildApp() {
   const githubSettings = new GithubSettingsStore(db);
   const feishuGateway = new FeishuGatewayService(db, gatewaySettings, piSessionService);
   const weixinGateway = new WeixinGatewayService(db, gatewaySettings, piSessionService);
+  const wecomGateway = new WecomGatewayService(db, gatewaySettings, piSessionService);
   weixinGateway.start();
   const repositoryCloner = new RepositoryCloner({
     spawnGit: (args, options) => spawn3("git", args, options),
@@ -14998,7 +16877,7 @@ async function buildApp() {
       ...await piSessionService.getClientAgentProxyEnvForRoutes(clientId || "default"),
       ...githubSettings.proxyEnv()
     }),
-    gitCloneParentPath: () => getSecuritySetting(db, "ui.gitCloneParentPath") || path12.join(os9.homedir(), "git", "github")
+    gitCloneParentPath: () => getApplicationSetting(db, "ui.gitCloneParentPath") || path12.join(os9.homedir(), "git", "github")
   });
   const gitHosting = new GitHostingService();
   const worktreeManager = new WorktreeManager();
@@ -15023,6 +16902,7 @@ async function buildApp() {
     worktreeMetadata: worktreeMetadataStore
   });
   app.addHook("onClose", async () => {
+    await modelWindowKickoffScheduler.stop();
     await weixinGateway.stop();
     terminalManager.disposeAll();
     piSessionService.disposeAll();
@@ -15040,7 +16920,7 @@ async function buildApp() {
     reply.header("X-Content-Type-Options", "nosniff");
     reply.header("X-Frame-Options", "DENY");
     reply.header("Referrer-Policy", "no-referrer");
-    reply.header("Permissions-Policy", "camera=(), microphone=(), geolocation=()");
+    reply.header("Permissions-Policy", "camera=(), microphone=(self), geolocation=()");
     if (authConfig.cookieSecure) {
       reply.header("Strict-Transport-Security", "max-age=31536000");
     }
@@ -15089,6 +16969,7 @@ async function buildApp() {
   await app.register(taskRoutes, { prefix: "/api/tasks", store: projectTaskStore, starter: projectTaskStarter, activityStore: sessionActivityStore });
   await app.register(gatewayRoutes, { prefix: "/api/gateways", settings: gatewaySettings, weixin: weixinGateway });
   await app.register(feishuGatewayRoutes, { prefix: "/api/gateways/feishu", service: feishuGateway });
+  await app.register(wecomGatewayRoutes, { prefix: "/api/gateways/wecom", service: wecomGateway });
   const gitHostingRouteOptions = {
     settings: giteaSettings,
     githubSettings,
@@ -15108,7 +16989,14 @@ async function buildApp() {
   });
   await app.register(slashCommandRoutes, { prefix: "/api/slash-commands" });
   await app.register(changelogRoutes, { prefix: "/api/changelog" });
+  await app.register(speechRoutes, { prefix: "/api/speech" });
   await app.register(reviewSourceRoutes, { prefix: "/api/review-sources", reviewSourceService, pinStore: sessionPinStore });
+  await app.register(modelWindowKickoffRoutes, {
+    prefix: "/api/model-window-kickoffs",
+    store: modelWindowKickoffStore,
+    notifications: notificationChannels,
+    sessions: piSessionService
+  });
   await app.register(chatWebSocket);
   await app.register(terminalWebSocket);
   app.get("/api/health", async () => {