kimiflare 0.68.1 → 0.69.0

package/dist/index.js

@@ -1244,7 +1244,10 @@ async function logTurnDebug(ctx) {
     durationMs: ctx.durationMs,
     intentClassification: ctx.intentClassification,
     codeMode: ctx.codeMode,
-    selectedSkills: ctx.selectedSkills?.map((s) => s.name)
+    selectedSkills: ctx.selectedSkills?.map((s) => s.name),
+    userPromptPreview: ctx.userPromptPreview,
+    preTurnMs: ctx.preTurnMs,
+    memoryRecalled: ctx.memoryRecalled
   });
 }
 var LOG_VERSION;
@@ -2703,6 +2706,10 @@ function deleteOrphanedSkills(db, existingPaths) {
   const result = db.prepare(`DELETE FROM skill_index WHERE file_path NOT IN (${placeholders})`).run(...existingPaths);
   return Number(result.changes);
 }
+function hasAnySections(db) {
+  const row = db.prepare("SELECT 1 FROM skill_sections LIMIT 1").get();
+  return row !== void 0;
+}
 function listAllSectionRows(db) {
   return db.prepare(
     `SELECT s.id, s.heading, s.body, s.embedding, i.name, i.description, i.file_path
@@ -2728,6 +2735,7 @@ var init_db = __esm({
 
 // src/skills/search.ts
 async function searchSections(query, db, opts2) {
+  if (!hasAnySections(db)) return [];
   const embeddings = await fetchEmbeddings({
     accountId: opts2.accountId,
     apiToken: opts2.apiToken,
@@ -3162,6 +3170,15 @@ function getSessionWebFetchHistory(sessionId) {
 function isHighSignalMemory(memory) {
   return memory.topicKey === "project_dependencies" || memory.topicKey === "project_tsconfig" || memory.topicKey === "project_entry_point" || memory.category === "instruction" || memory.category === "preference" || memory.category === "event" && memory.importance >= 3;
 }
+function extractLastUserText(messages) {
+  const lastUser = [...messages].reverse().find((m) => m.role === "user");
+  if (!lastUser) return "";
+  if (typeof lastUser.content === "string") return lastUser.content;
+  if (Array.isArray(lastUser.content)) {
+    return lastUser.content.filter((p) => p.type === "text").map((p) => p.text).join(" ");
+  }
+  return "";
+}
 function raceWithSignal(promise, signal) {
   return Promise.race([
     promise,
@@ -3179,87 +3196,84 @@ async function runAgentTurn(opts2) {
   logger.info("turn:start", { sessionId: opts2.sessionId, codeMode: opts2.codeMode ?? false });
   const max = opts2.maxToolIterations ?? 50;
   const codeMode = opts2.codeMode ?? false;
+  const preTurnStart = performance.now();
   let memoryRecalledCount = 0;
   let skillResult;
-  if (opts2.sessionStartRecall) {
-    try {
-      const results = await raceWithSignal(opts2.sessionStartRecall, opts2.signal);
-      if (results.length > 0 && opts2.memoryManager) {
-        const text = await raceWithSignal(
-          opts2.memoryManager.synthesizeRecalled(results, opts2.signal),
-          opts2.signal
-        );
-        memoryRecalledCount = results.length;
-        const lastSystemIdx = opts2.messages.findLastIndex((m) => m.role === "system");
-        const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : opts2.messages.length;
-        opts2.messages.splice(insertIdx, 0, { role: "system", content: text });
-        opts2.callbacks.onMemoryRecalled?.(results.length);
-      }
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "AbortError") throw err;
-    }
-  }
-  if (opts2.signal.aborted) {
-    throw new DOMException("aborted", "AbortError");
-  }
-  if (opts2.skillsDb && opts2.skillRoutingConfig && opts2.intentClassification) {
-    try {
-      const lastUserMsg = [...opts2.messages].reverse().find((m) => m.role === "user");
-      const prompt = typeof lastUserMsg?.content === "string" ? lastUserMsg.content : Array.isArray(lastUserMsg?.content) ? lastUserMsg.content.filter((p) => p.type === "text").map((p) => p.text).join(" ") : "";
-      if (prompt) {
-        skillResult = await raceWithSignal(
-          selectSkills(
-            {
-              prompt,
-              tier: opts2.intentClassification.tier,
-              maxSkillTokens: opts2.skillRoutingConfig.maxSkillTokens ?? 25e4 - 1e4
-            },
-            {
-              db: opts2.skillsDb,
-              accountId: opts2.skillRoutingConfig.accountId,
-              apiToken: opts2.skillRoutingConfig.apiToken,
-              embeddingModel: opts2.skillRoutingConfig.embeddingModel,
-              gateway: opts2.skillRoutingConfig.gateway,
-              cloudMode: opts2.skillRoutingConfig.cloudMode,
-              cloudToken: opts2.skillRoutingConfig.cloudToken,
-              cloudDeviceId: opts2.skillRoutingConfig.cloudDeviceId
-            }
-          ),
-          opts2.signal
-        );
-        opts2.callbacks.onSkillsSelected?.(skillResult);
-        const allTools = opts2.tools;
-        if (opts2.cacheStable) {
-          opts2.messages[1] = {
-            role: "system",
-            content: buildSessionPrefix({
-              cwd: opts2.cwd,
-              tools: allTools,
-              model: opts2.model,
-              mode: opts2.mode,
-              skillContext: skillResult.skillContext
-            })
-          };
-        } else {
-          opts2.messages[0] = {
-            role: "system",
-            content: buildSystemPrompt({
-              cwd: opts2.cwd,
-              tools: allTools,
-              model: opts2.model,
-              mode: opts2.mode,
-              skillContext: skillResult.skillContext
-            })
-          };
-        }
-      }
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "AbortError") throw err;
+  const lastUserPrompt = extractLastUserText(opts2.messages);
+  const userPromptPreview = lastUserPrompt.slice(0, 200);
+  const skipSkillRouting = opts2.intentClassification?.tier === "light" && lastUserPrompt.length < 40;
+  const recallPromise = opts2.sessionStartRecall && opts2.memoryManager ? (async () => {
+    const results = await opts2.sessionStartRecall;
+    if (results.length === 0 || !opts2.memoryManager) return null;
+    const text = await opts2.memoryManager.synthesizeRecalled(results, opts2.signal);
+    return { text, count: results.length };
+  })() : Promise.resolve(null);
+  const skillsPromise = opts2.skillsDb && opts2.skillRoutingConfig && opts2.intentClassification && lastUserPrompt && !skipSkillRouting ? selectSkills(
+    {
+      prompt: lastUserPrompt,
+      tier: opts2.intentClassification.tier,
+      maxSkillTokens: opts2.skillRoutingConfig.maxSkillTokens ?? 25e4 - 1e4
+    },
+    {
+      db: opts2.skillsDb,
+      accountId: opts2.skillRoutingConfig.accountId,
+      apiToken: opts2.skillRoutingConfig.apiToken,
+      embeddingModel: opts2.skillRoutingConfig.embeddingModel,
+      gateway: opts2.skillRoutingConfig.gateway,
+      cloudMode: opts2.skillRoutingConfig.cloudMode,
+      cloudToken: opts2.skillRoutingConfig.cloudToken,
+      cloudDeviceId: opts2.skillRoutingConfig.cloudDeviceId
+    }
+  ) : Promise.resolve(void 0);
+  const [recallSettled, skillsSettled] = await Promise.allSettled([
+    raceWithSignal(recallPromise, opts2.signal),
+    raceWithSignal(skillsPromise, opts2.signal)
+  ]);
+  for (const settled of [recallSettled, skillsSettled]) {
+    if (settled.status === "rejected" && settled.reason instanceof DOMException && settled.reason.name === "AbortError") {
+      throw settled.reason;
+    }
+  }
+  if (recallSettled.status === "fulfilled" && recallSettled.value) {
+    const { text, count } = recallSettled.value;
+    const lastSystemIdx = opts2.messages.findLastIndex((m) => m.role === "system");
+    const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : opts2.messages.length;
+    opts2.messages.splice(insertIdx, 0, { role: "system", content: text });
+    memoryRecalledCount = count;
+    opts2.callbacks.onMemoryRecalled?.(count);
+  }
+  if (skillsSettled.status === "fulfilled" && skillsSettled.value) {
+    skillResult = skillsSettled.value;
+    opts2.callbacks.onSkillsSelected?.(skillResult);
+    const allTools = opts2.tools;
+    if (opts2.cacheStable) {
+      opts2.messages[1] = {
+        role: "system",
+        content: buildSessionPrefix({
+          cwd: opts2.cwd,
+          tools: allTools,
+          model: opts2.model,
+          mode: opts2.mode,
+          skillContext: skillResult.skillContext
+        })
+      };
+    } else {
+      opts2.messages[0] = {
+        role: "system",
+        content: buildSystemPrompt({
+          cwd: opts2.cwd,
+          tools: allTools,
+          model: opts2.model,
+          mode: opts2.mode,
+          skillContext: skillResult.skillContext
+        })
+      };
     }
   }
   if (opts2.signal.aborted) {
     throw new DOMException("aborted", "AbortError");
   }
+  const preTurnMs = Math.round(performance.now() - preTurnStart);
   opts2.callbacks.onMetaBanner?.({
     intentTier: opts2.intentClassification?.tier ?? "medium",
     skillsActive: skillResult?.sectionCount ?? 0,
@@ -3414,7 +3428,9 @@ Use console.log() to return results. Only console.log output will be sent back t
         ...opts2.gateway.metadata ?? {},
         feature: "chat",
         ...opts2.sessionId ? { sessionId: opts2.sessionId } : {},
-        turnIdx: turn
+        tier: opts2.intentClassification?.tier ?? "medium",
+        cm: codeMode ? "1" : "0",
+        skl: String(skillResult?.sectionCount ?? 0)
       }
     } : void 0;
     const events = runKimi({
@@ -3512,7 +3528,14 @@ Use console.log() to return results. Only console.log output will be sent back t
           previousMessages,
           toolResults,
           usage: lastUsage,
-          shadowStrip: shadowStripMetrics
+          shadowStrip: shadowStripMetrics,
+          durationMs: Math.round(performance.now() - turnStart),
+          intentClassification: opts2.intentClassification,
+          codeMode: opts2.codeMode,
+          selectedSkills: opts2.selectedSkills,
+          userPromptPreview,
+          preTurnMs,
+          memoryRecalled: memoryRecalledCount > 0
         });
       }
       if (budgetExhausted) {
@@ -3821,7 +3844,10 @@ ${sandboxResult.output}` : sandboxResult.output;
         durationMs: Math.round(performance.now() - turnStart),
         intentClassification: opts2.intentClassification,
         codeMode: opts2.codeMode,
-        selectedSkills: opts2.selectedSkills
+        selectedSkills: opts2.selectedSkills,
+        userPromptPreview,
+        preTurnMs,
+        memoryRecalled: memoryRecalledCount > 0
       });
     }
     if (budgetExhausted) {
@@ -3942,15 +3968,61 @@ var init_paths = __esm({
 
 // src/tools/read.ts
 import { readFile as readFile3, stat as stat2 } from "fs/promises";
-var MAX_BYTES, readTool;
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+function aborted(signal) {
+  return signal?.aborted === true;
+}
+function abortError() {
+  return new DOMException("aborted", "AbortError");
+}
+async function readSliceStreaming(abs, offset, limit, signal) {
+  if (aborted(signal)) throw abortError();
+  const rs = createReadStream(abs, { encoding: "utf8" });
+  const onAbort = () => rs.destroy(abortError());
+  signal?.addEventListener("abort", onAbort);
+  try {
+    const rl = createInterface({ input: rs, crlfDelay: Infinity });
+    const startLine = Math.max(1, offset);
+    const endLine = startLine + Math.max(0, limit) - 1;
+    const collected = [];
+    let lineNum = 0;
+    let bytesScanned = 0;
+    for await (const line of rl) {
+      if (aborted(signal)) throw abortError();
+      lineNum += 1;
+      bytesScanned += Buffer.byteLength(line, "utf8") + 1;
+      if (bytesScanned > MAX_STREAM_BYTES) {
+        throw new Error(
+          `file too large to stream: exceeded ${MAX_STREAM_BYTES} bytes while seeking slice at line ${startLine}`
+        );
+      }
+      if (lineNum >= startLine && lineNum <= endLine) {
+        collected.push(line);
+      }
+      if (lineNum >= endLine) break;
+    }
+    return collected;
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    rs.destroy();
+  }
+}
+function formatLines(lines, startLine) {
+  const endLine = startLine + lines.length - 1;
+  const width = String(endLine).length;
+  return lines.map((l, i) => `${String(startLine + i).padStart(width, " ")}	${l}`).join("\n");
+}
+var MAX_BYTES, MAX_STREAM_BYTES, readTool;
 var init_read = __esm({
   "src/tools/read.ts"() {
     "use strict";
     init_paths();
     MAX_BYTES = 2 * 1024 * 1024;
+    MAX_STREAM_BYTES = 50 * 1024 * 1024;
     readTool = {
       name: "read",
-      description: "Read a text file from the local filesystem. Supports optional line offset/limit. Refuses files larger than 2MB. Returns contents with 1-indexed line numbers prefixed, cat -n style. When reading a full file without offset/limit, the output is reduced to a compact outline (imports, exports, signatures, preview) by default; use expand_artifact to retrieve the full content or specify offset/limit for a targeted slice.",
+      description: "Read a text file from the local filesystem. Supports optional line offset/limit. Files up to 2MB are read in a single pass; larger files require an explicit offset+limit slice and are streamed line by line (cancellable mid-stream). Returns contents with 1-indexed line numbers prefixed, cat -n style. When reading a full file without offset/limit, the output is reduced to a compact outline (imports, exports, signatures, preview) by default; use expand_artifact to retrieve the full content or specify offset/limit for a targeted slice.",
       parameters: {
         type: "object",
         properties: {
@@ -3964,13 +4036,21 @@ var init_read = __esm({
       needsPermission: false,
       render: ({ path }) => ({ title: `read ${collapsePath(path, process.cwd())}` }),
       async run(args, ctx) {
-        if (ctx.signal?.aborted) throw new DOMException("aborted", "AbortError");
+        if (aborted(ctx.signal)) throw abortError();
         const abs = resolvePath(ctx.cwd, args.path);
         const st = await stat2(abs);
-        if (st.size > MAX_BYTES) throw new Error(`file too large: ${st.size} bytes (max ${MAX_BYTES})`);
-        if (ctx.signal?.aborted) throw new DOMException("aborted", "AbortError");
+        if (aborted(ctx.signal)) throw abortError();
+        if (st.size > MAX_BYTES) {
+          if (args.offset === void 0 || args.limit === void 0) {
+            throw new Error(
+              `file too large: ${st.size} bytes (max ${MAX_BYTES} for full read; supply offset+limit to stream a slice)`
+            );
+          }
+          const lines2 = await readSliceStreaming(abs, args.offset, args.limit, ctx.signal);
+          return formatLines(lines2, args.offset);
+        }
         const text = await readFile3(abs, { encoding: "utf8", signal: ctx.signal });
-        if (ctx.signal?.aborted) throw new DOMException("aborted", "AbortError");
+        if (aborted(ctx.signal)) throw abortError();
         const lines = text.split("\n");
         const start = Math.max(0, (args.offset ?? 1) - 1);
         const end = args.limit ? Math.min(lines.length, start + args.limit) : lines.length;
@@ -10164,7 +10244,7 @@ var rpc_exports = {};
 __export(rpc_exports, {
   startRpcServer: () => startRpcServer
 });
-import { createInterface } from "readline";
+import { createInterface as createInterface2 } from "readline";
 async function startRpcServer(input = process.stdin, output = process.stdout) {
   let session = null;
   let unsubscribe = null;
@@ -10174,7 +10254,7 @@ async function startRpcServer(input = process.stdin, output = process.stdout) {
   function sendEvent(event) {
     send({ ...event });
   }
-  const rl = createInterface({
+  const rl = createInterface2({
     input,
     crlfDelay: Infinity
   });
@@ -10318,69 +10398,6 @@ var init_rpc = __esm({
   }
 });
 
-// src/agent/supervisor.ts
-var TurnSupervisor;
-var init_supervisor = __esm({
-  "src/agent/supervisor.ts"() {
-    "use strict";
-    init_loop();
-    init_logger();
-    TurnSupervisor = class {
-      currentTurn = null;
-      _phase = "idle";
-      _killRequested = false;
-      get phase() {
-        return this._phase;
-      }
-      get isRunning() {
-        return this._phase !== "idle";
-      }
-      get killRequested() {
-        return this._killRequested;
-      }
-      startTurn(opts2, callbacks) {
-        if (this.isRunning) {
-          logger.warn("supervisor:start_rejected", { reason: "turn_already_running", phase: this._phase });
-          throw new Error("TurnSupervisor: turn already in progress");
-        }
-        this._phase = "preparing";
-        this._killRequested = false;
-        logger.debug("supervisor:turn_start", { sessionId: opts2.sessionId });
-        this.currentTurn = runAgentTurn(opts2).then(async () => {
-          this._phase = "idle";
-          if (this._killRequested) {
-            logger.debug("supervisor:turn_killed", { sessionId: opts2.sessionId });
-          } else {
-            logger.debug("supervisor:turn_done", { sessionId: opts2.sessionId });
-          }
-          await callbacks?.onDone?.();
-        }).catch(async (error) => {
-          this._phase = "idle";
-          const err = error;
-          logger.warn("supervisor:turn_error", {
-            sessionId: opts2.sessionId,
-            error: err.message ?? String(err),
-            name: err.name
-          });
-          await callbacks?.onError?.(err);
-        }).finally(() => {
-          this.currentTurn = null;
-          this._killRequested = false;
-        });
-      }
-      /** Request that the current turn be killed. This does NOT directly abort
-       *  the turn — the caller must abort the AbortScope that was passed to
-       *  `startTurn`. This method only records the intent so the supervisor
-       *  knows the turn was intentionally killed rather than failing. */
-      killTurn() {
-        if (!this.isRunning) return;
-        this._killRequested = true;
-        logger.debug("supervisor:kill_requested", { phase: this._phase });
-      }
-    };
-  }
-});
-
 // src/agent/llm-summarize.ts
 function indexOfNthUserFromEnd(messages, n) {
   let seen = 0;
@@ -18537,6 +18554,401 @@ var init_modal_host = __esm({
   }
 });
 
+// src/ui/use-session-manager.ts
+import { useCallback as useCallback6, useRef as useRef5, useState as useState16 } from "react";
+function extractFirstUserText(messages) {
+  const firstUser = messages.find((m) => m.role === "user");
+  if (!firstUser) return "session";
+  if (typeof firstUser.content === "string") {
+    return firstUser.content || "session";
+  }
+  if (Array.isArray(firstUser.content)) {
+    const textPart = firstUser.content.find((p) => p.type === "text");
+    if (textPart?.text) return textPart.text;
+  }
+  return "session";
+}
+function useSessionManager(deps) {
+  const sessionIdRef = useRef5(null);
+  const sessionCreatedAtRef = useRef5(null);
+  const sessionTitleRef = useRef5(null);
+  const [resumeSessions, setResumeSessions] = useState16(null);
+  const [checkpointSession, setCheckpointSession] = useState16(null);
+  const [checkpointList, setCheckpointList] = useState16([]);
+  const depsRef = useRef5(deps);
+  depsRef.current = deps;
+  const ensureSessionId = useCallback6(() => {
+    if (sessionIdRef.current) return sessionIdRef.current;
+    const text = extractFirstUserText(depsRef.current.messagesRef.current);
+    sessionIdRef.current = makeSessionId(text);
+    return sessionIdRef.current;
+  }, []);
+  const saveSessionSafe = useCallback6(async () => {
+    const d = depsRef.current;
+    if (!d.cfg) return;
+    ensureSessionId();
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
+    if (!sessionCreatedAtRef.current) {
+      sessionCreatedAtRef.current = now2;
+    }
+    try {
+      await saveSession({
+        id: sessionIdRef.current,
+        cwd: process.cwd(),
+        model: d.cfg.model,
+        createdAt: sessionCreatedAtRef.current,
+        updatedAt: now2,
+        title: sessionTitleRef.current ?? void 0,
+        messages: d.messagesRef.current,
+        sessionState: d.compiledContextRef.current ? d.sessionStateRef.current : void 0,
+        artifactStore: serializeArtifactStore(d.artifactStoreRef.current)
+      });
+    } catch (e) {
+      d.setEvents((es) => [
+        ...es,
+        { kind: "error", key: d.mkKey(), text: `session save failed: ${e.message}` }
+      ]);
+    }
+  }, [ensureSessionId]);
+  const openResumePicker = useCallback6(async () => {
+    const sessions = await listSessions(200, process.cwd());
+    setResumeSessions(sessions);
+  }, []);
+  const doResumeSession = useCallback6(
+    async (filePath, checkpointId) => {
+      const d = depsRef.current;
+      try {
+        const file = checkpointId ? (await loadSessionFromCheckpoint(filePath, checkpointId)).file : await loadSession(filePath);
+        d.messagesRef.current = file.messages;
+        sessionIdRef.current = file.id;
+        sessionCreatedAtRef.current = file.createdAt;
+        if (file.sessionState && d.compiledContextRef.current) {
+          d.sessionStateRef.current = file.sessionState;
+        }
+        if (file.artifactStore) {
+          d.artifactStoreRef.current = deserializeArtifactStore(file.artifactStore);
+        } else {
+          d.artifactStoreRef.current = new ArtifactStore();
+        }
+        const manager = d.memoryManagerRef.current;
+        if (manager) {
+          try {
+            const cwd = process.cwd();
+            const results = await manager.recall({ text: cwd, repoPath: cwd, limit: 5 });
+            if (results.length > 0) {
+              const text = await manager.synthesizeRecalled(results);
+              const lastSystemIdx = d.messagesRef.current.findLastIndex((m) => m.role === "system");
+              const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : d.messagesRef.current.length;
+              d.messagesRef.current.splice(insertIdx, 0, { role: "system", content: text });
+            }
+          } catch {
+          }
+        }
+        const msg = checkpointId ? `resumed session ${file.id} from checkpoint` : `resumed session ${file.id} (${file.messages.filter((m) => m.role !== "system").length} msgs)`;
+        d.setEvents([{ kind: "info", key: d.mkKey(), text: msg }]);
+        const userMsgs = file.messages.filter((m) => m.role === "user" && m.content).map((m) => {
+          if (!m.content) return "";
+          if (typeof m.content === "string") return m.content;
+          const textPart = m.content.find((p) => p.type === "text");
+          return textPart?.text ?? "";
+        }).filter((text) => text.length > 0);
+        if (userMsgs.length > 0) d.setHistory(userMsgs);
+        d.setUsage(null);
+        d.setSessionUsage(null);
+        d.gatewayMetaRef.current = null;
+        d.setGatewayMeta(null);
+        void getCostReport(file.id).then((report) => d.setSessionUsage(report.session));
+      } catch (e) {
+        d.setEvents((es) => [
+          ...es,
+          { kind: "error", key: d.mkKey(), text: `failed to load session: ${e.message}` }
+        ]);
+      }
+    },
+    []
+  );
+  const handleResumePick = useCallback6(
+    async (picked) => {
+      setResumeSessions(null);
+      if (!picked) return;
+      if (picked.checkpointCount > 0) {
+        try {
+          const file = await loadSession(picked.filePath);
+          setCheckpointList(file.checkpoints ?? []);
+          setCheckpointSession(picked);
+        } catch (e) {
+          depsRef.current.setEvents((es) => [
+            ...es,
+            { kind: "error", key: depsRef.current.mkKey(), text: `failed to load checkpoints: ${e.message}` }
+          ]);
+          await doResumeSession(picked.filePath);
+        }
+        return;
+      }
+      await doResumeSession(picked.filePath);
+    },
+    [doResumeSession]
+  );
+  const handleCheckpointPick = useCallback6(
+    async (checkpointId) => {
+      const session = checkpointSession;
+      setCheckpointSession(null);
+      setCheckpointList([]);
+      if (!session || !checkpointId) {
+        if (session) {
+          setResumeSessions(await listSessions(200, process.cwd()));
+        }
+        return;
+      }
+      if (checkpointId === "__start__") {
+        await doResumeSession(session.filePath);
+        return;
+      }
+      await doResumeSession(session.filePath, checkpointId);
+    },
+    [checkpointSession, doResumeSession]
+  );
+  const resetSession = useCallback6(() => {
+    sessionIdRef.current = null;
+    sessionCreatedAtRef.current = null;
+    sessionTitleRef.current = null;
+    const d = depsRef.current;
+    d.sessionStateRef.current = emptySessionState();
+    d.artifactStoreRef.current = new ArtifactStore();
+  }, []);
+  return {
+    sessionIdRef,
+    sessionCreatedAtRef,
+    sessionTitleRef,
+    resumeSessions,
+    setResumeSessions,
+    checkpointSession,
+    setCheckpointSession,
+    checkpointList,
+    setCheckpointList,
+    hasPickerOpen: resumeSessions !== null || checkpointSession !== null,
+    ensureSessionId,
+    saveSessionSafe,
+    openResumePicker,
+    doResumeSession,
+    handleResumePick,
+    handleCheckpointPick,
+    resetSession
+  };
+}
+var init_use_session_manager = __esm({
+  "src/ui/use-session-manager.ts"() {
+    "use strict";
+    init_sessions();
+    init_session_state();
+    init_usage_tracker();
+  }
+});
+
+// src/agent/supervisor.ts
+var TurnSupervisor;
+var init_supervisor = __esm({
+  "src/agent/supervisor.ts"() {
+    "use strict";
+    init_loop();
+    init_logger();
+    TurnSupervisor = class {
+      currentTurn = null;
+      _phase = "idle";
+      _killRequested = false;
+      get phase() {
+        return this._phase;
+      }
+      get isRunning() {
+        return this._phase !== "idle";
+      }
+      get killRequested() {
+        return this._killRequested;
+      }
+      startTurn(opts2, callbacks) {
+        if (this.isRunning) {
+          logger.warn("supervisor:start_rejected", { reason: "turn_already_running", phase: this._phase });
+          throw new Error("TurnSupervisor: turn already in progress");
+        }
+        this._phase = "preparing";
+        this._killRequested = false;
+        logger.debug("supervisor:turn_start", { sessionId: opts2.sessionId });
+        this.currentTurn = runAgentTurn(opts2).then(async () => {
+          this._phase = "idle";
+          if (this._killRequested) {
+            logger.debug("supervisor:turn_killed", { sessionId: opts2.sessionId });
+          } else {
+            logger.debug("supervisor:turn_done", { sessionId: opts2.sessionId });
+          }
+          await callbacks?.onDone?.();
+        }).catch(async (error) => {
+          this._phase = "idle";
+          const err = error;
+          logger.warn("supervisor:turn_error", {
+            sessionId: opts2.sessionId,
+            error: err.message ?? String(err),
+            name: err.name
+          });
+          await callbacks?.onError?.(err);
+        }).finally(() => {
+          this.currentTurn = null;
+          this._killRequested = false;
+        });
+      }
+      /** Request that the current turn be killed. This does NOT directly abort
+       *  the turn — the caller must abort the AbortScope that was passed to
+       *  `startTurn`. This method only records the intent so the supervisor
+       *  knows the turn was intentionally killed rather than failing. */
+      killTurn() {
+        if (!this.isRunning) return;
+        this._killRequested = true;
+        logger.debug("supervisor:kill_requested", { phase: this._phase });
+      }
+    };
+  }
+});
+
+// src/ui/use-turn-controller.ts
+import { useCallback as useCallback7, useRef as useRef6, useState as useState17 } from "react";
+function useTurnController() {
+  const [busy, setBusy] = useState17(false);
+  const busyRef = useRef6(false);
+  const isAbortingRef = useRef6(false);
+  const lastEscapeAtRef = useRef6(0);
+  const supervisorRef = useRef6(new TurnSupervisor());
+  const [turnPhase, setTurnPhase] = useState17("waiting");
+  const [turnStartedAt, setTurnStartedAt] = useState17(null);
+  const [currentToolName, setCurrentToolName] = useState17(null);
+  const [lastActivityAt, setLastActivityAt] = useState17(null);
+  const turnCounterRef = useRef6(0);
+  const [showReasoning, setShowReasoning] = useState17(false);
+  const toggleReasoning = useCallback7(() => {
+    setShowReasoning((s) => !s);
+  }, []);
+  const [tasks, setTasks] = useState17([]);
+  const tasksRef = useRef6([]);
+  const [tasksStartedAt, setTasksStartedAt] = useState17(null);
+  const [tasksStartTokens, setTasksStartTokens] = useState17(0);
+  const beginTurn = useCallback7(() => {
+    setBusy(true);
+    busyRef.current = true;
+    setTurnStartedAt(Date.now());
+  }, []);
+  const endTurn = useCallback7(() => {
+    setBusy(false);
+    busyRef.current = false;
+    setTurnStartedAt(null);
+    setTurnPhase("waiting");
+    setCurrentToolName(null);
+    setLastActivityAt(null);
+    isAbortingRef.current = false;
+  }, []);
+  const clearTaskTracking = useCallback7(() => {
+    setTasks([]);
+    setTasksStartedAt(null);
+    setTasksStartTokens(0);
+    tasksRef.current = [];
+  }, []);
+  const markAborting = useCallback7(() => {
+    if (isAbortingRef.current) return false;
+    isAbortingRef.current = true;
+    supervisorRef.current.killTurn();
+    return true;
+  }, []);
+  return {
+    busy,
+    setBusy,
+    busyRef,
+    isAbortingRef,
+    lastEscapeAtRef,
+    supervisorRef,
+    turnPhase,
+    setTurnPhase,
+    turnStartedAt,
+    setTurnStartedAt,
+    currentToolName,
+    setCurrentToolName,
+    lastActivityAt,
+    setLastActivityAt,
+    turnCounterRef,
+    showReasoning,
+    setShowReasoning,
+    toggleReasoning,
+    tasks,
+    setTasks,
+    tasksRef,
+    tasksStartedAt,
+    setTasksStartedAt,
+    tasksStartTokens,
+    setTasksStartTokens,
+    beginTurn,
+    endTurn,
+    clearTaskTracking,
+    markAborting
+  };
+}
+var init_use_turn_controller = __esm({
+  "src/ui/use-turn-controller.ts"() {
+    "use strict";
+    init_supervisor();
+  }
+});
+
+// src/ui/input-handlers.ts
+function clearLimitLoopResolvers(deps) {
+  const hadLimit = deps.limitResolveRef.current !== null;
+  const hadLoop = deps.loopResolveRef.current !== null;
+  if (hadLimit) {
+    deps.limitResolveRef.current("stop");
+    deps.limitResolveRef.current = null;
+    deps.setLimitModal(null);
+  }
+  if (hadLoop) {
+    deps.loopResolveRef.current("stop");
+    deps.loopResolveRef.current = null;
+    deps.setLoopModal(null);
+  }
+  return { hadLimit, hadLoop };
+}
+function interruptTurn(deps) {
+  const hadPermission = deps.denyPendingPermission();
+  const { hadLimit, hadLoop } = clearLimitLoopResolvers(deps);
+  if (deps.busyRef.current && deps.activeScopeRef.current && !deps.isAbortingRef.current) {
+    deps.isAbortingRef.current = true;
+    deps.supervisorRef.current.killTurn();
+    deps.activeScopeRef.current.abort("user_stopped");
+    deps.setEvents((e) => [
+      ...e,
+      { kind: "info", key: deps.mkKey(), text: "(interrupted)" }
+    ]);
+    if (!deps.skipPendingToolCleanup) {
+      for (const [toolId] of deps.pendingToolCallsRef.current) {
+        deps.updateTool(toolId, { status: "cancelled" });
+      }
+      deps.pendingToolCallsRef.current.clear();
+    }
+    void deps.saveSessionSafe();
+    deps.clearTaskTracking();
+    return { hadPermission, hadLimit, hadLoop, didInterruptTurn: true };
+  }
+  return { hadPermission, hadLimit, hadLoop, didInterruptTurn: false };
+}
+function exitApp(deps) {
+  void deps.lspManagerRef.current.stopAll().finally(() => deps.exit());
+}
+function interruptOrExit(deps) {
+  const outcome = interruptTurn(deps);
+  if (!outcome.didInterruptTurn && !outcome.hadPermission && !outcome.hadLimit && !outcome.hadLoop) {
+    exitApp(deps);
+  }
+  return outcome;
+}
+var init_input_handlers = __esm({
+  "src/ui/input-handlers.ts"() {
+    "use strict";
+  }
+});
+
 // src/cost-attribution/tui-report.ts
 var tui_report_exports = {};
 __export(tui_report_exports, {
@@ -18624,7 +19036,7 @@ __export(app_exports, {
   buildFilePickerIgnoreList: () => buildFilePickerIgnoreList,
   renderApp: () => renderApp
 });
-import React15, { useState as useState16, useRef as useRef5, useEffect as useEffect8, useCallback as useCallback6 } from "react";
+import React17, { useState as useState18, useRef as useRef7, useEffect as useEffect8, useCallback as useCallback8 } from "react";
 import { Box as Box26, Text as Text27, useApp, useInput as useInput10, render } from "ink";
 import { existsSync as existsSync4, statSync as statSync4 } from "fs";
 import { join as join28 } from "path";
@@ -18863,13 +19275,13 @@ function App({
   initialCloudDeviceId
 }) {
   const { exit } = useApp();
-  const [cfg, setCfg] = useState16(initialCfg);
-  const [lspScope, setLspScope] = useState16(initialLspScope);
-  const [lspProjectPath, setLspProjectPath] = useState16(initialLspProjectPath);
-  const [cloudToken, setCloudToken] = useState16(initialCloudToken);
-  const [cloudDeviceId, setCloudDeviceId] = useState16(initialCloudDeviceId);
-  const [events, setRawEvents] = useState16([]);
-  const setEvents = useCallback6(
+  const [cfg, setCfg] = useState18(initialCfg);
+  const [lspScope, setLspScope] = useState18(initialLspScope);
+  const [lspProjectPath, setLspProjectPath] = useState18(initialLspProjectPath);
+  const [cloudToken, setCloudToken] = useState18(initialCloudToken);
+  const [cloudDeviceId, setCloudDeviceId] = useState18(initialCloudDeviceId);
+  const [events, setRawEvents] = useState18([]);
+  const setEvents = useCallback8(
     (updater) => {
       setRawEvents((prev) => {
         const next = typeof updater === "function" ? updater(prev) : updater;
@@ -18878,10 +19290,9 @@ function App({
     },
     []
   );
-  const [input, setInput] = useState16("");
-  const [busy, setBusy] = useState16(false);
-  const [usage, setUsage] = useState16(null);
-  const [sessionUsage, setSessionUsage] = useState16(null);
+  const [input, setInput] = useState18("");
+  const [usage, setUsage] = useState18(null);
+  const [sessionUsage, setSessionUsage] = useState18(null);
   useEffect8(() => {
     const handler = (sid) => {
       if (sessionIdRef.current && sid === sessionIdRef.current) {
@@ -18893,9 +19304,35 @@ function App({
       usageEvents.off("update", handler);
     };
   }, []);
-  const [gatewayMeta, setGatewayMeta] = useState16(null);
-  const [cloudBudget, setCloudBudget] = useState16(null);
-  const [showReasoning, setShowReasoning] = useState16(false);
+  const [gatewayMeta, setGatewayMeta] = useState18(null);
+  const [cloudBudget, setCloudBudget] = useState18(null);
+  const turn = useTurnController();
+  const {
+    busy,
+    busyRef,
+    isAbortingRef,
+    lastEscapeAtRef,
+    supervisorRef,
+    turnPhase,
+    setTurnPhase,
+    turnStartedAt,
+    currentToolName,
+    setCurrentToolName,
+    lastActivityAt,
+    setLastActivityAt,
+    turnCounterRef,
+    showReasoning,
+    tasks,
+    setTasks,
+    tasksRef,
+    tasksStartedAt,
+    setTasksStartedAt,
+    tasksStartTokens,
+    setTasksStartTokens,
+    beginTurn,
+    endTurn,
+    clearTaskTracking
+  } = turn;
   const {
     pending: perm,
     askPermission: askForPermission,
@@ -18941,38 +19378,28 @@ function App({
     hasFullscreenModal,
     hasAnyModal
   } = modals;
-  const [queue, setQueue] = useState16([]);
-  const [history, setHistory] = useState16([]);
-  const [historyIndex, setHistoryIndex] = useState16(-1);
-  const [draftInput, setDraftInput] = useState16("");
-  const [mode, setMode] = useState16("edit");
-  const [codeMode, setCodeMode] = useState16(false);
+  const [queue, setQueue] = useState18([]);
+  const [history, setHistory] = useState18([]);
+  const [historyIndex, setHistoryIndex] = useState18(-1);
+  const [draftInput, setDraftInput] = useState18("");
+  const [mode, setMode] = useState18("edit");
+  const [codeMode, setCodeMode] = useState18(false);
   const filePickerEnabled = initialCfg?.filePicker ?? true;
-  const [effort, setEffort] = useState16(
+  const [effort, setEffort] = useState18(
     initialCfg?.reasoningEffort ?? DEFAULT_REASONING_EFFORT
   );
-  const [resumeSessions, setResumeSessions] = useState16(null);
-  const [checkpointSession, setCheckpointSession] = useState16(null);
-  const [checkpointList, setCheckpointList] = useState16([]);
-  const [selectedRemoteSession, setSelectedRemoteSession] = useState16(null);
-  const [tasks, setTasks] = useState16([]);
-  const [tasksStartedAt, setTasksStartedAt] = useState16(null);
-  const [tasksStartTokens, setTasksStartTokens] = useState16(0);
-  const [turnStartedAt, setTurnStartedAt] = useState16(null);
-  const [turnPhase, setTurnPhase] = useState16("waiting");
-  const [currentToolName, setCurrentToolName] = useState16(null);
-  const [lastActivityAt, setLastActivityAt] = useState16(null);
-  const [verbose, setVerbose] = useState16(false);
-  const [hasUpdate, setHasUpdate] = useState16(initialUpdateResult?.hasUpdate ?? false);
-  const [latestVersion, setLatestVersion] = useState16(initialUpdateResult?.latestVersion ?? null);
-  const [theme, setTheme] = useState16(resolveTheme(initialCfg?.theme));
-  const [originalTheme, setOriginalTheme] = useState16(null);
-  const [skillsActive, setSkillsActive] = useState16(0);
-  const [memoryRecalled, setMemoryRecalled] = useState16(false);
-  const [intentTier, setIntentTier] = useState16(null);
-  const [kimiMdStale, setKimiMdStale] = useState16(false);
-  const [gitBranch, setGitBranch] = useState16(null);
-  const [lastSessionTopic, setLastSessionTopic] = useState16(null);
+  const [selectedRemoteSession, setSelectedRemoteSession] = useState18(null);
+  const [verbose, setVerbose] = useState18(false);
+  const [hasUpdate, setHasUpdate] = useState18(initialUpdateResult?.hasUpdate ?? false);
+  const [latestVersion, setLatestVersion] = useState18(initialUpdateResult?.latestVersion ?? null);
+  const [theme, setTheme] = useState18(resolveTheme(initialCfg?.theme));
+  const [originalTheme, setOriginalTheme] = useState18(null);
+  const [skillsActive, setSkillsActive] = useState18(0);
+  const [memoryRecalled, setMemoryRecalled] = useState18(false);
+  const [intentTier, setIntentTier] = useState18(null);
+  const [kimiMdStale, setKimiMdStale] = useState18(false);
+  const [gitBranch, setGitBranch] = useState18(null);
+  const [lastSessionTopic, setLastSessionTopic] = useState18(null);
   useEffect8(() => {
     setGitBranch(detectGitBranch());
   }, []);
@@ -19048,57 +19475,80 @@ ${wcagWarnings.join("\n")}` }
       cancelled = true;
     };
   }, [cfg?.cloudMode, initialCloudToken]);
-  const [cursorOffset, setCursorOffset] = useState16(0);
-  const [customCommandsVersion, setCustomCommandsVersion] = useState16(0);
-  const cacheStableRef = useRef5(initialCfg?.cacheStablePrompts !== false);
-  const messagesRef = useRef5(
+  const [cursorOffset, setCursorOffset] = useState18(0);
+  const [customCommandsVersion, setCustomCommandsVersion] = useState18(0);
+  const cacheStableRef = useRef7(initialCfg?.cacheStablePrompts !== false);
+  const messagesRef = useRef7(
     makePrefixMessages(cacheStableRef.current, cfg?.model ?? DEFAULT_MODEL, "edit", ALL_TOOLS)
   );
-  const executorRef = useRef5(new ToolExecutor(ALL_TOOLS));
-  const activeAsstIdRef = useRef5(null);
-  const sessionScopeRef = useRef5(new AbortScope());
-  const activeScopeRef = useRef5(null);
-  const supervisorRef = useRef5(new TurnSupervisor());
-  const isAbortingRef = useRef5(false);
-  const lastEscapeAtRef = useRef5(0);
-  const sigintHandlerRef = useRef5(null);
-  const limitResolveRef = useRef5(null);
-  const loopResolveRef = useRef5(null);
-  const pendingToolCallsRef = useRef5(/* @__PURE__ */ new Map());
-  const sessionIdRef = useRef5(null);
-  const sessionCreatedAtRef = useRef5(null);
-  const sessionTitleRef = useRef5(null);
-  const modeRef = useRef5(mode);
-  const effortRef = useRef5(effort);
-  const tasksRef = useRef5([]);
-  const usageRef = useRef5(null);
-  const gatewayMetaRef = useRef5(null);
-  const lastApiErrorRef = useRef5(null);
-  const updateCheckedRef = useRef5(false);
-  const sessionStateRef = useRef5(emptySessionState());
-  const artifactStoreRef = useRef5(new ArtifactStore());
-  const compiledContextRef = useRef5(initialCfg?.compiledContext === true);
-  const updateNudgedRef = useRef5(false);
-  const compactSuggestedRef = useRef5(false);
-  const mcpManagerRef = useRef5(new McpManager());
-  const mcpToolsRef = useRef5([]);
-  const mcpInitRef = useRef5(false);
-  const submitRef = useRef5(() => {
+  const executorRef = useRef7(new ToolExecutor(ALL_TOOLS));
+  const activeAsstIdRef = useRef7(null);
+  const sessionScopeRef = useRef7(new AbortScope());
+  const activeScopeRef = useRef7(null);
+  const sigintHandlerRef = useRef7(null);
+  const limitResolveRef = useRef7(null);
+  const loopResolveRef = useRef7(null);
+  const pendingToolCallsRef = useRef7(/* @__PURE__ */ new Map());
+  const modeRef = useRef7(mode);
+  const effortRef = useRef7(effort);
+  const usageRef = useRef7(null);
+  const gatewayMetaRef = useRef7(null);
+  const lastApiErrorRef = useRef7(null);
+  const updateCheckedRef = useRef7(false);
+  const sessionStateRef = useRef7(emptySessionState());
+  const artifactStoreRef = useRef7(new ArtifactStore());
+  const compiledContextRef = useRef7(initialCfg?.compiledContext === true);
+  const updateNudgedRef = useRef7(false);
+  const compactSuggestedRef = useRef7(false);
+  const mcpManagerRef = useRef7(new McpManager());
+  const mcpToolsRef = useRef7([]);
+  const mcpInitRef = useRef7(false);
+  const submitRef = useRef7(() => {
   });
-  const lspManagerRef = useRef5(new LspManager());
-  const lspToolsRef = useRef5([]);
-  const lspInitRef = useRef5(false);
-  const busyRef = useRef5(busy);
-  const memoryManagerRef = useRef5(null);
-  const sessionStartRecallRef = useRef5(null);
-  const kimiMdStaleNudgedRef = useRef5(false);
-  const turnCounterRef = useRef5(0);
-  const pendingTextRef = useRef5(/* @__PURE__ */ new Map());
-  const flushTimeoutRef = useRef5(null);
-  const customCommandsRef = useRef5([]);
-  const recentFilesRef = useRef5(/* @__PURE__ */ new Map());
+  const lspManagerRef = useRef7(new LspManager());
+  const lspToolsRef = useRef7([]);
+  const lspInitRef = useRef7(false);
+  const memoryManagerRef = useRef7(null);
+  const sessionStartRecallRef = useRef7(null);
+  const kimiMdStaleNudgedRef = useRef7(false);
+  const sessionMgr = useSessionManager({
+    cfg,
+    messagesRef,
+    sessionStateRef,
+    artifactStoreRef,
+    compiledContextRef,
+    gatewayMetaRef,
+    memoryManagerRef,
+    setEvents,
+    setHistory,
+    setUsage,
+    setSessionUsage,
+    setGatewayMeta,
+    mkKey
+  });
+  const {
+    sessionIdRef,
+    sessionCreatedAtRef,
+    sessionTitleRef,
+    resumeSessions,
+    setResumeSessions,
+    checkpointSession,
+    setCheckpointSession,
+    checkpointList,
+    ensureSessionId,
+    saveSessionSafe,
+    openResumePicker,
+    doResumeSession,
+    handleResumePick,
+    handleCheckpointPick,
+    resetSession
+  } = sessionMgr;
+  const pendingTextRef = useRef7(/* @__PURE__ */ new Map());
+  const flushTimeoutRef = useRef7(null);
+  const customCommandsRef = useRef7([]);
+  const recentFilesRef = useRef7(/* @__PURE__ */ new Map());
   const MAX_RECENT_FILES = 10;
-  const allSlashCommands = React15.useMemo(() => {
+  const allSlashCommands = React17.useMemo(() => {
     const customs = customCommandsRef.current.filter((c) => !BUILTIN_COMMAND_NAMES.has(c.name.toLowerCase())).map((c) => ({
       name: c.name,
       description: c.description ?? "",
@@ -19107,7 +19557,7 @@ ${wcagWarnings.join("\n")}` }
     return [...BUILTIN_COMMANDS, ...customs];
   }, [customCommandsVersion]);
   const modalActive = commandWizard !== null || commandPicker !== null || commandToDelete !== null || showCommandList || showLspWizard || resumeSessions !== null || checkpointSession !== null || perm !== null || limitModal !== null || loopModal !== null || showInboxModal;
-  const loadFilePickerItems = useCallback6(async () => {
+  const loadFilePickerItems = useCallback8(async () => {
     const cwd = process.cwd();
     const entries = await fg4("**/*", {
       cwd,
@@ -19264,7 +19714,7 @@ ${wcagWarnings.join("\n")}` }
     }, 3e5);
     return () => clearInterval(id);
   }, []);
-  const reloadCustomCommands = useCallback6(async () => {
+  const reloadCustomCommands = useCallback8(async () => {
     const { commands, warnings } = await loadCustomCommands(process.cwd());
     customCommandsRef.current = commands;
     setCustomCommandsVersion((v) => v + 1);
@@ -19391,7 +19841,7 @@ ${wcagWarnings.join("\n")}` }
     }, 30 * 60 * 1e3);
     return () => clearInterval(id);
   }, [cfg]);
-  const initMcp = useCallback6(async () => {
+  const initMcp = useCallback8(async () => {
     if (!cfg?.mcpServers || mcpInitRef.current) return;
     mcpInitRef.current = true;
     const manager = mcpManagerRef.current;
@@ -19456,7 +19906,7 @@ ${wcagWarnings.join("\n")}` }
       ]);
     }
   }, [cfg]);
-  const initLsp = useCallback6(async () => {
+  const initLsp = useCallback8(async () => {
     if (!cfg?.lspEnabled || !cfg?.lspServers || lspInitRef.current) {
       if (lspInitRef.current) return;
       if (!cfg?.lspEnabled) {
@@ -19527,46 +19977,7 @@ ${wcagWarnings.join("\n")}` }
       void initLsp();
     }
   }, [cfg, initMcp, initLsp]);
-  const ensureSessionId = useCallback6(() => {
-    if (sessionIdRef.current) return sessionIdRef.current;
-    const firstUser = messagesRef.current.find((m) => m.role === "user");
-    let firstText = "session";
-    if (typeof firstUser?.content === "string") {
-      firstText = firstUser.content;
-    } else if (Array.isArray(firstUser?.content)) {
-      const textPart = firstUser.content.find((p) => p.type === "text");
-      if (textPart?.text) firstText = textPart.text;
-    }
-    sessionIdRef.current = makeSessionId(firstText);
-    return sessionIdRef.current;
-  }, []);
-  const saveSessionSafe = useCallback6(async () => {
-    if (!cfg) return;
-    ensureSessionId();
-    const now2 = (/* @__PURE__ */ new Date()).toISOString();
-    if (!sessionCreatedAtRef.current) {
-      sessionCreatedAtRef.current = now2;
-    }
-    try {
-      await saveSession({
-        id: sessionIdRef.current,
-        cwd: process.cwd(),
-        model: cfg.model,
-        createdAt: sessionCreatedAtRef.current,
-        updatedAt: now2,
-        title: sessionTitleRef.current ?? void 0,
-        messages: messagesRef.current,
-        sessionState: compiledContextRef.current ? sessionStateRef.current : void 0,
-        artifactStore: serializeArtifactStore(artifactStoreRef.current)
-      });
-    } catch (e) {
-      setEvents((es) => [
-        ...es,
-        { kind: "error", key: mkKey(), text: `session save failed: ${e.message}` }
-      ]);
-    }
-  }, [cfg, ensureSessionId]);
-  const onIterationEnd = useCallback6(
+  const onIterationEnd = useCallback8(
     async (messages, signal) => {
       if (signal.aborted) return messages;
       if (!shouldCompact({ messages })) return messages;
@@ -19644,6 +20055,7 @@ ${wcagWarnings.join("\n")}` }
     },
     [cfg]
   );
+  const interruptDepsRef = useRef7(null);
   useInput10((inputChar, key) => {
     if (key.ctrl && inputChar === "c") {
       logger.info("input:ctrl+c", {
@@ -19653,36 +20065,9 @@ ${wcagWarnings.join("\n")}` }
         hasPerm: hasPendingPermission(),
         hasLimit: limitResolveRef.current !== null
       });
-      const hadPerm = denyPendingPermission();
-      const hadLimit = limitResolveRef.current !== null;
-      const hadLoop = loopResolveRef.current !== null;
-      if (hadLimit) {
-        limitResolveRef.current("stop");
-        limitResolveRef.current = null;
-        setLimitModal(null);
-      }
-      if (hadLoop) {
-        loopResolveRef.current("stop");
-        loopResolveRef.current = null;
-        setLoopModal(null);
-      }
-      if (busyRef.current && activeScopeRef.current && !isAbortingRef.current) {
-        isAbortingRef.current = true;
-        supervisorRef.current.killTurn();
-        activeScopeRef.current.abort("user_stopped");
-        setEvents((e) => [...e, { kind: "info", key: mkKey(), text: "(interrupted)" }]);
-        for (const [toolId] of pendingToolCallsRef.current) {
-          updateTool(toolId, { status: "cancelled" });
-        }
-        pendingToolCallsRef.current.clear();
-        void saveSessionSafe();
-        setTasks([]);
-        setTasksStartedAt(null);
-        setTasksStartTokens(0);
-        tasksRef.current = [];
-      } else if (!hadPerm && !hadLimit && !hadLoop) {
+      const outcome = interruptOrExit(interruptDepsRef.current);
+      if (!outcome.didInterruptTurn && !outcome.hadPermission && !outcome.hadLimit && !outcome.hadLoop) {
         logger.info("input:ctrl+c:exiting");
-        void lspManagerRef.current.stopAll().finally(() => exit());
       }
       return;
     }
@@ -19691,34 +20076,12 @@ ${wcagWarnings.join("\n")}` }
       const modalOpen = perm !== null || limitModal !== null || loopModal !== null || showLspWizard || showCommandList || commandWizard !== null || commandToDelete !== null || resumeSessions !== null || checkpointSession !== null || showThemePicker;
       if (!modalOpen && busyRef.current && activeScopeRef.current && !isAbortingRef.current && now2 - lastEscapeAtRef.current > 500) {
         lastEscapeAtRef.current = now2;
-        isAbortingRef.current = true;
-        supervisorRef.current.killTurn();
-        denyPendingPermission();
-        if (limitResolveRef.current) {
-          limitResolveRef.current("stop");
-          limitResolveRef.current = null;
-          setLimitModal(null);
-        }
-        if (loopResolveRef.current) {
-          loopResolveRef.current("stop");
-          loopResolveRef.current = null;
-          setLoopModal(null);
-        }
-        activeScopeRef.current.abort("user_stopped");
-        setEvents((e) => [...e, { kind: "info", key: mkKey(), text: "(interrupted)" }]);
-        for (const [toolId] of pendingToolCallsRef.current) {
-          updateTool(toolId, { status: "cancelled" });
-        }
-        pendingToolCallsRef.current.clear();
-        setTasks([]);
-        setTasksStartedAt(null);
-        setTasksStartTokens(0);
-        tasksRef.current = [];
+        interruptTurn(interruptDepsRef.current);
         return;
       }
     }
     if (key.ctrl && inputChar === "r") {
-      setShowReasoning((s) => !s);
+      turn.toggleReasoning();
       return;
     }
     if (key.shift && key.tab) {
@@ -19739,35 +20102,15 @@ ${wcagWarnings.join("\n")}` }
       hasLimit: limitResolveRef.current !== null,
       hasLoop: loopResolveRef.current !== null
     });
-    const hadPerm = denyPendingPermission();
-    const hadLimit = limitResolveRef.current !== null;
-    const hadLoop = loopResolveRef.current !== null;
-    if (hadLimit) {
-      limitResolveRef.current("stop");
-      limitResolveRef.current = null;
-      setLimitModal(null);
-    }
-    if (hadLoop) {
-      loopResolveRef.current("stop");
-      loopResolveRef.current = null;
-      setLoopModal(null);
-    }
-    if (busyRef.current && activeScopeRef.current && !isAbortingRef.current) {
-      isAbortingRef.current = true;
-      supervisorRef.current.killTurn();
-      activeScopeRef.current.abort("user_stopped");
-      setEvents((e) => [...e, { kind: "info", key: mkKey(), text: "(interrupted)" }]);
-      void saveSessionSafe();
-      setTasks([]);
-      setTasksStartedAt(null);
-      setTasksStartTokens(0);
-      tasksRef.current = [];
-    } else if (!hadPerm && !hadLimit) {
+    const outcome = interruptOrExit({
+      ...interruptDepsRef.current,
+      skipPendingToolCleanup: true
+    });
+    if (!outcome.didInterruptTurn && !outcome.hadPermission && !outcome.hadLimit && !outcome.hadLoop) {
       logger.info("sigint:handler:exiting");
-      void lspManagerRef.current.stopAll().finally(() => exit());
     }
   };
-  const flushAssistantUpdates = useCallback6(() => {
+  const flushAssistantUpdates = useCallback8(() => {
     flushTimeoutRef.current = null;
     const pending = pendingTextRef.current;
     if (pending.size === 0) return;
@@ -19785,7 +20128,7 @@ ${wcagWarnings.join("\n")}` }
       })
     );
   }, []);
-  const updateAssistant = useCallback6(
+  const updateAssistant = useCallback8(
     (id, patch) => {
       const result = patch({ text: "", reasoning: "" });
       const assistantResult = result;
@@ -19814,7 +20157,7 @@ ${wcagWarnings.join("\n")}` }
     },
     [flushAssistantUpdates]
   );
-  const updateTool = useCallback6(
+  const updateTool = useCallback8(
     (id, patch) => {
       setEvents(
         (evts) => evts.map(
@@ -19824,19 +20167,37 @@ ${wcagWarnings.join("\n")}` }
     },
     []
   );
-  const updateGatewayMeta = useCallback6((meta) => {
+  const updateGatewayMeta = useCallback8((meta) => {
     gatewayMetaRef.current = meta;
     setGatewayMeta(meta);
   }, []);
-  const runCompact = useCallback6(async () => {
+  interruptDepsRef.current = {
+    busyRef,
+    activeScopeRef,
+    isAbortingRef,
+    supervisorRef,
+    limitResolveRef,
+    loopResolveRef,
+    setLimitModal,
+    setLoopModal,
+    hasPendingPermission,
+    denyPendingPermission,
+    pendingToolCallsRef,
+    updateTool,
+    setEvents,
+    mkKey,
+    saveSessionSafe,
+    clearTaskTracking,
+    lspManagerRef,
+    exit
+  };
+  const runCompact = useCallback8(async () => {
     if (!cfg) return;
     if (busy) {
       setEvents((e) => [...e, { kind: "info", key: mkKey(), text: "can't compact while model is running" }]);
       return;
     }
-    setBusy(true);
-    busyRef.current = true;
-    setTurnStartedAt(Date.now());
+    beginTurn();
     const turnScope = sessionScopeRef.current.createChild();
     activeScopeRef.current = turnScope;
     try {
@@ -19911,24 +20272,14 @@ ${wcagWarnings.join("\n")}` }
       }
     } finally {
       logger.info("runCompact:finally");
-      setBusy(false);
-      busyRef.current = false;
-      setTurnStartedAt(null);
-      setTurnPhase("waiting");
-      setCurrentToolName(null);
-      setLastActivityAt(null);
+      endTurn();
       activeScopeRef.current = null;
-      isAbortingRef.current = false;
       clearPermissionResolveRef();
       limitResolveRef.current = null;
       pendingToolCallsRef.current.clear();
     }
   }, [cfg, busy, saveSessionSafe]);
-  const openResumePicker = useCallback6(async () => {
-    const sessions = await listSessions(200, process.cwd());
-    setResumeSessions(sessions);
-  }, []);
-  const runInit = useCallback6(async () => {
+  const runInit = useCallback8(async () => {
     if (!cfg) return;
     if (busy) {
       setEvents((e) => [...e, { kind: "info", key: mkKey(), text: "can't /init while model is running" }]);
@@ -19938,9 +20289,7 @@ ${wcagWarnings.join("\n")}` }
     const { prompt, targetFilename, isRefresh } = buildInitPrompt(cwd);
     setEvents((e) => [...e, { kind: "user", key: mkKey(), text: isRefresh ? `/init (refreshing ${targetFilename})` : "/init" }]);
     messagesRef.current.push({ role: "user", content: sanitizeString(prompt) });
-    setBusy(true);
-    busyRef.current = true;
-    setTurnStartedAt(Date.now());
+    beginTurn();
     const turnScope = sessionScopeRef.current.createChild();
     activeScopeRef.current = turnScope;
     const initClassification = classifyIntent(prompt);
@@ -20207,15 +20556,9 @@ ${wcagWarnings.join("\n")}` }
       setCodeMode(false);
       const asstId = activeAsstIdRef.current;
       if (asstId !== null) updateAssistant(asstId, () => ({ streaming: false }));
-      setBusy(false);
-      busyRef.current = false;
-      setTurnStartedAt(null);
-      setTurnPhase("waiting");
-      setCurrentToolName(null);
-      setLastActivityAt(null);
+      endTurn();
       activeAsstIdRef.current = null;
       activeScopeRef.current = null;
-      isAbortingRef.current = false;
       clearPermissionResolveRef();
       limitResolveRef.current = null;
       loopResolveRef.current = null;
@@ -20223,7 +20566,7 @@ ${wcagWarnings.join("\n")}` }
       pendingToolCallsRef.current.clear();
     }
   }, [cfg, busy, updateAssistant, updateTool, updateGatewayMeta]);
-  const handleThemePick = useCallback6(
+  const handleThemePick = useCallback8(
     (picked) => {
       setShowThemePicker(false);
       if (!picked) return;
@@ -20241,100 +20584,7 @@ ${wcagWarnings.join("\n")}` }
     },
     []
   );
-  const doResumeSession = useCallback6(
-    async (filePath, checkpointId) => {
-      try {
-        const file = checkpointId ? (await loadSessionFromCheckpoint(filePath, checkpointId)).file : await loadSession(filePath);
-        messagesRef.current = file.messages;
-        sessionIdRef.current = file.id;
-        sessionCreatedAtRef.current = file.createdAt;
-        if (file.sessionState && compiledContextRef.current) {
-          sessionStateRef.current = file.sessionState;
-        }
-        if (file.artifactStore) {
-          artifactStoreRef.current = deserializeArtifactStore(file.artifactStore);
-        } else {
-          artifactStoreRef.current = new ArtifactStore();
-        }
-        const manager = memoryManagerRef.current;
-        if (manager) {
-          try {
-            const cwd = process.cwd();
-            const results = await manager.recall({ text: cwd, repoPath: cwd, limit: 5 });
-            if (results.length > 0) {
-              const text = await manager.synthesizeRecalled(results);
-              const lastSystemIdx = messagesRef.current.findLastIndex((m) => m.role === "system");
-              const insertIdx = lastSystemIdx >= 0 ? lastSystemIdx + 1 : messagesRef.current.length;
-              messagesRef.current.splice(insertIdx, 0, { role: "system", content: text });
-            }
-          } catch {
-          }
-        }
-        const msg = checkpointId ? `resumed session ${file.id} from checkpoint` : `resumed session ${file.id} (${file.messages.filter((m) => m.role !== "system").length} msgs)`;
-        setEvents([{ kind: "info", key: mkKey(), text: msg }]);
-        const userMsgs = file.messages.filter((m) => m.role === "user" && m.content).map((m) => {
-          if (!m.content) return "";
-          if (typeof m.content === "string") return m.content;
-          const textPart = m.content.find((p) => p.type === "text");
-          return textPart?.text ?? "";
-        }).filter((text) => text.length > 0);
-        if (userMsgs.length > 0) setHistory(userMsgs);
-        setUsage(null);
-        setSessionUsage(null);
-        gatewayMetaRef.current = null;
-        setGatewayMeta(null);
-        void getCostReport(file.id).then((report) => setSessionUsage(report.session));
-      } catch (e) {
-        setEvents((es) => [
-          ...es,
-          { kind: "error", key: mkKey(), text: `failed to load session: ${e.message}` }
-        ]);
-      }
-    },
-    []
-  );
-  const handleResumePick = useCallback6(
-    async (picked) => {
-      setResumeSessions(null);
-      if (!picked) return;
-      if (picked.checkpointCount > 0) {
-        try {
-          const file = await loadSession(picked.filePath);
-          setCheckpointList(file.checkpoints ?? []);
-          setCheckpointSession(picked);
-        } catch (e) {
-          setEvents((es) => [
-            ...es,
-            { kind: "error", key: mkKey(), text: `failed to load checkpoints: ${e.message}` }
-          ]);
-          await doResumeSession(picked.filePath);
-        }
-        return;
-      }
-      await doResumeSession(picked.filePath);
-    },
-    [doResumeSession]
-  );
-  const handleCheckpointPick = useCallback6(
-    async (checkpointId) => {
-      const session = checkpointSession;
-      setCheckpointSession(null);
-      setCheckpointList([]);
-      if (!session || !checkpointId) {
-        if (session) {
-          setResumeSessions(await listSessions(200, process.cwd()));
-        }
-        return;
-      }
-      if (checkpointId === "__start__") {
-        await doResumeSession(session.filePath);
-        return;
-      }
-      await doResumeSession(session.filePath, checkpointId);
-    },
-    [checkpointSession, doResumeSession]
-  );
-  const handleSlash = useCallback6(
+  const handleSlash = useCallback8(
     (cmd) => {
       const raw = cmd.trim();
       const [head, ...rest] = raw.split(/\s+/);
@@ -20354,11 +20604,7 @@ ${wcagWarnings.join("\n")}` }
         } else {
           messagesRef.current = [messagesRef.current[0]];
         }
-        sessionIdRef.current = null;
-        sessionCreatedAtRef.current = null;
-        sessionTitleRef.current = null;
-        sessionStateRef.current = emptySessionState();
-        artifactStoreRef.current = new ArtifactStore();
+        resetSession();
         executorRef.current.clearArtifacts();
         if (flushTimeoutRef.current) {
           clearTimeout(flushTimeoutRef.current);
@@ -20374,15 +20620,13 @@ ${wcagWarnings.join("\n")}` }
         setSessionUsage(null);
         gatewayMetaRef.current = null;
         setGatewayMeta(null);
-        setTasks([]);
-        setTasksStartedAt(null);
-        setTasksStartTokens(0);
+        clearTaskTracking();
         compactSuggestedRef.current = false;
         updateNudgedRef.current = false;
         return true;
       }
       if (c === "/reasoning") {
-        setShowReasoning((s) => {
+        turn.setShowReasoning((s) => {
           const next = !s;
           setEvents((e) => [
             ...e,
@@ -21341,7 +21585,7 @@ ${lines.join("\n")}` }]);
     },
     [cfg, exit, usage, theme, mode, openResumePicker, runCompact, runInit, initMcp, setCfg, setShowRemoteDashboard, setSelectedRemoteSession]
   );
-  const handleCommandSave = useCallback6(
+  const handleCommandSave = useCallback8(
     async (opts2) => {
       setCommandWizard(null);
       try {
@@ -21363,7 +21607,7 @@ ${lines.join("\n")}` }]);
     },
     [commandWizard, reloadCustomCommands, setEvents]
   );
-  const handleCommandDelete = useCallback6(
+  const handleCommandDelete = useCallback8(
     async (cmd) => {
       setCommandToDelete(null);
       try {
@@ -21382,7 +21626,7 @@ ${lines.join("\n")}` }]);
     },
     [reloadCustomCommands, setEvents, setCommandToDelete]
   );
-  const handleLspSave = useCallback6(
+  const handleLspSave = useCallback8(
     (servers, enabled, scope) => {
       setCfg((c) => c ? { ...c, lspEnabled: enabled, lspServers: servers } : c);
       setLspScope(scope);
@@ -21411,7 +21655,7 @@ ${lines.join("\n")}` }]);
     },
     [cfg, setCfg, setEvents, setShowLspWizard]
   );
-  const handleRemoteCancel = useCallback6(
+  const handleRemoteCancel = useCallback8(
     async (session) => {
       try {
         const { cancelRemoteSession: cancelRemoteSession2 } = await Promise.resolve().then(() => (init_worker_client(), worker_client_exports));
@@ -21431,7 +21675,7 @@ ${lines.join("\n")}` }]);
     },
     [setEvents, setShowRemoteDashboard]
   );
-  const processMessage = useCallback6(
+  const processMessage = useCallback8(
     async (text, displayText, opts2) => {
       if (!cfg) return;
       let trimmed = text.trim();
@@ -21534,11 +21778,9 @@ ${lines.join("\n")}` }]);
           { kind: "info", key: mkKey(), text: "Tip: Rerunning /init occasionally helps KimiFlare stay accurate as your project evolves." }
         ]);
       }
-      setBusy(true);
-      busyRef.current = true;
+      beginTurn();
       gatewayMetaRef.current = null;
       setGatewayMeta(null);
-      setTurnStartedAt(Date.now());
       const classification = classifyIntent(trimmed);
       setIntentTier(classification.tier);
       if (!sessionTitleRef.current) {
@@ -21716,24 +21958,15 @@ ${lines.join("\n")}` }]);
         setCodeMode(false);
         const asstId = activeAsstIdRef.current;
         if (asstId !== null) updateAssistant(asstId, () => ({ streaming: false }));
-        setBusy(false);
-        busyRef.current = false;
-        setTurnStartedAt(null);
-        setTurnPhase("waiting");
-        setCurrentToolName(null);
-        setLastActivityAt(null);
+        endTurn();
         activeAsstIdRef.current = null;
         activeScopeRef.current = null;
-        isAbortingRef.current = false;
         clearPermissionResolveRef();
         limitResolveRef.current = null;
         loopResolveRef.current = null;
         setLoopModal(null);
         pendingToolCallsRef.current.clear();
-        setTasks([]);
-        setTasksStartedAt(null);
-        setTasksStartTokens(0);
-        tasksRef.current = [];
+        clearTaskTracking();
         setEvents(
           (evts) => evts.map((e) => e.kind === "tool" && e.status === "running" ? { ...e, status: "error", result: "(stopped)" } : e)
         );
@@ -21955,7 +22188,7 @@ ${lines.join("\n")}` }]);
       processMessage(next.full, next.display, { queuedKey: next.key });
     }
   }, [busy, queue, processMessage]);
-  const submit = useCallback6(
+  const submit = useCallback8(
     (full, display) => {
       const trimmedFull = full.trim();
       if (!trimmedFull) return;
@@ -22210,7 +22443,6 @@ var init_app = __esm({
   "src/app.tsx"() {
     "use strict";
     init_loop();
-    init_supervisor();
     init_system_prompt();
     init_llm_summarize();
     init_artifact_compaction();
@@ -22268,6 +22500,9 @@ var init_app = __esm({
     init_use_picker_controller();
     init_use_modal_host();
     init_modal_host();
+    init_use_session_manager();
+    init_use_turn_controller();
+    init_input_handlers();
     MAX_GITIGNORE_SIZE = 1 * 1024 * 1024;
     FEEDBACK_WORKER_URL2 = "https://hello.kimiflare.com";
     CONTEXT_LIMIT = 262e3;