@tea-agent/loop-agent 0.44.0-next.4 → 0.44.0-next.5

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

package/docs/README.md

@@ -2,7 +2,7 @@
 
 `docs/` 是 loop-agent 源仓的治理文档根目录。新读者不需要先浏览所有文件，先按任务选择入口，再由目录 README 或 `docs/document-catalog.json` 判断文档身份。
 
-**维护日：2026-08-16** — 对齐 `@tea-agent/loop-agent@0.35.3`。版本事实以根 `CHANGELOG.md` 与 `package.json` 为准；能力短摘要见 `reports/current-capability-summary.md`。
+**维护日：2026-09-16** — 对齐 `@tea-agent/loop-agent@0.41.1-beta.0`。版本事实以根 `CHANGELOG.md` 与 `package.json` 为准；能力短摘要见 `reports/current-capability-summary.md`。
 
 ## 我现在要做什么？
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.44.0-next.4",
+  "version": "0.44.0-next.5",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/dist/worker/console/static/assets/channel-Ym13M3Lb.js

@@ -1 +0,0 @@
-import{ag as o,ah as n}from"./mermaid.core-DY9_apIE.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/worker/console/static/assets/classDiagram-JCYQIIEL-BeFR1wGo.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-DL0vQ9MG.js";import{_ as i}from"./mermaid.core-DY9_apIE.js";import"./chunk-5VM5RSS4-boBu74dU.js";import"./chunk-XXDRQBXY-CGsbJoTV.js";import"./chunk-KBJHAD2P-v4BbT_r2.js";import"./chunk-2GRJ4B5K-BBiu3sCW.js";import"./index-PFjB6g6l.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/classDiagram-v2-OCEON4UE-BeFR1wGo.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-DL0vQ9MG.js";import{_ as i}from"./mermaid.core-DY9_apIE.js";import"./chunk-5VM5RSS4-boBu74dU.js";import"./chunk-XXDRQBXY-CGsbJoTV.js";import"./chunk-KBJHAD2P-v4BbT_r2.js";import"./chunk-2GRJ4B5K-BBiu3sCW.js";import"./index-PFjB6g6l.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/stateDiagram-v2-UEYNNEHI-cj5UUB6m.js

@@ -1 +0,0 @@
-import{s as r,b as e,a,S as s}from"./chunk-5RXB4S5H-lmNq9nYk.js";import{_ as i}from"./mermaid.core-DY9_apIE.js";import"./chunk-XXDRQBXY-CGsbJoTV.js";import"./chunk-KBJHAD2P-v4BbT_r2.js";import"./chunk-2GRJ4B5K-BBiu3sCW.js";import"./index-PFjB6g6l.js";var u={parser:a,get db(){return new s(2)},renderer:e,styles:r,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/worker/console/static/assets/swimlanesDiagram-ULZ7WXOC-C_Qp6bnh.js

@@ -1,8 +0,0 @@
-import{c as r,s as e}from"./flowDiagram-UKHOOZJN-C4ycm8KM.js";import{_ as a}from"./mermaid.core-DY9_apIE.js";import"./chunk-5VM5RSS4-boBu74dU.js";import"./chunk-XXDRQBXY-CGsbJoTV.js";import"./chunk-KBJHAD2P-v4BbT_r2.js";import"./chunk-2GRJ4B5K-BBiu3sCW.js";import"./channel-Ym13M3Lb.js";import"./index-PFjB6g6l.js";var o=a(t=>`${e(t)}
-  .swimlane.cluster rect {
-    stroke: ${t.clusterBorder} !important;
-  }
-  [data-look="neo"].cluster rect {
-    filter: none;
-  }
-`,"getStyles"),s=o,n=r({defaultLayout:"swimlane",styles:s});export{n as diagram};