pi-cloud 2.0.1 → 2.0.2

package/server/dist/index.js

@@ -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";
@@ -140,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;
     }
   }
@@ -775,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) || []
       }))
     };
   });
@@ -792,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;
@@ -823,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)
       }))
     };
@@ -1054,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) => {
@@ -1084,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) => {
@@ -1121,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) => {
@@ -1179,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) => {
@@ -1192,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) => {
@@ -1205,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) => {
@@ -1330,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);
     }
@@ -1406,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) => {
@@ -1440,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;
@@ -1561,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);
@@ -1767,13 +1795,13 @@ 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
@@ -2186,9 +2214,9 @@ async function fileRoutes(app) {
           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
@@ -2929,12 +2957,12 @@ async function synthesizeSpeech(text, options = {}) {
       continue;
     }
     if (!response.ok) {
-      const message = await providerError(response);
+      const message2 = await providerError(response);
       if (isRetryableStatus2(response.status) && attempt < MAX_SYNTHESIS_ATTEMPTS) {
         await wait2(retryDelayMs * attempt);
         continue;
       }
-      throw new Error(message);
+      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.");
@@ -3202,8 +3230,8 @@ 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");
@@ -3365,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 = {};
@@ -3442,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)) {
@@ -3457,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) {
@@ -3494,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) => {
@@ -3556,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 });
@@ -3636,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 {
@@ -3648,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
@@ -3664,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);
@@ -3675,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";
@@ -3685,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 {
@@ -3694,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
@@ -3719,8 +3747,8 @@ 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) => {
@@ -3731,8 +3759,8 @@ async function gitRoutes(app, options = {}) {
       if (commit) {
         const diff2 = await runGit(resolvedCwd, ["show", "--format=", "--patch", commit]);
         const remainingBytes2 = MAX_SLASH_COMMAND_OUTPUT_BYTES - Buffer.byteLength(diff2);
-        const stat10 = remainingBytes2 > 0 ? await runGit(resolvedCwd, ["show", "--format=", "--stat", commit], remainingBytes2) : "";
-        return { cwd: resolvedCwd, scope: `commit-${commit}`, commit, stat: stat10, 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] : [];
@@ -3741,11 +3769,11 @@ async function gitRoutes(app, options = {}) {
         diff = await appendUntrackedDiff(resolvedCwd, diff, [], path13, MAX_SLASH_COMMAND_OUTPUT_BYTES);
       }
       const remainingBytes = MAX_SLASH_COMMAND_OUTPUT_BYTES - Buffer.byteLength(diff);
-      let stat9 = remainingBytes > 0 ? await getDiff(resolvedCwd, ["--stat", ...pathArgs], scope, remainingBytes) : "";
+      let stat10 = remainingBytes > 0 ? await getDiff(resolvedCwd, ["--stat", ...pathArgs], scope, remainingBytes) : "";
       if (includeUntracked === "true" && scope !== "staged" && remainingBytes > 0) {
-        stat9 = await appendUntrackedDiff(resolvedCwd, stat9, ["--stat"], path13, remainingBytes);
+        stat10 = await appendUntrackedDiff(resolvedCwd, stat10, ["--stat"], path13, remainingBytes);
       }
-      return { cwd: resolvedCwd, scope, path: path13, stat: stat9, diff };
+      return { cwd: resolvedCwd, scope, path: path13, stat: stat10, diff };
     } catch (error) {
       if (error instanceof OversizedGitOutputError) {
         return {
@@ -3756,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 });
     }
   });
 }
@@ -3935,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) {
@@ -4108,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.
@@ -4202,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
@@ -4222,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
@@ -4258,8 +4286,8 @@ 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
@@ -4317,8 +4345,8 @@ async function wecomGatewayRoutes(app, options) {
 }
 function sendWecomError(reply, error) {
   const statusCode = Number(error?.statusCode) || 400;
-  const message = error instanceof Error ? error.message : "WeCom gateway request failed";
-  return reply.status(statusCode).send({ error: message });
+  const message2 = error instanceof Error ? error.message : "WeCom gateway request failed";
+  return reply.status(statusCode).send({ error: message2 });
 }
 
 // src/routes/git-hosting.ts
@@ -4360,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());
@@ -4423,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() {
@@ -4431,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());
@@ -4462,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 });
@@ -4793,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
@@ -4945,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"];
@@ -5092,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());
@@ -5176,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);
   }
@@ -5185,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 {
@@ -5367,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;
@@ -5450,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";
@@ -5542,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 {
   }
 }
@@ -5618,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)) {
@@ -5645,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",
@@ -5709,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",
@@ -5720,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,
@@ -5751,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.`,
@@ -5766,10 +5994,11 @@ async function chatWebSocket(app) {
                   }
                 }
               }
-              sendJson(socket, {
+              broadcastToSession(sessionId, {
                 type: "event",
                 sessionId,
-                event
+                event,
+                streamingStartedAt
               });
             });
             try {
@@ -5783,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
                   );
@@ -5803,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,
@@ -5830,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
               );
@@ -5843,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) {
@@ -5854,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;
           }
@@ -5868,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);
     });
   });
@@ -5946,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;
         }
@@ -6534,12 +6756,117 @@ var wecomGatewaySchemaMigration = {
   }
 };
 
+// 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,
-  wecomGatewaySchemaMigration
+  wecomGatewaySchemaMigration,
+  modelWindowKickoffSchemaMigration,
+  modelWindowKickoffProjectPathMigration,
+  userPromptsSchemaMigration,
+  applicationSettingsTableMigration,
+  pinnedFilesSchemaMigration
 ];
 function runDatabaseMigrations(db) {
   db.exec(`
@@ -6787,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);
   }
 };
 
@@ -7126,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();
@@ -7873,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
@@ -8292,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);
@@ -8317,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);
@@ -8342,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) {
@@ -8562,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) {
@@ -8678,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);
@@ -8700,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;
   }
@@ -8713,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,
@@ -8732,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) {
@@ -8753,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)
@@ -8779,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
@@ -8833,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);
@@ -8842,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,
@@ -9025,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}`);
@@ -9474,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;
@@ -9984,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";
   }
@@ -10349,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;
@@ -10997,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();
@@ -11013,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) {
@@ -11071,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 (
@@ -11375,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,
@@ -11886,7 +12270,7 @@ function createMemoryRuntime(options) {
 // src/services/worktree-manager.ts
 import { execFile as execFileCallback } from "child_process";
 import { copyFile, mkdir as mkdir5, readdir as readdir3 } from "fs/promises";
-import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute3, join as join13 } from "path";
+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 {
@@ -12008,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;
   }
 };
 
@@ -12381,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";
   }
@@ -12481,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;
 }
@@ -12556,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) {
@@ -12689,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" },
@@ -12710,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 };
@@ -12869,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 });
@@ -12877,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";
@@ -12964,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() {
@@ -13041,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
     };
   }
@@ -13070,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);
@@ -13101,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");
@@ -13122,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;
@@ -13132,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;
@@ -13266,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 });
   }
@@ -13428,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])
@@ -13458,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();
@@ -13471,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";
 
@@ -13734,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;
@@ -13750,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,
@@ -13770,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;
@@ -13786,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));
   }
@@ -13880,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;
@@ -13918,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);
@@ -13928,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;
@@ -13959,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;
@@ -13969,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;
@@ -14103,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 });
   }
@@ -14275,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))
@@ -14520,11 +14904,11 @@ 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;
     }
   }
@@ -14533,8 +14917,8 @@ function extractLastAssistantText2(messages) {
 
 // src/services/wecom-gateway.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { stat as stat8 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6 } from "node:path";
+import { stat as stat9 } from "node:fs/promises";
+import { isAbsolute as isAbsolute7 } from "node:path";
 
 // src/services/wecom-crypto.ts
 import { createDecipheriv as createDecipheriv3, createHash as createHash8, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
@@ -14682,24 +15066,24 @@ var WecomGatewayService = class {
     const encrypted = xmlValue(body, "Encrypt");
     if (!encrypted) throw gatewayError("Invalid WeCom callback envelope", 400);
     this.verifySignature(query, encrypted, config);
-    const message = parseWecomMessage(decryptWecomPayload(encrypted, config.encodingAesKey, config.corpId));
+    const message2 = parseWecomMessage(decryptWecomPayload(encrypted, config.encodingAesKey, config.corpId));
     this.markCallbackVerified();
-    if (!message || message.agentId !== config.agentId) return "success";
-    if (config.allowedUsers.length && !config.allowedUsers.includes(message.userId)) return "success";
-    if (this.markDuplicate(message.messageId)) return "success";
-    if (!["text", "image", "voice"].includes(message.messageType)) {
-      void this.sendReply(config, message.userId, "This WeCom gateway supports text, image, and voice messages only.").catch((error) => {
+    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: message.messageId,
-      userId: message.userId,
-      text: message.text,
-      messageType: message.messageType,
-      mediaId: message.mediaId,
-      picUrl: message.picUrl
+      messageId: message2.messageId,
+      userId: message2.userId,
+      text: message2.text,
+      messageType: message2.messageType,
+      mediaId: message2.mediaId,
+      picUrl: message2.picUrl
     }, config);
     return "success";
   }
@@ -14786,57 +15170,57 @@ var WecomGatewayService = class {
     this.seen.set(id, now + DEDUP_TTL_MS3);
     return false;
   }
-  enqueue(message, config) {
-    const clientId = `wecom:dm:${message.userId}`;
+  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, message, config)).catch((error) => console.error("[wecom-gateway] message handling failed:", error)).finally(() => {
+    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, 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.userId, "No gateway folders configured. Add at least one allowed folder in Web UI Settings > Gateway.");
+      await this.sendReply(config, message2.userId, "No gateway folders configured. Add at least one allowed folder in Web UI Settings > Gateway.");
       return;
     }
-    let promptText = message.text;
-    if (message.messageType === "voice") {
-      if (!message.mediaId) {
-        await this.sendReply(config, message.userId, "The WeCom voice message did not include downloadable media. Try sending it again.");
+    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, message.mediaId), "audio/amr")).trim();
+        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, message.userId, "The voice message could not be transcribed. Check the speech-to-text configuration and try again.");
+        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, message.userId, "The voice message did not contain recognizable speech. Try sending it again.");
+        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 (message.messageType === "image") {
-      if (!message.mediaId) {
-        await this.sendReply(config, message.userId, "The WeCom image message did not include downloadable media. Try sending it again.");
+    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, message.mediaId)];
+        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, message.userId, "The image could not be downloaded from WeCom. Try sending it again.");
+        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, message.userId, imageResult.message);
+      await this.sendReply(config, message2.userId, imageResult.message);
       return;
     }
     promptText ||= imageResult.images.length ? "Please analyze the attached image." : "";
@@ -14851,7 +15235,7 @@ var WecomGatewayService = class {
       unsubscribe();
     }
     const response = chunks.join("").trim() || extractLastAssistantText3(session.messages) || "(Pi finished without a text response.)";
-    await this.sendReply(config, message.userId, response);
+    await this.sendReply(config, message2.userId, response);
   }
   async ensureSession(clientId, config) {
     await this.sessionService.setClientAgentProfile(clientId, config.agentProfile || "default");
@@ -14880,28 +15264,28 @@ var WecomGatewayService = class {
     `).run(clientId, clientId, result.session.sessionId, now, now);
     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;
     try {
       if (normalized === "/new" || normalized === "/reset") {
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Reset this WeCom chat. A fresh Pi session will start with your next message."));
+        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, message.userId, this.formatHelp());
+        await this.sendReply(baseConfig, message2.userId, this.formatHelp());
         return true;
       }
       if (normalized === "/status") {
-        await this.sendReply(baseConfig, message.userId, await this.formatStatus(clientId, effectiveConfig));
+        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, message.userId, ["Available profiles:", ...profiles.map((profile) => `${profile.id === (effectiveConfig.agentProfile || "default") ? "*" : " "} ${profile.id}`)].join("\n"));
+        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") {
@@ -14911,25 +15295,25 @@ var WecomGatewayService = class {
         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, message.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Profile updated."));
+        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, message.userId, baseConfig.cwdChoices.length ? baseConfig.cwdChoices.map((cwd, index) => `${index + 1}: ${cwd}`).join("\n") : "No gateway folders configured.");
+        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 (!isAbsolute6(target) || !(await stat8(target)).isDirectory()) throw new Error(`Configured CWD ${slot} must be an existing absolute directory`);
+        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, message.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Working directory updated."));
+        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, message.userId, this.formatSkillsets(effectiveConfig.skillPresetId));
+        await this.sendReply(baseConfig, message2.userId, this.formatSkillsets(effectiveConfig.skillPresetId));
         return true;
       }
       if (normalized === "/skillset") {
@@ -14937,22 +15321,22 @@ var WecomGatewayService = class {
         if (!selected) throw new Error("Usage: /skillset <all|preset-name>");
         this.saveChatConfig(clientId, this.resolveSkillsetConfig(selected, true));
         this.resetSession(clientId);
-        await this.sendReply(baseConfig, message.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "Skillset updated."));
+        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, message.userId, await this.formatStatus(clientId, this.resolveChatConfig(clientId, baseConfig), "WeCom chat config cleared."));
+        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, message.userId, `Command failed: ${error instanceof Error ? error.message : "unknown error"}
+      await this.sendReply(baseConfig, message2.userId, `Command failed: ${error instanceof Error ? error.message : "unknown error"}
 
 ${this.formatHelp()}`);
       return true;
     }
-    await this.sendReply(baseConfig, message.userId, `Unknown command: ${command}
+    await this.sendReply(baseConfig, message2.userId, `Unknown command: ${command}
 
 ${this.formatHelp()}`);
     return true;
@@ -15181,8 +15565,8 @@ function normalizeList(value) {
 function stringValue3(value) {
   return typeof value === "string" ? value : value === void 0 || value === null ? "" : String(value);
 }
-function gatewayError(message, statusCode) {
-  const error = new Error(message);
+function gatewayError(message2, statusCode) {
+  const error = new Error(message2);
   error.statusCode = statusCode;
   return error;
 }
@@ -15198,11 +15582,11 @@ async function parseWecomResponse(response) {
 }
 function extractLastAssistantText3(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" && message.content.trim()) return message.content.trim();
-    if (!Array.isArray(message.content)) continue;
-    const text = message.content.filter((part) => part?.type === "text" && typeof part.text === "string").map((part) => part.text).join("").trim();
+    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;
@@ -15255,7 +15639,7 @@ var ClaudeCodeReviewSourceAdapter = 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);
   }
@@ -15276,14 +15660,14 @@ var ClaudeCodeReviewSourceAdapter = class {
       try {
         const records = this.readRecords(filePath);
         if (!records.length) return [];
-        const stat9 = fs5.statSync(filePath);
+        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((message) => message.role === "user");
+        const firstUserMessage = messages.find((message2) => message2.role === "user");
         return [{
           filePath,
           item: {
@@ -15292,8 +15676,8 @@ var ClaudeCodeReviewSourceAdapter = class {
             name: title,
             path: filePath,
             cwd,
-            created: new Date(timestamps.length ? Math.min(...timestamps) : stat9.birthtimeMs).toISOString(),
-            modified: new Date(timestamps.length ? Math.max(...timestamps) : stat9.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
           }
@@ -15418,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);
   }
@@ -15439,11 +15823,11 @@ var CodexReviewSourceAdapter = class {
       try {
         const records = this.readRecords(filePath);
         if (!records.length) return [];
-        const stat9 = 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: {
@@ -15451,8 +15835,8 @@ var CodexReviewSourceAdapter = class {
             sourceId: "",
             path: filePath,
             cwd: this.stringValue(metadata?.cwd),
-            created: new Date(timestamps.length ? Math.min(...timestamps) : stat9.birthtimeMs).toISOString(),
-            modified: new Date(timestamps.length ? Math.max(...timestamps) : stat9.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
           }
@@ -15719,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");
@@ -15769,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;
@@ -15988,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);
@@ -16076,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() {
@@ -16135,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();
@@ -16153,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();
@@ -16178,6 +16902,7 @@ async function buildApp() {
     worktreeMetadata: worktreeMetadataStore
   });
   app.addHook("onClose", async () => {
+    await modelWindowKickoffScheduler.stop();
     await weixinGateway.stop();
     terminalManager.disposeAll();
     piSessionService.disposeAll();
@@ -16266,6 +16991,12 @@ async function buildApp() {
   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 () => {