@ohos-cpf/3rdloop 0.0.5 → 0.0.7

package/README.md

@@ -260,7 +260,6 @@ LLM 凭据变量（`DASHSCOPE_API_KEY` / `LLM_MODEL` 等）：按上文场景二
 3rdloop update --registry https://registry.npmjs.org/
 ```
 
-- 以 `npm link` 开发方式安装（连接到仓库源码）时，`update` 默认跳过并提示用 `git pull` 更新源码，加 `--force` 可强制替换为 registry 正式包
 - 更新只替换程序文件，**数据目录** `~/.3lib/3rdloop/db` **与** `~/.3lib/.env` **配置不受影响**
 
 

package/lib/cli.js

@@ -145,7 +145,7 @@ export async function runCli(argv) {
             return cmdConfig({ flags, rest, projectRoot, user3libHome, jsonMode, out });
 
         case 'serve':
-            return cmdServe({ flags, rest, jsonMode });
+            return cmdServe({ flags, rest, jsonMode, dataDir });
 
         case 'update':
             return cmdUpdate({ flags, rest, jsonMode, out });
@@ -226,9 +226,9 @@ async function cmdUpdate({ flags, rest, jsonMode, out }) {
 
 // ─── serve（启动 Server HTTP 后端，供前端展示）─────────────────────────
 
-async function cmdServe({ flags, rest, jsonMode }) {
+async function cmdServe({ flags, rest, jsonMode, dataDir }) {
     const { cmdServe: impl } = await import('./serve.js');
-    return impl({ rest: flags.rest, jsonMode });
+    return impl({ rest: flags.rest, jsonMode, dataDir });
 }
 
 // ─── run / submit ──────────────────────────────────────────────────
@@ -660,7 +660,7 @@ function printHelp() {
   3rdloop run <工作流名> [--flag <值> ...]     以固定编排执行工作流（阻塞到终态）
   3rdloop config list|get|set|unset ...  配置 .env 配置项（默认读写 ~/.3lib/.env）
   3rdloop serve [--port N] [-w|--web] [--web-port N]  启动 Server HTTP 后端（供前端展示）
-  3rdloop update [--check] [--yes] [--force] [--registry <url>]  自更新到 npm 最新版
+  3rdloop update [--check] [--yes] [--registry <url>]  自更新到 npm 最新版
   3rdloop web [--port N] [--backend <url>]       启动 Web 前端服务
   3rdloop web install-ext <dir>                  安装扩展（tag/issue/prcheck 等二级功能）
   3rdloop web list-ext | remove-ext <name>       扩展管理
@@ -687,7 +687,6 @@ config 子命令:
 update 专用选项:
   --check          仅检查是否有新版本，不执行更新
   --yes, -y        跳过交互确认直接更新
-  --force          开发态（npm link）也强制替换为 registry 正式包
   --registry <url> 覆盖 npm registry（默认尊重用户 npm 镜像配置）
   注意: 数据目录 ~/.3lib/3rdloop/db 与 SKILL 配置不受更新影响
 

package/lib/serve.js

@@ -88,9 +88,10 @@ function _parseServeArgs(rest = []) {
  * @param {object} opts
  * @param {string[]} opts.rest - flags.rest（含 serve 专用参数）
  * @param {boolean} opts.jsonMode
+ * @param {string} [opts.dataDir] - CLI 解析后的数据目录（--data-dir / 3LIB_DATA_DIR / 默认）
  * @returns {Promise<number>} 退出码（serve 为长驻命令，仅 --help/启动失败正常返回）
  */
-export async function cmdServe({ rest = [], jsonMode = false }) {
+export async function cmdServe({ rest = [], jsonMode = false, dataDir = '' }) {
     // --help / -h：打印用法
     if (rest.includes('--help') || rest.includes('-h')) {
         _printServeHelp();
@@ -106,6 +107,15 @@ export async function cmdServe({ rest = [], jsonMode = false }) {
         return 1;
     }
 
+    // ── 数据目录对齐 CLI（A3）：与 run/submit 共用同一 dataDir ──────
+    // 通过 env 注入而非逐层传参：Server 内部所有自建 createStorage()
+    // 都经 StorageManager 默认根目录解析，env 一处生效（含 FlexRunner /
+    // KnowledgeManager / MessageArchive 等惰性自建实例）。
+    // 必须在 import Server 模块前设置（覆盖部分模块加载期构造的实例）。
+    if (dataDir) {
+        process.env['3LIB_DATA_DIR'] = dataDir;
+    }
+
     const serverModule = await _importServerModule();
 
     // json 模式下纯化 stdout：Server 内部 console.log/info 重定向到 stderr
@@ -141,7 +151,9 @@ export async function cmdServe({ rest = [], jsonMode = false }) {
 
     try {
         // cliType 由环境决定（shell > .env > 默认 opencode），与 CLI 嵌入式一致；
-        // dataDir/skillDir 沿用 Server 默认（workspace 根 db/），本期不与 CLI 打通
+        // dataDir 已通过 3LIB_DATA_DIR env 注入（见上），Server 内部所有默认
+        // createStorage() 均落到用户数据目录；skillDir 沿用包内 vendor 默认
+        // （npm 更新自动获得新 SKILL，不与 CLI 的 3LIB_SKILL_DIR 联动）
         const server = await serverModule.createServer({ port: serverPort });
 
         if (jsonMode) {

package/lib/update.js

@@ -3,8 +3,7 @@
  *
  * 职责：
  *   - 检测本地版本（getCliVersion）与 npm registry 最新版
- *   - 识别开发态（npm link 软链）与正式全局安装
- *   - 交互确认后通过 npm install -g 重装
+ *   - 交互确认后卸载旧版 + npm install -g 重装最新版
  *
  * 交互/输出契约：
  *   - 进度/日志 → stderr；--json 结构化结果 → stdout
@@ -17,7 +16,6 @@
  *     该分支对用户可控的 --registry 值做白名单校验防 shell 注入
  */
 
-import fs from 'node:fs';
 import path from 'node:path';
 import readline from 'node:readline';
 import { execFileSync } from 'node:child_process';
@@ -26,7 +24,6 @@ import { fileURLToPath } from 'node:url';
 // 本文件在 cli/lib/ 下
 const CLI_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const PKG_NAME = '@ohos-cpf/3rdloop';
-const BIN_ABS = path.join(CLI_ROOT, 'bin', '3rdloop.mjs');
 
 // ── npm 调用封装 ─────────────────────────────────────────────────
 
@@ -92,22 +89,6 @@ export function compareVersions(a, b) {
     return String(preA).localeCompare(String(preB));
 }
 
-/**
- * 检测当前命令是否为 npm link 软链（开发态）。
- *
- * 原理：npm link 的全局 bin 是指向仓库 bin 的软链；真实全局安装则是
- * node_modules 内的副本。比较 process.argv[1] 与仓库内 bin 的 realpath 是否相同。
- */
-export function detectLinkMode(argv1 = process.argv[1]) {
-    try {
-        const realArgv = fs.realpathSync(argv1 || '');
-        const realLocal = fs.realpathSync(BIN_ABS);
-        return realArgv === realLocal;
-    } catch {
-        return false;
-    }
-}
-
 /**
  * 获取最新版本。
  * 优先 `npm view`（尊重用户 .npmrc 镜像配置）；失败回退 packument API。
@@ -171,33 +152,15 @@ export async function confirmUpdate({ current, latest } = {}) {
 }
 
 /**
- * 执行更新。
+ * 执行更新：卸载旧版后通过 npm install -g 重装最新版。
  * @param {object} opts
  * @param {string} opts.latest        目标版本（registry latest）
  * @param {string} [opts.registry]    registry 覆盖
- * @param {boolean} [opts.force]      开发态也强制替换
- * @param {boolean} [opts.isLink]     是否 link 模式（可注入便于测试）
  */
-export function performUpdate({ latest, registry, force = false, isLink = detectLinkMode() } = {}) {
+export function performUpdate({ latest, registry } = {}) {
     const installArgs = ['install', '-g', `${PKG_NAME}@latest`];
     if (registry) installArgs.push('--registry', registry);
 
-    // 开发态（npm link）：默认警告并跳过，仅提示 git pull
-    if (isLink && !force) {
-        process.stderr.write(
-            `\n[update] 检测到当前为开发态（npm link），已跳过自更新。\n` +
-            `  开发态请用 git pull 更新仓库源码（数据目录 ~/.3lib/3rdloop/db 不受影响）。\n` +
-            `  如需强制用正式包替换链接，可加 --force。\n`
-        );
-        return { updated: false, skipped: 'link-mode' };
-    }
-
-    // 开发态 + --force：先解除链接
-    if (isLink && force) {
-        process.stderr.write(`[update] 检测到 npm link，先解除链接...\n`);
-        runNpm(['unlink', '-g', PKG_NAME], { encoding: 'utf-8', stdio: 'inherit' });
-    }
-
     process.stderr.write(`[update] 卸载旧版本（@${PKG_NAME}）...\n`);
     try {
         runNpm(['uninstall', '-g', PKG_NAME], { encoding: 'utf-8', stdio: 'inherit' });
@@ -219,19 +182,17 @@ export function performUpdate({ latest, registry, force = false, isLink = detect
 export async function cmdUpdateImpl({ jsonMode = false, rest = [] } = {}) {
     const checkOnly = rest.includes('--check');
     const yes = rest.includes('--yes') || rest.includes('-y');
-    const force = rest.includes('--force');
     const regIdx = rest.indexOf('--registry');
     const registry = regIdx !== -1 ? rest[regIdx + 1] : undefined;
 
     // update 用法说明（--help，离线可测，不触碰网络）
     if (rest.includes('--help') || rest.includes('-h')) {
         const help = [
-            '用法: 3rdloop update [--check] [--yes] [--force] [--registry <url>]',
+            '用法: 3rdloop update [--check] [--yes] [--registry <url>]',
             '',
             '  默认: 检测本地版本与 npm registry 最新版，差异存在时交互确认后重装',
             '  --check           仅检查是否有新版本，不执行更新',
             '  --yes, -y         跳过交互确认直接更新（非 TTY 必须）',
-            '  --force           开发态（npm link）也强制替换为 registry 正式包',
             '  --registry <url>  覆盖 npm registry（默认尊重用户 npm 镜像配置）',
             '  注意: 数据目录 ~/.3lib/3rdloop/db 与 SKILL 配置不受更新影响',
         ].join('\n');
@@ -268,7 +229,7 @@ export async function cmdUpdateImpl({ jsonMode = false, rest = [] } = {}) {
         if (!checkOnly) {
             // --json 下不交互，直接更新（用户显式要求命令行为，等价 --yes）
             try {
-                const r = performUpdate({ latest, registry, force });
+                const r = performUpdate({ latest, registry });
                 process.stdout.write(JSON.stringify({ ...r, ok: true }, null, 2) + '\n');
                 return { ok: true, ...r };
             } catch (err) {
@@ -310,7 +271,7 @@ export async function cmdUpdateImpl({ jsonMode = false, rest = [] } = {}) {
 
     process.stderr.write(`\n`);
     try {
-        const r = performUpdate({ latest, registry, force });
+        const r = performUpdate({ latest, registry });
         return { ok: true, ...r };
     } catch (err) {
         const msg = `更新失败: ${err.message}`;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ohos-cpf/3rdloop",
-    "version": "0.0.5",
+    "version": "0.0.7",
     "description": "3rdLibraryLoop 三方库自动化检视 CLI：嵌入式复用核心引擎，任务生命周期管理（submit/run/wait/progress/abort/list/result/doctor）",
     "type": "module",
     "license": "MIT",

package/vendor/Server/CLI/opencode/index.js

@@ -388,7 +388,7 @@ class OpenCodeCLI {
             try {
                 statusMap = await this.client.session.status({ query: {} });
             } catch (e) {
-                this._log('warn', `checkSessionStatus: session.status() 失败，降级为拉消息: ${e.message}`);
+                this._log('debug', `checkSessionStatus: session.status() 失败，降级为拉消息: ${e.message}`);
             }
             const rawStatus = statusMap?.data?.[sessionId];
             if (rawStatus && (rawStatus.type === 'busy' || rawStatus.type === 'retry')) {
@@ -487,7 +487,7 @@ class OpenCodeCLI {
                 hasNewMessage: !!checkRes.hasNewMessage
             };
         } catch (error) {
-            this._log('warn', `checkSessionStatus 异常 id=${sessionId}: ${error.message}`);
+            this._log('debug', `checkSessionStatus 异常 id=${sessionId}: ${error.message}`);
             return { status: 'unknown' };
         }
     }
@@ -639,7 +639,7 @@ class OpenCodeCLI {
                 sessionId,
                 data.map(m => this._toArchiveMessage(m))
             );
-            this._log('info',
+            this._log('debug',
                 `自动归档 id=${sessionId} reason=${reason} — appended=${archRes.appended} skipped=${archRes.skipped}`);
         } catch (e) {
             this._log('warn', `自动归档失败 id=${sessionId} reason=${reason}: ${e.message}`);

package/vendor/Server/DbUse/StorageManager.js

@@ -1,4 +1,4 @@
-import { join, dirname } from 'node:path';
+import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import JsonAdapter from './adapters/JsonAdapter.js';
@@ -36,6 +36,12 @@ class StorageManager {
     constructor(options = {}) {
         if (options.rootDir) {
             this.rootDir = options.rootDir;
+        } else if (process.env['3LIB_DATA_DIR']) {
+            // CLI 数据目录策略（与 WEB_STATS_ROOT 同模式）：
+            // 3rdloop serve/run 等命令将解析后的数据目录注入 env，
+            // 使内部所有自建 createStorage()（FlexRunner/KnowledgeManager/
+            // MessageArchive 等）统一落到用户数据目录，而非模块相对路径。
+            this.rootDir = resolve(process.env['3LIB_DATA_DIR']);
         } else {
             // 本文件 (Server/DbUse/) 上溯 3 层到 workspace 根 → db/
             const here = dirname(fileURLToPath(import.meta.url));

package/vendor/Server/FlexRunner/FlexRunner.js

@@ -846,7 +846,7 @@ class FlexRunner {
                 return false;
             }
 
-            this._log('info', `invokeSkill 完成 — sessionId: ${sessionId}`);
+            this._log('debug', `invokeSkill 完成 — sessionId: ${sessionId}`);
             return true;
         } catch (err) {
             this._log('error', `invokeSkill 异常: ${err.message}`);
@@ -907,18 +907,18 @@ class FlexRunner {
 
         try {
             const content = await fs.readFile(summaryFilePath, 'utf-8');
-            this._log('info', `persistKnowledge: 已读取经验文件 (${content.length} 字符)`);
+            this._log('debug', `persistKnowledge: 已读取经验文件 (${content.length} 字符)`);
 
             // 1. 将经验内容持久化到步骤记录
             await this._persistStep({ knowledgeSummary: content });
-            this._log('info', 'persistKnowledge: 经验已持久化到步骤记录');
+            this._log('debug', 'persistKnowledge: 经验已持久化到步骤记录');
 
             // 2. 登记到知识沉淀系统
             if (this.#knowledgeManager) {
                 // 避免重复登记：先检查是否已存在
                 const existing = await this.#knowledgeManager.findByDocPath(summaryFilePath);
                 if (existing) {
-                    this._log('info', `persistKnowledge: 经验已登记过，跳重复登记 — id: ${existing.id}`);
+                    this._log('debug', `persistKnowledge: 经验已登记过，跳重复登记 — id: ${existing.id}`);
                 } else {
                     const record = await this.#knowledgeManager.addExperience({
                         docPath: summaryFilePath,
@@ -929,7 +929,7 @@ class FlexRunner {
                         skillDir: this.#matchedSkillDir,
                         taskDescription: this.#taskDescription
                     });
-                    this._log('info', `persistKnowledge: 经验已登记到知识沉淀系统 — id: ${record.id}`);
+                    this._log('debug', `persistKnowledge: 经验已登记到知识沉淀系统 — id: ${record.id}`);
                 }
             } else {
                 this._log('warn', 'persistKnowledge: KnowledgeManager 未初始化，跳过知识沉淀登记');
@@ -1112,12 +1112,12 @@ class FlexRunner {
         const value = raw.replace(/^[#>*\-\s]+/, '').trim();
 
         if (value === '成功') {
-            this._log('info', `checkResult: 执行状态 = 成功 (${resultFilePath})`);
+            this._log('debug', `checkResult: 执行状态 = 成功 (${resultFilePath})`);
             return true;
         }
 
         if (value === '失败') {
-            this._log('info', `checkResult: 执行状态 = 失败 (${resultFilePath})`);
+            this._log('error', `checkResult: 执行状态 = 失败 (${resultFilePath})`);
             return false;
         }
 
@@ -1578,7 +1578,7 @@ class FlexRunner {
 
             // 等待 AI 回复期间收到终止请求 → 不再等待文件生成（session 已被远程中止）
             if (this.#aborted) {
-                this._log('info', '_summarizeExperience: 等待回复期间被终止，放弃经验总结');
+                this._log('warn', '_summarizeExperience: 等待回复期间被终止，放弃经验总结');
                 return false;
             }
 
@@ -1587,7 +1587,7 @@ class FlexRunner {
                 return false;
             }
 
-            this._log('info',
+            this._log('debug',
                 `_summarizeExperience: AI 回复完成，content 长度 ${result.content?.length || 0}，` +
                 `等待 Summary 文件生成…`
             );
@@ -1601,7 +1601,7 @@ class FlexRunner {
                 return false;
             }
 
-            this._log('info', `经验总结完成 — Summary 文件已生成: ${summaryFilePath}`);
+            this._log('debug', `经验总结完成 — Summary 文件已生成: ${summaryFilePath}`);
             return true;
         } catch (err) {
             this._log('error', `_summarizeExperience 异常: ${err.message}`);

package/vendor/Server/Orchestrator/Orchestrator.js

@@ -36,6 +36,7 @@
  */
 
 import path from 'node:path';
+import { hostname } from 'node:os';
 
 import { FlexRunner } from '../FlexRunner/FlexRunner.js';
 import { StepNode, NodeStatus } from './StepNode.js';
@@ -409,6 +410,10 @@ class Orchestrator {
         this._startTime = nowCST();
         this._emit(SSE_EVENT.TASK_START, this.getProgress());
         await this._persistState();
+        // 写入属主标记（pid/hostname）：标识本编排由当前进程执行。
+        // 服务重启时 restoreFromDisk 据此判定 running 任务的归属——
+        // 属主进程仍存活（如 3rdloop run 嵌入式 CLI）则跳过，不误标 FAILED。
+        await this._writeOwnerFile();
 
         try {
             // 初始就绪：将所有入口步骤标记为 ready
@@ -460,6 +465,8 @@ class Orchestrator {
 
         this._log('info', `── 编排执行结束: status=${this._status} ──`);
         await this._persistState();
+        // 已到终态，属主标记失效，清理（先持久化终态再清理，崩溃窗口内重启仍可正确判定）
+        await this._deleteOwnerFile();
         return { status: this._status, summary: this.getProgress() };
     }
 
@@ -1275,6 +1282,38 @@ class Orchestrator {
         await this._persistChain;
     }
 
+    /**
+     * 写入属主标记文件（db/task/{taskId}/owner.json）。
+     *
+     * 记录执行本编排的进程 pid 与 hostname。服务重启时
+     * OrchestratorController.restoreFromDisk 据此判定 running 状态任务的归属：
+     * 属主进程仍存活（如 3rdloop run 嵌入式 CLI 在独立进程执行）则跳过恢复，
+     * 不标记 FAILED、不写 SQLite 中断记录、不回写注册表。
+     * 静默失败，不影响编排主流程。
+     * @private
+     */
+    async _writeOwnerFile() {
+        if (!this.storage || !this._taskId) return;
+        try {
+            await this.storage.json('task').write(`${this._taskId}/owner`, {
+                pid: process.pid,
+                hostname: hostname(),
+                wroteAt: new Date().toISOString()
+            });
+        } catch { /* 静默失败 */ }
+    }
+
+    /**
+     * 删除属主标记文件（编排到终态时调用）。
+     * @private
+     */
+    async _deleteOwnerFile() {
+        if (!this.storage || !this._taskId) return;
+        try {
+            await this.storage.json('task').delete(`${this._taskId}/owner`);
+        } catch { /* 静默失败 */ }
+    }
+
     /**
      * 从持久化文件恢复编排状态。
      *

package/vendor/Server/Routes/controllers/FlexRunnerController.js

@@ -776,6 +776,77 @@ class FlexRunnerController {
         }
     }
 
+    /**
+     * POST /api/flexrunner/clean-source
+     * 删除任务目录下的源码克隆目录（{taskDir}/source/），释放存储空间。
+     *
+     * 仓库检视（ArkTS/Flutter/RN）与 PR 代码检视（arkts/flutter/rn-code-check）均把
+     * 仓库源码克隆到任务目录的 source/ 固定路径；检视结束后源码不再被引用
+     * （检视报告 .md、meta .json、orchestration.json 等过程文件均在 taskDir 根目录），
+     * 由前端在任务终态时调用本接口清理。
+     *
+     * 安全约束：
+     *   - 只删除固定子目录名 source（不接受任意路径参数，防误删报告/过程文件）
+     *   - taskDir 经 _resolveTaskDir 解析（内存实例 → 编排元信息 → 磁盘白名单兜底）
+     *   - 内存中编排器仍有步骤执行（pending/ready/running）时拒绝清理
+     *   - source/ 不存在时幂等返回 cleaned=false（如 tpc-cpp-check 不克隆源码）
+     *
+     * Body: { taskId }
+     */
+    async cleanSource(req, res) {
+        const body = req.body || {};
+        const { taskId } = body;
+        if (!taskId) {
+            return res.error(400, 'taskId 为必填项');
+        }
+
+        try {
+            // 活跃任务保护：内存中编排器仍有步骤在执行时拒绝（防止误删执行中正在使用的源码）
+            if (this._orchestratorController) {
+                try {
+                    const steps = this._orchestratorController.getTaskSteps(taskId);
+                    const active = steps.some(s =>
+                        ['pending', 'ready', 'running'].includes(String(s.status || '').toLowerCase()));
+                    if (active) {
+                        return res.error(409, '任务仍在执行中，暂不能清理源码');
+                    }
+                } catch { /* 内存无实例（已结束 / 重启后磁盘恢复）→ 继续清理 */ }
+            }
+
+            const taskDir = await this._resolveTaskDir(taskId);
+            if (!taskDir) {
+                return res.error(404, `未找到任务目录: taskId=${taskId}`);
+            }
+
+            const sourceDir = path.join(taskDir, 'source');
+
+            let st = null;
+            try { st = await fs.stat(sourceDir); } catch { /* 目录不存在 */ }
+            if (!st || !st.isDirectory()) {
+                return res.json({
+                    status: 'ok',
+                    cleaned: false,
+                    freedBytes: 0,
+                    message: '任务目录下无源码目录（source/ 不存在），无需清理',
+                });
+            }
+
+            // 统计释放空间（统计失败不阻塞删除，按 0 返回）
+            const freedBytes = await this._dirSize(sourceDir).catch(() => 0);
+            await fs.rm(sourceDir, { recursive: true, force: true });
+
+            res.json({
+                status: 'ok',
+                cleaned: true,
+                freedBytes,
+                path: sourceDir,
+                message: '已删除源码目录 source/，报告与过程文件保留',
+            });
+        } catch (err) {
+            res.error(500, `源码清理失败: ${err.message}`);
+        }
+    }
+
     /**
      * 解析任务工作目录（供 archive 打包等场景使用）。
      *
@@ -823,6 +894,27 @@ class FlexRunnerController {
         return null;
     }
 
+    /**
+     * 递归统计目录占用大小（字节）。符号链接不计入（防循环遍历）。
+     * @param {string} dir
+     * @returns {Promise<number>}
+     * @private
+     */
+    async _dirSize(dir) {
+        let total = 0;
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+            const fp = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                total += await this._dirSize(fp);
+            } else if (e.isFile()) {
+                const st = await fs.stat(fp).catch(() => null);
+                if (st) total += st.size;
+            }
+        }
+        return total;
+    }
+
     /**
      * GET /api/flexrunner/runners
      * 列出所有已注册的 FlexRunner 实例

package/vendor/Server/Routes/controllers/OrchestratorController.js

@@ -18,6 +18,7 @@
 
 import path from 'node:path';
 import fs from 'node:fs';
+import { hostname } from 'node:os';
 import { Orchestrator, OrchestratorStatus } from '../../Orchestrator/Orchestrator.js';
 import { StorageManager } from '../../DbUse/index.js';
 
@@ -291,11 +292,26 @@ class OrchestratorController {
 
             this._orchestrators.set(taskId, orch);
 
-            // 注册任务摘要到注册表（SQLite），供历史列表分页查询
+            // 注册任务摘要到注册表（SQLite），供历史列表分页查询。
+            // 注意：任务已注册时保留原 task_type —— 大循环任务由
+            // LoopEngineController.start 先注册为 'loop'，随后 LoopEngine 内部
+            // 调用本 load() 加载编排，若无条件 upsert 'orchestrator' 会覆盖
+            // 任务类型；一旦进程中断（finally 未执行改回），任务将无法在
+            // 大循环历史页（taskType='loop' 过滤）中显示。
+            const registry = this._getRegistry();
+            let taskType = 'orchestrator';
+            if (registry) {
+                try {
+                    const registered = await registry.get(taskId);
+                    if (registered && registered.task_type) {
+                        taskType = registered.task_type;
+                    }
+                } catch { /* 查询失败按新任务处理 */ }
+            }
             const firstStep = body.steps[0] || {};
             this._registerTask({
                 taskId,
-                taskType: 'orchestrator',
+                taskType,
                 status: 'loaded',
                 title: (firstStep.taskDescription || body.title || '').slice(0, 200),
                 description: body.title || firstStep.taskDescription || '',
@@ -751,6 +767,52 @@ class OrchestratorController {
         }
     }
 
+    /**
+     * 判断 running 状态的持久化任务是否有仍存活的"外部属主进程"。
+     *
+     * owner.json 由 Orchestrator.start() 写入（pid/hostname），终态时删除：
+     *   - 无 owner.json → 老任务（机制上线前创建）或已正常收尾 → false（维持中断语义）
+     *   - pid 已死（同机）→ 属主进程已崩溃，清理残留文件后返回 false
+     *   - pid 存活且非当前进程 → 外部进程（如 3rdloop run）仍在执行 → true
+     *   - hostname 不同（共享数据目录跨机部署）→ 本机 pid 探测无意义，保守返回 true
+     *
+     * @param {string} taskId
+     * @returns {Promise<boolean>}
+     * @private
+     */
+    async _hasLiveExternalOwner(taskId) {
+        let owner = null;
+        try {
+            owner = await this.storage.json('task').read(`${taskId}/owner`);
+        } catch {
+            return false;
+        }
+        if (!owner || typeof owner.pid !== 'number') return false;
+
+        // 本进程残留（防御：restoreFromDisk 运行期本进程不可能有在途编排）
+        if (owner.pid === process.pid) return false;
+
+        // 异机属主：pid 属于另一台机器，本机探测会误判无关进程，保守视为存活
+        if (owner.hostname && owner.hostname !== hostname()) return true;
+
+        // 同机：探测属主进程死活（EPERM = 进程存在但属其他用户）
+        let alive = false;
+        try {
+            process.kill(owner.pid, 0);
+            alive = true;
+        } catch (err) {
+            alive = err.code === 'EPERM';
+        }
+        if (!alive) {
+            // 属主已崩溃但未及清理 → 删除残留，交由调用方维持 RUNNING→FAILED 语义
+            try {
+                await this.storage.json('task').delete(`${taskId}/owner`);
+            } catch { /* ignore */ }
+            return false;
+        }
+        return true;
+    }
+
     /**
      * 从磁盘恢复所有持久化的编排任务到内存。
      *
@@ -762,6 +824,12 @@ class OrchestratorController {
      *     registry 停留在 loaded/running 的记录修正为恢复后的终态（含 metrics、
      *     interrupted 标记）；未入库的老任务补录摘要。
      *
+     * 跨进程属主检测（RUNNING 状态专属）：
+     *   3rdloop run（嵌入式 CLI）在独立进程中执行编排、共享同一 db/ 目录，
+     *   服务重启不能把这类"仍在执行中"的任务误判为崩溃残留。依据 owner.json
+     * （Orchestrator.start 写入、终态删除）判定：属主进程仍存活 → 跳过该任务
+     * （不恢复入内存、不标 FAILED、不改注册表），由属主进程自行推进与收尾。
+     *
      * @returns {Promise<{restored: string[], failed: string[]}>}
      */
     async restoreFromDisk() {
@@ -785,6 +853,14 @@ class OrchestratorController {
                     continue;
                 }
 
+                // ── 跨进程属主检测：running 任务可能属于另一存活进程 ──
+                if (state.status === 'running' && await this._hasLiveExternalOwner(taskId)) {
+                    console.log(
+                        `[OrchestratorController] 跳过 running 任务（属主进程仍在执行，疑似 3rdloop run 嵌入式任务）: taskId=${taskId}`
+                    );
+                    continue;
+                }
+
                 const wasRunning = state.status === 'running';
                 const orch = this._createOrchestrator();
                 await orch.restoreState(state);
@@ -853,11 +929,19 @@ class OrchestratorController {
             const status = progress.status || 'failed';
             const firstStep = (state.steps || [])[0] || {};
 
+            // task_type 自愈：任务目录存在 loop.json 说明是大循环任务
+            // （LoopEngine 产物）。中断场景下 LoopEngineController.start 的
+            // finally 未执行，task_type 可能停留在被编排 load() 覆盖后的
+            // 'orchestrator' —— 修正为 'loop'，否则大循环历史页
+            // （taskType='loop' 过滤）看不到该任务。
+            const isLoopTask = state.taskDir
+                && fs.existsSync(path.join(state.taskDir, 'loop.json'));
+
             if (!existing) {
                 // 老任务未入库（TaskRegistryStore 上线前创建）：补录摘要，保留原始创建时间
                 await registry.upsert({
                     taskId,
-                    taskType: 'orchestrator',
+                    taskType: isLoopTask ? 'loop' : 'orchestrator',
                     status,
                     title: (firstStep.taskDescription || taskId).slice(0, 200),
                     description: firstStep.taskDescription || '',
@@ -865,7 +949,11 @@ class OrchestratorController {
                     metadata
                 });
             } else {
-                await registry.patch(taskId, { status, metadata });
+                const patchBody = { status, metadata };
+                if (isLoopTask && existing.task_type !== 'loop') {
+                    patchBody.task_type = 'loop';
+                }
+                await registry.patch(taskId, patchBody);
             }
             console.log(
                 `[OrchestratorController] 注册表已修正: taskId=${taskId}, ` +

package/vendor/Server/Routes/routes/flexrunner.js

@@ -21,6 +21,7 @@ import FlexRunnerController from '../controllers/FlexRunnerController.js';
  *  GET    /steps             — 列出任务步骤和文件
  *  GET    /file              — 读取指定文件内容
  *  GET    /archive           — 打包下载任务目录下全部 .md 报告（ZIP）
+ *  POST   /clean-source      — 删除任务目录下源码克隆目录 source/（释放存储，保留报告/过程文件）
  *  GET    /runners           — 列出所有已注册实例
  *  DELETE /runner            — 移除一个实例
  *
@@ -51,6 +52,7 @@ export function createFlexRunnerRouter(dependencies) {
     router.get('/steps',          controller.steps.bind(controller));
     router.get('/file',           controller.file.bind(controller));
     router.get('/archive',        controller.archive.bind(controller));
+    router.post('/clean-source',  controller.cleanSource.bind(controller));
     router.get('/runners',        controller.runners.bind(controller));
 
     // ── 控制与检查 ──

package/vendor/Server/TestCheck/TestCheck.js

@@ -451,7 +451,7 @@ class TestCheck {
             this._log('warn', `审核 Session ${sessionId} 未在超时时间内完成`);
         }
 
-        this._log('info', `invokeSkill 完成 — sessionId: ${sessionId}, completed: ${completed}`);
+        this._log('debug', `invokeSkill 完成 — sessionId: ${sessionId}, completed: ${completed}`);
         return { sessionId, executed: completed };
     }
 

package/vendor/VERSION

@@ -1,3 +1,3 @@
-0.0.5
-built=2026-09-03T03:43:15.270Z
-sha=45ad839069c351a8
+0.0.7
+built=2026-09-03T07:18:44.123Z
+sha=f1a4be02fe03f0c6

package/web/js/arktslibrarycheck.js

@@ -9,6 +9,8 @@
  *   步骤 2  arkts-library-interface-spec               — 接口规格分析（复用已克隆源码）
  *   步骤 3~6 stability / memoryLeak /                  — 4 个检视维度并发执行
  *            documentation / testCoverage                （dependId=2 fan-out）
+ *   步骤 ⑦  源码清理（前端动作，非编排步骤）           — 终态后删除 source/ 释放存储，
+ *                                                        仅删源码，报告与过程文件保留
  *
  * 每个检视 SKILL 输出 0-100 评分：
  *   - 首选：SKILL 按约定写 meta .json（stepId{X}_loop{L}_meta_{N}.json），
@@ -32,6 +34,7 @@
  *   6. GET  /api/flexrunner/steps?taskId= — 解析报告文件（懒加载）
  *   7. GET  /api/flexrunner/file?path= — 读取报告 / 评分兜底解析
  *   8. POST /api/orchestrator/abort — 取消任务
+ *   9. POST /api/flexrunner/clean-source — 终态后清理源码（仅删 source/，报告保留）
  *
  * 依赖：utils.js（apiFetch / createPagination / escapeHtml / toast / $）
  *       codecheck.css（cc-* 通用卡片样式）+ arktslibrarycheck.css（akt-* 扩展样式）
@@ -47,6 +50,8 @@ var _AKT_STEP_DEFS = [
     { stepId: 4, key: 'memoryleak',    skill: 'arkts-library-memory-leak-check',           num: '④', name: '内存泄露检视', desc: '生命周期、NAPI 引用、事件订阅',            report: '内存泄露检视报告.md',  scoreKey: 'memoryLeakScore' },
     { stepId: 5, key: 'documentation', skill: 'arkts-library-documentation-quality-check', num: '⑤', name: '文档质量检视', desc: '完整性、准确性、鸿蒙化专项',              report: '文档质量检视报告.md',  scoreKey: 'documentationScore' },
     { stepId: 6, key: 'testcoverage',  skill: 'arkts-library-test-coverage-check',         num: '⑥', name: '用例覆盖度检视', desc: '接口覆盖率、测试质量',                  report: '用例覆盖度检视报告.md', scoreKey: 'testCoverageScore' },
+    // ⑦ 源码清理：纯前端动作（uiOnly，不进 taskDef），终态后调用 /api/flexrunner/clean-source 删除 source/
+    { stepId: 7, key: 'cleansource',   skill: '', num: '⑦', name: '源码清理', desc: '检视完成删除 source/ 源码释放存储，保留报告与过程文件', report: null, scoreKey: null, uiOnly: true },
 ];
 
 /* 评分权重（与 AIweb ArktsLibraryCheck 综合评分口径一致，权重和 = 1） */
@@ -340,6 +345,7 @@ async function doArktsLibraryCheck() {
         // 4 个检视步骤（并发）：依赖步骤 1 已克隆的 source/ 和 步骤 2 生成的 接口规格说明.md
         for (var i = 2; i < _AKT_STEP_DEFS.length; i++) {
             var def = _AKT_STEP_DEFS[i];
+            if (def.uiOnly) continue; // 源码清理为纯前端动作，不进编排 taskDef
             var desc = [
                 '请使用 ' + def.skill + ' SKILL 对 ArkTS 三方库「' + repoInfo.repoName + '」进行' + def.name + '，生成检视报告。',
                 '',
@@ -431,6 +437,7 @@ function _aktNewTaskState(taskId, repoName, repoUrl) {
         _resolving: false,
         _progressLoaded: false,
         _terminalDone: false,
+        _cleanStarted: false,   // 源码清理是否已触发（幂等防重）
         mdFileCount: 0,    // taskDir 下的 .md 文件数（驱动"下载全部报告"按钮）
         reportPaths: {},   // 各维度专属报告文件（如 稳定性检视报告.md）
         resultPaths: {},   // 各步骤 result .md 兜底路径（部分 SKILL 会把报告合入 result 文件）
@@ -1035,6 +1042,8 @@ function _aktOnTerminal(idx, status) {
     _aktResolveFiles(idx).then(function () {
         _aktFallbackScores(idx);
     });
+    // 最后环节：清理源码（仅删 taskDir/source/，报告 .md / meta .json 等过程文件保留）
+    _aktCleanSource(idx);
 }
 
 function _aktFinishSSE(idx) {
@@ -1083,6 +1092,77 @@ function _aktRenderElapsed(idx) {
     if (timeEl && task.startedAt) timeEl.textContent = _aktFormatTime(task.startedAt);
 }
 
+/* ════════════════════════════════════════════════════════════════════
+ * 源码清理（检视最后环节：删除 taskDir/source/，节省存储）
+ *
+ * 后端 POST /api/flexrunner/clean-source 只删除任务目录下固定的 source/ 子目录
+ * （源码克隆路径），检视报告 .md、meta .json、orchestration.json 等文档与
+ * 过程文件均在 taskDir 根目录，不受影响。
+ * 触发时机：任务终态（_aktOnTerminal）；历史终态任务渲染时静默补删
+ * （覆盖检视期间页面被关闭、清理未触发的场景）。
+ * ════════════════════════════════════════════════════════════════════ */
+
+/** 字节数格式化：B / KB / MB / GB */
+function _aktFormatBytes(n) {
+    if (!isFinite(n) || n <= 0) return '0 B';
+    var units = ['B', 'KB', 'MB', 'GB'];
+    var i = 0;
+    while (n >= 1024 && i < units.length - 1) { n /= 1024; i++; }
+    return (i === 0 ? Math.round(n) : n.toFixed(1)) + ' ' + units[i];
+}
+
+/** 更新⑦"源码清理"步骤行状态（running / completed / failed） */
+function _aktSetCleanStatus(idx, status, freedBytes) {
+    var row = document.getElementById('akt-' + idx + '-row-cleansource');
+    var icon = document.getElementById('akt-' + idx + '-icon-cleansource');
+    var txt = document.getElementById('akt-' + idx + '-cleansource-txt');
+    if (row) row.className = 'akt-step-row ' + status;
+    if (icon) {
+        if (status === 'running') { icon.className = 'akt-step-icon running'; icon.textContent = '🧹'; }
+        else if (status === 'completed') { icon.className = 'akt-step-icon completed'; icon.textContent = '✓'; }
+        else if (status === 'failed') { icon.className = 'akt-step-icon failed'; icon.textContent = '✗'; }
+    }
+    if (txt) {
+        if (status === 'running') txt.textContent = '正在清理源码…';
+        else if (status === 'completed') txt.textContent = freedBytes != null ? '已清理源码，释放 ' + _aktFormatBytes(freedBytes) : '源码已清理';
+        else if (status === 'failed') txt.textContent = '清理失败';
+    }
+}
+
+/**
+ * 调用后端清理源码（幂等，失败允许下次触发重试）。
+ * @param {number} idx
+ * @param {boolean} [silent] - 静默模式（历史补删，不弹 toast）
+ */
+function _aktCleanSource(idx, silent) {
+    var task = _aktTasks[idx];
+    if (!task || task._cleanStarted) return;
+    task._cleanStarted = true;
+
+    _aktSetCleanStatus(idx, 'running');
+    apiFetch('POST', '/api/flexrunner/clean-source', { taskId: task.taskId }, 60000)
+        .then(function (r) {
+            if (r.data && r.data.status === 'ok' && r.data.cleaned) {
+                _aktSetCleanStatus(idx, 'completed', r.data.freedBytes);
+                if (!silent) {
+                    toast('info', '已清理源码（' + _aktEsc(task.repoName) + '），释放 ' + _aktFormatBytes(r.data.freedBytes) + ' 存储空间');
+                }
+            } else if (r.data && r.data.status === 'ok') {
+                // 无源码可清（未克隆 / 已清理过）→ 幂等完成
+                _aktSetCleanStatus(idx, 'completed');
+            } else {
+                // HTTP 错误（如 409 任务仍在执行）→ 失败可重试
+                task._cleanStarted = false;
+                _aktSetCleanStatus(idx, 'failed');
+            }
+        })
+        .catch(function () {
+            // 清理失败：重置标记，下次触发（如历史重新渲染）时重试
+            task._cleanStarted = false;
+            _aktSetCleanStatus(idx, 'failed');
+        });
+}
+
 /* ════════════════════════════════════════════════════════════════════
  * 停止检视
  * ════════════════════════════════════════════════════════════════════ */
@@ -1387,6 +1467,8 @@ function _aktRenderHistoryPage(tasks, isFirstPage) {
             _aktStartProgressPoll(idx);
         } else {
             _aktFinishSSE(idx);
+            // 终态历史任务：静默补删源码（覆盖检视期间页面关闭、终态清理未触发的场景）
+            _aktCleanSource(idx, true);
         }
     }
 }

package/web/js/codecheck.js

@@ -13,6 +13,7 @@
  *   6. GET  /api/flexrunner/steps?taskId= — 获取结果文件列表
  *   7. GET  /api/flexrunner/file?path= — 读取检视报告
  *   8. POST /api/orchestrator/abort — 取消任务
+ *   9. POST /api/flexrunner/clean-source — 终态后清理源码（仅删 source/，报告保留）
  *
  * 依赖：utils.js（apiFetch / API / createPagination / escapeHtml / toast / $）
  * ════════════════════════════════════════════════════════════════════ */
@@ -322,6 +323,7 @@ function _renderCCHistoryPage(tasks, isFirstPage) {
             startedAt: startTime || null,
             finishedAt: endTime || null,
             resultPath: null,
+            _cleanStarted: false,   // 源码清理是否已触发（幂等防重）
             // 列表响应中的结构化指标（终态任务直接渲染徽章，无需额外请求）
             metrics: t.metadata || null,
         };
@@ -372,6 +374,8 @@ function _handleTaskStage(idx, stage) {
         _startProgressPoll(idx);
     } else {
         _finishCCSSE(idx);
+        // 终态历史任务：静默补删源码（覆盖检视期间页面关闭、终态清理未触发的场景）
+        _ccCleanSource(idx, true);
         // 终态任务不主动拉文件（上千任务时列表渲染零额外请求）；
         // 展开卡片 / 点击预览/下载时才懒加载（toggleCCCard / viewCCReport / downloadCCReport）
     }
@@ -460,6 +464,7 @@ async function doCodeCheck() {
             startedAt: null,
             finishedAt: null,
             resultPath: null,
+            _cleanStarted: false,   // 源码清理是否已触发（幂等防重）
         };
 
         _createCCCard(idx, displayLabel, prUrl, libType, new Date().toISOString());
@@ -516,6 +521,8 @@ function _startProgressPoll(idx) {
                 _stopProgressPoll(idx);
                 _finishCCSSE(idx);
                 _loadCCResultFiles(idx);
+                // 最后环节：清理源码（仅删 taskDir/source/，报告与过程文件保留）
+                _ccCleanSource(idx);
             }
         } catch (e) { /* 静默失败 */ }
     }, 3000);
@@ -610,6 +617,52 @@ async function _loadCCResultFiles(idx) {
     } catch (e) { /* 静默失败 */ }
 }
 
+/* ── 源码清理（检视最后环节：删除 taskDir/source/，节省存储）──────────
+ *
+ * arkts/flutter/rn-code-check 检视过程中会把 PR 目标仓库克隆到任务目录的
+ * source/ 下，检视终态后源码不再被引用（报告 .md / meta .json 等过程文件
+ * 均在 taskDir 根目录，不受影响）；tpc-cpp-check 不克隆源码，后端幂等返回。
+ * 触发时机：任务终态（轮询 / SSE complete / 取消）；历史终态任务渲染时
+ * 静默补删（覆盖检视期间页面被关闭、清理未触发的场景）。
+ * ──────────────────────────────────────────────────────────────────── */
+
+/** 字节数格式化：B / KB / MB / GB */
+function _ccFormatBytes(n) {
+    if (!isFinite(n) || n <= 0) return '0 B';
+    var units = ['B', 'KB', 'MB', 'GB'];
+    var i = 0;
+    while (n >= 1024 && i < units.length - 1) { n /= 1024; i++; }
+    return (i === 0 ? Math.round(n) : n.toFixed(1)) + ' ' + units[i];
+}
+
+/**
+ * 调用后端清理源码（幂等，失败允许下次触发重试）。
+ * @param {number} idx
+ * @param {boolean} [silent] - 静默模式（历史补删 / 取消场景，不弹 toast）
+ */
+function _ccCleanSource(idx, silent) {
+    var task = _ccTasks[idx];
+    if (!task || task._cleanStarted) return;
+    task._cleanStarted = true;
+
+    apiFetch('POST', '/api/flexrunner/clean-source', { taskId: task.taskId }, 60000)
+        .then(function (r) {
+            if (r.data && r.data.status === 'ok' && r.data.cleaned) {
+                if (!silent) {
+                    toast('info', '已清理检视源码，释放 ' + _ccFormatBytes(r.data.freedBytes) + ' 存储空间');
+                }
+            } else if (!(r.data && r.data.status === 'ok')) {
+                // HTTP 错误（如 409 任务仍在执行）→ 失败可重试
+                task._cleanStarted = false;
+            }
+            // ok 且 cleaned=false：无源码可清（未克隆 / 已清理过）→ 幂等完成，不提示
+        })
+        .catch(function () {
+            // 清理失败：重置标记，下次触发（如历史重新渲染）时重试
+            task._cleanStarted = false;
+        });
+}
+
 /* ── 创建检视任务卡片 ────────────────────────────────────────────────── */
 function _createCCCard(idx, displayLabel, prUrl, libType, createdAt, isHistory) {
     var emptyEl = $('cc-tasks-empty');
@@ -764,6 +817,8 @@ function _connectCCSSE(idx) {
         _stopProgressPoll(idx);
         _finishCCSSE(idx);
         _loadCCResultFiles(idx);
+        // 最后环节：清理源码（仅删 taskDir/source/，报告与过程文件保留）
+        _ccCleanSource(idx);
     });
 
     // 编排错误
@@ -777,6 +832,8 @@ function _connectCCSSE(idx) {
         _updateCCStage(idx, 'aborted', {});
         _stopProgressPoll(idx);
         _finishCCSSE(idx);
+        // 终止场景：静默清理源码（已有"已取消"提示，避免 toast 叠加）
+        _ccCleanSource(idx, true);
     });
 
     // 连接建立
@@ -920,6 +977,8 @@ async function stopCCTask(idx) {
     _updateCCStage(idx, 'aborted', {});
     _stopProgressPoll(idx);
     _finishCCSSE(idx);
+    // 终止场景：静默清理源码（SSE aborted 监听会幂等兜底）
+    _ccCleanSource(idx, true);
 }
 
 /* ── 报告下载 ────────────────────────────────────────────────────────── */

package/web/js/flutterlibrarycheck.js

@@ -8,6 +8,8 @@
  *   步骤 1  flutter-interface                            — 克隆仓库 + 接口规格分析
  *   步骤 2~6 stability / consistency / memoryLeak /      — 5 个检视维度并发执行
  *            documentation / testCoverage                  （dependId=1 fan-out）
+ *   步骤 ⑦  源码清理（前端动作，非编排步骤）             — 终态后删除 source/ 释放存储，
+ *                                                          仅删源码，报告与过程文件保留
  *
  * 每个检视 SKILL 输出 0-100 评分：
  *   - 首选：SKILL 按约定写 meta .json（stepId{X}_loop{L}_meta_{N}.json），
@@ -24,6 +26,7 @@
  *   6. GET  /api/flexrunner/steps?taskId= — 解析报告文件（懒加载）
  *   7. GET  /api/flexrunner/file?path= — 读取报告 / 评分兜底解析
  *   8. POST /api/orchestrator/abort — 取消任务
+ *   9. POST /api/flexrunner/clean-source — 终态后清理源码（仅删 source/，报告保留）
  *
  * 依赖：utils.js（apiFetch / createPagination / escapeHtml / toast / $）
  *       codecheck.css（cc-* 通用卡片样式）+ flutterlibrarycheck.css（flc-* 扩展样式）
@@ -39,6 +42,8 @@ var _FLC_STEP_DEFS = [
     { stepId: 4, key: 'memoryleak',    skill: 'flutter-library-memory-leak-check',          num: '④', name: '内存泄露检视', desc: '生命周期、资源释放、Stream 管理',      report: '内存泄露检视报告.md', scoreKey: 'memoryLeakScore' },
     { stepId: 5, key: 'documentation', skill: 'flutter-library-documentation-quality-check', num: '⑤', name: '文档质量检视', desc: '鸿蒙化文档完整性、准确性、易读性',     report: '文档质量检视报告.md', scoreKey: 'documentationScore' },
     { stepId: 6, key: 'testcoverage',  skill: 'flutter-library-test-coverage-check',        num: '⑥', name: '用例覆盖度检视', desc: '测试覆盖率、Demo 覆盖率',           report: '用例覆盖度检视报告.md', scoreKey: 'testCoverageScore' },
+    // ⑦ 源码清理：纯前端动作（uiOnly，不进 taskDef），终态后调用 /api/flexrunner/clean-source 删除 source/
+    { stepId: 7, key: 'cleansource',   skill: '', num: '⑦', name: '源码清理', desc: '检视完成删除 source/ 源码释放存储，保留报告与过程文件', report: null, scoreKey: null, uiOnly: true },
 ];
 
 /* 评分权重（与 AIweb FlutterLibraryCheck 综合评分口径一致，权重和 = 1） */
@@ -301,6 +306,7 @@ async function doFlutterLibraryCheck() {
         // 5 个检视步骤（并发）：依赖步骤 1 已克隆的 source/ 和 接口规格说明.md
         for (var i = 1; i < _FLC_STEP_DEFS.length; i++) {
             var def = _FLC_STEP_DEFS[i];
+            if (def.uiOnly) continue; // 源码清理为纯前端动作，不进编排 taskDef
             var desc = [
                 '请使用 ' + def.skill + ' SKILL 对 Flutter 三方库「' + repoInfo.repoName + '」进行' + def.name + '，生成检视报告。',
                 '',
@@ -383,6 +389,7 @@ function _flcNewTaskState(taskId, repoUrl, repoName) {
         _resolving: false,
         _progressLoaded: false,
         _terminalDone: false,
+        _cleanStarted: false,   // 源码清理是否已触发（幂等防重）
         mdFileCount: 0,    // taskDir 下的 .md 文件数（驱动"下载全部报告"按钮）
         reportPaths: {},   // 各维度专属报告文件（如 稳定性检视报告.md）
         resultPaths: {},   // 各步骤 result .md 兜底路径（部分 SKILL 会把报告合入 result 文件）
@@ -826,9 +833,10 @@ async function _flcResolveFiles(idx) {
     var task = _flcTasks[idx];
     if (!task) return;
 
-    // 全部专属报告已找到 → 幂等返回
+    // 全部专属报告已找到 → 幂等返回（uiOnly / 无报告步骤跳过，如⑦源码清理）
     var allFound = true;
     for (var a = 0; a < _FLC_STEP_DEFS.length; a++) {
+        if (_FLC_STEP_DEFS[a].uiOnly || !_FLC_STEP_DEFS[a].report) continue;
         if (!task.reportPaths[_FLC_STEP_DEFS[a].key]) { allFound = false; break; }
     }
     if (allFound) { task.filesResolved = true; _flcShowReportButtons(idx); return; }
@@ -986,6 +994,8 @@ function _flcOnTerminal(idx, status) {
     _flcResolveFiles(idx).then(function () {
         _flcFallbackScores(idx);
     });
+    // 最后环节：清理源码（仅删 taskDir/source/，报告 .md / meta .json 等过程文件保留）
+    _flcCleanSource(idx);
 }
 
 function _flcFinishSSE(idx) {
@@ -1034,6 +1044,77 @@ function _flcRenderElapsed(idx) {
     if (timeEl && task.startedAt) timeEl.textContent = _flcFormatTime(task.startedAt);
 }
 
+/* ════════════════════════════════════════════════════════════════════
+ * 源码清理（检视最后环节：删除 taskDir/source/，节省存储）
+ *
+ * 后端 POST /api/flexrunner/clean-source 只删除任务目录下固定的 source/ 子目录
+ * （源码克隆路径），检视报告 .md、meta .json、orchestration.json 等文档与
+ * 过程文件均在 taskDir 根目录，不受影响。
+ * 触发时机：任务终态（_flcOnTerminal）；历史终态任务渲染时静默补删
+ * （覆盖检视期间页面被关闭、清理未触发的场景）。
+ * ════════════════════════════════════════════════════════════════════ */
+
+/** 字节数格式化：B / KB / MB / GB */
+function _flcFormatBytes(n) {
+    if (!isFinite(n) || n <= 0) return '0 B';
+    var units = ['B', 'KB', 'MB', 'GB'];
+    var i = 0;
+    while (n >= 1024 && i < units.length - 1) { n /= 1024; i++; }
+    return (i === 0 ? Math.round(n) : n.toFixed(1)) + ' ' + units[i];
+}
+
+/** 更新⑦"源码清理"步骤行状态（running / completed / failed） */
+function _flcSetCleanStatus(idx, status, freedBytes) {
+    var row = document.getElementById('flc-' + idx + '-row-cleansource');
+    var icon = document.getElementById('flc-' + idx + '-icon-cleansource');
+    var txt = document.getElementById('flc-' + idx + '-cleansource-txt');
+    if (row) row.className = 'flc-step-row ' + status;
+    if (icon) {
+        if (status === 'running') { icon.className = 'flc-step-icon running'; icon.textContent = '🧹'; }
+        else if (status === 'completed') { icon.className = 'flc-step-icon completed'; icon.textContent = '✓'; }
+        else if (status === 'failed') { icon.className = 'flc-step-icon failed'; icon.textContent = '✗'; }
+    }
+    if (txt) {
+        if (status === 'running') txt.textContent = '正在清理源码…';
+        else if (status === 'completed') txt.textContent = freedBytes != null ? '已清理源码，释放 ' + _flcFormatBytes(freedBytes) : '源码已清理';
+        else if (status === 'failed') txt.textContent = '清理失败';
+    }
+}
+
+/**
+ * 调用后端清理源码（幂等，失败允许下次触发重试）。
+ * @param {number} idx
+ * @param {boolean} [silent] - 静默模式（历史补删，不弹 toast）
+ */
+function _flcCleanSource(idx, silent) {
+    var task = _flcTasks[idx];
+    if (!task || task._cleanStarted) return;
+    task._cleanStarted = true;
+
+    _flcSetCleanStatus(idx, 'running');
+    apiFetch('POST', '/api/flexrunner/clean-source', { taskId: task.taskId }, 60000)
+        .then(function (r) {
+            if (r.data && r.data.status === 'ok' && r.data.cleaned) {
+                _flcSetCleanStatus(idx, 'completed', r.data.freedBytes);
+                if (!silent) {
+                    toast('info', '已清理源码（' + _flcEsc(task.repoName) + '），释放 ' + _flcFormatBytes(r.data.freedBytes) + ' 存储空间');
+                }
+            } else if (r.data && r.data.status === 'ok') {
+                // 无源码可清（未克隆 / 已清理过）→ 幂等完成
+                _flcSetCleanStatus(idx, 'completed');
+            } else {
+                // HTTP 错误（如 409 任务仍在执行）→ 失败可重试
+                task._cleanStarted = false;
+                _flcSetCleanStatus(idx, 'failed');
+            }
+        })
+        .catch(function () {
+            // 清理失败：重置标记，下次触发（如历史重新渲染）时重试
+            task._cleanStarted = false;
+            _flcSetCleanStatus(idx, 'failed');
+        });
+}
+
 /* ════════════════════════════════════════════════════════════════════
  * 停止检视
  * ════════════════════════════════════════════════════════════════════ */
@@ -1338,6 +1419,8 @@ function _flcRenderHistoryPage(tasks, isFirstPage) {
             _flcStartProgressPoll(idx);
         } else {
             _flcFinishSSE(idx);
+            // 终态历史任务：静默补删源码（覆盖检视期间页面关闭、终态清理未触发的场景）
+            _flcCleanSource(idx, true);
         }
     }
 }

package/web/js/rnlibrarycheck.js

@@ -9,6 +9,9 @@
  *   步骤 2~7 stability / consistency / memoryLeak /    — 6 个检视维度并发执行
  *            documentation / testCoverage /             （dependId=1 fan-out）
  *            knownIssue（独立扣分项）
+ *   步骤 ⑧  源码清理（前端动作，非编排步骤）           — 终态后删除 source/ 释放存储
+ *                                                          （ohos/ + RN/），仅删源码，
+ *                                                          报告与过程文件保留
  *
  * 每个检视 SKILL 输出 0-100 评分：
  *   - 首选：SKILL 按约定写 meta .json（stepId{X}_loop{L}_meta_{N}.json），
@@ -33,6 +36,7 @@
  *   6. GET  /api/flexrunner/steps?taskId= — 解析报告文件（懒加载）
  *   7. GET  /api/flexrunner/file?path= — 读取报告 / 评分兜底解析
  *   8. POST /api/orchestrator/abort — 取消任务
+ *   9. POST /api/flexrunner/clean-source — 终态后清理源码（仅删 source/，报告保留）
  *
  * 依赖：utils.js（apiFetch / createPagination / escapeHtml / toast / $）
  *       codecheck.css（cc-* 通用卡片样式）+ rnlibrarycheck.css（rn-* 扩展样式）
@@ -49,6 +53,8 @@ var _RN_STEP_DEFS = [
     { stepId: 5, key: 'documentation', skill: 'rn-library-documentation-quality-check',   num: '⑤', name: '文档质量检视', desc: 'API 注释、适配说明、示例质量',              report: '文档质量检视报告.md', scoreKey: 'documentationScore' },
     { stepId: 6, key: 'testcoverage',  skill: 'rn-library-test-coverage-check',           num: '⑥', name: '用例覆盖度检视', desc: '测试覆盖率、Demo 覆盖率',               report: '用例覆盖度检视报告.md', scoreKey: 'testCoverageScore' },
     { stepId: 7, key: 'knownissue',    skill: 'rn-library-known-issue-check',             num: '⑦', name: '已知问题检视', desc: '历史案例规则回归，独立扣分项（命中一条扣 30 分）', report: '已知问题检视报告.md', scoreKey: 'knownIssueScore' },
+    // ⑧ 源码清理：纯前端动作（uiOnly，不进 taskDef），终态后调用 /api/flexrunner/clean-source 删除 source/（ohos/ + RN/）
+    { stepId: 8, key: 'cleansource',   skill: '', num: '⑧', name: '源码清理', desc: '检视完成删除 source/ 源码释放存储，保留报告与过程文件', report: null, scoreKey: null, uiOnly: true },
 ];
 
 /* 评分权重（与 AIweb RNLibraryCheck 综合评分口径一致，权重和 = 1；knownissue 为独立扣分项不参与加权） */
@@ -283,6 +289,7 @@ async function doRNLibraryCheck() {
         // 6 个检视步骤（并发）：依赖步骤 1 已克隆的 source/ohos/、source/RN/ 和 接口规格说明.md
         for (var i = 1; i < _RN_STEP_DEFS.length; i++) {
             var def = _RN_STEP_DEFS[i];
+            if (def.uiOnly) continue; // 源码清理为纯前端动作，不进编排 taskDef
             var desc = [
                 '请使用 ' + def.skill + ' SKILL 对 RN 三方库「' + libraryName + '」进行' + def.name + '，生成检视报告。',
                 '',
@@ -384,6 +391,7 @@ function _rnNewTaskState(taskId, libraryName, ohosRepoUrl, upstreamRepoUrl, rndo
         _resolving: false,
         _progressLoaded: false,
         _terminalDone: false,
+        _cleanStarted: false,   // 源码清理是否已触发（幂等防重）
         mdFileCount: 0,    // taskDir 下的 .md 文件数（驱动"下载全部报告"按钮）
         reportPaths: {},   // 各维度专属报告文件（如 稳定性检视报告.md）
         resultPaths: {},   // 各步骤 result .md 兜底路径（部分 SKILL 会把报告合入 result 文件）
@@ -837,9 +845,10 @@ async function _rnResolveFiles(idx) {
     var task = _rnTasks[idx];
     if (!task) return;
 
-    // 全部专属报告已找到 → 幂等返回
+    // 全部专属报告已找到 → 幂等返回（uiOnly / 无报告步骤跳过，如⑧源码清理）
     var allFound = true;
     for (var a = 0; a < _RN_STEP_DEFS.length; a++) {
+        if (_RN_STEP_DEFS[a].uiOnly || !_RN_STEP_DEFS[a].report) continue;
         if (!task.reportPaths[_RN_STEP_DEFS[a].key]) { allFound = false; break; }
     }
     if (allFound) { task.filesResolved = true; _rnShowReportButtons(idx); return; }
@@ -997,6 +1006,8 @@ function _rnOnTerminal(idx, status) {
     _rnResolveFiles(idx).then(function () {
         _rnFallbackScores(idx);
     });
+    // 最后环节：清理源码（仅删 taskDir/source/（ohos/ + RN/），报告 .md / meta .json 等过程文件保留）
+    _rnCleanSource(idx);
 }
 
 function _rnFinishSSE(idx) {
@@ -1045,6 +1056,77 @@ function _rnRenderElapsed(idx) {
     if (timeEl && task.startedAt) timeEl.textContent = _rnFormatTime(task.startedAt);
 }
 
+/* ════════════════════════════════════════════════════════════════════
+ * 源码清理（检视最后环节：删除 taskDir/source/，节省存储）
+ *
+ * 后端 POST /api/flexrunner/clean-source 只删除任务目录下固定的 source/ 子目录
+ * （RN 双仓库源码克隆路径，含 ohos/ 与 RN/），检视报告 .md、meta .json、
+ * orchestration.json 等文档与过程文件均在 taskDir 根目录，不受影响。
+ * 触发时机：任务终态（_rnOnTerminal）；历史终态任务渲染时静默补删
+ * （覆盖检视期间页面被关闭、清理未触发的场景）。
+ * ════════════════════════════════════════════════════════════════════ */
+
+/** 字节数格式化：B / KB / MB / GB */
+function _rnFormatBytes(n) {
+    if (!isFinite(n) || n <= 0) return '0 B';
+    var units = ['B', 'KB', 'MB', 'GB'];
+    var i = 0;
+    while (n >= 1024 && i < units.length - 1) { n /= 1024; i++; }
+    return (i === 0 ? Math.round(n) : n.toFixed(1)) + ' ' + units[i];
+}
+
+/** 更新⑧"源码清理"步骤行状态（running / completed / failed） */
+function _rnSetCleanStatus(idx, status, freedBytes) {
+    var row = document.getElementById('rn-' + idx + '-row-cleansource');
+    var icon = document.getElementById('rn-' + idx + '-icon-cleansource');
+    var txt = document.getElementById('rn-' + idx + '-cleansource-txt');
+    if (row) row.className = 'rn-step-row ' + status;
+    if (icon) {
+        if (status === 'running') { icon.className = 'rn-step-icon running'; icon.textContent = '🧹'; }
+        else if (status === 'completed') { icon.className = 'rn-step-icon completed'; icon.textContent = '✓'; }
+        else if (status === 'failed') { icon.className = 'rn-step-icon failed'; icon.textContent = '✗'; }
+    }
+    if (txt) {
+        if (status === 'running') txt.textContent = '正在清理源码…';
+        else if (status === 'completed') txt.textContent = freedBytes != null ? '已清理源码，释放 ' + _rnFormatBytes(freedBytes) : '源码已清理';
+        else if (status === 'failed') txt.textContent = '清理失败';
+    }
+}
+
+/**
+ * 调用后端清理源码（幂等，失败允许下次触发重试）。
+ * @param {number} idx
+ * @param {boolean} [silent] - 静默模式（历史补删，不弹 toast）
+ */
+function _rnCleanSource(idx, silent) {
+    var task = _rnTasks[idx];
+    if (!task || task._cleanStarted) return;
+    task._cleanStarted = true;
+
+    _rnSetCleanStatus(idx, 'running');
+    apiFetch('POST', '/api/flexrunner/clean-source', { taskId: task.taskId }, 60000)
+        .then(function (r) {
+            if (r.data && r.data.status === 'ok' && r.data.cleaned) {
+                _rnSetCleanStatus(idx, 'completed', r.data.freedBytes);
+                if (!silent) {
+                    toast('info', '已清理源码（' + _rnEsc(task.libraryName) + '），释放 ' + _rnFormatBytes(r.data.freedBytes) + ' 存储空间');
+                }
+            } else if (r.data && r.data.status === 'ok') {
+                // 无源码可清（未克隆 / 已清理过）→ 幂等完成
+                _rnSetCleanStatus(idx, 'completed');
+            } else {
+                // HTTP 错误（如 409 任务仍在执行）→ 失败可重试
+                task._cleanStarted = false;
+                _rnSetCleanStatus(idx, 'failed');
+            }
+        })
+        .catch(function () {
+            // 清理失败：重置标记，下次触发（如历史重新渲染）时重试
+            task._cleanStarted = false;
+            _rnSetCleanStatus(idx, 'failed');
+        });
+}
+
 /* ════════════════════════════════════════════════════════════════════
  * 停止检视
  * ════════════════════════════════════════════════════════════════════ */
@@ -1352,6 +1434,8 @@ function _rnRenderHistoryPage(tasks, isFirstPage) {
             _rnStartProgressPoll(idx);
         } else {
             _rnFinishSSE(idx);
+            // 终态历史任务：静默补删源码（覆盖检视期间页面关闭、终态清理未触发的场景）
+            _rnCleanSource(idx, true);
         }
     }
 }