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

package/dist/infrastructure/evaluation/candidate-store.js

@@ -0,0 +1,439 @@
+import { access, lstat, mkdir, mkdtemp, readdir, readFile, realpath, rename, rm, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { computeBundleHash, eventHashHex, formatContentSha, LIFECYCLE_GENESIS_HASH, normalizeContentSha, sha256Hex, } from "../../application/evaluation/candidate-hash.js";
+import { candidateManifestInputSchema, candidateManifestSchema, lifecycleEventSchema, } from "../../application/evaluation/types.js";
+import { appendJsonlLineAtomic, writeJsonAtomic, } from "../harness/atomic-write.js";
+import { EVALUATION_ROOT } from "./store.js";
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const MANIFEST_INTEGRITY_FILE = "manifest.sha256";
+const LIFECYCLE_LOCK_DIR = ".lifecycle.lock";
+const LIFECYCLE_LOCK_RETRIES = 100;
+const LIFECYCLE_LOCK_DELAY_MS = 10;
+const FORBIDDEN_PREFIXES = [
+    "src/application/evaluation/",
+    "src/workflows/dag/",
+    "src/executors/",
+    "src/worker/",
+    "src/infrastructure/harness/completed-facts-guard.ts",
+    ".harness/dag-runs/",
+    ".harness/runs/",
+    ".harness/evaluation/",
+];
+const FORBIDDEN_SEGMENTS = [
+    "private-verifier",
+    "private_verifier",
+    "held-out-evaluator",
+    "held_out_evaluator",
+    "held-out",
+    "completed-facts",
+];
+export function assertCandidateId(value) {
+    if (!SAFE_ID.test(value)) {
+        throw new Error(`candidate-id must contain only letters, numbers, dot, underscore, or hyphen: ${value}`);
+    }
+}
+export function candidateDir(repoRoot, candidateId) {
+    assertCandidateId(candidateId);
+    return path.join(repoRoot, EVALUATION_ROOT, "candidates", candidateId);
+}
+export function candidateManifestPath(repoRoot, candidateId) {
+    return path.join(candidateDir(repoRoot, candidateId), "manifest.json");
+}
+export function candidateLifecyclePath(repoRoot, candidateId) {
+    return path.join(candidateDir(repoRoot, candidateId), "lifecycle.jsonl");
+}
+export async function resolveRepoRelativeSafe(repoRoot, repoRelativePath) {
+    if (path.isAbsolute(repoRelativePath) ||
+        repoRelativePath.startsWith("/") ||
+        /^[A-Za-z]:[\\/]/.test(repoRelativePath)) {
+        throw new Error(`content ref path must be repo-relative: ${repoRelativePath}`);
+    }
+    const normalized = repoRelativePath.replace(/\\/g, "/");
+    if (normalized.split("/").includes("..") ||
+        normalized.startsWith("./../") ||
+        normalized.includes("/../")) {
+        throw new Error(`content ref path escapes repo root: ${repoRelativePath}`);
+    }
+    const canonicalRoot = await realpath(repoRoot);
+    const lexical = path.resolve(repoRoot, normalized);
+    let absolute;
+    try {
+        absolute = await realpath(lexical);
+    }
+    catch {
+        // File may not exist yet for some flows; still check lexical containment.
+        const relativeLexical = path.relative(canonicalRoot, lexical);
+        if (!relativeLexical ||
+            relativeLexical.startsWith("..") ||
+            path.isAbsolute(relativeLexical)) {
+            throw new Error(`content ref path escapes repo root: ${repoRelativePath}`);
+        }
+        throw new Error(`content ref missing: ${normalized}`);
+    }
+    const relative = path.relative(canonicalRoot, absolute).replace(/\\/g, "/");
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`content ref path escapes repo root: ${repoRelativePath}`);
+    }
+    const st = await lstat(absolute).catch(() => null);
+    if (st?.isSymbolicLink()) {
+        // realpath already resolved; re-check containment after resolve (done above)
+    }
+    return { absolute, relative };
+}
+export function assertAllowedContentRefPath(relativePosix) {
+    const rel = relativePosix.replace(/\\/g, "/");
+    if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error(`forbidden content ref path: ${rel}`);
+    }
+    for (const prefix of FORBIDDEN_PREFIXES) {
+        if (rel === prefix.replace(/\/$/, "") || rel.startsWith(prefix)) {
+            throw new Error(`content ref enters forbidden candidate surface: ${rel}`);
+        }
+    }
+    const lower = rel.toLowerCase();
+    for (const segment of FORBIDDEN_SEGMENTS) {
+        if (lower.includes(`/${segment}/`) ||
+            lower.endsWith(`/${segment}`) ||
+            lower.startsWith(`${segment}/`) ||
+            lower === segment) {
+            throw new Error(`content ref enters forbidden candidate surface: ${rel}`);
+        }
+    }
+}
+async function hashExistingContent(repoRoot, repoRelativePath) {
+    const { absolute, relative } = await resolveRepoRelativeSafe(repoRoot, repoRelativePath);
+    assertAllowedContentRefPath(relative);
+    const content = await readFile(absolute);
+    return { relative, sha256: sha256Hex(content) };
+}
+function lifecycleTransitionAllowed(from, to) {
+    if (from === null && to === "proposed")
+        return true;
+    const edges = {
+        proposed: ["eligible", "invalid"],
+        eligible: ["experimenting", "invalid"],
+        experimenting: ["accepted", "rejected", "invalid"],
+        accepted: ["retired"],
+        rejected: ["retired"],
+        invalid: ["retired"],
+        retired: [],
+    };
+    if (from === null)
+        return false;
+    return edges[from]?.includes(to) ?? false;
+}
+function computeEventHash(event) {
+    return eventHashHex({
+        schemaVersion: event.schemaVersion,
+        seq: event.seq,
+        from: event.from,
+        to: event.to,
+        reason: event.reason,
+        at: event.at,
+        previousEventHash: event.previousEventHash,
+    });
+}
+export async function materializeManifest(repoRoot, raw) {
+    const input = candidateManifestInputSchema.parse(raw);
+    const verifiedRefs = [];
+    for (const ref of input.contentRefs) {
+        const expected = normalizeContentSha(ref.sha256);
+        const actual = await hashExistingContent(repoRoot, ref.path);
+        assertAllowedContentRefPath(actual.relative);
+        if (actual.sha256 !== expected) {
+            throw new Error(`content ref hash mismatch for ${actual.relative}: expected ${expected}, got ${actual.sha256}`);
+        }
+        // Persist repo-relative posix path as resolved relative (no abs paths).
+        verifiedRefs.push({
+            path: actual.relative,
+            sha256: formatContentSha(actual.sha256),
+        });
+    }
+    const withoutHash = {
+        schemaVersion: 1,
+        candidateId: input.candidateId,
+        parentCandidateId: input.parentCandidateId ?? null,
+        candidateKind: input.candidateKind,
+        createdAt: input.createdAt,
+        ...(input.description !== undefined
+            ? { description: input.description }
+            : {}),
+        contentRefs: verifiedRefs,
+    };
+    const bundleHash = computeBundleHash(withoutHash);
+    if (input.bundleHash) {
+        const provided = formatContentSha(normalizeContentSha(input.bundleHash));
+        if (provided !== bundleHash) {
+            throw new Error(`bundleHash mismatch: expected ${bundleHash}, got ${provided}`);
+        }
+    }
+    const manifest = {
+        ...withoutHash,
+        bundleHash,
+    };
+    return candidateManifestSchema.parse(manifest);
+}
+function serializeManifest(manifest) {
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+function manifestIntegrityPath(repoRoot, candidateId) {
+    return path.join(candidateDir(repoRoot, candidateId), MANIFEST_INTEGRITY_FILE);
+}
+async function assertManifestIntegrity(repoRoot, candidateId, rawManifest) {
+    const expected = (await readFile(manifestIntegrityPath(repoRoot, candidateId), "utf-8")).trim();
+    const actual = sha256Hex(rawManifest);
+    if (expected !== actual) {
+        throw new Error(`candidate manifest integrity mismatch for ${candidateId}: expected ${expected}, got ${actual}`);
+    }
+}
+async function acquireLifecycleLock(repoRoot, candidateId) {
+    const lockPath = path.join(candidateDir(repoRoot, candidateId), LIFECYCLE_LOCK_DIR);
+    for (let attempt = 0; attempt < LIFECYCLE_LOCK_RETRIES; attempt += 1) {
+        try {
+            await mkdir(lockPath);
+            return async () => {
+                await rm(lockPath, { recursive: true, force: true });
+            };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, LIFECYCLE_LOCK_DELAY_MS));
+        }
+    }
+    throw new Error(`timed out acquiring lifecycle lock for ${candidateId}`);
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function manifestsEqual(existing, manifest) {
+    return (existing.candidateId === manifest.candidateId &&
+        existing.bundleHash === manifest.bundleHash &&
+        existing.candidateKind === manifest.candidateKind &&
+        existing.createdAt === manifest.createdAt &&
+        (existing.description ?? "") === (manifest.description ?? "") &&
+        (existing.parentCandidateId ?? null) ===
+            (manifest.parentCandidateId ?? null) &&
+        JSON.stringify(existing.contentRefs) ===
+            JSON.stringify(manifest.contentRefs));
+}
+async function readExistingRegistration(repoRoot, manifest, manifestPath, lifecyclePath) {
+    const existingRaw = await readFile(manifestPath, "utf-8");
+    await assertManifestIntegrity(repoRoot, manifest.candidateId, existingRaw);
+    const existing = candidateManifestSchema.parse(JSON.parse(existingRaw));
+    if (!manifestsEqual(existing, manifest)) {
+        throw new Error(`candidate already exists with different content: ${manifest.candidateId}`);
+    }
+    const record = await readCandidateRecord(repoRoot, manifest.candidateId);
+    return { record, idempotent: true, manifestPath, lifecyclePath };
+}
+export async function registerCandidateManifest(input) {
+    const { repoRoot, manifest } = input;
+    assertCandidateId(manifest.candidateId);
+    const manifestPath = candidateManifestPath(repoRoot, manifest.candidateId);
+    const lifecyclePath = candidateLifecyclePath(repoRoot, manifest.candidateId);
+    if (await pathExists(manifestPath)) {
+        return readExistingRegistration(repoRoot, manifest, manifestPath, lifecyclePath);
+    }
+    const at = input.now ?? new Date().toISOString();
+    const baseEvent = {
+        schemaVersion: 1,
+        seq: 1,
+        from: null,
+        to: "proposed",
+        reason: "registered",
+        at,
+        previousEventHash: LIFECYCLE_GENESIS_HASH,
+    };
+    const event = {
+        ...baseEvent,
+        eventHash: computeEventHash(baseEvent),
+    };
+    lifecycleEventSchema.parse(event);
+    const candidatesRoot = path.dirname(candidateDir(repoRoot, manifest.candidateId));
+    await mkdir(candidatesRoot, { recursive: true });
+    const stagingDir = await mkdtemp(path.join(candidatesRoot, `.${manifest.candidateId}.register-`));
+    try {
+        await writeJsonAtomic(path.join(stagingDir, "manifest.json"), manifest, {
+            repoRoot,
+        });
+        await writeFile(path.join(stagingDir, MANIFEST_INTEGRITY_FILE), `${sha256Hex(serializeManifest(manifest))}\n`, "utf-8");
+        await appendJsonlLineAtomic(path.join(stagingDir, "lifecycle.jsonl"), event, {
+            repoRoot,
+        });
+        try {
+            await rename(stagingDir, candidateDir(repoRoot, manifest.candidateId));
+        }
+        catch (error) {
+            const code = error.code;
+            const isCreateRace = code === "EEXIST" ||
+                code === "ENOTEMPTY" ||
+                (code === "EPERM" &&
+                    (await pathExists(candidateDir(repoRoot, manifest.candidateId))));
+            if (!isCreateRace)
+                throw error;
+            await rm(stagingDir, { recursive: true, force: true });
+            return readExistingRegistration(repoRoot, manifest, manifestPath, lifecyclePath);
+        }
+    }
+    catch (error) {
+        await rm(stagingDir, { recursive: true, force: true });
+        throw error;
+    }
+    return {
+        record: {
+            manifest,
+            status: "proposed",
+            events: [event],
+            promotionApplied: false,
+        },
+        idempotent: false,
+        manifestPath,
+        lifecyclePath,
+    };
+}
+async function readLifecycleEvents(repoRoot, candidateId) {
+    const lifecyclePath = candidateLifecyclePath(repoRoot, candidateId);
+    const text = await readFile(lifecyclePath, "utf-8");
+    const lines = text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const events = [];
+    let previous = LIFECYCLE_GENESIS_HASH;
+    for (let i = 0; i < lines.length; i += 1) {
+        const parsed = lifecycleEventSchema.parse(JSON.parse(lines[i]));
+        if (parsed.seq !== i + 1) {
+            throw new Error(`lifecycle seq gap for ${candidateId}: expected ${i + 1}, got ${parsed.seq}`);
+        }
+        if (parsed.previousEventHash !== previous) {
+            throw new Error(`lifecycle chain break for ${candidateId} at seq ${parsed.seq}`);
+        }
+        const expectedHash = computeEventHash({
+            schemaVersion: parsed.schemaVersion,
+            seq: parsed.seq,
+            from: parsed.from,
+            to: parsed.to,
+            reason: parsed.reason,
+            at: parsed.at,
+            previousEventHash: parsed.previousEventHash,
+        });
+        if (parsed.eventHash !== expectedHash) {
+            throw new Error(`lifecycle event hash mismatch for ${candidateId} at seq ${parsed.seq}`);
+        }
+        if (i === 0) {
+            if (parsed.from !== null || parsed.to !== "proposed") {
+                throw new Error(`lifecycle genesis must be null→proposed for ${candidateId}`);
+            }
+        }
+        else {
+            const prev = events[i - 1];
+            if (parsed.from !== prev.to) {
+                throw new Error(`lifecycle from-state mismatch for ${candidateId} at seq ${parsed.seq}`);
+            }
+            if (!lifecycleTransitionAllowed(parsed.from, parsed.to)) {
+                throw new Error(`illegal lifecycle transition recorded for ${candidateId}: ${parsed.from}→${parsed.to}`);
+            }
+        }
+        events.push(parsed);
+        previous = parsed.eventHash;
+    }
+    if (events.length === 0) {
+        throw new Error(`empty lifecycle for candidate ${candidateId}`);
+    }
+    return events;
+}
+export async function readCandidateRecord(repoRoot, candidateId) {
+    assertCandidateId(candidateId);
+    const manifestPath = candidateManifestPath(repoRoot, candidateId);
+    const rawText = await readFile(manifestPath, "utf-8");
+    await assertManifestIntegrity(repoRoot, candidateId, rawText);
+    const raw = JSON.parse(rawText);
+    const stored = candidateManifestSchema.parse(raw);
+    if (stored.candidateId !== candidateId) {
+        throw new Error(`candidate manifest identity mismatch: directory=${candidateId}, manifest=${stored.candidateId}`);
+    }
+    // Re-verify each content ref against workspace bytes.
+    for (const ref of stored.contentRefs) {
+        const expected = normalizeContentSha(ref.sha256);
+        const actual = await hashExistingContent(repoRoot, ref.path);
+        if (actual.sha256 !== expected) {
+            throw new Error(`content ref hash mismatch for ${actual.relative}: expected ${expected}, got ${actual.sha256}`);
+        }
+    }
+    const recomputed = computeBundleHash(stored);
+    if (recomputed !== stored.bundleHash) {
+        throw new Error(`bundleHash mismatch for ${candidateId}: expected ${recomputed}, got ${stored.bundleHash}`);
+    }
+    const events = await readLifecycleEvents(repoRoot, candidateId);
+    const status = events[events.length - 1].to;
+    return {
+        manifest: stored,
+        status,
+        events,
+        promotionApplied: false,
+    };
+}
+export async function listCandidateIds(repoRoot) {
+    const root = path.join(repoRoot, EVALUATION_ROOT, "candidates");
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && SAFE_ID.test(entry.name))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function transitionCandidateLifecycle(input) {
+    const reason = input.reason.trim();
+    if (!reason) {
+        throw new Error("lifecycle transition requires non-empty --reason");
+    }
+    const releaseLock = await acquireLifecycleLock(input.repoRoot, input.candidateId);
+    try {
+        const record = await readCandidateRecord(input.repoRoot, input.candidateId);
+        const from = record.status;
+        if (!lifecycleTransitionAllowed(from, input.to)) {
+            throw new Error(`illegal lifecycle transition: ${from} → ${input.to}`);
+        }
+        const previous = record.events[record.events.length - 1];
+        const base = {
+            schemaVersion: 1,
+            seq: previous.seq + 1,
+            from,
+            to: input.to,
+            reason,
+            at: input.now ?? new Date().toISOString(),
+            previousEventHash: previous.eventHash,
+        };
+        const event = {
+            ...base,
+            eventHash: computeEventHash(base),
+        };
+        lifecycleEventSchema.parse(event);
+        await appendJsonlLineAtomic(candidateLifecyclePath(input.repoRoot, input.candidateId), event, { repoRoot: input.repoRoot });
+        return readCandidateRecord(input.repoRoot, input.candidateId);
+    }
+    finally {
+        await releaseLock();
+    }
+}
+export async function loadManifestInputFromPath(repoRoot, manifestPath) {
+    const resolved = path.isAbsolute(manifestPath)
+        ? manifestPath
+        : path.resolve(repoRoot, manifestPath);
+    const raw = JSON.parse(await readFile(resolved, "utf-8"));
+    return candidateManifestInputSchema.parse(raw);
+}

package/dist/infrastructure/evaluation/store.js

@@ -0,0 +1,40 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { replaySpecSchema, } from "../../application/evaluation/types.js";
+import { writeJsonAtomic, writeTextAtomic } from "../harness/atomic-write.js";
+export const EVALUATION_ROOT = path.join(".harness", "evaluation");
+export function assertReplayId(value) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value)) {
+        throw new Error(`replay-id must contain only letters, numbers, dot, underscore, or hyphen: ${value}`);
+    }
+}
+export async function readReplaySpec(repoRoot, specPath) {
+    const resolved = path.resolve(repoRoot, specPath);
+    const raw = JSON.parse(await readFile(resolved, "utf-8"));
+    return replaySpecSchema.parse(raw);
+}
+export function replayDir(repoRoot, replayId) {
+    assertReplayId(replayId);
+    return path.join(repoRoot, EVALUATION_ROOT, "replays", replayId);
+}
+export function replayScorecardPath(repoRoot, replayId) {
+    return path.join(replayDir(repoRoot, replayId), "scorecard.json");
+}
+export function replayMarkdownPath(repoRoot, replayId) {
+    return path.join(replayDir(repoRoot, replayId), "report.md");
+}
+export async function writeReplayArtifacts(input) {
+    const scorecardPath = replayScorecardPath(input.repoRoot, input.replayId);
+    const markdownPath = replayMarkdownPath(input.repoRoot, input.replayId);
+    await writeJsonAtomic(scorecardPath, input.scorecard, {
+        repoRoot: input.repoRoot,
+    });
+    await writeTextAtomic(markdownPath, input.markdown, {
+        repoRoot: input.repoRoot,
+    });
+    return { scorecardPath, markdownPath };
+}
+export async function readReplayScorecard(repoRoot, replayId) {
+    const raw = await readFile(replayScorecardPath(repoRoot, replayId), "utf-8");
+    return JSON.parse(raw);
+}

package/dist/task/config-types.js

@@ -11,6 +11,7 @@ export const taskKindSchema = z.enum([
     "standard",
     "feature-study",
     "frontend-implementation",
+    "frontend-test",
     "backend-test",
     "knowledge-sync",
     "knowledge-graph-bootstrap",
@@ -53,6 +54,24 @@ export const loopAutoExecutionPolicySchema = z.enum([
 ]);
 export const LOOP_AUTO_WRITE_POLICY_REMOVED_ERROR = "task field loopAutoWritePolicy is no longer supported; use loopAutoExecutionPolicy (off | approval-required | enabled)";
 export const CURSOR_TASK_FIELD_REMOVED_ERROR = 'task fields "executor" and "cursorModel" are no longer supported; governed runtime is Pi-only';
+export const frontendMockPolicySchema = z.enum(["auto", "required", "disabled"]);
+export const frontendMockVerifyCommandSchema = z.object({
+    label: z.string().min(1),
+    command: z.string().min(1),
+    timeoutMs: z.number().int().positive().optional(),
+});
+export const frontendMockConfigSchema = z.object({
+    policy: frontendMockPolicySchema.optional().default("auto"),
+    serviceRoot: z.string().min(1).optional(),
+    verifyCommands: z.array(frontendMockVerifyCommandSchema).optional().default([]),
+});
+/** Batch limits for the browser-driven frontend test DAG. These are post-case
+ * stop thresholds, not model-provider hard token caps. */
+export const frontendTestConfigSchema = z.object({
+    maxCasesPerBatch: z.number().int().min(1).max(50).optional().default(20),
+    maxTokensPerCase: z.number().int().positive().optional(),
+    maxTotalTokens: z.number().int().positive().optional(),
+});
 export const convergenceConfigSchema = z.object({
     enabled: z.boolean().optional().default(false),
     maxPasses: z.number().int().positive().optional().default(3),
@@ -111,6 +130,10 @@ const taskConfigObjectSchema = z.object({
     maxGoalContinuationsPerRun: z.number().int().positive().optional().default(5),
     /** Pi subagent assisted mode: 'off' (default), 'analyze-plan', or 'full' */
     piSubagentMode: piSubagentModeSchema.optional().default("off"),
+    /** Frontend mock data workflow policy, service root hint, and deterministic mock verification commands. */
+    frontendMock: frontendMockConfigSchema.optional(),
+    /** Frontend browser-test batch and post-case token-stop configuration. */
+    frontendTest: frontendTestConfigSchema.optional(),
     notes: z.string().optional().default(""),
 });
 export const taskConfigSchema = z.preprocess((raw) => {

package/dist/worker/observe/routes.js

@@ -6,6 +6,7 @@ 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, 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";
@@ -714,12 +715,16 @@ async function handleDagNodeSpecEvidence(_req, res, match, ctx) {
     }
     // 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;
@@ -732,26 +737,36 @@ async function handleDagNodeSpecEvidence(_req, res, match, ctx) {
     }
     const evidence = await extractSpecEvidence(ctx.repoRoot, dagRunId, nodeId);
     if (!evidence) {
+        const hasSourceBinding = Boolean(sourceBinding);
         sendJson(res, 200, {
             dagRunId,
             nodeId,
-            status: "no-evidence",
-            skillInjection: { skills: [], references: [] },
+            status: hasSourceBinding ? "source-bound" : "no-evidence",
+            skillInjection,
+            sourceBinding,
             specReads: [],
             specSearches: [],
             knowledgeBaseQueries: [],
-            summary: "未找到该节点的 session events 记录。",
+            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);

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

@@ -216,7 +216,7 @@ export async function extractSpecEvidence(repoRoot, dagRunId, nodeId) {
         path: p,
         timestamp: t || undefined,
     }));
-    const hasInjection = true; // DAG nodes always have skills/resolved instructions injected
+    const hasInjection = false; // Injection is authoritative only after run.json is inspected by the route.
     if (specReads.length > 0) {
         status = "spec-read";
     }