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

package/dist/worker/observe/routes.js

@@ -5,9 +5,10 @@ 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 { 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 +33,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 +70,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 +225,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 +297,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 +705,57 @@ 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: [] };
+    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 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) {
+        sendJson(res, 200, {
+            dagRunId,
+            nodeId,
+            status: "no-evidence",
+            skillInjection: { skills: [], references: [] },
+            specReads: [],
+            specSearches: [],
+            knowledgeBaseQueries: [],
+            summary: "未找到该节点的 session events 记录。",
+        });
+        return;
+    }
+    evidence.skillInjection = skillInjection;
+    // 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 (skillInjection.skills.length > 0) {
+            evidence.status = "spec-injected";
+        }
+    }
+    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 = true; // DAG nodes always have skills/resolved instructions injected
+    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

@@ -10,6 +10,25 @@ export async function fetchJson(url) {
 	}
 }
 
+/**
+ * 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`;
 }

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

@@ -128,7 +128,7 @@ function route() {
 	} else if (r.view === "pool") {
 		startPoolPolling();
 	} else if (r.view === "task") {
-		startTaskPolling(r.taskId);
+		startTaskPolling(r.featureId, r.taskId);
 	} else if (r.view === "feature") {
 		void renderFeatureDetail(r.featureId);
 	}
@@ -145,6 +145,6 @@ if (typeof window !== "undefined") {
 		if (r.view === "run") startRunPolling(r.workerRunId, false);
 		if (r.view === "dag") startDagPolling(r.dagRunId, false);
 		if (r.view === "pool") startPoolPolling();
-		if (r.view === "task") startTaskPolling(r.taskId);
+		if (r.view === "task") startTaskPolling(r.featureId, r.taskId);
 	});
 }

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

@@ -2,13 +2,15 @@
 import { el } from "./dom.js";
 import { navigate } from "./router.js";
 
-export function objectExistsInSnapshot(kind, id, snapshot) {
+export function objectExistsInSnapshot(kind, id, snapshot, featureId) {
 	if (!id) return false;
 	if (kind === "feature") {
 		return (snapshot?.features ?? []).some((f) => f.featureId === id);
 	}
 	if (kind === "task") {
-		return (snapshot?.tasks ?? []).some((t) => t.taskId === id);
+		return (snapshot?.tasks ?? []).some(
+			(t) => t.taskId === id && (!featureId || t.featureId === featureId),
+		);
 	}
 	if (kind === "batch") {
 		return (snapshot?.batches ?? []).some((b) => b.batchRunId === id);
@@ -27,8 +29,11 @@ export function objectExistsInSnapshot(kind, id, snapshot) {
 	return false;
 }
 
-export function objectRoutePath(kind, id) {
+export function objectRoutePath(kind, id, featureId) {
 	if (kind === "feature") return `/feature/${encodeURIComponent(id)}`;
+	if (kind === "task" && featureId) {
+		return `/feature/${encodeURIComponent(featureId)}/task/${encodeURIComponent(id)}`;
+	}
 	if (kind === "task") return `/task/${encodeURIComponent(id)}`;
 	if (kind === "batch") return `/batch/${encodeURIComponent(id)}`;
 	if (kind === "run") return `/run/${encodeURIComponent(id)}`;
@@ -37,11 +42,11 @@ export function objectRoutePath(kind, id) {
 }
 
 /** Hash-route link only when id is present and snapshot contains the object. */
-export function objectRouteLink(kind, id, snapshot) {
+export function objectRouteLink(kind, id, snapshot, featureId) {
 	if (!id) return el("span", "muted", "缺失");
-	const exists = objectExistsInSnapshot(kind, id, snapshot);
+	const exists = objectExistsInSnapshot(kind, id, snapshot, featureId);
 	if (!exists) return el("span", "muted", id);
-	const path = objectRoutePath(kind, id);
+	const path = objectRoutePath(kind, id, featureId);
 	const a = el("a", "object-link", id);
 	a.href = `#${path}`;
 	a.addEventListener("click", (e) => {
@@ -80,7 +85,7 @@ export function buildObjectRelations(ids, snapshot) {
 	const input = ids ?? {};
 	const candidates = [
 		{ kind: "feature", id: input.featureId },
-		{ kind: "task", id: input.taskId },
+		{ kind: "task", id: input.taskId, featureId: input.featureId },
 		{ kind: "batch", id: input.batchRunId },
 		{ kind: "run", id: input.workerRunId },
 		{ kind: "dag", id: input.dagRunId },
@@ -89,13 +94,14 @@ export function buildObjectRelations(ids, snapshot) {
 	for (const kind of RELATION_KIND_ORDER) {
 		const entry = candidates.find((c) => c.kind === kind);
 		if (!entry?.id) continue;
-		if (!objectExistsInSnapshot(kind, entry.id, snapshot)) continue;
+		if (!objectExistsInSnapshot(kind, entry.id, snapshot, entry.featureId)) continue;
 		out.push({
 			kind,
 			id: entry.id,
 			label: RELATION_LABELS[kind] ?? kind,
-			href: `#${objectRoutePath(kind, entry.id)}`,
-			path: objectRoutePath(kind, entry.id),
+			featureId: entry.featureId,
+			href: `#${objectRoutePath(kind, entry.id, entry.featureId)}`,
+			path: objectRoutePath(kind, entry.id, entry.featureId),
 		});
 	}
 	return out;
@@ -117,7 +123,7 @@ export function renderObjectRelationBar(relations, snapshot) {
 		item.appendChild(el("span", "object-relation-label", rel.label));
 		item.appendChild(document.createTextNode(" "));
 		if (rel.href && rel.id) {
-			item.appendChild(objectRouteLink(rel.kind, rel.id, snapshot));
+			item.appendChild(objectRouteLink(rel.kind, rel.id, snapshot, rel.featureId));
 		} else {
 			item.appendChild(el("span", "muted", rel.id ?? "缺失"));
 		}
@@ -125,4 +131,3 @@ export function renderObjectRelationBar(relations, snapshot) {
 	});
 	return bar;
 }
-

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

@@ -14,6 +14,14 @@ export function parseHashRoute(hashValue) {
 	if (dagMatch) {
 		return { view: "dag", dagRunId: decodeURIComponent(dagMatch[1]) };
 	}
+	const featureTaskMatch = /^\/feature\/([^/]+)\/task\/([^/]+)$/.exec(hash);
+	if (featureTaskMatch) {
+		return {
+			view: "task",
+			featureId: decodeURIComponent(featureTaskMatch[1]),
+			taskId: decodeURIComponent(featureTaskMatch[2]),
+		};
+	}
 	const taskMatch = /^\/task\/([^/]+)$/.exec(hash);
 	if (taskMatch) {
 		return { view: "task", taskId: decodeURIComponent(taskMatch[1]) };

package/dist/worker/observe/static/styles.css

@@ -1351,6 +1351,18 @@ body.is-resizing-dag-graph {
 	font-weight: 700;
 }
 
+.spec-evidence-section { padding-bottom: var(--space-4); border-bottom: 1px solid var(--hairline); }
+.spec-evidence-section + .spec-evidence-section { margin-top: var(--space-4); }
+.spec-evidence-section h4 { margin: 0 0 var(--space-2); color: var(--ink); font-size: 12px; font-weight: 700; }
+.spec-evidence-summary { margin: var(--space-2) 0 0; color: var(--body); font-size: 12px; line-height: 1.6; }
+.spec-evidence-list { display: grid; gap: 6px; margin: var(--space-2) 0 0; padding: 0; list-style: none; }
+.spec-evidence-list li { display: flex; align-items: flex-start; gap: 6px; color: var(--body); font-size: 12px; line-height: 1.5; overflow-wrap: anywhere; }
+.spec-evidence-list li > i { flex-shrink: 0; margin-top: 2px; color: var(--muted); font-size: 13px; }
+.spec-evidence-list code { font-size: 11px; }
+.spec-evidence-time { margin-left: auto; color: var(--muted); font-size: 10px; font-variant-numeric: tabular-nums; white-space: nowrap; }
+.spec-evidence-warning { display: flex; align-items: flex-start; gap: 8px; margin-top: var(--space-4); padding: 10px 12px; border: 1px solid color-mix(in srgb, var(--amber) 50%, var(--hairline)); border-radius: var(--radius-sm); background: #fff8e7; color: var(--body); font-size: 12px; line-height: 1.6; }
+.spec-evidence-warning > i { flex-shrink: 0; margin-top: 2px; color: var(--amber); }
+
 .run-layer-process {
 	display: grid;
 	gap: var(--space-4);