@kkelly-offical/kkcode 0.1.6 → 0.1.7

package/src/session/longagent-hybrid.mjs

@@ -457,6 +457,7 @@ export async function runHybridLongAgent({
     "### Preview Findings", previewFindings.slice(0, 2000), "",
     "### Blueprint Architecture", architectureText.slice(0, 3000)
   ].join("\n")
+  const seenFilePaths = new Set() // #3 去重：跨阶段文件路径去重
 
   let codingRollbackCount = 0
   const maxCodingRollbacks = Number(hybridConfig.max_coding_rollbacks || 2)
@@ -499,10 +500,17 @@ export async function runHybridLongAgent({
         stage.tasks.map(t => [t.taskId, taskProgress[t.taskId]]).filter(([, v]) => Boolean(v))
       )
 
+      // #4 计划锚点 — 每阶段动态构建，不存入 priorContext 避免被压缩掉
+      const stageStatuses = stagePlan.stages.map((s, i) => {
+        const marker = i < stageIndex ? "✓" : i === stageIndex ? "→" : " "
+        return `[${marker}] 阶段${i + 1}: ${s.name || s.stageId}`
+      }).join("\n")
+      const planAnchor = `## 计划锚点\n目标: ${stagePlan.objective || prompt}\n进度: ${stageIndex + 1}/${stagePlan.stages.length}\n${stageStatuses}\n\n`
+
       const stageResult = await runStageBarrier({
         stage, sessionId, config: configState.config, model, providerType,
         seedTaskProgress: seeded, objective: prompt,
-        stageIndex, stageCount: stagePlan.stages.length, priorContext,
+        stageIndex, stageCount: stagePlan.stages.length, priorContext: planAnchor + priorContext,
         stuckTracker,
         onTaskComplete: async (taskData) => {
           await saveTaskCheckpoint(sessionId, taskData.stageId, taskData.taskId, taskData)
@@ -536,12 +544,19 @@ export async function runHybridLongAgent({
         successCount: stageResult.successCount, failCount: stageResult.failCount
       }
 
-      // 知识传递
+      // #1 阶段级压缩 + #3 文件去重 — 结构化摘要，跨阶段去重文件路径
       const taskSummaries = Object.values(stageResult.taskProgress || {})
         .filter(t => t.lastReply)
-        .map(t => `[${t.taskId}] ${t.status}: ${t.lastReply.slice(0, 300)}`)
-      if (taskSummaries.length) {
-        priorContext += `\n### Stage ${stageIndex + 1}: ${stage.name || stage.stageId} (${stageResult.allSuccess ? "PASS" : "FAIL"})\n${taskSummaries.join("\n")}\n`
+        .map(t => `  - [${t.taskId}] ${t.status}: ${t.lastReply.slice(0, 250)}`)
+      const stageFiles = (stageResult.fileChanges || [])
+        .map(f => (typeof f === "string" ? f : (f.path || f.file || "")))
+        .filter(Boolean)
+      const newFiles = stageFiles.filter(f => !seenFilePaths.has(f))
+      newFiles.forEach(f => seenFilePaths.add(f))
+      if (taskSummaries.length || newFiles.length) {
+        const fileNote = newFiles.length ? `\n  新增/修改文件: ${newFiles.join(", ")}` : ""
+        const failNote = !stageResult.allSuccess ? ` 失败任务数: ${stageResult.failCount}` : ""
+        priorContext += `\n### 阶段${stageIndex + 1}: ${stage.name || stage.stageId} (${stageResult.allSuccess ? "PASS" : "FAIL"}${failNote})\n${taskSummaries.join("\n")}${fileNote}\n`
       }
       // #4 TaskBus 注入到 priorContext
       if (taskBus) {
@@ -665,6 +680,7 @@ export async function runHybridLongAgent({
       }
 
       stageIndex++
+      recoveryCount = 0  // reset per-stage recovery counter after successful stage
       await saveCheckpoint(sessionId, { name: `hybrid_stage_${stage.stageId}`, iteration, currentPhase, stageIndex, stagePlan, taskProgress, planFrozen, lastProgress })
     }
 

package/src/session/longagent.mjs

@@ -357,6 +357,7 @@ async function runParallelLongAgent({
   // --- End L1.5 ---
 
   let priorContext = ""
+  const seenFilePaths = new Set() // #3 去重：跨阶段文件路径去重，避免 priorContext 重复提及
 
   while (stageIndex < stagePlan.stages.length) {
     const state = await LongAgentManager.get(sessionId)
@@ -411,6 +412,13 @@ async function runParallelLongAgent({
         .filter(([, value]) => Boolean(value))
     )
 
+    // #4 计划锚点 — 每个阶段执行前重建，确保模型始终看到完整计划和当前进度
+    const stageStatuses = stagePlan.stages.map((s, i) => {
+      const marker = i < stageIndex ? "✓" : i === stageIndex ? "→" : " "
+      return `[${marker}] 阶段${i + 1}: ${s.name || s.stageId}`
+    }).join("\n")
+    const planAnchor = `## 计划锚点\n目标: ${stagePlan.objective || prompt}\n进度: ${stageIndex + 1}/${stagePlan.stages.length}\n${stageStatuses}\n\n`
+
     const stageResult = await runStageBarrier({
       stage,
       sessionId,
@@ -421,7 +429,7 @@ async function runParallelLongAgent({
       objective: prompt,
       stageIndex,
       stageCount: stagePlan.stages.length,
-      priorContext
+      priorContext: planAnchor + priorContext
     })
 
     for (const [taskId, progress] of Object.entries(stageResult.taskProgress || {})) {
@@ -446,12 +454,19 @@ async function runParallelLongAgent({
       remainingFiles: stageResult.remainingFiles
     }
 
-    // Build inter-stage knowledge transfer summary
+    // #1 阶段级压缩 + #3 去重 — 结构化阶段摘要，文件路径跨阶段去重
     const taskSummaries = Object.values(stageResult.taskProgress || {})
       .filter(t => t.lastReply)
-      .map(t => `[${t.taskId}] ${t.status}: ${t.lastReply.slice(0, 300)}`)
-    if (taskSummaries.length) {
-      priorContext += `### Stage ${stageIndex + 1}: ${stage.name || stage.stageId} (${stageResult.allSuccess ? "PASS" : "FAIL"})\n${taskSummaries.join("\n")}\n\n`
+      .map(t => `  - [${t.taskId}] ${t.status}: ${t.lastReply.slice(0, 250)}`)
+    const stageFiles = (stageResult.fileChanges || [])
+      .map(f => (typeof f === "string" ? f : (f.path || f.file || "")))
+      .filter(Boolean)
+    const newFiles = stageFiles.filter(f => !seenFilePaths.has(f))
+    newFiles.forEach(f => seenFilePaths.add(f))
+    if (taskSummaries.length || newFiles.length) {
+      const fileNote = newFiles.length ? `\n  新增/修改文件: ${newFiles.join(", ")}` : ""
+      const failNote = !stageResult.allSuccess ? `\n  失败任务数: ${stageResult.failCount}` : ""
+      priorContext += `### 阶段${stageIndex + 1}: ${stage.name || stage.stageId} (${stageResult.allSuccess ? "PASS" : "FAIL"})${failNote}\n${taskSummaries.join("\n")}${fileNote}\n\n`
     }
 
     lastProgress = {
@@ -557,6 +572,7 @@ async function runParallelLongAgent({
     }
 
     stageIndex += 1
+    recoveryCount = 0  // reset per-stage recovery counter after successful stage
     // Always checkpoint after each stage for reliable recovery
     await saveCheckpoint(sessionId, {
       name: `stage_${stage.stageId}`,

package/src/session/loop.mjs

@@ -29,8 +29,11 @@ import { saveCheckpoint } from "./checkpoint.mjs"
 import { askPlanApproval } from "../tool/question-prompt.mjs"
 import { createValidator } from "./task-validator.mjs"
 
+// Max chars kept in active context per tool_result — process output beyond this is truncated
+const TOOL_RESULT_ACTIVE_LIMIT = 3000
+
 const READ_ONLY_TOOLS = new Set([
-  "read", "glob", "grep", "list", "webfetch", "websearch", "codesearch", "background_output", "todowrite", "enter_plan", "exit_plan"
+  "read", "glob", "grep", "list", "webfetch", "websearch", "codesearch", "background_output", "todowrite", "enter_plan"
 ])
 
 function addUsage(target, delta) {
@@ -534,9 +537,16 @@ export async function processTurnLoop({
             ? `\n被截断的工具调用: ${truncatedToolNames}。请完整重新发起这些工具调用。如果是创建大文件，使用 write(mode="append") 分段追加；如果是修改已有文件的局部内容，使用 patch 按行号范围替换。`
             : `\nTruncated tool calls: ${truncatedToolNames}. Re-issue these tool calls completely. For large file creation, use write(mode="append") to append in chunks. For modifying sections of existing files, use patch to replace by line range.`)
           : ""
+        // Anchor: last 200 chars of truncated text so model knows exactly where to resume
+        const textTail = response.text ? response.text.slice(-200) : ""
+        const anchorHint = textTail
+          ? (language === "zh"
+            ? `\n[锚点] 上次输出末尾：...${textTail}`
+            : `\n[Anchor] Last output ended with: ...${textTail}`)
+          : ""
         const continuePrompt = language === "zh"
-          ? `[输出被截断 ${continueCount}/${MAX_CONTINUES}] 你的上一条回复在输出 token 上限处被截断。请从你停止的地方精确继续，不要重复已经写过的内容。如果你正在执行工具调用，请完整重新发起。${toolHint}`
-          : `[OUTPUT TRUNCATED ${continueCount}/${MAX_CONTINUES}] Your previous response was cut off at the output token limit. Continue EXACTLY from where you stopped. Do not repeat any content you already wrote. If you were in the middle of a tool call, re-issue it completely.${toolHint}`
+          ? `[输出被截断 ${continueCount}/${MAX_CONTINUES}] 你的上一条回复在输出 token 上限处被截断。请从你停止的地方精确继续，不要重复已经写过的内容。如果你正在执行工具调用，请完整重新发起。${toolHint}${anchorHint}`
+          : `[OUTPUT TRUNCATED ${continueCount}/${MAX_CONTINUES}] Your previous response was cut off at the output token limit. Continue EXACTLY from where you stopped. Do not repeat any content you already wrote. If you were in the middle of a tool call, re-issue it completely.${toolHint}${anchorHint}`
         await appendMessage(sessionId, "user", continuePrompt,
           { mode, model, providerType, step, turnId, synthetic: true }
         )
@@ -642,42 +652,51 @@ export async function processTurnLoop({
             }
           }
 
-          await PermissionEngine.check({
-            config: configState.config,
-            sessionId,
-            tool: call.name,
-            mode,
-            pattern,
-            command,
-            risk,
-            reason: `tool call from model at step ${step}`
-          })
+          // Plan mode enforcement: block write tools when _planMode is active
+          if (toolContext._planMode && !READ_ONLY_TOOLS.has(call.name) && call.name !== "exit_plan") {
+            result = {
+              name: call.name,
+              status: "error",
+              output: `[PLAN MODE] Cannot execute '${call.name}' in plan mode. Finish your plan outline and call exit_plan to present it for user approval.`
+            }
+          } else {
+            await PermissionEngine.check({
+              config: configState.config,
+              sessionId,
+              tool: call.name,
+              mode,
+              pattern,
+              command,
+              risk,
+              reason: `tool call from model at step ${step}`
+            })
 
-          const tool = await ToolRegistry.get(call.name)
-          result = !tool
-            ? {
-                name: call.name,
-                status: "error",
-                output: `unknown tool: ${call.name}`,
-                error: `unknown tool: ${call.name}`
-              }
-            : await executeTool({
-                tool,
-                args: call.args,
-                sessionId,
-                turnId,
-                context: {
-                  cwd,
-                  mode,
-                  delegateTask,
-                  signal,
+            const tool = await ToolRegistry.get(call.name)
+            result = !tool
+              ? {
+                  name: call.name,
+                  status: "error",
+                  output: `unknown tool: ${call.name}`,
+                  error: `unknown tool: ${call.name}`
+                }
+              : await executeTool({
+                  tool,
+                  args: call.args,
                   sessionId,
                   turnId,
-                  config: configState.config,
-                  ...toolContext
-                },
-                signal
-              })
+                  context: {
+                    cwd,
+                    mode,
+                    delegateTask,
+                    signal,
+                    sessionId,
+                    turnId,
+                    config: configState.config,
+                    ...toolContext
+                  },
+                  signal
+                })
+          }
         } catch (error) {
           result = {
             name: call.name,
@@ -700,8 +719,10 @@ export async function processTurnLoop({
           result = {
             ...result,
             output: approval.approved
-              ? "User APPROVED the plan. Proceed with implementation."
-              : `User REJECTED the plan. Feedback: ${approval.feedback || "no feedback provided"}`,
+              ? "User APPROVED the plan. Proceed with implementation immediately."
+              : approval.requestChanges
+                ? `User requested changes to the plan. Feedback: ${approval.feedback || "no specific feedback"}. Revise your plan and call exit_plan again with the updated plan.`
+                : `User REJECTED the plan. Feedback: ${approval.feedback || "no feedback provided"}. Do not proceed — the plan has been cancelled.`,
             metadata: { ...result.metadata, planApprovalResult: approval }
           }
         }
@@ -798,15 +819,19 @@ export async function processTurnLoop({
       })
 
       // User message: tool_result blocks (one per tool call, in order)
+      // Process output beyond TOOL_RESULT_ACTIVE_LIMIT is truncated to keep context lean
       const resultContent = []
       for (const call of response.toolCalls) {
         const entry = callResults.get(call.id)
-        const output = entry?.result?.output || ""
+        const rawOutput = entry?.result?.output || ""
         const isError = entry?.result?.status === "error"
+        const content = rawOutput.length > TOOL_RESULT_ACTIVE_LIMIT
+          ? `${rawOutput.slice(0, TOOL_RESULT_ACTIVE_LIMIT)}\n[...过程输出已截断，共 ${rawOutput.length} 字符，仅保留前 ${TOOL_RESULT_ACTIVE_LIMIT} 字符]`
+          : rawOutput
         resultContent.push({
           type: "tool_result",
           tool_use_id: call.id,
-          content: output,
+          content,
           is_error: isError
         })
       }

package/src/session/prompt/agent.txt

@@ -0,0 +1,25 @@
+Agent mode active. Full tool access enabled.
+
+## When to use plan mode first
+
+Call enter_plan PROACTIVELY before making changes when ANY of these apply:
+- Task requires changes to 3+ files
+- Multiple valid implementation approaches exist
+- Architectural decisions need user input
+- The user hasn't specified implementation details
+- The task involves refactoring, new features, or system-level changes
+
+Simple tasks can proceed directly without planning:
+- Single-file bug fix with clear solution
+- Typo or minor text correction
+- Adding one small function with clear requirements
+
+## Plan → Execute flow
+
+1. Call enter_plan (reason: why planning is needed)
+2. Explore the codebase to understand the context (read, glob, grep)
+3. Outline your complete plan in your response text
+4. Call exit_plan(plan, files) to present it for user approval
+5. If approved: proceed with implementation immediately
+6. If changes requested: revise and call exit_plan again
+7. If rejected: stop and ask the user what they want instead

package/src/session/prompt/plan.txt

@@ -1,9 +1,31 @@
-Plan mode active.
-
-Return:
-1. goal summary
-2. implementation steps
-3. files to edit
-4. validation checklist
-
-Do not execute mutation actions in this mode.
+Plan mode active.
+
+## Your task
+Create a detailed implementation plan. Do NOT execute any file mutations, bash commands, or write operations in this mode.
+
+## Required plan format
+
+1. **Goal**: Clear statement of what will be accomplished
+2. **Approach**: High-level strategy and key architectural decisions
+3. **Implementation steps**: Numbered, specific, actionable steps
+4. **Files to create/modify**: List each file with the specific change description
+5. **Validation checklist**: How to verify the implementation is correct (tests, syntax checks, manual steps)
+
+## Quality criteria
+- Each step must be specific enough to execute without ambiguity
+- Include file paths, function names, and line numbers where relevant
+- Identify dependencies between steps (step N must complete before step M)
+- Flag risks, trade-offs, or alternative approaches considered
+- Estimate complexity: simple / medium / complex
+
+## Allowed actions in plan mode
+- Read files (read, glob, grep)
+- Search the web (websearch, codesearch)
+- Explore the codebase to gather information
+
+## After creating your plan
+Call exit_plan with the complete plan text and the list of files to modify.
+The user will then choose:
+- **Approve** → you proceed with implementation immediately
+- **Request Changes** → you revise the plan and call exit_plan again
+- **Reject** → the plan is cancelled, do not proceed

package/src/session/rollback.mjs

@@ -0,0 +1,196 @@
+import { isGitRepo } from "../util/git.mjs"
+import { getLatestGhostCommit, listGhostCommits } from "../storage/ghost-commit-store.mjs"
+import { restoreGhostCommit } from "../util/git.mjs"
+import { askQuestionInteractive } from "../tool/question-prompt.mjs"
+import { EventBus } from "../core/events.mjs"
+import { EVENT_TYPES } from "../core/constants.mjs"
+
+/**
+ * 回溯意图检测关键词
+ * 分为中文和英文两组，按置信度排序
+ */
+const ROLLBACK_PATTERNS = [
+  // 高置信度 — 明确的回退指令（中文不用 \b，英文保留）
+  { pattern: /(回退|撤销|撤回|回滚|还原)/i, confidence: 0.9 },
+  { pattern: /\b(undo|rollback|revert)\b/i, confidence: 0.9 },
+  // 中置信度 — 需要上下文
+  { pattern: /(恢复到|恢复之前|回到之前|退回|取消(刚才|上次|之前)的(修改|更改|变更|操作))/i, confidence: 0.8 },
+  { pattern: /\b(restore previous|go back|undo (last|previous|recent))\b/i, confidence: 0.8 },
+  // 低置信度 — 可能是回退也可能不是
+  { pattern: /(不要了|算了不改了|改回去|恢复原样)/i, confidence: 0.7 }
+]
+
+/**
+ * 检测用户消息中的回溯意图
+ * @param {string} text - 用户输入文本
+ * @returns {{ isRollback: boolean, confidence: number, matchedPattern: string }}
+ */
+export function detectRollbackIntent(text) {
+  if (!text || typeof text !== "string") {
+    return { isRollback: false, confidence: 0, matchedPattern: "" }
+  }
+
+  const normalized = text.trim().toLowerCase()
+  // 过短的消息不太可能是回退指令（除非就是 "undo" 这样的单词）
+  if (normalized.length > 200) {
+    return { isRollback: false, confidence: 0, matchedPattern: "" }
+  }
+
+  for (const { pattern, confidence } of ROLLBACK_PATTERNS) {
+    const match = normalized.match(pattern)
+    if (match) {
+      return { isRollback: true, confidence, matchedPattern: match[0] }
+    }
+  }
+
+  return { isRollback: false, confidence: 0, matchedPattern: "" }
+}
+
+/**
+ * 向用户确认是否执行回滚，并展示可用快照
+ * @returns {{ confirmed: boolean, snapshotId: string|null, message: string }}
+ */
+export async function confirmRollback({ cwd, language = "en" }) {
+  const inGit = await isGitRepo(cwd)
+  if (!inGit) {
+    return {
+      confirmed: false,
+      snapshotId: null,
+      message: language === "zh"
+        ? "当前目录不是 Git 仓库，无法执行代码回滚。"
+        : "Not a git repository — cannot rollback code changes."
+    }
+  }
+
+  const latest = await getLatestGhostCommit(cwd)
+  if (!latest) {
+    return {
+      confirmed: false,
+      snapshotId: null,
+      message: language === "zh"
+        ? "没有找到可用的快照。本次会话尚未创建任何代码快照，无法回滚。"
+        : "No snapshots found. No code snapshots were created in this session."
+    }
+  }
+
+  const snapDate = new Date(latest.createdAt).toLocaleString()
+  const fileCount = latest.files?.length || 0
+  const shortHash = latest.commitHash?.slice(0, 8) || "unknown"
+
+  const zhWarning = [
+    `找到最近的快照: ${shortHash} (${snapDate})`,
+    `包含 ${fileCount} 个文件: ${(latest.files || []).slice(0, 5).join(", ")}${fileCount > 5 ? " ..." : ""}`,
+    "",
+    "⚠ 注意: 回滚只能恢复文件变更。已执行的 bash 命令（如安装依赖、删除文件等）无法自动撤销。"
+  ].join("\n")
+
+  const enWarning = [
+    `Latest snapshot: ${shortHash} (${snapDate})`,
+    `Contains ${fileCount} file(s): ${(latest.files || []).slice(0, 5).join(", ")}${fileCount > 5 ? " ..." : ""}`,
+    "",
+    "Warning: Rollback only restores file changes. Bash commands (installs, deletions, etc.) cannot be undone."
+  ].join("\n")
+
+  const answers = await askQuestionInteractive({
+    questions: [{
+      id: "rollback_confirm",
+      text: language === "zh" ? "确认回滚代码？" : "Confirm code rollback?",
+      description: language === "zh" ? zhWarning : enWarning,
+      options: [
+        {
+          label: language === "zh" ? "确认回滚" : "Confirm rollback",
+          value: "yes",
+          description: language === "zh"
+            ? "恢复文件到快照状态"
+            : "Restore files to snapshot state"
+        },
+        {
+          label: language === "zh" ? "取消" : "Cancel",
+          value: "no",
+          description: language === "zh"
+            ? "不执行回滚，继续当前对话"
+            : "Skip rollback, continue conversation"
+        }
+      ],
+      allowCustom: false
+    }]
+  })
+
+  const answer = String(answers.rollback_confirm || "").toLowerCase().trim()
+  const confirmed = ["yes", "confirm", "确认回滚", "1"].includes(answer)
+
+  return {
+    confirmed,
+    snapshotId: confirmed ? latest.id : null,
+    commitHash: confirmed ? latest.commitHash : null,
+    message: confirmed
+      ? (language === "zh" ? `正在回滚到快照 ${shortHash}...` : `Rolling back to snapshot ${shortHash}...`)
+      : (language === "zh" ? "已取消回滚。" : "Rollback cancelled.")
+  }
+}
+
+/**
+ * 执行代码回滚
+ * @returns {{ ok: boolean, message: string }}
+ */
+export async function executeRollback({ cwd, commitHash, sessionId, language = "en" }) {
+  try {
+    const result = await restoreGhostCommit(cwd, commitHash, false)
+    if (!result.ok) {
+      return {
+        ok: false,
+        message: language === "zh"
+          ? `回滚失败: ${result.error}`
+          : `Rollback failed: ${result.error}`
+      }
+    }
+
+    await EventBus.emit({
+      type: EVENT_TYPES.TURN_STEP_FINISH,
+      sessionId,
+      payload: { action: "rollback", commitHash }
+    })
+
+    return {
+      ok: true,
+      message: language === "zh"
+        ? `已成功回滚到快照 ${commitHash.slice(0, 8)}。文件已恢复，但已执行的 bash 命令无法撤销。`
+        : `Rolled back to snapshot ${commitHash.slice(0, 8)}. Files restored, but executed bash commands cannot be undone.`
+    }
+  } catch (err) {
+    return {
+      ok: false,
+      message: language === "zh"
+        ? `回滚异常: ${err.message}`
+        : `Rollback error: ${err.message}`
+    }
+  }
+}
+
+/**
+ * 完整的回溯流程：检测 → 确认 → 执行
+ * 在 loop.mjs 的 processTurnLoop 入口调用
+ *
+ * @returns {{ handled: boolean, reply: string }}
+ *   handled=true 表示消息已被回溯流程处理，不需要再发给模型
+ */
+export async function handleRollbackIfNeeded({ prompt, cwd, sessionId, language = "en" }) {
+  const intent = detectRollbackIntent(prompt)
+  if (!intent.isRollback) {
+    return { handled: false, reply: "" }
+  }
+
+  const confirmation = await confirmRollback({ cwd, language })
+  if (!confirmation.confirmed) {
+    return { handled: true, reply: confirmation.message }
+  }
+
+  const result = await executeRollback({
+    cwd,
+    commitHash: confirmation.commitHash,
+    sessionId,
+    language
+  })
+
+  return { handled: true, reply: result.message }
+}

package/src/session/store.mjs

@@ -222,7 +222,7 @@ export async function touchSession({
       model,
       providerType,
       cwd,
-      title: title || existing?.title || `${mode}:${model}`,
+      title: existing?.title || title || `${mode}:${model}`,
       status,
       parentSessionId: parentSessionId || existing?.parentSessionId || null,
       forkFrom: forkFrom || existing?.forkFrom || null,
@@ -326,9 +326,18 @@ export async function getConversationHistory(sessionId, limit = 30) {
   return withLock(async () => {
     await ensureLoadedUnsafe()
     const data = await loadSessionDataUnsafe(sessionId)
-    return data.messages.slice(-limit).map((msg) => ({
+    const msgs = data.messages
+    // Always preserve compaction summary (first message) — it must never be sliced off
+    // by the limit window, otherwise the model loses all prior context
+    const firstIsCompaction = msgs.length > 0 &&
+      typeof msgs[0].content === "string" &&
+      msgs[0].content.includes("<compaction-summary>")
+    const sliced = firstIsCompaction
+      ? [msgs[0], ...msgs.slice(1).slice(-limit)]
+      : msgs.slice(-limit)
+    return sliced.map((msg) => ({
       role: msg.role,
-      content: msg.content // preserves array content blocks (images) as-is
+      content: msg.content
     }))
   })
 }