npm - @tea-agent/loop-agent - Versions diffs - 0.16.25 → 0.17.0 - Mend

@tea-agent/loop-agent 0.16.25 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (115) hide show

package/CHANGELOG.md +46 -0
package/README.md +14 -3
package/dist/cli/command-definitions.js +43 -0
package/dist/cli/program.js +26 -0
package/dist/commands/dag-approve.js +4 -0
package/dist/commands/dag-resume.js +1 -0
package/dist/commands/dag-validate.js +6 -0
package/dist/commands/operator.js +44 -0
package/dist/commands/task-contract.js +271 -0
package/dist/executors/dag-pi-executor.js +118 -16
package/dist/executors/pi-executor.js +206 -13
package/dist/executors/pi-sdk-executor.js +21 -6
package/dist/executors/shell-executor.js +85 -8
package/dist/executors/shell-presets.js +16 -3
package/dist/executors/shell-write-guard.js +64 -2
package/dist/shared/operator/capabilities.js +255 -0
package/dist/shared/operator/envelope.js +59 -0
package/dist/shared/operator/index.js +4 -0
package/dist/shared/operator/registry.js +38 -0
package/dist/shared/operator/types.js +5 -0
package/dist/task/contract/adopt.js +166 -0
package/dist/task/contract/apply.js +326 -0
package/dist/task/contract/canonicalize.js +60 -0
package/dist/task/contract/constants.js +29 -0
package/dist/task/contract/diff.js +177 -0
package/dist/task/contract/hash.js +42 -0
package/dist/task/contract/import-revision.js +96 -0
package/dist/task/contract/index.js +17 -0
package/dist/task/contract/journal.js +155 -0
package/dist/task/contract/lock.js +153 -0
package/dist/task/contract/observe.js +296 -0
package/dist/task/contract/paths.js +19 -0
package/dist/task/contract/project.js +170 -0
package/dist/task/contract/recover.js +312 -0
package/dist/task/contract/request-ledger.js +37 -0
package/dist/task/contract/schema.js +151 -0
package/dist/task/contract/transaction.js +160 -0
package/dist/task/contract/types.js +1 -0
package/dist/task/contract/validate-draft.js +106 -0
package/dist/task/index.js +3 -0
package/dist/task/operator/capabilities.js +6 -0
package/dist/task/operator/envelope.js +2 -0
package/dist/task/operator/index.js +5 -0
package/dist/task/operator/registry.js +2 -0
package/dist/task/operator/types.js +1 -0
package/dist/task/runtime.js +5 -1
package/dist/task/source-references.js +7 -0
package/dist/worker/cli.js +150 -32
package/dist/worker/console/app-data.js +185 -0
package/dist/worker/console/dag-confirmation.js +313 -0
package/dist/worker/console/doctor.js +169 -0
package/dist/worker/console/draft-store.js +80 -0
package/dist/worker/console/index.js +15 -0
package/dist/worker/console/interview/assessment.js +67 -0
package/dist/worker/console/interview/session.js +100 -0
package/dist/worker/console/interview/tools.js +109 -0
package/dist/worker/console/loopback.js +16 -0
package/dist/worker/console/observe-health-match.js +174 -0
package/dist/worker/console/observe-link.js +33 -0
package/dist/worker/console/operation-runner.js +166 -0
package/dist/worker/console/operation-sse.js +158 -0
package/dist/worker/console/operation-store.js +147 -0
package/dist/worker/console/operator-actions.js +769 -0
package/dist/worker/console/pi-readiness.js +94 -0
package/dist/worker/console/recovery-cta.js +133 -0
package/dist/worker/console/repo-fingerprint.js +29 -0
package/dist/worker/console/resource-loader.js +95 -0
package/dist/worker/console/routes.js +368 -0
package/dist/worker/console/security.js +126 -0
package/dist/worker/console/server.js +149 -0
package/dist/worker/console/sibling-controller.js +28 -0
package/dist/worker/console/static/assets/index-CbnMgdWa.js +9 -0
package/dist/worker/console/static/assets/index-Dnj0RVs8.css +1 -0
package/dist/worker/console/static/index.html +13 -0
package/dist/worker/console/vite.config.js +27 -0
package/dist/worker/delivery/git-transaction.js +43 -8
package/dist/worker/observe/health.js +57 -0
package/dist/worker/observe/paths.js +81 -0
package/dist/worker/observe/routes.js +142 -27
package/dist/worker/observe/spec-evidence.js +84 -0
package/dist/worker/observe/static/api.js +23 -0
package/dist/worker/observe/static/state.js +26 -0
package/dist/worker/observe/static/styles.css +10 -0
package/dist/worker/observe/static/views/dag-inspector.js +173 -6
package/dist/workflows/dag/backend-test-analysis-contract.js +34 -9
package/dist/workflows/dag/dynamic-runtime/shared.js +1 -0
package/dist/workflows/dag/frontend-repair.js +1 -10
package/dist/workflows/dag/init-hybrid.js +372 -115
package/dist/workflows/dag/node-execution.js +57 -6
package/dist/workflows/dag/project-governance-context.js +508 -0
package/dist/workflows/dag/prompt.js +46 -1
package/dist/workflows/dag/retry-policy.js +16 -1
package/dist/workflows/dag/runner.js +9 -0
package/dist/workflows/dag/skill-snapshot.js +1 -0
package/dist/workflows/dag/task-contract-binding.js +138 -0
package/dist/workflows/dag/types.js +84 -10
package/dist/workflows/dag/validate.js +53 -7
package/docs/README.md +2 -0
package/docs/architecture/evolution.md +2 -0
package/docs/architecture/system-overview.md +6 -0
package/docs/architecture/worker-and-feature.md +7 -0
package/docs/templates/agent-dag.schema.json +64 -2
package/docs/templates/agent-dag.supervised-implementation.json +1 -0
package/docs/templates/backend-test-dag.classify.prompt.md +1 -1
package/docs/templates/backend-test-dag.generate-pytest.prompt.md +5 -5
package/docs/templates/backend-test-dag.json +26 -154
package/docs/templates/backend-test-dag.retrospect.prompt.md +1 -1
package/docs/templates/backend-test-dag.review-cases.prompt.md +2 -2
package/package.json +8 -2
package/skills/agent-worker/SKILL.md +1 -0
package/skills/agent-worker/references/agent-worker-operator.md +3 -2
package/skills/frontend-design-review/SKILL.md +25 -16
package/skills/frontend-implementation/references/node-contracts.md +5 -5
package/skills/loop-agent/references/command-reference.md +48 -1
package/skills/loop-agent/references/hybrid-dag.md +4 -4

package/dist/worker/console/static/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Loop Operator Console</title>
+    <script type="module" crossorigin src="/assets/index-CbnMgdWa.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Dnj0RVs8.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/worker/console/vite.config.js ADDED Viewed

@@ -0,0 +1,27 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+const consoleDir = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(consoleDir, "../../..");
+/**
+ * Vite SPA build for Loop Operator Console.
+ * Output: dist/worker/console/static (no source maps in publish tarball).
+ */
+export default defineConfig({
+    root: path.join(consoleDir, "static-src"),
+    base: "/",
+    build: {
+        outDir: path.join(repoRoot, "dist/worker/console/static"),
+        emptyOutDir: true,
+        sourcemap: false,
+        // Keep Phase 1 shell small; no code-split complexity required.
+        rollupOptions: {
+            input: path.join(consoleDir, "static-src/index.html"),
+        },
+    },
+    // React is a devDependency; esbuild jsx transform avoids needing @vitejs/plugin-react.
+    esbuild: {
+        jsx: "automatic",
+        jsxImportSource: "react",
+    },
+});

package/dist/worker/delivery/git-transaction.js CHANGED Viewed

@@ -122,22 +122,51 @@ export async function finalizeGitTask(transaction, outcome) {
     const changes = await readChanges(transaction.repoRoot);
     const newIgnored = currentIgnored.map((entry) => entry.path).filter((entry) => !ignoredBaselineByPath.has(entry));
     if (outcome.status === "succeeded") {
-        if (changes.length === 0)
+        const allowedPaths = expandAllowedPathsForWorkflow(resolveWorkflow(outcome.taskSpec).workflow, outcome.taskSpec.constraints.allowed_paths);
+        // Evidence under allowed_paths may be gitignored for local convenience (e.g.
+        // reports/welcome/** smoke JSON) but must still checkpoint for Task Pool Done.
+        // Sensitive / out-of-scope ignored files remain fail-closed; ephemeral tool
+        // caches neither block nor force-add.
+        const forceAddIgnored = [];
+        const blockedIgnored = [];
+        for (const entry of newIgnored) {
+            if (isEphemeralToolCachePath(entry))
+                continue;
+            if (isSensitivePath(entry)) {
+                blockedIgnored.push(entry);
+                continue;
+            }
+            if (allowedPaths.some((glob) => matchesGlob(entry, glob))) {
+                forceAddIgnored.push(entry);
+            }
+            else {
+                blockedIgnored.push(entry);
+            }
+        }
+        if (blockedIgnored.length > 0) {
+            throw new Error(`task created ignored files outside the Git checkpoint: ${blockedIgnored.join(", ")}`);
+        }
+        const checkpointFiles = [...changes, ...forceAddIgnored];
+        if (checkpointFiles.length === 0) {
             throw new Error(`successful task produced no checkpointable changes: ${outcome.taskSpec.id}`);
-        if (newIgnored.length > 0)
-            throw new Error(`task created ignored files outside the Git checkpoint: ${newIgnored.join(", ")}`);
-        auditChangedPaths(changes, outcome.taskSpec);
-        await git(transaction.repoRoot, ["add", "--", ...changes]);
+        }
+        auditChangedPaths(checkpointFiles, outcome.taskSpec);
+        if (changes.length > 0) {
+            await git(transaction.repoRoot, ["add", "--", ...changes]);
+        }
+        if (forceAddIgnored.length > 0) {
+            await git(transaction.repoRoot, ["add", "-f", "--", ...forceAddIgnored]);
+        }
         const message = commitMessage(outcome.taskSpec, outcome.workerRunId);
         await git(transaction.repoRoot, ["commit", "-m", message]);
         const commit = await git(transaction.repoRoot, ["rev-parse", "HEAD"]);
-        const checkpoint = { taskId: outcome.taskSpec.id, workerRunId: outcome.workerRunId, commit, changedFiles: changes, createdAt: (outcome.now ?? new Date()).toISOString() };
+        const checkpoint = { taskId: outcome.taskSpec.id, workerRunId: outcome.workerRunId, commit, changedFiles: checkpointFiles, createdAt: (outcome.now ?? new Date()).toISOString() };
         const previousCheckpoint = current.lastCheckpoint;
         try {
             await assertTransactionPosition(transaction.repoRoot, { ...current, lastCheckpoint: commit });
             await assertCheckpointMetadata(transaction.repoRoot, commit, outcome.taskSpec, outcome.workerRunId);
             const afterCommitIgnored = await readIgnoredBaseline(transaction.repoRoot);
-            assertIgnoredBaselineUnchanged(current.ignoredBaseline, afterCommitIgnored);
+            assertIgnoredBaselineUnchanged(current.ignoredBaseline.filter((entry) => !isEphemeralToolCachePath(entry.path)), afterCommitIgnored.filter((entry) => !isEphemeralToolCachePath(entry.path)));
         }
         catch (error) {
             const branch = await git(transaction.repoRoot, ["branch", "--show-current"]).catch(() => "");
@@ -162,7 +191,13 @@ export async function finalizeGitTask(transaction, outcome) {
         }
         transaction.record = current;
         await assertClean(transaction.repoRoot);
-        return { status: "checkpointed", taskId: outcome.taskSpec.id, workerRunId: outcome.workerRunId, commit, changedFiles: changes };
+        return {
+            status: "checkpointed",
+            taskId: outcome.taskSpec.id,
+            workerRunId: outcome.workerRunId,
+            commit,
+            changedFiles: checkpointFiles,
+        };
     }
     const artifactDir = path.join(path.dirname(transaction.recordPath), "failures", outcome.workerRunId);
     await captureFailureArtifacts(transaction.repoRoot, artifactDir, changes, newIgnored, outcome);

package/dist/worker/observe/health.js ADDED Viewed

@@ -0,0 +1,57 @@
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { findPackageRoot, readPackageName, readPackageVersion, } from "../../shared/package-metadata.js";
+import { repoFingerprintV1 } from "../console/repo-fingerprint.js";
+/** Observe `/api/health` schema version (independent of Console product health). */
+export const OBSERVE_HEALTH_SCHEMA_VERSION = 1;
+function routeExists(routes, method, pathname) {
+    return routes.some((route) => route.method === method && route.pattern.test(pathname));
+}
+/**
+ * Derive capability flags from live ROUTES matchers (single source of truth).
+ * Synthetic paths exercise patterns; do not maintain a second handwritten table.
+ */
+export function deriveObserveRouteCapabilities(routes) {
+    return {
+        dagRun: routeExists(routes, "GET", "/api/dag-runs/example-run"),
+        task: routeExists(routes, "GET", "/api/tasks/example-task") ||
+            routeExists(routes, "GET", "/api/features/example-feature/tasks/example-task"),
+        feature: routeExists(routes, "GET", "/api/features/example-feature/tasks/example-task"),
+        workerRun: routeExists(routes, "GET", "/api/runs/example-run"),
+        batch: routeExists(routes, "GET", "/api/batches/example-batch"),
+    };
+}
+export function resolveObservePackageIdentity(fromFileUrl = import.meta.url) {
+    const startDir = path.dirname(fileURLToPath(fromFileUrl));
+    const packageRoot = findPackageRoot(startDir);
+    const packageName = packageRoot
+        ? (readPackageName(packageRoot) ?? "unknown")
+        : "unknown";
+    const packageVersion = packageRoot
+        ? (readPackageVersion(packageRoot) ?? "0.0.0")
+        : "0.0.0";
+    return { packageName, packageVersion };
+}
+/**
+ * Build versioned Observe health DTO for GET /api/health.
+ */
+export function buildObserveHealthV1(input) {
+    const { packageName, packageVersion } = resolveObservePackageIdentity(input.fromFileUrl);
+    let repoFingerprint;
+    try {
+        repoFingerprint = repoFingerprintV1(input.repoRoot);
+    }
+    catch (error) {
+        repoFingerprint = `error:${error instanceof Error ? error.message : String(error)}`;
+    }
+    return {
+        ok: true,
+        schemaVersion: OBSERVE_HEALTH_SCHEMA_VERSION,
+        repoRoot: input.repoRoot,
+        repoFingerprint,
+        packageName,
+        packageVersion,
+        routeCapabilities: deriveObserveRouteCapabilities(input.routes),
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+    };
+}

package/dist/worker/observe/paths.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import { existsSync, realpathSync } from "node:fs";
+import { open, stat } from "node:fs/promises";
 import path from "node:path";
 const ALLOWED_ARTIFACT_EXTENSIONS = new Set([
     ".csv",
@@ -91,3 +92,83 @@ function isPathInside(root, target) {
     const normalizedTarget = path.normalize(target);
     return normalizedTarget === root || normalizedTarget.startsWith(normalizedRoot);
 }
+/**
+ * Safe repo-relative file resolver for spec-evidence previews (binding sources).
+ *
+ * Enforces AC-003: rejects `..`, absolute paths (POSIX + Windows drive),
+ * directory, binary content, and symlink escape via realpath re-check.
+ *
+ * Unlike resolveArtifactPath (which only allows .harness artifact roots), this
+ * allows any repo-relative text file that was already validated as an evidence
+ * member by the caller. Returns { absPath, size } on success, throws otherwise.
+ */
+export async function resolveRepoFilePreview(repoRoot, relPath) {
+    if (!relPath || typeof relPath !== "string") {
+        throw new Error("Invalid path");
+    }
+    if (path.isAbsolute(relPath)) {
+        throw new Error("Absolute paths are not allowed");
+    }
+    // Windows drive letters (e.g. C:\) or POSIX absolute already covered, plus
+    // explicit backslash-drive form used in tests.
+    if (/^[A-Za-z]:[\\/]/.test(relPath)) {
+        throw new Error("Absolute paths are not allowed");
+    }
+    // Reject any path segment that is ".." (handles ../, nested .., ./..).
+    const preSegments = relPath.split(/[\\/]/).filter(Boolean);
+    if (preSegments.includes("..")) {
+        throw new Error("Path traversal is not allowed");
+    }
+    if (!isAllowedArtifactTextPath(relPath)) {
+        throw new Error("Binary or disallowed file type");
+    }
+    const resolvedRepoRoot = path.resolve(repoRoot);
+    let realRepoRoot;
+    try {
+        realRepoRoot = realpathSync(resolvedRepoRoot);
+    }
+    catch {
+        realRepoRoot = resolvedRepoRoot;
+    }
+    const candidate = path.resolve(realRepoRoot, relPath);
+    const relative = path.relative(realRepoRoot, candidate);
+    if (relative === "" ||
+        relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative)) {
+        throw new Error("Path escapes repo root");
+    }
+    if (!existsSync(candidate)) {
+        throw new Error("File not found");
+    }
+    let realCandidate;
+    try {
+        realCandidate = realpathSync(candidate);
+    }
+    catch {
+        throw new Error("File not found");
+    }
+    if (!isPathInside(realRepoRoot, realCandidate)) {
+        throw new Error("Symlink escapes repo root");
+    }
+    const fileStat = await stat(realCandidate);
+    if (!fileStat.isFile()) {
+        throw new Error("Path is not a regular file");
+    }
+    const sampleLength = Math.min(fileStat.size, 8 * 1024);
+    if (sampleLength > 0) {
+        const sample = Buffer.alloc(sampleLength);
+        const handle = await open(realCandidate, "r");
+        let bytesRead = 0;
+        try {
+            ({ bytesRead } = await handle.read(sample, 0, sampleLength, 0));
+        }
+        finally {
+            await handle.close();
+        }
+        if (sample.subarray(0, bytesRead).includes(0)) {
+            throw new Error("Binary file content is not allowed");
+        }
+    }
+    return { absPath: realCandidate, size: fileStat.size };
+}

package/dist/worker/observe/routes.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { open as openFile, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
@@ -8,8 +9,9 @@ import { clampEventHistoryLimit, listBatchEventHistory, listPoolEventHistory, }
 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";
+import { isAllowedArtifactTextPath, resolveArtifactPath, resolveRepoFilePreview, toRepoRelativeArtifactPath, } from "./paths.js";
+import { extractSpecEvidence, extractSpecReadContent, } from "./spec-evidence.js";
+import { buildObserveHealthV1 } from "./health.js";
 const ARTIFACT_PREVIEW_MAX_BYTES = 64 * 1024;
 export function createObserveSnapshotCache() {
     return { expiresAt: 0 };
@@ -76,6 +78,11 @@ const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence$/,
         handler: handleDagNodeSpecEvidence,
     },
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence\/file$/,
+        handler: handleDagNodeSpecEvidenceFile,
+    },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)$/,
@@ -149,11 +156,10 @@ export async function serveStatic(req, res, staticDir) {
     res.end(content);
 }
 async function handleHealth(_req, res, _match, ctx) {
-    sendJson(res, 200, {
-        ok: true,
+    sendJson(res, 200, buildObserveHealthV1({
         repoRoot: ctx.repoRoot,
-        generatedAt: new Date().toISOString(),
-    });
+        routes: ROUTES,
+    }));
 }
 async function getSnapshot(ctx) {
     const now = Date.now();
@@ -706,35 +712,142 @@ 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");
+async function loadDagRunSourceBinding(repoRoot, dagRunId) {
+    const dagRunsRoot = path.resolve(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;
+            const parsed = dagSourceBindingSchema.safeParse(runSpec.sourceBinding);
+            if (parsed.success)
+                return parsed.data;
+            return undefined;
         }
         catch {
             // run.json may not exist; continue to next lifecycle
         }
     }
+    return undefined;
+}
+/**
+ * Read-only spec-evidence file preview (AC-001..AC-005). Re-validates evidence
+ * membership server-side: binding paths must be in sourceBinding.sources, read
+ * paths must have a successful paired read in session events. Enforces AC-003
+ * path safety and AC-004 truncation + redaction.
+ */
+async function handleDagNodeSpecEvidenceFile(_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;
+    }
+    const source = match.query.get("source");
+    const rawPath = match.query.get("path");
+    if (source !== "binding" && source !== "read") {
+        sendJson(res, 400, { error: "Invalid source" });
+        return;
+    }
+    if (!rawPath) {
+        sendJson(res, 400, { error: "path is required" });
+        return;
+    }
+    const maxBytes = ARTIFACT_PREVIEW_MAX_BYTES;
+    if (source === "binding") {
+        const sourceBinding = await loadDagRunSourceBinding(ctx.repoRoot, dagRunId);
+        const member = sourceBinding?.sources?.find((s) => s.path === rawPath);
+        if (!sourceBinding || !member) {
+            sendJson(res, 404, { error: "Path is not a bound source" });
+            return;
+        }
+        let resolved;
+        try {
+            resolved = await resolveRepoFilePreview(ctx.repoRoot, rawPath);
+        }
+        catch {
+            sendJson(res, 400, { error: "Invalid or unsafe path" });
+            return;
+        }
+        let raw;
+        try {
+            raw = await readFile(resolved.absPath, "utf-8");
+        }
+        catch {
+            sendJson(res, 404, { error: "File not found" });
+            return;
+        }
+        const redacted = redactSecrets(raw);
+        const content = truncateUtf8Preview(redacted, maxBytes);
+        const truncated = content !== redacted;
+        const currentSha256 = createHash("sha256")
+            .update(raw, "utf-8")
+            .digest("hex");
+        sendJson(res, 200, {
+            source: "binding",
+            path: rawPath,
+            sha256: member.sha256,
+            currentSha256,
+            hashMatch: currentSha256 === member.sha256,
+            content,
+            truncated,
+            contentBytes: Buffer.byteLength(content, "utf-8"),
+            maxBytes,
+        });
+        return;
+    }
+    // source === "read"
+    const record = await extractSpecReadContent(ctx.repoRoot, dagRunId, nodeId, rawPath);
+    if (!record) {
+        sendJson(res, 404, { error: "Path was not successfully read" });
+        return;
+    }
+    const redacted = redactSecrets(record.content);
+    const content = truncateUtf8Preview(redacted, maxBytes);
+    const truncated = content !== redacted;
+    sendJson(res, 200, {
+        source: "read",
+        path: rawPath,
+        content,
+        truncated,
+        contentBytes: Buffer.byteLength(content, "utf-8"),
+        maxBytes,
+        readAt: record.timestamp ?? null,
+    });
+}
+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 sourceBinding = await loadDagRunSourceBinding(ctx.repoRoot, dagRunId);
+    {
+        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) {
         const hasSourceBinding = Boolean(sourceBinding);
@@ -756,7 +869,8 @@ async function handleDagNodeSpecEvidence(_req, res, match, ctx) {
     evidence.skillInjection = skillInjection;
     evidence.sourceBinding = sourceBinding;
     // Recompute status considering skill injection
-    if (evidence.specReads.length === 0 && evidence.knowledgeBaseQueries.length === 0) {
+    if (evidence.specReads.length === 0 &&
+        evidence.knowledgeBaseQueries.length === 0) {
         if (evidence.specSearches.length > 0) {
             evidence.status = "search-only";
         }
@@ -766,7 +880,8 @@ async function handleDagNodeSpecEvidence(_req, res, match, ctx) {
         }
         else if (skillInjection.skills.length > 0) {
             evidence.status = "spec-injected";
-            evidence.summary = "规范 skill 已注入但未观察到规范文件读取或知识库查询。";
+            evidence.summary =
+                "规范 skill 已注入但未观察到规范文件读取或知识库查询。";
         }
     }
     sendJson(res, 200, evidence);

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

@@ -132,6 +132,90 @@ async function readSessionEvents(filePath) {
         return [];
     }
 }
+/**
+ * Coerce a `tool_execution_end` result body (toolResult.content or result.content)
+ * into a string. Accepts plain strings, `{type:"text", text}[]` arrays, and
+ * message.content shapes. Returns null when no usable body is present.
+ */
+function resultContentToString(content) {
+    if (content == null)
+        return null;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const part of content) {
+            if (typeof part === "string") {
+                parts.push(part);
+            }
+            else if (part && typeof part === "object" && typeof part.text === "string") {
+                parts.push(part.text);
+            }
+        }
+        return parts.length > 0 ? parts.join("\n") : null;
+    }
+    return null;
+}
+/**
+ * Scan session events for successful paired `read` tool calls and return the
+ * most recent result body + timestamp whose repo-relative path matches
+ * `relPath` exactly. Used for AC-002: show the content the model actually
+ * received at read time, never the current workspace file.
+ */
+export async function extractSpecReadContent(repoRoot, dagRunId, nodeId, relPath) {
+    if (!relPath || !isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
+        return null;
+    }
+    // The preview endpoint must expose exactly the same membership as the
+    // `specReads` list, not every file the node happened to read.
+    if (!isSpecFilePath(relPath))
+        return null;
+    const eventsPath = resolveSessionEventsPath(repoRoot, dagRunId, nodeId);
+    if (!eventsPath)
+        return null;
+    const events = await readSessionEvents(eventsPath);
+    const startMap = new Map();
+    let latest = null;
+    for (const event of events) {
+        const type = event.type;
+        const toolName = resolveToolName(event);
+        const toolCallId = event.toolCallId;
+        if (type === "tool_execution_start" && toolCallId) {
+            startMap.set(toolCallId, { toolName, input: eventToolArgs(event) });
+            continue;
+        }
+        if (type !== "tool_execution_end" || toolName !== "read" || !toolCallId)
+            continue;
+        const start = startMap.get(toolCallId);
+        if (!start || start.toolName !== "read")
+            continue;
+        const isErrored = event.isError === true ||
+            event.toolResult?.error != null ||
+            event.toolResult?.ok === false ||
+            event.result?.error != null ||
+            event.result?.ok === false;
+        if (isErrored) {
+            startMap.delete(toolCallId);
+            continue;
+        }
+        const startInput = start.input ?? {};
+        const filePath = typeof startInput.path === "string" ? startInput.path : undefined;
+        if (!filePath) {
+            startMap.delete(toolCallId);
+            continue;
+        }
+        const rel = toRepoRelative(repoRoot, filePath);
+        startMap.delete(toolCallId);
+        if (!rel || rel !== relPath)
+            continue;
+        const body = resultContentToString(event.toolResult?.content) ??
+            resultContentToString(event.result?.content);
+        if (body == null)
+            continue;
+        latest = { content: body, timestamp: eventTimestamp(event) };
+    }
+    return latest;
+}
 export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
     if (!isSafeObservabilityIdentifier(dagRunId) || !isSafeObservabilityIdentifier(nodeId)) {
         return null;

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

@@ -29,6 +29,29 @@ export async function fetchJsonResult(url) {
 	}
 }
+/**
+ * Fetch a spec-evidence file preview (binding source or successful read).
+ * Resolves to the parsed JSON body, or throws an Error carrying the HTTP
+ * status and server message so the UI can render an accessible error state.
+ */
+export async function fetchSpecEvidenceFile(runId, nodeId, source, relPath) {
+	const url = `/api/dag-runs/${encodeURIComponent(runId)}/nodes/${encodeURIComponent(nodeId)}/spec-evidence/file?source=${encodeURIComponent(source)}&path=${encodeURIComponent(relPath)}`;
+	const res = await fetch(url);
+	let body = null;
+	try {
+		body = await res.json();
+	} catch {
+		body = null;
+	}
+	if (!res.ok) {
+		const message = body?.error || `加载失败：HTTP ${res.status}`;
+		const error = new Error(message);
+		error.status = res.status;
+		throw error;
+	}
+	return body;
+}
 export function artifactUrl(artifactPath) {
 	return `/api/artifacts?path=${encodeURIComponent(artifactPath)}&tail=200`;
 }

package/dist/worker/observe/static/state.js CHANGED Viewed

@@ -46,6 +46,13 @@ export const uiState = {
 	dagTimelineViewportState: null,
 	dagNodeOutputViewportState: null,
 	runOutputViewportState: null,
+	/**
+	 * Spec-evidence file preview drill-down. null = list view; otherwise
+	 * { source, path, loading, error, data, triggerId } for the active preview.
+	 */
+	specEvidenceDetail: null,
+	/** Last-rendered spec-evidence list, used to restore the list synchronously. */
+	specEvidenceListEvidence: null,
 	pollingGeneration: 0,
 };
@@ -271,3 +278,22 @@ export function bumpPollingGeneration() {
 	uiState.pollingGeneration += 1;
 	return uiState.pollingGeneration;
 }
+/** Open an in-inspector spec-evidence file preview (AC-001/002). */
+export function openSpecEvidenceDetail(source, path, triggerEl) {
+	uiState.specEvidenceDetail = {
+		source,
+		path,
+		loading: true,
+		error: null,
+		data: null,
+		triggerId: triggerEl?.id ?? null,
+	};
+}
+/** Close the preview; caller restores focus to the trigger element. */
+export function closeSpecEvidenceDetail() {
+	const detail = uiState.specEvidenceDetail;
+	uiState.specEvidenceDetail = null;
+	return detail;
+}

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

@@ -1863,6 +1863,16 @@ body.is-resizing-dag-graph {
 .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); }
+.spec-evidence-file-btn { display: flex; align-items: flex-start; gap: 6px; width: 100%; padding: 4px 0; background: none; border: none; text-align: left; cursor: pointer; color: inherit; font: inherit; line-height: 1.5; overflow-wrap: anywhere; border-radius: var(--radius-sm); }
+.spec-evidence-file-btn:hover, .spec-evidence-file-btn:focus-visible { background: color-mix(in srgb, var(--accent, #2563eb) 8%, transparent); outline: none; }
+.spec-evidence-file-btn:focus-visible { box-shadow: 0 0 0 2px var(--accent, #2563eb); }
+.spec-evidence-detail { display: grid; gap: var(--space-3); }
+.spec-evidence-back { display: inline-flex; align-items: center; gap: 6px; padding: 4px 10px; border: 1px solid var(--hairline); border-radius: var(--radius-sm); background: var(--surface, #fff); color: var(--ink); font-size: 12px; cursor: pointer; }
+.spec-evidence-back:hover, .spec-evidence-back:focus-visible { background: color-mix(in srgb, var(--accent, #2563eb) 8%, var(--surface, #fff)); }
+.spec-evidence-detail-meta { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; font-size: 12px; color: var(--body); }
+.spec-evidence-detail-content { min-height: 0; max-width: 100%; margin: 0; padding: var(--space-3); border: 1px solid var(--hairline); border-radius: var(--radius-sm); background: var(--surface, #fff); white-space: pre-wrap; overflow-wrap: anywhere; font-size: 12px; line-height: 1.6; }
+.spec-evidence-detail-error { margin: 0; color: var(--red, #c00); font-size: 12px; }
+.spec-evidence-detail-truncated { margin: 0; color: var(--muted); font-size: 11px; }
 .run-layer-process {
 	display: grid;