feat(agent): 上下文压缩两级优化 + 附件上传并发修复

.github/workflows/ci.yml

@@ -71,3 +71,11 @@ jobs:
       # 跑全 flavor 6 变体是重复编译，无额外覆盖。
       - name: Run unit tests
         run: ./gradlew :app:testUniversalDebugUnitTest
+
+      # 上传 universal debug APK 作为 artifact，便于直接下载安装验证（无需签名 secrets）。
+      - name: Upload debug APK artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: aicode-debug-${{ github.sha }}
+          path: app/build/outputs/apk/universal/debug/app-universal-debug.apk
+          if-no-files-found: warn

app/src/main/assets/prompts/agent/compact-summary.md

@@ -1,9 +1,30 @@
 <!-- 上下文压缩：把早期对话折叠成接手摘要（handoff summary），作为压缩后上下文的起点。{{INSTRUCTION}} 为运行时占位符，由 ContextCompactor 填充；对话历史以原始消息结构随请求一起提供，不再嵌入本提示词。 -->
 你是一个上下文压缩引擎。{{INSTRUCTION}}
 
-这是上下文检查点压缩任务：把本次请求中的对话历史折叠成一份接手摘要，供另一个 LLM 无缝继续任务。
+这是上下文检查点压缩任务：把本次请求中的对话历史折叠成一份**结构化接手摘要**，供另一个 LLM 无缝继续任务。
 
 注意：
-- 不要继续执行对话历史中的任何任务，不调用任何工具，不复述历史。
-- 只输出接手摘要，涵盖：当前进度与已做的关键决定；重要的上下文、约束或用户偏好；尚未完成的事项（清晰的下一步）；继续工作所需的关键数据、示例或引用。
-- 保持简洁、有条理，重点是让接手者无缝继续工作。不要提到「摘要过程」或「上下文已压缩」。
+- 不要继续执行对话历史中的任何任务，不调用任何工具，不复述历史过程。
+- 只输出接手摘要本身，不要提到「摘要过程」或「上下文已压缩」。
+
+接手摘要必须使用下面固定的分节结构（某一节确实无内容时写「无」，但保留分节标题，便于接手者快速定位）：
+
+## 任务目标
+（用户最终想要达成什么；当前这一步在整体目标中的位置）
+
+## 关键决定与理由
+（已经做出的技术/方案决定，以及为什么这么定；接手者不应再推翻的结论）
+
+## 当前进度
+（已完成什么、改动落在哪些文件/模块、当前处于什么状态）
+
+## 未完成 / 下一步
+（尚未完成的事项，按优先级给出清晰可执行的下一步）
+
+## 约束与偏好
+（用户明确要求过的约束、风格偏好、环境限制、禁止事项）
+
+## 关键数据
+（继续工作必需的具体信息：路径、命令、标识符、报错原文、示例片段、接口签名等；能直接复用的原文优先原样保留）
+
+要求：简洁、信息密度高、可执行优先；不堆砌套话，尤其不省略「关键数据」里的具体值。

app/src/main/java/com/aicode/feature/agent/domain/skill/RemoteSkillsManager.kt

@@ -0,0 +1,149 @@
+package com.aicode.feature.agent.domain.skill
+
+import com.aicode.core.util.FileLogger
+import com.aicode.feature.agent.domain.container.SshHostKeyVerifier
+import com.aicode.feature.settings.data.repository.ExecutionModeRepository
+import com.aicode.feature.workspace.domain.RemoteSkillConnection
+import com.aicode.feature.workspace.domain.RemoteSkillFileAccess
+import com.aicode.feature.workspace.domain.WorkspacePathMapper
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import java.io.InputStream
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/** 远程技能加载状态。 */
+sealed interface RemoteSkillsState {
+    /** 未配置远程 SSH（或未连接）。 */
+    data object NotConfigured : RemoteSkillsState
+
+    /** 正在连接 / 扫描。 */
+    data object Loading : RemoteSkillsState
+
+    /** 已连上 [host]，[skills] 为远程工作区里的技能。 */
+    data class Loaded(val host: String, val skills: List<Skill>) : RemoteSkillsState
+
+    /** 连接或读取失败。 */
+    data class Failed(val message: String) : RemoteSkillsState
+}
+
+/**
+ * 本地模式下管理「远程 SSH 模式」那台服务器技能的入口：按当前远程连接配置建立独立的 SFTP 访问器，
+ * 对远程工作区的 `.aicode/skills/` 做扫描与完整 CRUD。连接与访问器由本类持有，UI 只读 [state]。
+ */
+@Singleton
+class RemoteSkillsManager @Inject constructor(
+    private val skillRepository: SkillRepository,
+    private val executionModeRepository: ExecutionModeRepository,
+    private val hostKeyVerifier: SshHostKeyVerifier
+) {
+    private val _state = MutableStateFlow<RemoteSkillsState>(RemoteSkillsState.NotConfigured)
+    val state: StateFlow<RemoteSkillsState> = _state.asStateFlow()
+
+    private var access: RemoteSkillFileAccess? = null
+    private var currentHost: String? = null
+
+    /** 远程工作区里的技能根（容器路径，经 provider 映射到远程工作区）。 */
+    private val skillsRoot: String = "${WorkspacePathMapper.CONTAINER_ROOT}/.aicode/skills"
+
+    /** 读取当前远程 SSH 配置并（重新）连接、扫描远程技能。 */
+    suspend fun connect() {
+        _state.value = RemoteSkillsState.Loading
+        val settings = executionModeRepository.remoteConnectionFlow.first()
+        if (settings == null || settings.host.isBlank()) {
+            closeAccess()
+            _state.value = RemoteSkillsState.NotConfigured
+            return
+        }
+        try {
+            if (access == null || currentHost != settings.host) {
+                closeAccess()
+                access = RemoteSkillFileAccess(
+                    RemoteSkillConnection(
+                        host = settings.host,
+                        port = settings.port,
+                        username = settings.username,
+                        password = settings.password,
+                        workspaceRoot = settings.remoteWorkspacePath
+                    ),
+                    hostKeyVerifier
+                )
+                currentHost = settings.host
+            }
+            val skills = skillRepository.listSkillsFrom(requireAccess(), skillsRoot)
+            _state.value = RemoteSkillsState.Loaded(settings.host, skills)
+        } catch (e: Exception) {
+            FileLogger.w(TAG, "加载远程技能失败", e)
+            _state.value = RemoteSkillsState.Failed(e.message ?: "连接失败")
+        }
+    }
+
+    /** 重新扫描已连接的远程技能；未连接时退回 [connect]。 */
+    suspend fun refresh() {
+        val a = access
+        val host = currentHost
+        if (a == null || host == null) return connect()
+        try {
+            val skills = skillRepository.listSkillsFrom(a, skillsRoot)
+            _state.value = RemoteSkillsState.Loaded(host, skills)
+        } catch (e: Exception) {
+            FileLogger.w(TAG, "刷新远程技能失败", e)
+            _state.value = RemoteSkillsState.Failed(e.message ?: "连接失败")
+        }
+    }
+
+    suspend fun save(form: SkillForm, originalName: String?): SkillSaveError? {
+        val a = requireAccess()
+        val existing = skillRepository.listSkillsFrom(a, skillsRoot)
+        val error = skillRepository.saveTo(a, skillsRoot, form, originalName, existing)
+        if (error == null) refresh()
+        return error
+    }
+
+    suspend fun delete(name: String): Boolean {
+        val a = requireAccess()
+        val existing = skillRepository.listSkillsFrom(a, skillsRoot)
+        val ok = skillRepository.deleteSkillFrom(a, name, existing)
+        if (ok) refresh()
+        return ok
+    }
+
+    suspend fun importMarkdown(text: String, fallbackName: String): SkillImportReport {
+        val a = requireAccess()
+        val existing = existingNames(a)
+        val report = skillRepository.importMarkdownTo(a, skillsRoot, existing, text, fallbackName)
+        refresh()
+        return report
+    }
+
+    suspend fun importZip(input: InputStream, fallbackName: String): SkillImportReport {
+        val a = requireAccess()
+        val existing = existingNames(a)
+        val report = skillRepository.importZipTo(a, skillsRoot, existing, input, fallbackName)
+        refresh()
+        return report
+    }
+
+    fun disconnect() {
+        closeAccess()
+        _state.value = RemoteSkillsState.NotConfigured
+    }
+
+    private suspend fun existingNames(a: RemoteSkillFileAccess): Set<String> =
+        skillRepository.listSkillsFrom(a, skillsRoot).map { it.name.lowercase() }.toSet()
+
+    private fun requireAccess(): RemoteSkillFileAccess =
+        access ?: throw IllegalStateException("远程技能未连接")
+
+    private fun closeAccess() {
+        runCatching { access?.close() }
+        access = null
+        currentHost = null
+    }
+
+    private companion object {
+        const val TAG = "RemoteSkillsManager"
+    }
+}

app/src/main/java/com/aicode/feature/agent/domain/skill/SkillRepository.kt

@@ -30,6 +30,10 @@ class SkillRepository @Inject constructor(
     fun listSkills(): List<Skill> =
         filterDisabled(listAllSkills(), skillConfigRepository.disabledNames()).map { it.skill }
 
+    /** 用外部 [provider] + 技能根 [root] 扫描技能（本地/远程同一套逻辑）。 */
+    fun listSkillsFrom(provider: FileAccessProvider, root: String): List<Skill> =
+        SkillDirectoryScanner.scan(provider, root)
+
     /** 读取指定 skill 的完整指令正文；不存在 / 解析失败 / 已被禁用时返回 null。 */
     fun loadInstructions(name: String): String? {
         if (name.lowercase() in skillConfigRepository.disabledNames()) return null
@@ -52,21 +56,32 @@ class SkillRepository @Inject constructor(
      * 技能正文常按 `~/.aicode/skills/<目录>/run.py` 引用同目录脚本，跟着改名会把这些引用打断。
      */
     fun save(form: SkillForm, scope: SkillScope, originalName: String? = null): SkillSaveError? {
+        val existing = listAllSkills().filter { it.scope == scope }.map { it.skill }
+        return saveTo(providerFor(scope), skillsRoot(scope), form, originalName, existing)
+    }
+
+    /**
+     * 用外部 [provider] + 技能根 [root] 保存技能（本地与远程同一套逻辑）。
+     * [existing] 为该来源下已有技能，用于同名冲突判定与定位编辑前的原目录。
+     */
+    fun saveTo(
+        provider: FileAccessProvider,
+        root: String,
+        form: SkillForm,
+        originalName: String? = null,
+        existing: List<Skill> = emptyList()
+    ): SkillSaveError? {
         val name = form.name.trim()
         if (!isValidName(name)) return SkillSaveError.INVALID_NAME
         if (form.instructions.isBlank()) return SkillSaveError.EMPTY_INSTRUCTIONS
 
-        val entries = listAllSkills()
         val keepingName = originalName != null && originalName.equals(name, ignoreCase = true)
-        if (!keepingName) {
-            val taken = entries.any { it.scope == scope && it.skill.name.equals(name, ignoreCase = true) }
-            if (taken) return SkillSaveError.NAME_CONFLICT
+        if (!keepingName && existing.any { it.name.equals(name, ignoreCase = true) }) {
+            return SkillSaveError.NAME_CONFLICT
         }
 
         val existingDir = originalName?.let { old ->
-            entries.firstOrNull {
-                it.scope == scope && it.skill.name.equals(old, ignoreCase = true)
-            }?.skill?.dirPath
+            existing.firstOrNull { it.name.equals(old, ignoreCase = true) }?.dirPath
         }
 
         val text = SkillParser.serialize(
@@ -76,9 +91,8 @@ class SkillRepository @Inject constructor(
             instructions = form.instructions
         )
 
-        val provider = providerFor(scope)
         return try {
-            val dir = existingDir?.takeIf { provider.isDirectory(it) } ?: "${skillsRoot(scope)}/$name"
+            val dir = existingDir?.takeIf { provider.isDirectory(it) } ?: "${root.trimEnd('/')}/$name"
             provider.mkdirs(dir)
             val target = instructionFile(provider, dir) ?: "${dir.trimEnd('/')}/$INSTRUCTION_FILE"
             provider.writeFile(target, text, overwrite = true)
@@ -102,23 +116,44 @@ class SkillRepository @Inject constructor(
      * 名称非法 / 同名冲突 / 正文为空时整体失败，不落盘。
      */
     fun importMarkdown(text: String, fallbackName: String, scope: SkillScope): SkillImportReport =
-        SkillImporter.importMarkdown(providerFor(scope), skillsRoot(scope), existingNamesIn(scope), text, fallbackName)
+        importMarkdownTo(providerFor(scope), skillsRoot(scope), existingNamesIn(scope), text, fallbackName)
+
+    /** 用外部 [provider] + 技能根 [root] 导入 Markdown 技能。 */
+    fun importMarkdownTo(
+        provider: FileAccessProvider,
+        root: String,
+        existingNames: Set<String>,
+        text: String,
+        fallbackName: String
+    ): SkillImportReport = SkillImporter.importMarkdown(provider, root, existingNames, text, fallbackName)
 
     /** 从 zip 输入流导入技能（可含多个技能目录）到指定作用域。 */
     fun importZip(input: InputStream, fallbackName: String, scope: SkillScope): SkillImportReport =
-        SkillImporter.importArchive(providerFor(scope), skillsRoot(scope), existingNamesIn(scope), input, fallbackName)
+        importZipTo(providerFor(scope), skillsRoot(scope), existingNamesIn(scope), input, fallbackName)
+
+    /** 用外部 [provider] + 技能根 [root] 导入 zip 技能。 */
+    fun importZipTo(
+        provider: FileAccessProvider,
+        root: String,
+        existingNames: Set<String>,
+        input: InputStream,
+        fallbackName: String
+    ): SkillImportReport = SkillImporter.importArchive(provider, root, existingNames, input, fallbackName)
 
     /** 指定作用域下已有技能名（小写），供导入查重。 */
     private fun existingNamesIn(scope: SkillScope): Set<String> =
         listAllSkills().filter { it.scope == scope }.map { it.skill.name.lowercase() }.toSet()
 
     /** 删除指定作用域的技能（删除其目录，不可恢复）。返回是否成功。 */
     fun deleteSkill(name: String, scope: SkillScope): Boolean {
-        val entry = listAllSkills().firstOrNull {
-            it.skill.name.equals(name, ignoreCase = true) && it.scope == scope
-        } ?: return false
-        val dirPath = entry.skill.dirPath ?: return false
-        return safeDeleteSkillDir(providerFor(scope), dirPath)
+        val existing = listAllSkills().filter { it.scope == scope }.map { it.skill }
+        return deleteSkillFrom(providerFor(scope), name, existing)
+    }
+
+    /** 用外部 [provider] 删除指定技能（删除其目录，不可恢复）。 */
+    fun deleteSkillFrom(provider: FileAccessProvider, name: String, existing: List<Skill>): Boolean {
+        val dirPath = existing.firstOrNull { it.name.equals(name, ignoreCase = true) }?.dirPath ?: return false
+        return safeDeleteSkillDir(provider, dirPath)
     }
 
     /** 全局技能固定在本地私有目录，项目级技能跟随工作区（可能是远程）。 */

app/src/main/java/com/aicode/feature/agent/domain/workflow/ContextCompactor.kt

@@ -35,6 +35,9 @@ class ContextCompactor @Inject constructor(
         const val TAG = "ContextCompactor"
 
         const val TOOL_OUTPUT_MAX_CHARS = 2_000
+
+        /** 软精简时单条工具输出的保留上限（比硬压缩宽松，尽量少丢信息）。 */
+        const val SOFT_TRIM_TOOL_CHARS = 3_000
         const val COMPACT_PROMPT_FILE = "agent/compact-summary.md"
         val LEADING_COMMENT = Regex("(?s)^\\s*<!--.*?-->\\s*")
     }
@@ -70,15 +73,29 @@ class ContextCompactor @Inject constructor(
         val windowMetadata = modelMetadataService.resolve(windowModel.providerId, inferProviderType(windowModel), windowModel.model)
         val summaryMetadata = modelMetadataService.resolve(aiProvider.providerId, inferProviderType(aiProvider), aiProvider.model)
         val contextLimit = windowMetadata.contextTokens.takeIf { it > 0 } ?: ModelContextPolicy.DEFAULT_CONTEXT_TOKENS
-        // 触发阈值百分比由「偏好设置 → 模型」配置（默认 90，见 GeneralSettingsRepository）。
-        val triggerThreshold = (contextLimit * generalSettingsRepository.compactionThresholdPercent() / 100.0).toInt()
+        // 硬阈值：完整摘要压缩；软阈值：只精简历史工具输出（不调 LLM）。均可在偏好设置配置。
+        val hardPercent = generalSettingsRepository.compactionThresholdPercent()
+        val softPercent = generalSettingsRepository.softCompactionThresholdPercent()
+        val triggerThreshold = (contextLimit * hardPercent / 100.0).toInt()
+        val softThreshold = (contextLimit * softPercent / 100.0).toInt()
         // 真实 usage 优先（含 system prompt + tools，与上下文窗口同口径）；取不到（0）回退本地估算
         val currentTokens = lastInputTokens.takeIf { it > 0 } ?: estimatedTokens
-        val reachedThreshold = currentTokens >= triggerThreshold
-        val reachedHardLimit = currentTokens >= contextLimit
-        if (messages.size <= 2 || (!force && !reachedThreshold && !reachedHardLimit)) {
-            return messages.toList()
+        val reachedHard = currentTokens >= triggerThreshold || currentTokens >= contextLimit
+        val reachedSoft = currentTokens >= softThreshold
+        if (messages.size <= 2) return messages.toList()
+        // 软阈值：先静默精简历史里的超长工具输出（不调摘要模型、不发事件、不落库），
+        // 让上下文尽量在 40% 退化分界以下停留更久，只在真正逼近硬上限时才做完整摘要。
+        if (!force && !reachedHard && reachedSoft) {
+            val trimmed = softTrim(messages)
+            if (trimmed !== messages) {
+                FileLogger.i(
+                    TAG,
+                    "会话 ${sessionId ?: "-"} 上下文约 $currentTokens tokens 达软阈值 $softThreshold，精简历史工具输出（未调用摘要模型）"
+                )
+            }
+            return trimmed
         }
+        if (!force && !reachedHard) return messages.toList()
 
         val tokensSource = if (lastInputTokens > 0) "真实 usage" else "本地估算"
         // 窗口来源一并打出来：命中目录（含命中的 provider 与自定义覆盖）还是走了 128k 兜底，
@@ -240,6 +257,24 @@ class ContextCompactor @Inject constructor(
         return newMessages
     }
 
+    /**
+     * 软精简：不调 LLM、不落库，只把历史里超长的工具输出截断，降低主上下文冗余。
+     * 输入主要来自工具结果（文件内容、命令输出等），这里只做保守截断，不改角色结构、不动 DB。
+     * 未产生变化时返回原列表引用，便于调用方判断。
+     */
+    private fun softTrim(messages: List<AgentMessage>): List<AgentMessage> {
+        var changed = false
+        val result = messages.map { msg ->
+            if (msg is AgentMessage.ToolResultMessage && msg.result.length > SOFT_TRIM_TOOL_CHARS) {
+                changed = true
+                msg.copy(result = msg.result.take(SOFT_TRIM_TOOL_CHARS) + "\n[工具输出已精简以节省上下文]")
+            } else {
+                msg
+            }
+        }
+        return if (changed) result else messages
+    }
+
     /**
      * 调整拆分索引，确保 tail 不是以 ToolResultMessage 开头。
      *