@tea-agent/loop-agent 0.12.0 → 0.13.0-beta.0

package/dist/worker/observe/routes.js

@@ -5,9 +5,11 @@ import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { parseWorkerEventLine } from "../observability/events.js";
 import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
 import { clampEventHistoryLimit, listBatchEventHistory, listPoolEventHistory, } from "../observability/event-history.js";
-import { buildGlobalSnapshot, clampTaskRunHistoryLimit, listTaskRunHistory, } from "../observability/read-model.js";
+import { buildGlobalSnapshot, clampTaskRunHistoryLimit, listTaskRunHistory, resolveLegacyTask, } from "../observability/read-model.js";
+import { dagSourceBindingSchema } from "../../workflows/dag/types.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
 import { isAllowedArtifactTextPath, resolveArtifactPath, toRepoRelativeArtifactPath, } from "./paths.js";
+import { extractSpecEvidence, } from "./spec-evidence.js";
 const ARTIFACT_PREVIEW_MAX_BYTES = 64 * 1024;
 export function createObserveSnapshotCache() {
     return { expiresAt: 0 };
@@ -32,6 +34,17 @@ const ROUTES = [
      */
     { method: "GET", pattern: /^\/api\/events$/, handler: handlePoolEvents },
     { method: "GET", pattern: /^\/api\/tasks$/, handler: handleTasks },
+    // Canonical feature-scoped task routes (must precede legacy /api/tasks/:id).
+    {
+        method: "GET",
+        pattern: /^\/api\/features\/([^/]+)\/tasks\/([^/]+)\/runs$/,
+        handler: handleFeatureTaskRuns,
+    },
+    {
+        method: "GET",
+        pattern: /^\/api\/features\/([^/]+)\/tasks\/([^/]+)$/,
+        handler: handleFeatureTaskById,
+    },
     {
         method: "GET",
         pattern: /^\/api\/tasks\/([^/]+)\/runs$/,
@@ -58,6 +71,11 @@ const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/session-events$/,
         handler: handleDagNodeSessionEvents,
     },
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence$/,
+        handler: handleDagNodeSpecEvidence,
+    },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)$/,
@@ -208,15 +226,71 @@ async function handleTasks(_req, res, _match, ctx) {
     const snapshot = await getSnapshot(ctx);
     sendJson(res, 200, snapshot.tasks);
 }
-async function handleTaskById(_req, res, match, ctx) {
+async function handleFeatureTaskById(_req, res, match, ctx) {
+    const resolved = resolveFeatureTaskParams(match);
+    if (!resolved) {
+        sendJson(res, 400, { error: "Invalid task identifier" });
+        return;
+    }
+    if (!isSafeObservabilityIdentifier(resolved.featureId) ||
+        !isSafeObservabilityIdentifier(resolved.taskId)) {
+        sendJson(res, 400, { error: "Invalid task identifier" });
+        return;
+    }
     const snapshot = await getSnapshot(ctx);
-    const task = snapshot.tasks.find((t) => t.taskId === match.params.id);
+    const task = snapshot.tasks.find((t) => t.featureId === resolved.featureId && t.taskId === resolved.taskId);
     if (!task) {
         sendJson(res, 404, { error: "Task not found" });
         return;
     }
     sendJson(res, 200, task);
 }
+async function handleFeatureTaskRuns(_req, res, match, ctx) {
+    const resolved = resolveFeatureTaskParams(match);
+    if (!resolved) {
+        sendJson(res, 400, { error: "Invalid task identifier" });
+        return;
+    }
+    if (!isSafeObservabilityIdentifier(resolved.featureId) ||
+        !isSafeObservabilityIdentifier(resolved.taskId)) {
+        sendJson(res, 400, { error: "Invalid task identifier" });
+        return;
+    }
+    const limit = clampTaskRunHistoryLimit(parsePositiveInt(match.query.get("limit"), 0) || undefined);
+    const before = match.query.get("before");
+    const page = await listTaskRunHistory(ctx.repoRoot, resolved.featureId, resolved.taskId, {
+        limit,
+        before: before && before.length > 0 ? before : null,
+    });
+    // 404 only when neither snapshot row nor ledger history exists for this composite id.
+    if (page.runs.length === 0) {
+        const snapshot = await getSnapshot(ctx);
+        const known = snapshot.tasks.some((t) => t.featureId === resolved.featureId && t.taskId === resolved.taskId);
+        if (!known) {
+            sendJson(res, 404, { error: "Task not found" });
+            return;
+        }
+    }
+    sendJson(res, 200, page);
+}
+async function handleTaskById(_req, res, match, ctx) {
+    const taskId = match.params.id;
+    if (!isSafeObservabilityIdentifier(taskId)) {
+        sendJson(res, 400, { error: "Invalid task identifier" });
+        return;
+    }
+    const snapshot = await getSnapshot(ctx);
+    const resolved = resolveLegacyTask(snapshot.tasks, taskId);
+    if (resolved.kind === "missing") {
+        sendJson(res, 404, { error: "Task not found" });
+        return;
+    }
+    if (resolved.kind === "ambiguous") {
+        sendJson(res, 409, ambiguousTaskBody(taskId, resolved.candidates));
+        return;
+    }
+    sendJson(res, 200, resolved.task);
+}
 async function handleTaskRuns(_req, res, match, ctx) {
     const taskId = match.params.id;
     if (!isSafeObservabilityIdentifier(taskId)) {
@@ -224,26 +298,45 @@ async function handleTaskRuns(_req, res, match, ctx) {
         return;
     }
     const snapshot = await getSnapshot(ctx);
-    const known = snapshot.tasks.some((t) => t.taskId === taskId) ||
-        snapshot.batches.some((b) => b.tasks.some((t) => t.taskId === taskId));
-    if (!known) {
-        // Still allow history when ledger has runs but current snapshot has no task row
-        const pageProbe = await listTaskRunHistory(ctx.repoRoot, taskId, {
-            limit: 1,
-        });
-        if (pageProbe.runs.length === 0) {
-            sendJson(res, 404, { error: "Task not found" });
-            return;
-        }
+    const resolved = resolveLegacyTask(snapshot.tasks, taskId);
+    if (resolved.kind === "ambiguous") {
+        sendJson(res, 409, ambiguousTaskBody(taskId, resolved.candidates));
+        return;
+    }
+    if (resolved.kind === "missing") {
+        // No snapshot row: do not guess featureId for history.
+        sendJson(res, 404, { error: "Task not found" });
+        return;
+    }
+    const featureId = resolved.task.featureId;
+    if (!featureId) {
+        sendJson(res, 404, { error: "Task not found" });
+        return;
     }
     const limit = clampTaskRunHistoryLimit(parsePositiveInt(match.query.get("limit"), 0) || undefined);
     const before = match.query.get("before");
-    const page = await listTaskRunHistory(ctx.repoRoot, taskId, {
+    const page = await listTaskRunHistory(ctx.repoRoot, featureId, taskId, {
         limit,
         before: before && before.length > 0 ? before : null,
     });
     sendJson(res, 200, page);
 }
+function ambiguousTaskBody(taskId, candidates) {
+    return {
+        error: "Task identity ambiguous",
+        taskId,
+        candidates,
+    };
+}
+/** Extract featureId/taskId from /api/features/:featureId/tasks/:taskId[...]. */
+function resolveFeatureTaskParams(match) {
+    // handleRequest maps capture groups to params.id (group 1) and params.sub (group 2).
+    const featureId = match.params.featureId ?? match.params.id;
+    const taskId = match.params.taskId ?? match.params.sub;
+    if (!featureId || !taskId)
+        return null;
+    return { featureId, taskId };
+}
 async function handleRunById(_req, res, match, ctx) {
     if (!isSafeObservabilityIdentifier(match.params.id)) {
         sendJson(res, 400, { error: "Invalid run identifier" });
@@ -613,6 +706,71 @@ function sendJson(res, status, body) {
     });
     res.end(payload);
 }
+async function handleDagNodeSpecEvidence(_req, res, match, ctx) {
+    const dagRunId = match.params.id;
+    const nodeId = match.params.sub;
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        sendJson(res, 400, { error: "Invalid dag run or node identifier" });
+        return;
+    }
+    // Extract skill injection info from the DAG run spec (run.json)
+    const skillInjection = { skills: [], references: [] };
+    let sourceBinding;
+    const dagRunsRoot = path.resolve(ctx.repoRoot, ".harness", "dag-runs");
+    for (const lifecycle of ["active", "completed", "paused"]) {
+        const runJsonPath = path.join(dagRunsRoot, lifecycle, dagRunId, "run.json");
+        try {
+            const runRaw = await readFile(runJsonPath, "utf-8");
+            const runSpec = JSON.parse(runRaw);
+            const parsedSourceBinding = dagSourceBindingSchema.safeParse(runSpec.sourceBinding);
+            if (parsedSourceBinding.success)
+                sourceBinding = parsedSourceBinding.data;
+            const task = runSpec.tasks?.find((t) => t.id === nodeId);
+            if (task?.skills && Array.isArray(task.skills)) {
+                skillInjection.skills = task.skills;
+            }
+            break;
+        }
+        catch {
+            // run.json may not exist; continue to next lifecycle
+        }
+    }
+    const evidence = await extractSpecEvidence(ctx.repoRoot, dagRunId, nodeId);
+    if (!evidence) {
+        const hasSourceBinding = Boolean(sourceBinding);
+        sendJson(res, 200, {
+            dagRunId,
+            nodeId,
+            status: hasSourceBinding ? "source-bound" : "no-evidence",
+            skillInjection,
+            sourceBinding,
+            specReads: [],
+            specSearches: [],
+            knowledgeBaseQueries: [],
+            summary: hasSourceBinding
+                ? `已绑定 ${sourceBinding.sources.length} 个任务源文件和 ${sourceBinding.requirementIds.length} 个显式需求编号；未观察到 read 工具调用。`
+                : "未找到该节点的 session events 记录。",
+        });
+        return;
+    }
+    evidence.skillInjection = skillInjection;
+    evidence.sourceBinding = sourceBinding;
+    // Recompute status considering skill injection
+    if (evidence.specReads.length === 0 && evidence.knowledgeBaseQueries.length === 0) {
+        if (evidence.specSearches.length > 0) {
+            evidence.status = "search-only";
+        }
+        else if (sourceBinding) {
+            evidence.status = "source-bound";
+            evidence.summary = `已绑定 ${sourceBinding.sources.length} 个任务源文件和 ${sourceBinding.requirementIds.length} 个显式需求编号；未观察到 read 工具调用。`;
+        }
+        else if (skillInjection.skills.length > 0) {
+            evidence.status = "spec-injected";
+            evidence.summary = "规范 skill 已注入但未观察到规范文件读取或知识库查询。";
+        }
+    }
+    sendJson(res, 200, evidence);
+}
 function contentTypeFor(pathname) {
     if (pathname.endsWith(".html"))
         return "text/html; charset=utf-8";

package/dist/worker/observe/spec-evidence.js

@@ -0,0 +1,281 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
+const DAG_RUN_LIFECYCLE_DIRS = ["active", "completed", "paused"];
+/**
+ * Known knowledge-base connector tool names.
+ */
+const KB_CONNECTOR_TOOLS = new Set([
+    "knowledge-base-query",
+    "kb_query",
+    "kb-search",
+    "knowledge_base_search",
+    "rag_search",
+    "vector_search",
+    "mcp__knowledge",
+    "mcp__kb",
+]);
+/**
+ * Pattern for detecting spec-related files:
+ * - openSpec/** files
+ * - *.spec.md / *.spec.ts / *.spec.tsx
+ * - project-specs/**
+ * - design-spec.md, code-standards.md, review-checklist.md, etc.
+ * - SKILL.md files
+ * - docs/** specification files
+ */
+const SPEC_FILE_PATTERNS = [
+    /openspec\//i,
+    /\/openSpec\//i,
+    /\/project-specs\//i,
+    /\/spec\//i,
+    /\.spec\.(md|tsx?|jsx?)$/i,
+    /\bdesign-spec\b/i,
+    /\bcode-standards\b/i,
+    /\breview-checklist\b/i,
+    /\bverification-checklist\b/i,
+    /\bnode-contracts\b/i,
+    /\breview-findings\b/i,
+    /\bSKILL\.md$/i,
+    /\bskills\//i,
+    /\bdocs\/design\//i,
+    /\bdocs\/templates\//i,
+];
+function isSpecFilePath(filePath) {
+    return SPEC_FILE_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+function isKnowledgeBaseTool(toolName) {
+    return KB_CONNECTOR_TOOLS.has(toolName);
+}
+function resolveSessionEventsPath(repoRoot, dagRunId, nodeId) {
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        return null;
+    }
+    const dagRunsRoot = path.resolve(repoRoot, ".harness", "dag-runs");
+    const candidates = [];
+    for (const lifecycle of DAG_RUN_LIFECYCLE_DIRS) {
+        candidates.push(path.join(dagRunsRoot, lifecycle, dagRunId, nodeId, "session-events.jsonl"));
+    }
+    for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
+        if (!isPathInside(dagRunsRoot, resolved))
+            continue;
+        if (!isExpectedSessionEventsRelativePath(dagRunsRoot, resolved, dagRunId, nodeId)) {
+            continue;
+        }
+        if (existsSync(resolved))
+            return resolved;
+    }
+    return null;
+}
+function isExpectedSessionEventsRelativePath(dagRunsRoot, resolvedPath, dagRunId, nodeId) {
+    const relative = path.relative(dagRunsRoot, resolvedPath);
+    const parts = relative.split(path.sep).filter(Boolean);
+    return (parts.length === 4 &&
+        DAG_RUN_LIFECYCLE_DIRS.includes(parts[0]) &&
+        parts[1] === dagRunId &&
+        parts[2] === nodeId &&
+        parts[3] === "session-events.jsonl");
+}
+function isPathInside(root, target) {
+    const normalizedRoot = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+    const normalizedTarget = path.normalize(target);
+    return normalizedTarget === root || normalizedTarget.startsWith(normalizedRoot);
+}
+function resolveToolName(event) {
+    return (event.toolName ?? "").toLowerCase();
+}
+function eventTimestamp(event) {
+    return event.timestamp ?? event.at;
+}
+/**
+ * Parse a tool input path to a repo-relative path.
+ * Handles both absolute paths and paths that are already repo-relative.
+ */
+function toRepoRelative(repoRoot, filePath) {
+    if (!filePath)
+        return null;
+    try {
+        const resolved = path.resolve(repoRoot, filePath);
+        const rel = path.relative(repoRoot, resolved);
+        if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) {
+            return null;
+        }
+        return rel.replaceAll(path.sep, "/");
+    }
+    catch {
+        return null;
+    }
+}
+async function readSessionEvents(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        return raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((event) => event !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
+    if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        return null;
+    }
+    const eventsPath = resolveSessionEventsPath(repoRoot, dagRunId, nodeId);
+    if (!eventsPath) {
+        return null;
+    }
+    const events = await readSessionEvents(eventsPath);
+    // Track successful read calls with their paths (dedup by path)
+    const readPaths = new Map();
+    const searches = [];
+    const kbQueries = [];
+    // Track tool_execution_start events by toolCallId for pairing.
+    // Only tool_execution_end events with a matching start are counted as reads.
+    const startMap = new Map();
+    // Scan events for tool calls
+    for (const event of events) {
+        const type = event.type;
+        const toolName = resolveToolName(event);
+        const toolCallId = event.toolCallId;
+        const toolInput = event.toolInput ?? event.input ?? {};
+        const ts = eventTimestamp(event);
+        // Collect tool_execution_start events by toolCallId
+        if (type === "tool_execution_start" && toolCallId) {
+            startMap.set(toolCallId, { toolName, input: toolInput });
+            continue;
+        }
+        // Process tool_execution_end events
+        if (type === "tool_execution_end") {
+            // Successful read calls: must have matching start event and no error
+            if (toolName === "read") {
+                const isErrored = event.isError === true ||
+                    event.toolResult?.error != null ||
+                    event.toolResult?.ok === false;
+                if (isErrored)
+                    continue;
+                let filePath;
+                // Only paired read calls qualify: must have toolCallId, matching start
+                // with same toolName, and start must be a "read" tool.
+                if (toolCallId) {
+                    const start = startMap.get(toolCallId);
+                    if (start && start.toolName === "read") {
+                        const startInput = start.input ?? {};
+                        filePath = typeof startInput.path === "string" ? startInput.path : undefined;
+                        startMap.delete(toolCallId);
+                    }
+                    // No fallback: unmatched end, mismatched toolName, or missing start → skip
+                }
+                // No legacy path: toolCallId-less read ends never qualify as spec reads
+                if (filePath) {
+                    const relPath = toRepoRelative(repoRoot, filePath);
+                    if (relPath && isSpecFilePath(relPath) && !readPaths.has(relPath)) {
+                        readPaths.set(relPath, ts ?? "");
+                    }
+                }
+            }
+            // Search/scan tool calls (grep, find, ls, glob)
+            if (["grep", "find", "ls", "glob"].includes(toolName)) {
+                const query = typeof toolInput.pattern === "string"
+                    ? toolInput.pattern
+                    : typeof toolInput.query === "string"
+                        ? toolInput.query
+                        : typeof toolInput.path === "string"
+                            ? toolInput.path
+                            : toolName;
+                searches.push({
+                    tool: toolName,
+                    query,
+                    timestamp: ts,
+                });
+            }
+            // Knowledge base connector calls
+            if (isKnowledgeBaseTool(toolName)) {
+                kbQueries.push({
+                    connector: toolName,
+                    timestamp: ts,
+                });
+            }
+        }
+    }
+    // Determine status
+    let status;
+    const specReads = Array.from(readPaths.entries()).map(([p, t]) => ({
+        path: p,
+        timestamp: t || undefined,
+    }));
+    const hasInjection = false; // Injection is authoritative only after run.json is inspected by the route.
+    if (specReads.length > 0) {
+        status = "spec-read";
+    }
+    else if (kbQueries.length > 0) {
+        status = "kb-queried";
+    }
+    else if (searches.length > 0) {
+        status = "search-only";
+    }
+    else if (hasInjection) {
+        status = "spec-injected";
+    }
+    else {
+        status = "no-evidence";
+    }
+    // Build summary
+    const summaryLines = [];
+    if (status === "spec-read") {
+        summaryLines.push(`已读取 ${specReads.length} 个规范文件：${specReads.map((r) => r.path).join("、")}`);
+    }
+    if (searches.length > 0) {
+        summaryLines.push(`已执行 ${searches.length} 次检索操作。`);
+    }
+    if (kbQueries.length > 0) {
+        summaryLines.push(`已观察到 ${kbQueries.length} 次知识库查询。`);
+    }
+    if (status === "spec-injected") {
+        summaryLines.push("规范 skill 已注入但未观察到规范文件读取或知识库查询。");
+    }
+    if (status === "no-evidence") {
+        summaryLines.push("未观察到任何规范证据：无 skill 注入、无文件读取、无检索操作。");
+    }
+    return {
+        dagRunId,
+        nodeId,
+        status,
+        skillInjection: {
+            skills: [],
+            references: [],
+        },
+        specReads,
+        specSearches: searches,
+        knowledgeBaseQueries: kbQueries,
+        summary: summaryLines.join(" "),
+    };
+}
+export async function extractSpecEvidenceWithSkills(repoRoot, dagRunId, nodeId, skillInjection) {
+    const base = await extractSpecEvidence(repoRoot, dagRunId, nodeId);
+    if (!base)
+        return null;
+    base.skillInjection = skillInjection;
+    // Recompute status considering skill injection knowledge
+    if (base.status === "no-evidence" && skillInjection.skills.length > 0) {
+        base.status = "spec-injected";
+        base.summary = "规范 skill 已注入但未观察到规范文件读取或知识库查询。";
+    }
+    else if (base.status === "spec-injected" ||
+        (base.status === "no-evidence" && skillInjection.skills.length === 0)) {
+        base.summary = base.summary || "规范 skill 已注入但未观察到规范文件读取或知识库查询。";
+    }
+    return base;
+}

package/dist/worker/observe/static/api.js

@@ -1,27 +1,46 @@
-/** Fetch and artifact helpers (Observe UI R5). */
-
-export async function fetchJson(url) {
-	try {
-		const res = await fetch(url);
-		if (!res.ok) return null;
-		return await res.json();
-	} catch {
-		return null;
-	}
-}
-
-export function artifactUrl(artifactPath) {
-	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
-}
-
-export function parseArtifactPreviewResponse(text) {
-	const parsed = JSON.parse(text);
-	if (!parsed || typeof parsed.content !== "string") {
-		throw new Error("Artifact preview response is invalid");
-	}
-	return {
-		content: parsed.content,
-		truncated: parsed.truncated === true,
-	};
-}
-
+/** Fetch and artifact helpers (Observe UI R5). */
+
+export async function fetchJson(url) {
+	try {
+		const res = await fetch(url);
+		if (!res.ok) return null;
+		return await res.json();
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Read-only JSON fetch that preserves HTTP status so callers can distinguish
+ * 404 (missing) from 409 (ambiguous task identity). Body is parsed best-effort.
+ */
+export async function fetchJsonResult(url) {
+	try {
+		const res = await fetch(url);
+		let body = null;
+		try {
+			body = await res.json();
+		} catch {
+			body = null;
+		}
+		return { ok: res.ok, status: res.status, body };
+	} catch {
+		return { ok: false, status: 0, body: null };
+	}
+}
+
+export function artifactUrl(artifactPath) {
+	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
+}
+
+export function parseArtifactPreviewResponse(text) {
+	const parsed = JSON.parse(text);
+	if (!parsed || typeof parsed.content !== "string") {
+		throw new Error("Artifact preview response is invalid");
+	}
+	return {
+		content: parsed.content,
+		truncated: parsed.truncated === true,
+	};
+}
+