@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.10

package/dist/worker/console/workspace-context.js

@@ -265,6 +265,7 @@ export async function createWorkspaceContext(record, deps) {
     const aimaxAuth = new AimaxAuthReader();
     await aimaxAuth.getToken();
     const sddDataAlignment = new SddDataAlignmentService(chatStore, aimaxAuth, deps.fetchImpl);
+    actionContext.sddDataAlignment = sddDataAlignment;
     const chatEventEpoch = randomBytes(12).toString("hex");
     const chatEvents = createChatEventStore({
         appData,
@@ -318,6 +319,7 @@ export async function createWorkspaceContext(record, deps) {
         terminalRegistry,
         scmService,
         browserAutomation,
+        globalAppDataRoot: appData.root,
     });
     let chatRouteDeps;
     const goalRoundDriver = new GoalRoundDriver((sessionId) => driveGoalRound(chatRouteDeps, sessionId));

package/dist/worker/console/workspace-initialization.js

@@ -2,7 +2,7 @@ import { lstat, readFile } from "node:fs/promises";
 import path from "node:path";
 import { acquireUpdateLock, updateLockPath } from "../../shared/update/state.js";
 import os from "node:os";
-import { TERMINAL_OPERATION_STATES } from "../../infrastructure/console/operation-store.js";
+import { isOperationOccupied } from "../../infrastructure/console/operation-store.js";
 import { readInitRuntimeActivity } from "../observability/init-runtime-activity.js";
 const record = (value) => {
     if (!value || typeof value !== "object" || Array.isArray(value))
@@ -138,7 +138,7 @@ export class WorkspaceInitializationService {
     }
     async check(refresh = false) {
         const latest = (await this.options.operations.list()).filter(op => op.action === "workspaceInitialize").at(-1);
-        const running = latest && !TERMINAL_OPERATION_STATES.has(latest.state) && latest.state !== "needs-reconcile";
+        const running = latest && isOperationOccupied(latest.state);
         if (!running && (refresh || !this.cached || Date.now() - this.cached.at > 30_000)) {
             const generation = this.generation;
             this.pending ??= this.inspect().then(value => { if (generation === this.generation)
@@ -174,7 +174,7 @@ export class WorkspaceInitializationService {
             if (activity.workerProjectionError || activity.activeDagRunIds.length || activity.activeWorkerTasks || activity.activeWorkerBatches || this.options.activeChatTurnCount())
                 throw new Error("当前工作区有任务或对话正在运行，请结束后重试");
             const operations = await this.options.operations.list();
-            if (operations.some(op => op.operationId !== operationId && !TERMINAL_OPERATION_STATES.has(op.state) && op.state !== "needs-reconcile"))
+            if (operations.some(op => op.operationId !== operationId && isOperationOccupied(op.state)))
                 throw new Error("当前工作区有其他操作正在运行，请稍后重试");
             const before = await this.inspect();
             if (before.state === "error")

package/dist/worker/observability/read-model.js

@@ -2176,6 +2176,12 @@ function isExecutedNodeStatus(status) {
         return false;
     return EXECUTED_NODE_STATUSES.has(status.toLowerCase());
 }
+/**
+ * Node statuses that have not reached a terminal outcome. A live node's last
+ * recorded attempt can be a failure that is already being retried, so history
+ * copy must not present it as the final result.
+ */
+const LIVE_NODE_STATUSES = new Set(["running", "started", "paused"]);
 const PASS_SUCCESS_STATUSES = new Set([
     "finished",
     "completed",
@@ -2221,12 +2227,21 @@ export function projectExecutionSummary(options) {
         const recovered = totalAttemptCount > 1 &&
             firstOutcome === "failure" &&
             finalOutcome === "success";
+        // A node that is still live (running/started/paused) has not reached a
+        // final outcome: its last *recorded* attempt may have failed while a
+        // retry is already queued. Labelling that "最终失败" told the operator
+        // the run was over when it was still working, so keep the attempt count
+        // and mark the last attempt instead of the node.
+        const stillRunning = options.status !== undefined &&
+            LIVE_NODE_STATUSES.has(options.status.toLowerCase());
         // 一次就成功/失败：卡片不展示 historyLabel；Inspector 仍可拿 attempts 元数据。
         const historyLabel = totalAttemptCount <= 1
             ? undefined
             : recovered
                 ? `${totalAttemptCount} 次 · 先失败后成功`
-                : `${totalAttemptCount} 次 · 最终${finalOutcome === "success" ? "成功" : "失败"}`;
+                : stillRunning && finalOutcome === "failure"
+                    ? `${totalAttemptCount} 次 · 最近一次失败，仍在重试`
+                    : `${totalAttemptCount} 次 · 最终${finalOutcome === "success" ? "成功" : "失败"}`;
         return {
             totalAttemptCount,
             ...(recovered ? { recovered: true } : {}),
@@ -2266,12 +2281,18 @@ export function projectExecutionSummary(options) {
         }
         // 仅一轮 pass 时不在卡片展示（无叙事价值）；多轮才展示中文「修复轮次 N」
         // 主文案，裸 P1/P2 编号不再作为主标题（原始编号仅 hover/title/诊断）。
+        // 与 attempt 分支同理：节点仍在运行时，最后一个已记录 pass 的失败只是
+        // 阶段性事实，不能当作最终结论。
+        const livePasses = options.status !== undefined &&
+            LIVE_NODE_STATUSES.has(options.status.toLowerCase());
         const historyLabel = passes.length <= 1
             ? undefined
             : `修复轮次 ${passes.join(",")}${finalOutcome === "success"
                 ? " · 最终成功"
                 : finalOutcome === "failure"
-                    ? " · 最终失败"
+                    ? livePasses
+                        ? " · 最近一轮失败，仍在重试"
+                        : " · 最终失败"
                     : ""}`;
         return {
             totalAttemptCount: passes.length,

package/dist/worker/observe/node-context-insights.js

@@ -0,0 +1,479 @@
+/**
+ * Read-only context insights projection for a DAG node attempt — the
+ * loop-agent counterpart of the dsh-context dashboard, built exclusively from
+ * recorded run facts:
+ *
+ *   - context receipt (`<node>/context-receipts/attempt-N.json`) → composition
+ *   - session events (`<node>/session-events.jsonl`) → per-request usage
+ *     trend, tool activity, file footprint, timing
+ *   - node record (`<node>.json`) → skill injection footprint, headline totals
+ *
+ * Everything is derived deterministically from persisted facts; nothing is
+ * estimated beyond what the recorded bytes already contain. All projections are
+ * read-only, bounded, and redaction-preserving (paths already pass through
+ * redactSecrets in node-transparency before reaching here for receipt data;
+ * file-activity paths are redacted in this module).
+ */
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { redactSecrets } from "../../shared/preview.js";
+import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
+import { resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
+export const NODE_CONTEXT_INSIGHTS_SCHEMA_VERSION = 1;
+/** Upper bound on session-event lines scanned per attempt (defensive). */
+const SESSION_EVENT_LINE_LIMIT = 50_000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asInt(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : null;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+/** Minimal per-line JSON parse (session events are JSONL). */
+function parseSessionEventLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function messageOf(event) {
+    const message = event.message;
+    return isRecord(message) ? message : null;
+}
+function contentBlocksOf(message) {
+    const content = message?.content;
+    return Array.isArray(content) ? content : [];
+}
+function usageOf(message) {
+    const usage = message?.usage;
+    return isRecord(usage) ? usage : null;
+}
+function toolNameOfArgs(args) {
+    for (const key of ["path", "file", "file_path", "filePath"]) {
+        const value = args[key];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return null;
+}
+function searchTargetsOfArgs(args) {
+    const targets = [];
+    const push = (value) => {
+        if (typeof value === "string" && value.length > 0)
+            targets.push(value);
+    };
+    push(args.path);
+    push(args.directory);
+    push(args.dir);
+    const pattern = asString(args.pattern) ?? asString(args.query);
+    if (pattern)
+        targets.push(`pattern:${pattern.slice(0, 120)}`);
+    return targets;
+}
+/** Extract referenced file paths from a bash command string (best effort). */
+function filesFromCommand(command) {
+    const files = [];
+    const patterns = [
+        /(?:^|\s)(?:cat|head|tail|less|more)\s+([^\s;&|]+)/g,
+        /(?:^|\s)(?:rg|grep|find|fd|ls)\s+.*?([^\s;&|]*\.[A-Za-z0-9]{1,8})/g,
+        /(?:^|\s)(?:sed|awk|sort|uniq|wc)\s+.*?([^\s;&|]*\.[A-Za-z0-9]{1,8})/g,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(command)) !== null) {
+            const candidate = match[1];
+            if (candidate && candidate.length > 1)
+                files.push(candidate);
+        }
+    }
+    return files;
+}
+function classifyFileOp(toolName) {
+    const name = toolName.toLowerCase();
+    if (["read", "read_file", "readfile", "view"].includes(name))
+        return "read";
+    if (["write", "write_file", "writefile", "create"].includes(name))
+        return "write";
+    if (["edit", "str_replace", "str_replace_editor", "apply_patch"].includes(name))
+        return "edit";
+    if (["grep", "rg", "find", "fd", "search", "glob", "list", "ls"].includes(name))
+        return "search";
+    return null;
+}
+function normalizeRepoPath(raw, repoRoot) {
+    let value = raw;
+    const resolvedRoot = path.resolve(repoRoot);
+    const rootVariants = [
+        resolvedRoot,
+        resolvedRoot.replace(/\\/g, "/"),
+        resolvedRoot.replace(/\\/g, "/").toLowerCase(),
+    ];
+    for (const variant of rootVariants) {
+        if (value.toLowerCase().startsWith(`${variant.toLowerCase()}\\`) ||
+            value.toLowerCase().startsWith(`${variant.toLowerCase()}/`)) {
+            value = value.slice(variant.length + 1);
+            break;
+        }
+        if (value.toLowerCase() === variant.toLowerCase()) {
+            value = ".";
+            break;
+        }
+    }
+    return value.replace(/\\/g, "/");
+}
+function accumulateFileActivity(fileActivity, key, op) {
+    const existing = fileActivity.get(key) ?? {
+        path: key,
+        reads: 0,
+        writes: 0,
+        edits: 0,
+        searches: 0,
+    };
+    if (op === "read")
+        existing.reads += 1;
+    else if (op === "write")
+        existing.writes += 1;
+    else if (op === "edit")
+        existing.edits += 1;
+    else
+        existing.searches += 1;
+    fileActivity.set(key, existing);
+}
+/**
+ * Pure projection over parsed session events. Exported for unit tests.
+ */
+export function projectSessionInsights(events, repoRoot) {
+    let requestCount = 0;
+    let toolCalls = 0;
+    let toolErrors = 0;
+    let humanInputs = 0;
+    let thinkingSteps = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    let cacheSamples = 0;
+    let cacheHits = 0;
+    const requests = [];
+    const toolCounters = new Map();
+    const fileActivity = new Map();
+    // Tool calls issued in the current in-flight model request (reset per
+    // assistant message_end) so each request row attributes its own calls.
+    let pendingToolCalls = 0;
+    let pendingThinking = false;
+    for (const event of events) {
+        if (!event)
+            continue;
+        const type = asString(event.type);
+        if (type === "tool_execution_start") {
+            toolCalls += 1;
+            pendingToolCalls += 1;
+            const toolName = asString(event.toolName) ?? "unknown";
+            const row = toolCounters.get(toolName) ?? {
+                toolName,
+                calls: 0,
+                errors: 0,
+            };
+            row.calls += 1;
+            toolCounters.set(toolName, row);
+            const args = isRecord(event.args) ? event.args : {};
+            const op = classifyFileOp(toolName);
+            if (op === "read" || op === "write" || op === "edit") {
+                const target = toolNameOfArgs(args);
+                if (target) {
+                    accumulateFileActivity(fileActivity, normalizeRepoPath(redactSecrets(target), repoRoot), op);
+                }
+            }
+            else if (op === "search") {
+                for (const target of searchTargetsOfArgs(args)) {
+                    accumulateFileActivity(fileActivity, normalizeRepoPath(redactSecrets(target), repoRoot), "search");
+                }
+            }
+            else if (toolName.toLowerCase() === "bash") {
+                const command = asString(args.command) ?? "";
+                for (const file of filesFromCommand(command)) {
+                    accumulateFileActivity(fileActivity, normalizeRepoPath(redactSecrets(file), repoRoot), "search");
+                }
+            }
+            continue;
+        }
+        if (type === "tool_execution_end") {
+            if (event.isError === true)
+                toolErrors += 1;
+            continue;
+        }
+        const message = messageOf(event);
+        if (!message)
+            continue;
+        const role = asString(message.role);
+        if (type === "message_start" && role === "assistant") {
+            // A new model request begins.
+            requestCount += 1;
+            pendingToolCalls = 0;
+            pendingThinking = false;
+            continue;
+        }
+        if (type === "message_end" && role === "assistant") {
+            for (const block of contentBlocksOf(message)) {
+                if (isRecord(block) && asString(block.type) === "thinking") {
+                    thinkingSteps += 1;
+                    pendingThinking = true;
+                }
+            }
+            const usage = usageOf(message);
+            const input = asInt(usage?.input);
+            const output = asInt(usage?.output);
+            const cacheRead = asInt(usage?.cacheRead);
+            const cacheWrite = asInt(usage?.cacheWrite);
+            if (usage && (input ?? 0) + (cacheRead ?? 0) > 0) {
+                cacheSamples += 1;
+                if ((cacheRead ?? 0) > 0)
+                    cacheHits += 1;
+            }
+            if (input != null)
+                inputTokens += input;
+            if (output != null)
+                outputTokens += output;
+            if (cacheRead != null)
+                cacheReadTokens += cacheRead;
+            if (cacheWrite != null)
+                cacheWriteTokens += cacheWrite;
+            requests.push({
+                request: requestCount,
+                recordedAt: asString(event.recordedAt),
+                model: asString(message.model),
+                provider: asString(message.provider),
+                usage: usage == null
+                    ? null
+                    : {
+                        input,
+                        output,
+                        cacheRead,
+                        cacheWrite,
+                        totalTokens: asInt(usage.totalTokens),
+                    },
+                stopReason: asString(message.stopReason),
+                toolCalls: pendingToolCalls,
+                thinking: pendingThinking,
+            });
+            pendingToolCalls = 0;
+            pendingThinking = false;
+            continue;
+        }
+        if (type === "message_end" && role === "user") {
+            humanInputs += 1;
+        }
+    }
+    const toolActivity = [...toolCounters.values()].sort((a, b) => b.calls - a.calls || a.toolName.localeCompare(b.toolName));
+    const fileActivityRows = [...fileActivity.values()].sort((a, b) => b.reads + b.writes + b.edits + b.searches -
+        (a.reads + a.writes + a.edits + a.searches) ||
+        a.path.localeCompare(b.path));
+    return {
+        requests,
+        toolActivity,
+        fileActivity: fileActivityRows,
+        stats: {
+            requests: requestCount,
+            toolCalls,
+            toolErrors,
+            humanInputs,
+            thinkingSteps,
+            cacheHitRate: cacheSamples > 0 ? cacheHits / cacheSamples : null,
+            inputTokens,
+            outputTokens,
+            cacheReadTokens,
+            cacheWriteTokens,
+        },
+    };
+}
+export async function loadDagNodeContextInsights(repoRoot, dagRunId, nodeId, attempt) {
+    if (!isSafeObservabilityIdentifier(dagRunId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid DAG run identifier", reason: "invalid-id" },
+        };
+    }
+    if (!isSafeObservabilityIdentifier(nodeId)) {
+        return {
+            status: 400,
+            body: { error: "Invalid node identifier", reason: "invalid-id" },
+        };
+    }
+    const resolvedRun = resolveDagRunJson(repoRoot, dagRunId);
+    if (!resolvedRun.ok) {
+        return {
+            status: resolvedRun.reason === "invalid-id" ? 400 : 404,
+            body: { error: "DAG run not found", reason: resolvedRun.reason },
+        };
+    }
+    // Node record (<nodeId>.json) carries attempt metadata + headline totals.
+    const recordResolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        `${nodeId}.json`,
+    ]);
+    let nodeRecord = null;
+    if (recordResolved.ok) {
+        try {
+            const raw = JSON.parse(await readFile(recordResolved.result.absolutePath, "utf8"));
+            if (isRecord(raw))
+                nodeRecord = raw;
+        }
+        catch {
+            nodeRecord = null;
+        }
+    }
+    const selectedAttempt = normalizeAttemptNumber(attempt, nodeRecord);
+    // Context receipt composition.
+    const receiptResolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "context-receipts",
+        `attempt-${selectedAttempt}.json`,
+    ]);
+    let composition = null;
+    if (receiptResolved.ok) {
+        try {
+            const raw = JSON.parse(await readFile(receiptResolved.result.absolutePath, "utf8"));
+            if (isRecord(raw) && Array.isArray(raw.orderedComponents)) {
+                const byKind = new Map();
+                for (const entry of raw.orderedComponents) {
+                    if (!isRecord(entry))
+                        continue;
+                    const kind = asString(entry.kind);
+                    const bytes = asInt(entry.bytes) ?? 0;
+                    if (!kind)
+                        continue;
+                    const slice = byKind.get(kind) ?? { kind, items: 0, bytes: 0 };
+                    slice.items += 1;
+                    slice.bytes += bytes;
+                    byKind.set(kind, slice);
+                }
+                composition = [...byKind.values()].sort((a, b) => b.bytes - a.bytes);
+            }
+        }
+        catch {
+            composition = null;
+        }
+    }
+    // Session events for the node (single file across attempts in v1 format).
+    const sessionResolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "session-events.jsonl",
+    ]);
+    let sessionProjection = null;
+    if (sessionResolved.ok) {
+        try {
+            const raw = await readFile(sessionResolved.result.absolutePath, "utf8");
+            const lines = raw.split("\n").slice(0, SESSION_EVENT_LINE_LIMIT);
+            const events = lines
+                .map((line) => line.trim())
+                .filter(Boolean)
+                .map(parseSessionEventLine);
+            sessionProjection = projectSessionInsights(events, repoRoot);
+        }
+        catch {
+            sessionProjection = null;
+        }
+    }
+    const attemptRecord = findAttemptRecord(nodeRecord, selectedAttempt);
+    const timing = timingFromRecords(nodeRecord, attemptRecord);
+    const skills = skillInjectionsOf(nodeRecord);
+    const body = {
+        schemaVersion: NODE_CONTEXT_INSIGHTS_SCHEMA_VERSION,
+        dagRunId,
+        nodeId,
+        attempt: selectedAttempt,
+        generatedFrom: {
+            sessionEvents: sessionProjection != null,
+            contextReceipt: composition != null,
+            nodeRecord: nodeRecord != null,
+        },
+        stats: {
+            requests: sessionProjection?.stats.requests ?? 0,
+            toolCalls: sessionProjection?.stats.toolCalls ?? 0,
+            toolErrors: sessionProjection?.stats.toolErrors ?? 0,
+            humanInputs: sessionProjection?.stats.humanInputs ?? 0,
+            thinkingSteps: sessionProjection?.stats.thinkingSteps ?? 0,
+            tokensUsed: asInt(attemptRecord?.tokensUsed) ?? asInt(nodeRecord?.tokensUsed),
+            parsedEvents: asInt(attemptRecord?.parsedEvents) ?? asInt(nodeRecord?.parsedEvents),
+            writeToolCallCount: asInt(attemptRecord?.writeToolCallCount) ??
+                asInt(nodeRecord?.writeToolCallCount),
+            cacheHitRate: sessionProjection?.stats.cacheHitRate ?? null,
+            inputTokens: sessionProjection?.stats.inputTokens ?? null,
+            outputTokens: sessionProjection?.stats.outputTokens ?? null,
+            cacheReadTokens: sessionProjection?.stats.cacheReadTokens ?? null,
+            cacheWriteTokens: sessionProjection?.stats.cacheWriteTokens ?? null,
+        },
+        timing,
+        composition,
+        skills,
+        toolActivity: sessionProjection?.toolActivity ?? [],
+        fileActivity: sessionProjection?.fileActivity ?? [],
+        usageTrend: sessionProjection?.requests ?? [],
+    };
+    return { status: 200, body };
+}
+function normalizeAttemptNumber(rawAttempt, nodeRecord) {
+    if (Number.isSafeInteger(rawAttempt) && (rawAttempt ?? 0) > 0) {
+        return rawAttempt;
+    }
+    if (typeof nodeRecord?.currentAttempt === "number" &&
+        Number.isSafeInteger(nodeRecord.currentAttempt) &&
+        nodeRecord.currentAttempt > 0) {
+        return nodeRecord.currentAttempt;
+    }
+    return 1;
+}
+function findAttemptRecord(nodeRecord, attempt) {
+    if (!nodeRecord)
+        return null;
+    const attempts = nodeRecord.attempts;
+    if (!Array.isArray(attempts))
+        return null;
+    for (const entry of attempts) {
+        if (isRecord(entry) && entry.attempt === attempt)
+            return entry;
+    }
+    return null;
+}
+function timingFromRecords(nodeRecord, attemptRecord) {
+    const attemptTiming = isRecord(attemptRecord?.timing)
+        ? attemptRecord.timing
+        : null;
+    const nodeTiming = isRecord(nodeRecord?.timing)
+        ? nodeRecord.timing
+        : null;
+    return {
+        startedAt: asString(attemptRecord?.startedAt) ?? asString(nodeRecord?.startedAt),
+        finishedAt: asString(attemptRecord?.finishedAt) ?? asString(nodeRecord?.finishedAt),
+        durationMs: asInt(attemptRecord?.durationMs) ?? asInt(nodeRecord?.durationMs),
+        executorDurationMs: asInt(attemptTiming?.executorDurationMs) ??
+            asInt(nodeTiming?.executorDurationMs),
+    };
+}
+function skillInjectionsOf(nodeRecord) {
+    const raw = nodeRecord?.resolvedSkills;
+    if (!Array.isArray(raw))
+        return [];
+    const skills = [];
+    for (const entry of raw) {
+        if (!isRecord(entry))
+            continue;
+        const name = asString(entry.name);
+        if (!name)
+            continue;
+        skills.push({
+            name,
+            resolution: asString(entry.resolution) ?? "unknown",
+            bytes: asInt(entry.bytes),
+            truncated: entry.truncated === true,
+            injectionMode: asString(entry.injectionMode),
+        });
+    }
+    return skills;
+}