opencode-metrics-plugin 0.3.1 → 0.3.3

package/dist/metrics/upload/uploadManager.js

@@ -3,9 +3,9 @@ import * as path from "node:path";
 import { log } from "../../shared/log.js";
 import { EvidenceCollector, isPathInside, resolveAndroidProjectName, resolveWorkspaceRoots, } from "./workspaceResolver.js";
 import { archiveSessionPackage } from "./packageArchiver.js";
-import { createAgcUploader, defaultAgcConfigPath, loadAgcCredentials, remoteArchiveKey } from "./agcUploader.js";
+import { createAgcUploader, composeRemoteBase, defaultAgcConfigPath, loadAgcCredentials, remoteArchiveKey } from "./agcUploader.js";
 import { createUploadQueue } from "./uploadQueue.js";
-import { resolveScenarios } from "./scenarios.js";
+import { resolveScenarios, matchToolScenarios } from "./scenarios.js";
 import { MAX_ROOTS } from "./types.js";
 /**
  * 创建上传管理器：串联证据 → 根推断 → 打包 → 队列 → AGC 上传，
@@ -25,37 +25,87 @@ export function createUploadManager(options) {
     const uploader = createAgcUploader(credentialsResult.credentials);
     const scenarios = resolveScenarios(config.scenarios);
     const directories = options.dirs;
-    // 启动扫残留：上次进程未清理的暂存产物直接删除
-    sweepStagingDirectory(directories.uploadStagingDir);
+    // 终态场景标签集合：这些标签的包上传成功即写已传标记（孤儿扫描防重依据）
+    const terminalLabels = new Set(scenarios
+        .filter((s) => s.enabled && (s.events.includes("session.deleted") || s.toolNames.length > 0))
+        .map((s) => s.label));
+    // 失败保留与启动补偿配置（默认开启）
+    const rescueEnabled = config.retryRescue?.enabled !== false;
+    const retentionMs = (config.retryRescue?.retentionDays ?? 7) * 24 * 60 * 60 * 1000;
+    const maxFailedBytes = config.retryRescue?.maxFailedBytes ?? 1024 * 1024 * 1024;
+    // 启动扫残留：崩溃遗留的完整三件套移入 failed/（待重传），孤立文件删除；
+    // failed/ 存量先做过期/超量清理再重新入队补偿上传
     const queue = createUploadQueue({
         worker: (uploadPackage) => uploader.uploadPackage(uploadPackage),
         maxAttempts: config.retry?.maxAttempts,
         backoffMs: config.retry?.backoffMs,
         onSettled: (uploadPackage, ok, reason) => {
-            removeQuietly(uploadPackage.archive.filePath);
-            removeQuietly(uploadPackage.snapshot.filePath);
+            const metaPath = uploadPackage.archive.filePath.replace(/\.tar\.gz$/, ".meta.json");
             if (ok) {
+                removeQuietly(uploadPackage.archive.filePath);
+                removeQuietly(uploadPackage.snapshot.filePath);
+                removeQuietly(metaPath);
+                // 终态包上云成功：写已传标记，孤儿扫描据此跳过该会话
+                if (terminalLabels.has(uploadPackage.trigger)) {
+                    markSessionUploaded(directories.metricsDir, uploadPackage.sessionId);
+                }
+                // 来自 failed/ 的补偿重传：清掉可能残留的空目录
+                removeEmptyDirsUp(path.dirname(uploadPackage.archive.filePath), path.join(directories.uploadStagingDir, "failed"));
                 log.info("[Metrics] 上传完成", {
                     sessionId: uploadPackage.sessionId,
                     fileName: uploadPackage.archive.fileName,
                     remoteKey: remoteArchiveKey(uploadPackage),
                 });
+                return;
             }
-            else {
+            if (!rescueEnabled) {
+                removeQuietly(uploadPackage.archive.filePath);
+                removeQuietly(uploadPackage.snapshot.filePath);
+                removeQuietly(metaPath);
                 log.error("[Metrics] 上传失败（暂存已清理）", { sessionId: uploadPackage.sessionId, reason: reason ?? "" });
+                return;
+            }
+            const atStagingTop = path.resolve(path.dirname(uploadPackage.archive.filePath)) === path.resolve(directories.uploadStagingDir);
+            if (atStagingTop) {
+                const failedDir = movePackageIntoFailed(directories.uploadStagingDir, uploadPackage, metaPath);
+                log.error("[Metrics] 上传失败（已保留至 failed 目录，下次启动重传）", {
+                    sessionId: uploadPackage.sessionId,
+                    reason: reason ?? "",
+                    failedDir,
+                });
+            }
+            else {
+                // 补偿重传仍失败：原地保留，下次启动再试
+                log.error("[Metrics] 补偿重传仍失败（继续保留待下次）", { sessionId: uploadPackage.sessionId, reason: reason ?? "" });
             }
         },
     });
+    const rescued = [
+        ...sweepStagingDirectory(directories.uploadStagingDir, rescueEnabled),
+        ...collectFailedPackages(directories.uploadStagingDir, retentionMs, maxFailedBytes),
+    ];
+    if (rescued.length > 0) {
+        log.info("[Metrics] 启动补偿：历史失败/遗留包重新入队", { count: rescued.length });
+        for (const pkg of rescued)
+            queue.enqueue(pkg);
+    }
+    // 孤儿快照补传：宿主死亡导致终态触发从未发生时，按快照年龄补打 session-end 包
+    if (config.orphanRescue?.enabled !== false) {
+        const idleMs = (config.orphanRescue?.idleHours ?? 24) * 3_600_000;
+        const maxAgeMs = (config.orphanRescue?.maxAgeDays ?? 7) * 86_400_000;
+        void rescueOrphanSnapshots(idleMs, maxAgeMs);
+    }
     const sessions = new Map();
     const childToParent = new Map();
     const completedBashCalls = new Set();
+    const toolTriggeredCalls = new Set();
     function resolveSessionId(rawId) {
         return childToParent.get(rawId) ?? rawId;
     }
     function getOrCreateEvidence(sessionId) {
         let entry = sessions.get(sessionId);
         if (!entry) {
-            entry = { collector: new EvidenceCollector(), agentName: "", workingDirectory: "" };
+            entry = { collector: new EvidenceCollector(), agentName: "", workingDirectory: "", startedAt: Date.now() };
             sessions.set(sessionId, entry);
         }
         return entry;
@@ -63,23 +113,27 @@ export function createUploadManager(options) {
     /**
      * 触发一次上传：根推断 + 包名推断 + 打包入队。
      *
-     * @param sessionId    会话 id
-     * @param triggerLabel 场景命名标签
+     * @param sessionId        会话 id
+     * @param triggerLabel     场景命名标签
+     * @param evidenceOverride 证据覆盖（孤儿补传时由快照构造，代替内存证据）
      */
-    async function triggerUpload(sessionId, triggerLabel) {
-        const evidence = sessions.get(sessionId) ?? { collector: new EvidenceCollector(), agentName: "", workingDirectory: "" };
+    async function triggerUpload(sessionId, triggerLabel, evidenceOverride) {
+        const evidence = evidenceOverride ??
+            sessions.get(sessionId) ??
+            { collector: new EvidenceCollector(), agentName: "", workingDirectory: "", startedAt: Date.now() };
         const seeds = evidence.collector.seeds();
         const { directRoots, extraMarkers } = collectArtifactRules(seeds, evidence.workingDirectory, config.appendArtifacts ?? []);
         const detectedRoots = resolveWorkspaceRoots(seeds, {
             extraDirMarkers: extraMarkers.extraDirMarkers,
             extraFileMarkers: extraMarkers.extraFileMarkers,
             excludeAndroidProjects: config.excludeAndroidProjects,
+            sessionStartedAt: evidence.startedAt,
         });
         const roots = dedupePaths([...detectedRoots, ...directRoots]).slice(0, MAX_ROOTS);
         const projectName = resolveAndroidProjectName(seeds, {
             fallbackDirectory: evidence.workingDirectory || roots[0] || "",
         }) ?? "project";
-        options.onBeforeArchive?.();
+        options.onBeforeArchive?.(sessionId);
         const archiveResult = await archiveSessionPackage({
             sessionId,
             trigger: triggerLabel,
@@ -114,8 +168,12 @@ export function createUploadManager(options) {
             const evidence = getOrCreateEvidence(resolveSessionId(id));
             if (event.type === "session.created") {
                 const directory = info.directory;
-                if (directory)
+                if (directory) {
                     evidence.workingDirectory = directory;
+                    // 工作目录作为证据种子：即使全程无 write/bash 证据（如纯 task 转换会话），
+                    // 触发上传时也能扫描工作区完成根推断与包名推断
+                    evidence.collector.recordBash(directory, "");
+                }
             }
             else {
                 const agent = info.agent;
@@ -134,18 +192,19 @@ export function createUploadManager(options) {
             if (!part || part.type !== "tool")
                 return;
             const toolState = part.state;
-            if (toolState?.status !== "completed")
+            const status = toolState?.status;
+            if (status !== "completed" && status !== "error")
                 return;
             const tool = part.tool;
-            const input = toolState.input;
+            const input = toolState?.input;
             const callID = part.callID;
-            if (tool === "write" || tool === "edit") {
+            if (status === "completed" && (tool === "write" || tool === "edit")) {
                 const filePath = input?.filePath || input?.path;
                 if (filePath)
                     evidence.collector.recordFileEdit(filePath);
                 return;
             }
-            if (tool === "bash") {
+            if (status === "completed" && tool === "bash") {
                 const command = input?.command || "";
                 const workdir = input?.workdir;
                 evidence.collector.recordBash(workdir, command);
@@ -161,6 +220,18 @@ export function createUploadManager(options) {
                         void triggerUpload(sessionId, scenario.label);
                     }
                 }
+                return;
+            }
+            // 工具名场景命中：根会话直接调用的工具进入终态（completed/error）即触发
+            // （task 委派返回即业务终态，失败也存终态；子代理内部的嵌套调用不触发）
+            const matched = matchToolScenarios(scenarios, tool ?? "", status ?? "", !childToParent.has(rawSessionId));
+            if (matched.length > 0 && (!callID || !toolTriggeredCalls.has(callID))) {
+                if (callID)
+                    toolTriggeredCalls.add(callID);
+                for (const scenario of matched) {
+                    log.info("[Metrics] 工具终态触发", { sessionId, tool, status, scenario: scenario.label });
+                    void triggerUpload(sessionId, scenario.label);
+                }
             }
             return;
         }
@@ -182,6 +253,40 @@ export function createUploadManager(options) {
         }
         await queue.drain(10_000);
     }
+    /** 终态场景标签：事件含 session.deleted 的启用场景，缺省回退 session-end */
+    function terminalScenarioLabel() {
+        return scenarios.find((s) => s.enabled && s.events.includes("session.deleted"))?.label ?? "session-end";
+    }
+    /**
+     * 扫描 metrics 目录孤儿快照并补打 session-end 包：mtime 静默 [idleMs, maxAgeMs]
+     * 且不属于本进程活跃会话的快照视为孤儿。上传成功后快照即被删除，
+     * "文件仍在"天然等价于"终态未传出"，无需额外标记。
+     *
+     * @param idleMs   静默下限（毫秒）
+     * @param maxAgeMs 年龄上限（毫秒）
+     */
+    async function rescueOrphanSnapshots(idleMs, maxAgeMs) {
+        const triggerLabel = terminalScenarioLabel();
+        const orphans = await selectOrphanSnapshots(directories.metricsDir, idleMs, maxAgeMs, (sessionId) => sessions.has(sessionId));
+        for (const orphan of orphans) {
+            try {
+                // 工作目录作为证据种子：推断产物根与项目名（内存证据已随进程丢失）
+                const collector = new EvidenceCollector();
+                if (orphan.workingDirectory)
+                    collector.recordBash(orphan.workingDirectory, "");
+                await triggerUpload(orphan.sessionId, triggerLabel, {
+                    collector,
+                    agentName: orphan.agentName,
+                    workingDirectory: orphan.workingDirectory,
+                    startedAt: orphan.startedAt,
+                });
+                log.info("[Metrics] 孤儿快照补传", { sessionId: orphan.sessionId, trigger: triggerLabel });
+            }
+            catch (err) {
+                log.warn("[Metrics] 孤儿快照补传失败", { sessionId: orphan.sessionId, error: String(err) });
+            }
+        }
+    }
     return { observe, dispose };
 }
 /** 应用 appendArtifacts 规则：marker 进探测扩展，显式路径按 matchBy 命中后作为直接根 */
@@ -225,12 +330,41 @@ function dedupePaths(paths) {
     }
     return result;
 }
-/** 启动清扫暂存目录：删除上次进程遗留的产物与组装目录 */
-function sweepStagingDirectory(stagingDir) {
+/**
+ * 启动清扫暂存目录顶层：崩溃遗留的完整三件套（tar.gz + json + meta.json）
+ * 移入 failed/ 同构目录并入队重传；孤立文件与组装目录直接删除。
+ *
+ * @param stagingDir    暂存目录
+ * @param rescueEnabled 失败保留开关（false 时完整三件套也直接删除，旧行为）
+ * @returns             可补偿重传的包列表（顶层遗留部分）
+ */
+function sweepStagingDirectory(stagingDir, rescueEnabled) {
+    const rescued = [];
     try {
+        const entries = fs.readdirSync(stagingDir);
+        const names = new Set(entries);
+        const handled = new Set(["failed"]);
         let removed = 0;
-        for (const entry of fs.readdirSync(stagingDir)) {
-            if (entry.endsWith(".tar.gz") || entry.endsWith(".json") || entry.startsWith(".assembly-")) {
+        for (const entry of entries) {
+            if (handled.has(entry))
+                continue;
+            if (entry.endsWith(".tar.gz")) {
+                const base = entry.slice(0, -".tar.gz".length);
+                const pkg = rescueEnabled ? loadIntactPackage(stagingDir, base, names) : undefined;
+                if (pkg) {
+                    movePackageIntoFailed(stagingDir, pkg, path.join(stagingDir, `${base}.meta.json`));
+                    rescued.push(pkg);
+                }
+                else {
+                    fs.rmSync(path.join(stagingDir, entry), { force: true });
+                    removed++;
+                }
+                handled.add(entry);
+                handled.add(`${base}.json`);
+                handled.add(`${base}.meta.json`);
+                continue;
+            }
+            if (entry.endsWith(".json") || entry.startsWith(".assembly-")) {
                 fs.rmSync(path.join(stagingDir, entry), { recursive: true, force: true });
                 removed++;
             }
@@ -241,6 +375,157 @@ function sweepStagingDirectory(stagingDir) {
     catch {
         // 目录不存在：无需处理
     }
+    return rescued;
+}
+/**
+ * 读取暂存顶层完整三件套并重建上传包（meta 反序列化 + 双文件在位校验）。
+ *
+ * @param stagingDir 暂存目录
+ * @param base       包基名（不含后缀）
+ * @param names      顶层文件名集合
+ * @returns           完整时返回包；任何缺失/损坏返回 undefined
+ */
+function loadIntactPackage(stagingDir, base, names) {
+    const jsonName = `${base}.json`;
+    const metaName = `${base}.meta.json`;
+    if (!names.has(jsonName) || !names.has(metaName))
+        return undefined;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(stagingDir, metaName), "utf-8"));
+        if (pkg?.archive?.fileName !== `${base}.tar.gz` || pkg?.snapshot?.fileName !== jsonName)
+            return undefined;
+        pkg.archive.filePath = path.join(stagingDir, pkg.archive.fileName);
+        pkg.snapshot.filePath = path.join(stagingDir, pkg.snapshot.fileName);
+        if (!fs.existsSync(pkg.archive.filePath) || !fs.existsSync(pkg.snapshot.filePath))
+            return undefined;
+        return pkg;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 计算包在 failed/ 下的落位目录（与云端对象路径同构，便于查找与手动上传）：
+ * failed/YYYYMMDD/<projectName>-<sessionId>/<agent缩写>-<trigger>-v<n>/
+ */
+function failedDirFor(stagingDir, pkg) {
+    const segments = composeRemoteBase(pkg).split("/");
+    segments.pop();
+    return path.join(stagingDir, "failed", ...segments);
+}
+/**
+ * 把包的双文件与 meta 移入 failed/ 同构目录（同盘 rename）。
+ *
+ * @param stagingDir 暂存目录
+ * @param pkg        上传包
+ * @param metaPath   meta 文件当前路径
+ * @returns           落位目录
+ */
+function movePackageIntoFailed(stagingDir, pkg, metaPath) {
+    const targetDir = failedDirFor(stagingDir, pkg);
+    fs.mkdirSync(targetDir, { recursive: true });
+    pkg.archive.filePath = renameInto(pkg.archive.filePath, path.join(targetDir, pkg.archive.fileName));
+    pkg.snapshot.filePath = renameInto(pkg.snapshot.filePath, path.join(targetDir, pkg.snapshot.fileName));
+    renameInto(metaPath, path.join(targetDir, path.basename(metaPath)));
+    return targetDir;
+}
+/** rename 到目标（已存在则先删）；返回目标路径 */
+function renameInto(source, target) {
+    try {
+        fs.rmSync(target, { force: true });
+        fs.renameSync(source, target);
+    }
+    catch {
+        // 移动失败：文件留在原处，下次启动清扫兜底
+    }
+    return target;
+}
+/**
+ * 收集 failed/ 存量包：先做过期（retentionMs）与总量（maxFailedBytes，从最旧删起）
+ * 清理，再把完整包重建（filePath 重指 failed/ 内）返回入队。
+ *
+ * @param stagingDir     暂存目录
+ * @param retentionMs    保留时长（毫秒）
+ * @param maxFailedBytes 总量字节上限
+ * @returns              可重传的包列表
+ */
+function collectFailedPackages(stagingDir, retentionMs, maxFailedBytes) {
+    const failedRoot = path.join(stagingDir, "failed");
+    if (!fs.existsSync(failedRoot))
+        return [];
+    const packages = [];
+    const walk = (dir, depth) => {
+        if (depth > 4)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const child = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(child, depth + 1);
+                continue;
+            }
+            if (!entry.name.endsWith(".meta.json"))
+                continue;
+            try {
+                const pkg = JSON.parse(fs.readFileSync(child, "utf-8"));
+                const pkgDir = path.dirname(child);
+                pkg.archive.filePath = path.join(pkgDir, pkg.archive.fileName);
+                pkg.snapshot.filePath = path.join(pkgDir, pkg.snapshot.fileName);
+                if (!fs.existsSync(pkg.archive.filePath) || !fs.existsSync(pkg.snapshot.filePath)) {
+                    fs.rmSync(pkgDir, { recursive: true, force: true });
+                    continue;
+                }
+                pkg.archive.sizeBytes = fs.statSync(pkg.archive.filePath).size;
+                pkg.snapshot.sizeBytes = fs.statSync(pkg.snapshot.filePath).size;
+                packages.push({ pkg, dir: pkgDir, size: pkg.archive.sizeBytes + pkg.snapshot.sizeBytes, createdAt: pkg.createdAt ?? 0 });
+            }
+            catch {
+                // meta 损坏：整目录删除，防止永久残留
+                fs.rmSync(path.dirname(child), { recursive: true, force: true });
+            }
+        }
+    };
+    walk(failedRoot, 0);
+    const now = Date.now();
+    const survivors = [];
+    let totalBytes = 0;
+    let removed = 0;
+    for (const item of packages.sort((a, b) => a.createdAt - b.createdAt)) {
+        if (now - item.createdAt > retentionMs || totalBytes + item.size > maxFailedBytes) {
+            fs.rmSync(item.dir, { recursive: true, force: true });
+            removeEmptyDirsUp(path.dirname(item.dir), failedRoot);
+            removed++;
+            continue;
+        }
+        totalBytes += item.size;
+        survivors.push(item);
+    }
+    if (removed > 0)
+        log.info("[Metrics] failed 目录清理（过期/超量）", { stagingDir, removed });
+    removeEmptyDirsUp(failedRoot, failedRoot);
+    return survivors.map((item) => item.pkg);
+}
+/** 自下而上删除空目录（直到 root，含 root 本身可删） */
+function removeEmptyDirsUp(directory, root) {
+    let current = path.resolve(directory);
+    const top = path.resolve(root);
+    while (current.startsWith(top)) {
+        try {
+            fs.rmdirSync(current);
+        }
+        catch {
+            return;
+        }
+        if (current === top)
+            return;
+        current = path.dirname(current);
+    }
 }
 function removeQuietly(filePath) {
     try {
@@ -250,3 +535,78 @@ function removeQuietly(filePath) {
         // 删除失败只记日志层面忽略
     }
 }
+// ─── 孤儿快照补传（§13 失败补偿链路） ─────────────────────────────────────────
+/** 已传终态标记目录名（metrics/.sent/<sessionId>） */
+const SENT_MARKER_DIR = ".sent";
+/**
+ * 记录会话终态包已成功上云。
+ * 快照原件（metrics/<sessionId>.json）会永久保留为本地记录，
+ * "已传标记"才是孤儿扫描防重复上传的依据。
+ */
+export function markSessionUploaded(metricsDir, sessionId) {
+    try {
+        fs.mkdirSync(path.join(metricsDir, SENT_MARKER_DIR), { recursive: true });
+        fs.writeFileSync(path.join(metricsDir, SENT_MARKER_DIR, sessionId), String(Date.now()));
+    }
+    catch {
+        // 标记失败仅导致下次启动多一次补传判断，不阻塞上传链路
+    }
+}
+/** 会话终态包是否已成功上云 */
+export function isSessionUploaded(metricsDir, sessionId) {
+    return fs.existsSync(path.join(metricsDir, SENT_MARKER_DIR, sessionId));
+}
+/**
+ * 扫描目录选出孤儿快照候选：mtime 静默 [idleMs, maxAgeMs] 且不在活跃集的快照。
+ * 上传成功后快照即被删除，"文件仍在"天然等价于"终态未传出"。
+ *
+ * @param metricsDir 快照目录
+ * @param idleMs     静默下限（毫秒）
+ * @param maxAgeMs   年龄上限（毫秒）
+ * @param isActive   活跃会话判定（IO 前后各查一次，防竞态）
+ * @returns           候选列表（无法解析的快照跳过）
+ */
+export async function selectOrphanSnapshots(metricsDir, idleMs, maxAgeMs, isActive) {
+    const result = [];
+    let entries;
+    try {
+        entries = await fs.promises.readdir(metricsDir);
+    }
+    catch {
+        return result;
+    }
+    const now = Date.now();
+    for (const entry of entries) {
+        if (!entry.endsWith(".json"))
+            continue;
+        const sessionId = entry.slice(0, -".json".length);
+        if (isSessionUploaded(metricsDir, sessionId))
+            continue;
+        const filePath = path.join(metricsDir, entry);
+        try {
+            const stats = await fs.promises.stat(filePath);
+            const age = now - stats.mtimeMs;
+            if (age < idleMs || age > maxAgeMs)
+                continue;
+            if (isActive(sessionId))
+                continue;
+            const snapshot = JSON.parse(await fs.promises.readFile(filePath, "utf-8"));
+            if (isActive(sessionId))
+                continue;
+            const header = (snapshot.header ?? {});
+            result.push({
+                sessionId,
+                filePath,
+                workingDirectory: header.workingDirectory || "",
+                agentName: header.agent || "",
+                startedAt: (typeof snapshot.startTime === "number" && snapshot.startTime > 0 && snapshot.startTime) ||
+                    Date.parse(header.startTime || "") ||
+                    stats.mtimeMs,
+            });
+        }
+        catch {
+            // 无法解析的快照跳过，不阻塞其余候选
+        }
+    }
+    return result;
+}

package/dist/metrics/upload/workspaceResolver.d.ts

@@ -30,6 +30,8 @@ export interface ResolveRootsOptions {
     extraFileMarkers?: string[];
     /** 剔除安卓工程根（缺省 true） */
     excludeAndroidProjects?: boolean;
+    /** 会话开始时间戳（毫秒）；提供时启用兄弟鸿蒙工程探测（mtime 时间窗防邻居混入） */
+    sessionStartedAt?: number;
 }
 /**
  * 判断目录是否为安卓工程：统计 gradle 构建信号（settings.gradle、gradlew、

package/dist/metrics/upload/workspaceResolver.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { DEFAULT_DIR_MARKERS, DEFAULT_FILE_MARKERS, MAX_PROBE_DEPTH, MAX_ROOTS, sanitizeNameSegment, } from "./types.js";
+import { DEFAULT_BLACKLIST, DEFAULT_DIR_MARKERS, DEFAULT_FILE_MARKERS, MAX_PROBE_DEPTH, MAX_ROOTS, sanitizeNameSegment, } from "./types.js";
 /**
  * 会话证据收集器：旁路记录 write/edit 的文件路径与 bash 的工作目录、命令路径线索。
  * 触发上传时用这些路径推断产物根。
@@ -87,6 +87,86 @@ export function looksLikeAndroidProject(directory) {
 function hasHarmonyProjectMarkers(directory) {
     return ["oh-package.json5", "build-profile.json5", "hvigorfile.ts", "AppScope"].some((marker) => fs.existsSync(path.join(directory, marker)));
 }
+/** 安卓根内可直接提升为产物根的工作区目录名（droid2hmos 的 .migration 与转换工具的 .harmonyos） */
+const HARMONY_WORKSPACE_DIRS = [".migration", ".harmonyos"];
+/** 容器化降级扫描深度：安卓根内向内找鸿蒙子根的最大层数 */
+const NESTED_SCAN_DEPTH = 2;
+/**
+ * 在安卓工程根内部收集鸿蒙产物根：BFS 扫描（最多 NESTED_SCAN_DEPTH 层，
+ * 跳过黑名单目录），子目录含鸿蒙工程标记、或为 .migration/.harmonyos
+ * 工作区目录时提升为产物根；命中后不再深入该子树。
+ *
+ * @param androidRoot 安卓工程根绝对路径
+ * @returns           提升的鸿蒙产物根数组（空数组 = 纯安卓工程，整体丢弃）
+ */
+function findNestedHarmonyRoots(androidRoot) {
+    const found = [];
+    const skipped = new Set(DEFAULT_BLACKLIST.map((name) => name.toLowerCase()));
+    const queue = [{ directory: androidRoot, depth: 0 }];
+    while (queue.length > 0) {
+        const { directory, depth } = queue.shift();
+        let entries;
+        try {
+            entries = fs.readdirSync(directory, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || skipped.has(entry.name.toLowerCase()))
+                continue;
+            const child = path.join(directory, entry.name);
+            if (HARMONY_WORKSPACE_DIRS.includes(entry.name) || hasHarmonyProjectMarkers(child)) {
+                found.push(child);
+                continue;
+            }
+            if (depth + 1 < NESTED_SCAN_DEPTH) {
+                queue.push({ directory: child, depth: depth + 1 });
+            }
+        }
+    }
+    return found;
+}
+/**
+ * 在安卓工程根的同级目录探测兄弟鸿蒙工程：扫描父目录一级，子目录含鸿蒙
+ * 工程标记、且目录 mtime 不早于会话开始时间（本会话内被写入，防邻居旧
+ * 工程混入）时提升为产物根。
+ *
+ * @param androidRoot      安卓工程根绝对路径
+ * @param sessionStartedAt 会话开始时间戳（毫秒）
+ * @returns                提升的兄弟鸿蒙产物根数组
+ */
+function findSiblingHarmonyRoots(androidRoot, sessionStartedAt) {
+    const parent = path.dirname(path.resolve(androidRoot));
+    const selfKey = normalizeKey(androidRoot);
+    let entries;
+    try {
+        entries = fs.readdirSync(parent, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const entry of entries) {
+        // 隐藏目录（.git/.idea 等）不作为工程候选
+        if (!entry.isDirectory() || entry.name.startsWith("."))
+            continue;
+        const sibling = path.join(parent, entry.name);
+        if (normalizeKey(sibling) === selfKey)
+            continue;
+        if (!hasHarmonyProjectMarkers(sibling))
+            continue;
+        try {
+            if (fs.statSync(sibling).mtimeMs < sessionStartedAt)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        found.push(sibling);
+    }
+    return found;
+}
 /**
  * 从证据路径推断产物根：自每条证据所在目录向上逐级探测标记（最多 5 层），
  * 目录内存在任一标记即记为根；安卓工程根（自身无鸿蒙工程标记）先剔除，
@@ -111,6 +191,11 @@ export function resolveWorkspaceRoots(seeds, options) {
             if (markers.some((marker) => fs.existsSync(path.join(current, marker)))) {
                 found.push(current);
             }
+            else if (looksLikeAndroidProject(current)) {
+                // 无标记的安卓根也纳入候选：由剔除分支做容器化降级
+                // （向内提升鸿蒙子根/工作区、按时间窗探测兄弟工程）
+                found.push(current);
+            }
             const parent = path.dirname(current);
             if (parent === current)
                 break;
@@ -119,7 +204,20 @@ export function resolveWorkspaceRoots(seeds, options) {
     }
     let candidates = dedupeRoots(found);
     if (options?.excludeAndroidProjects !== false) {
-        candidates = candidates.filter((root) => !looksLikeAndroidProject(root) || hasHarmonyProjectMarkers(root));
+        const kept = [];
+        for (const root of candidates) {
+            if (!looksLikeAndroidProject(root) || hasHarmonyProjectMarkers(root)) {
+                kept.push(root);
+                continue;
+            }
+            // 安卓根容器化降级：不整体丢弃，向内收集鸿蒙子根/工作区，
+            // 并按会话时间窗向外探测兄弟鸿蒙工程（防邻居旧工程混入）
+            kept.push(...findNestedHarmonyRoots(root));
+            if (options?.sessionStartedAt !== undefined) {
+                kept.push(...findSiblingHarmonyRoots(root, options.sessionStartedAt));
+            }
+        }
+        candidates = dedupeRoots(kept);
     }
     return limitRoots(mergeNestedRoots(candidates));
 }

package/dist/shared/log.d.ts

@@ -1,7 +1,12 @@
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export declare function setLogLevel(level: LogLevel): void;
-/** 设置运行日志落盘文件；传 null 关闭文件输出（仅 console）。 */
+/** 设置运行日志基准文件；实际写入 <所在目录>/log/plugin/YYYYMMDD.log；传 null 关闭文件输出（仅 console）。 */
 export declare function setLogFile(file: string | null): void;
+/**
+ * 清理过期运行日志：只删基准同目录 log/plugin/ 下严格 YYYYMMDD.log
+ * 且 mtime 超过保留天数的文件；其余任何文件一概不碰。幂等，可反复调用。
+ */
+export declare function cleanupOldLogFiles(): void;
 export declare function flushLogs(): void;
 export declare const log: {
     debug(...parts: unknown[]): void;