@ohos-cpf/3rdloop 0.0.5 → 0.0.6

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 ──────────────────────────────────────────────────

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ohos-cpf/3rdloop",
-    "version": "0.0.5",
+    "version": "0.0.6",
     "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' };
         }
     }

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/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/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/VERSION

@@ -1,3 +1,3 @@
-0.0.5
-built=2026-09-03T03:43:15.270Z
-sha=45ad839069c351a8
+0.0.6
+built=2026-09-03T04:17:37.208Z
+sha=3dae4a21a88fb4e7

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);
         }
     }
 }