@ohos-cpf/3rdloop 0.0.6 → 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

@@ -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/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.6",
+    "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

@@ -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/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/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/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.6
-built=2026-09-03T04:17:37.208Z
-sha=3dae4a21a88fb4e7
+0.0.7
+built=2026-09-03T07:18:44.123Z
+sha=f1a4be02fe03f0c6