@tea-agent/loop-agent 0.24.10 → 0.24.11-beta.0

package/docs/templates/frontend-implementation-contract.schema.json

@@ -10,9 +10,9 @@
     "sourceBinding": { "$ref": "#/$defs/sourceBinding" },
     "riskLevel": { "enum": ["small", "standard", "high-risk"] },
     "targets": { "type": "object", "additionalProperties": false, "required": ["files"], "properties": { "files": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/path" } }, "routes": { "type": "array", "items": { "type": "string", "pattern": "^/" } }, "publicApiChanges": { "type": "array", "items": { "type": "string", "minLength": 1 } } } },
-    "requirements": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "implementationTargets", "verificationTargetIds"], "properties": { "id": { "$ref": "#/$defs/requirementId" }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "evidenceGap": { "$ref": "#/$defs/gap" } } } },
+    "requirements": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "expectedOutcome", "implementationTargets", "verificationTargetIds"], "properties": { "id": { "$ref": "#/$defs/requirementId" }, "expectedOutcome": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "evidenceGap": { "$ref": "#/$defs/gap" } } } },
     "uiStates": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "applicable"], "properties": { "name": { "type": "string", "minLength": 1 }, "applicable": { "type": "boolean" }, "expectedBehavior": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "notApplicableReason": { "type": "string", "minLength": 1 } }, "allOf": [{ "if": { "properties": { "applicable": { "const": true } }, "required": ["applicable"] }, "then": { "required": ["expectedBehavior", "implementationTargets", "verificationTargetIds"], "properties": { "implementationTargets": { "minItems": 1 }, "verificationTargetIds": { "minItems": 1 } } } }, { "if": { "properties": { "applicable": { "const": false } }, "required": ["applicable"] }, "then": { "required": ["notApplicableReason"] } }] } },
-    "interactions": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "implementationTargets", "verificationTargetIds"], "properties": { "name": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string" } } } } },
+    "interactions": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "trigger", "expectedBehavior", "implementationTargets", "verificationTargetIds"], "properties": { "name": { "type": "string", "minLength": 1 }, "trigger": { "type": "string", "minLength": 1 }, "expectedBehavior": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string" } } } } },
     "mockApi": { "type": "object", "additionalProperties": false, "required": ["strategy", "productionDefaultOff", "activation", "endpoints"], "properties": { "strategy": { "enum": ["native", "browser-intercept", "request-adapter", "not-needed"] }, "productionDefaultOff": { "const": true }, "activation": { "type": "string", "minLength": 1 }, "endpoints": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["method", "path"], "properties": { "method": { "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] }, "path": { "type": "string", "pattern": "^/" }, "fixture": { "$ref": "#/$defs/path" }, "consumer": { "$ref": "#/$defs/path" } } } } } },
     "designEvidence": { "type": "object", "additionalProperties": false, "required": ["source", "paths", "conflicts"], "properties": { "source": { "type": "string", "minLength": 1 }, "paths": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "conflicts": { "type": "array", "items": { "type": "string", "minLength": 1 } } } },
     "verificationTargets": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "type", "commandLabel", "file", "requirementIds", "uiStates"], "properties": { "id": { "type": "string", "minLength": 1 }, "type": { "enum": ["static", "unit", "component", "integration", "mock"] }, "commandLabel": { "type": "string", "minLength": 1 }, "file": { "$ref": "#/$defs/path" }, "symbol": { "type": "string", "minLength": 1 }, "requirementIds": { "type": "array", "items": { "$ref": "#/$defs/requirementId" } }, "uiStates": { "type": "array", "items": { "type": "string", "minLength": 1 } } } } },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.24.10",
+  "version": "0.24.11-beta.0",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/frontend-bounded-implement/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: frontend-bounded-implement
+description: >-
+  Use only for frontend implementation and repair writers after the canonical
+  contract gate has authorized a bounded write set.
+---
+
+# Frontend Bounded Implement
+
+## Authoritative Inputs
+
+- For implementation, use the run-owned
+  `contracts/frontend-implementation-contract.json`.
+- For repair, also use `contracts/frontend-repair-assessment.json`.
+- Treat requirement `expectedOutcome`, interaction `trigger` /
+  `expectedBehavior`, target files, UI states, Mock/API strategy, and verification
+  targets as closed decisions. Do not rediscover or reinterpret them.
+
+## Exploration Boundary
+
+- Read the canonical contract, its declared target files, and only directly
+  imported/called local code needed to edit those targets safely.
+- Do not open task sources, plans, reviews, OpenSpec, `ai_workspace/`, knowledge
+  bases, or unrelated repository areas. Do not recursively search the repository.
+- Start the bounded edit after confirming the contract and targets. Optional
+  context is not a reason to postpone implementation.
+- If behavior is still ambiguous or a required target is outside `writeSet`, stop
+  with `IMPLEMENTATION_OUTCOME: blocked`; do not compensate with broader scouting.
+
+## Implementation Discipline
+
+- Work test-first where behavior changes. Preserve unrelated files and stay inside
+  `allowedPaths` and `writeSet`.
+- Implement every requirement outcome, interaction, and applicable UI state
+  assigned to the writer. Keep the real request path enabled by default and use
+  only the approved Mock/API strategy.
+- Do not add dependencies unless the contract approves them. Never relax lint,
+  type, test, or build configuration; never add `.skip` or `.only`.
+- Run only the focused checks already frozen by the task. Leave full verification
+  to downstream deterministic nodes.
+
+## Required Outcome
+
+The first non-empty response line must be exactly one of:
+
+- `IMPLEMENTATION_OUTCOME: changed` — a non-empty bounded diff was produced.
+- `IMPLEMENTATION_OUTCOME: already-satisfied` — the contract was already met and
+  no file changed.
+- `IMPLEMENTATION_OUTCOME: blocked` — implementation cannot proceed without
+  guessing or exceeding the write boundary.
+
+Then report changed files, requirements/interactions implemented, tests or focused
+checks attempted, and residual risks. Never report `changed` for an empty diff.

package/skills/frontend-implementation/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: frontend-implementation
 description: >-
-  Use for frontend contract, scout, mock strategy, plan, and implementation DAG nodes.
+  Use for frontend contract, scout, mock strategy, and plan DAG nodes.
 references:
   - path: references/node-contracts.md
     required: true
@@ -29,12 +29,8 @@ rules, commands, or retrievals. Scout/planners locate and explicitly read applic
 specs; only successful paired reads count. Lockfile-only, fixture-only, or unread
 search hits do not prove a reusable Mock service.
 
-This broad discovery rule applies only to contract, scout, and plan phases. For
-`frontend-implement-pi`, the run-owned
-`contracts/frontend-implementation-contract.json` is the approved semantic input;
-do not repeat task-source, OpenSpec, AI workspace, plan, or repository-wide
-discovery. For `frontend-repair-pi`, consume that contract plus
-`contracts/frontend-repair-assessment.json` and make only the bounded repair.
+This broad discovery rule applies only to contract, scout, and plan phases.
+Implementation and repair use the separate `frontend-bounded-implement` skill.
 
 ## Implementation Discipline
 

package/skills/frontend-implementation/references/node-contracts.md

@@ -6,9 +6,9 @@ Pre-write nodes are read-only. Preserve IDs, labels, commands, language, require
 
 - **`frontend-contract-pi`**: `Scope`, `Non-goals`, `Acceptance Criteria`, `UI States`, `Target Runtime Environment`, `Risks`, `Verification Expectations`. No guessed requirements.
 - **`frontend-scout-pi`**: routes, components, tokens, data/API/Mock, scripts, tests, assets. Fact vs inference vs gap. Query the knowledge base when available and always search+read `openspec/schemas/`, `openspec/project-specs/`, and `ai_workspace/` before repo fallback. Output stack, routes, components, styling, conventions, state/data, test entry points, reuse, risks.
-- **`frontend-plan-pi` + conditional design loop**: AC → steps, in-bound files, applicable UI states, reuse, deps, Mock/API strategy, activation/rollback, frozen verify entrypoints, real-integration gap, and exactly one `frontend-implementation-contract-v1` JSON object. Use `uiStates: []` for logic-only changes with no user-visible UI state; do not invent UI states. Applicable states require behavior/implementation/verification, while non-applicable states require a reason and omit empty behavior placeholders. Prefer native Mock; browser intercept only with existing e2e; request-adapter only for a reversible seam. `auto` may select `not-needed` when no project Mock capability exists, while keeping real requests default and recording the gap; `required` cannot. Initial design pass uses the original plan; only exact `request-revision` runs read-only revision plus final review. Small-risk runs one design review only.
+- **`frontend-plan-pi` + conditional design loop**: AC → explicit observable `expectedOutcome`, interactions → explicit `trigger` + `expectedBehavior`, then steps, in-bound files, applicable UI states, reuse, deps, Mock/API strategy, activation/rollback, frozen verify entrypoints, real-integration gap, and exactly one `frontend-implementation-contract-v1` JSON object. IDs plus file paths are not sufficient behavior semantics. Use `uiStates: []` for logic-only changes with no user-visible UI state; do not invent UI states. Applicable states require behavior/implementation/verification, while non-applicable states require a reason and omit empty behavior placeholders. Prefer native Mock; browser intercept only with existing e2e; request-adapter only for a reversible seam. `auto` may select `not-needed` when no project Mock capability exists, while keeping real requests default and recording the gap; `required` cannot. Initial design pass uses the original plan; only exact `request-revision` runs read-only revision plus final review. Small-risk runs one design review only.
 - **`frontend-prewrite-gate-shell`**: the sole write authorization. Resolve effective plan/review, require exact pass, retain every REQ/BR/AC id, enforce Mock policy, validate schema/source binding, and materialize `contracts/frontend-implementation-contract.json`. Fallback is allowed only when a conditional primary is absent; an existing malformed primary fails closed. Generation-time blocked Mock produces one deterministic blocking shell node and no writer.
-- **`frontend-implement-pi`**: sole exclusive writer. Stay in `writeSet`; real requests default-on; Mock reversible, dev/test-only, production-off. Atomic handler/intercept/adapter with consumer+tests. Stop on forbidden paths or guesses. Output changed files, behavior, UI states, styling notes, verification attempted, residual risks. Optional mock-verify when frozen; static+behavior always; behavior must prove page consumption. Skipped-Mock `not-needed` keeps real integration pending unless the real backend path has fresh evidence.
+- **`frontend-implement-pi`**: sole regular exclusive writer and consumer of `frontend-bounded-implement`, not this discovery skill. Stay in `writeSet`; real requests default-on; Mock reversible, dev/test-only, production-off. Atomic handler/intercept/adapter with consumer+tests. Stop on forbidden paths or guesses. First line must be `IMPLEMENTATION_OUTCOME: changed|already-satisfied|blocked`; runtime checks it against the attributed diff. Optional mock-verify when frozen; static+behavior always; behavior must prove page consumption. Skipped-Mock `not-needed` keeps real integration pending unless the real backend path has fresh evidence.
 
 ## Contract / trace / stages (M1–M2)
 

package/dist/worker/observe/dag-run-artifacts.js

@@ -1,90 +0,0 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { isSafeObservabilityIdentifier } from "../observability/event-store.js";
-export const DAG_RUN_LIFECYCLES = ["active", "completed", "paused"];
-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 normalizeRelativeSegments(relativeSegments) {
-    if (!Array.isArray(relativeSegments) || relativeSegments.length === 0) {
-        return null;
-    }
-    const segments = [];
-    for (const segment of relativeSegments) {
-        if (typeof segment !== "string" || !segment)
-            return null;
-        if (segment === "." || segment === "..")
-            return null;
-        if (segment.includes("/") || segment.includes("\\") || segment.includes("\0")) {
-            return null;
-        }
-        segments.push(segment);
-    }
-    return segments;
-}
-/**
- * Resolve a path under `.harness/dag-runs/{lifecycle}/{dagRunId}/...`.
- * Fail closed on invalid ids, path escape, or the same runId appearing in
- * multiple lifecycle directories.
- */
-export function resolveDagRunArtifact(repoRoot, dagRunId, relativeSegments) {
-    if (!isSafeObservabilityIdentifier(dagRunId)) {
-        return { ok: false, reason: "invalid-id" };
-    }
-    const segments = normalizeRelativeSegments(relativeSegments);
-    if (!segments) {
-        return { ok: false, reason: "unsafe-path" };
-    }
-    for (const segment of segments) {
-        if (segment !== "run.json" &&
-            segment !== "state.json" &&
-            !isSafeObservabilityIdentifier(segment) &&
-            !/^[a-zA-Z0-9._-]+$/.test(segment)) {
-            // Allow known artifact filenames under a validated node id prefix.
-            if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(segment)) {
-                return { ok: false, reason: "unsafe-path" };
-            }
-        }
-    }
-    const dagRunsRoot = path.resolve(repoRoot, ".harness", "dag-runs");
-    const matches = [];
-    for (const lifecycle of DAG_RUN_LIFECYCLES) {
-        const runDir = path.join(dagRunsRoot, lifecycle, dagRunId);
-        const absolutePath = path.resolve(runDir, ...segments);
-        if (!isPathInside(dagRunsRoot, absolutePath))
-            continue;
-        const relative = path.relative(dagRunsRoot, absolutePath);
-        const parts = relative.split(path.sep).filter(Boolean);
-        if (parts[0] !== lifecycle || parts[1] !== dagRunId)
-            continue;
-        if (!existsSync(absolutePath))
-            continue;
-        matches.push({
-            lifecycle,
-            runDir,
-            absolutePath,
-            relativePath: path.join(lifecycle, dagRunId, ...segments),
-        });
-    }
-    if (matches.length === 0) {
-        return { ok: false, reason: "not-found" };
-    }
-    if (matches.length > 1) {
-        return { ok: false, reason: "ambiguous" };
-    }
-    return { ok: true, result: matches[0] };
-}
-export function resolveDagRunJson(repoRoot, dagRunId) {
-    return resolveDagRunArtifact(repoRoot, dagRunId, ["run.json"]);
-}
-export function resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId) {
-    if (!isSafeObservabilityIdentifier(nodeId)) {
-        return { ok: false, reason: "invalid-id" };
-    }
-    return resolveDagRunArtifact(repoRoot, dagRunId, [
-        nodeId,
-        "prompt.redacted.md",
-    ]);
-}

package/dist/worker/observe/node-input.js

@@ -1,444 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { redactSecrets, truncateUtf8Preview, } from "../../shared/preview.js";
-import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
-import { resolveDagNodePromptRedacted, resolveDagRunJson, } from "./dag-run-artifacts.js";
-export const NODE_INPUT_SCHEMA_VERSION = 1;
-export const NODE_INPUT_PREVIEW_MAX_BYTES = 64 * 1024;
-const SHELL_GATE_KEYS = [
-    "verdictGate",
-    "projectGovernanceGate",
-    "requirementCoverageGate",
-    "jsonArtifactGate",
-    "frontendPrewriteGate",
-    "frontendLintBaseline",
-    "frontendVerificationBundle",
-    "frontendReviewContext",
-    "backendTestPipeline",
-    "verifyEvidence",
-    "repairArtifactGate",
-];
-const PROMPT_FINGERPRINT_RE = /<prompt\s+sha256=([a-f0-9]{12})\s+len=(\d+)\s*>/i;
-function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
-    return {
-        schemaVersion: NODE_INPUT_SCHEMA_VERSION,
-        dagRunId,
-        nodeId,
-        available: false,
-        availabilityReason: reason,
-        source: null,
-        summary: null,
-        dependency: null,
-        prompt: null,
-        executorInput: null,
-        boundaries: null,
-        promptFingerprint: null,
-        warnings,
-    };
-}
-function redactString(value) {
-    if (typeof value !== "string")
-        return null;
-    return redactSecrets(value);
-}
-function redactStringList(values) {
-    if (!Array.isArray(values))
-        return [];
-    return values
-        .filter((item) => typeof item === "string")
-        .map((item) => redactSecrets(item));
-}
-function truncatedField(text, maxBytes = NODE_INPUT_PREVIEW_MAX_BYTES) {
-    const redacted = redactSecrets(text);
-    const truncated = truncateUtf8Preview(redacted, maxBytes);
-    return {
-        text: truncated,
-        truncated: truncated !== redacted,
-        maxBytes,
-    };
-}
-export function parsePromptRedactedFingerprint(markdown) {
-    const match = PROMPT_FINGERPRINT_RE.exec(markdown);
-    if (!match) {
-        return { ok: false, error: "fingerprint-format-mismatch" };
-    }
-    const sha256Prefix = match[1];
-    const lengthChars = Number(match[2]);
-    if (!Number.isSafeInteger(lengthChars) || lengthChars < 0) {
-        return { ok: false, error: "fingerprint-length-invalid" };
-    }
-    return { ok: true, sha256Prefix, lengthChars };
-}
-function isLikelyDynamicExpandedNode(nodeId, tasks) {
-    for (const parent of tasks) {
-        const parentId = typeof parent.id === "string" ? parent.id : "";
-        const expansion = parent.dynamicExpansion;
-        if (expansion && typeof expansion === "object") {
-            const childIdPrefix = typeof expansion.childIdPrefix ===
-                "string"
-                ? expansion.childIdPrefix
-                : "";
-            if (childIdPrefix) {
-                const prefix = `${childIdPrefix}-`;
-                if (nodeId.startsWith(prefix)) {
-                    const suffix = nodeId.slice(prefix.length);
-                    if (/^\d{4}$/.test(suffix) && Number(suffix) >= 1) {
-                        return true;
-                    }
-                }
-            }
-        }
-        const loop = parent.dynamicLoopUntil;
-        if (loop && typeof loop === "object" && parentId) {
-            const prefix = `${parentId}-r`;
-            if (nodeId.startsWith(prefix)) {
-                const rest = nodeId.slice(prefix.length);
-                const dash = rest.indexOf("-");
-                if (dash > 0) {
-                    const iterationText = rest.slice(0, dash);
-                    if (/^\d+$/.test(iterationText) && Number(iterationText) >= 1) {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-    return false;
-}
-function shellGateNames(shell) {
-    const gates = [];
-    for (const key of SHELL_GATE_KEYS) {
-        if (shell[key] != null)
-            gates.push(key);
-    }
-    return gates;
-}
-function resolveModelHint(spec, task) {
-    const complexity = typeof task.complexity === "string" ? task.complexity : null;
-    const executorModels = spec.executorModels;
-    if (complexity &&
-        executorModels &&
-        typeof executorModels === "object" &&
-        !Array.isArray(executorModels)) {
-        const pi = executorModels.pi;
-        if (pi && typeof pi === "object" && !Array.isArray(pi)) {
-            const model = pi[complexity];
-            if (typeof model === "string" && model.trim()) {
-                return redactSecrets(model);
-            }
-        }
-    }
-    const defaults = spec.defaults;
-    if (defaults && typeof defaults === "object" && !Array.isArray(defaults)) {
-        const model = defaults.model;
-        if (typeof model === "string" && model.trim()) {
-            return redactSecrets(model);
-        }
-    }
-    return null;
-}
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warnings) {
-    const defaults = spec.defaults && typeof spec.defaults === "object"
-        ? spec.defaults
-        : undefined;
-    const executorDeclared = typeof task.executor === "string";
-    const executor = executorDeclared
-        ? String(task.executor)
-        : "pi";
-    const executorSource = executorDeclared
-        ? "task"
-        : "schema-default";
-    const writePolicyDeclared = typeof task.writePolicy === "string";
-    let writePolicy = null;
-    let writePolicySource = null;
-    if (writePolicyDeclared) {
-        writePolicy = String(task.writePolicy);
-        writePolicySource = "task";
-    }
-    else if (typeof defaults?.writePolicy === "string") {
-        writePolicy = defaults.writePolicy;
-        writePolicySource = "defaults";
-    }
-    const skillSpec = {
-        defaults,
-        skillsByRole: spec.skillsByRole && typeof spec.skillsByRole === "object"
-            ? spec.skillsByRole
-            : undefined,
-    };
-    const skills = resolveDagNodeSkills(skillSpec, {
-        role: typeof task.role === "string" ? task.role : undefined,
-        skills: Array.isArray(task.skills)
-            ? task.skills.filter((s) => typeof s === "string")
-            : undefined,
-    }).map((skill) => redactSecrets(skill));
-    const promptRaw = typeof task.subtask_prompt === "string" ? task.subtask_prompt : "";
-    const promptBody = truncatedField(promptRaw);
-    const promptSourceRaw = task.subtask_prompt_source;
-    let promptSource = null;
-    if (promptSourceRaw && typeof promptSourceRaw === "object") {
-        const src = promptSourceRaw;
-        if (src.type === "markdown" && typeof src.path === "string") {
-            promptSource = {
-                type: "markdown",
-                path: redactSecrets(src.path),
-                sha256Prefix: typeof src.sha256 === "string" && src.sha256.length >= 12
-                    ? src.sha256.slice(0, 12)
-                    : null,
-            };
-        }
-    }
-    const shellRaw = task.shell && typeof task.shell === "object" && !Array.isArray(task.shell)
-        ? task.shell
-        : null;
-    const staticRaw = task.static && typeof task.static === "object" && !Array.isArray(task.static)
-        ? task.static
-        : null;
-    let kind = "unknown";
-    if (executor === "shell" || shellRaw)
-        kind = "shell";
-    else if (executor === "static" || staticRaw)
-        kind = "static";
-    else if (executor === "pi")
-        kind = "pi";
-    const shell = shellRaw
-        ? {
-            commands: redactStringList(shellRaw.commands),
-            preset: typeof shellRaw.preset === "string"
-                ? redactSecrets(shellRaw.preset)
-                : null,
-            cwd: typeof shellRaw.cwd === "string"
-                ? redactSecrets(shellRaw.cwd)
-                : null,
-            timeoutMs: typeof shellRaw.timeoutMs === "number" &&
-                Number.isFinite(shellRaw.timeoutMs)
-                ? shellRaw.timeoutMs
-                : null,
-            nonZeroExitPolicy: typeof shellRaw.nonZeroExitPolicy === "string"
-                ? shellRaw.nonZeroExitPolicy
-                : null,
-            gates: shellGateNames(shellRaw),
-        }
-        : null;
-    const staticPreview = staticRaw && typeof staticRaw.resultMarkdown === "string"
-        ? truncatedField(staticRaw.resultMarkdown)
-        : null;
-    const staticBlock = staticRaw
-        ? {
-            status: typeof staticRaw.status === "string" ? staticRaw.status : null,
-            resultPreview: staticPreview?.text ?? "",
-            truncated: staticPreview?.truncated ?? false,
-            maxBytes: staticPreview?.maxBytes ?? NODE_INPUT_PREVIEW_MAX_BYTES,
-        }
-        : null;
-    return {
-        schemaVersion: NODE_INPUT_SCHEMA_VERSION,
-        dagRunId,
-        nodeId,
-        available: true,
-        availabilityReason: "available",
-        source: {
-            kind: "frozen-run-spec",
-            artifact: "run.json#tasks",
-            lifecycle,
-        },
-        summary: {
-            executor: redactString(executor),
-            executorSource,
-            role: typeof task.role === "string" ? redactSecrets(task.role) : null,
-            complexity: typeof task.complexity === "string"
-                ? task.complexity
-                : null,
-            writePolicy: writePolicy ? redactSecrets(writePolicy) : null,
-            writePolicySource,
-            toolProfile: typeof task.toolProfile === "string"
-                ? redactSecrets(task.toolProfile)
-                : null,
-        },
-        dependency: {
-            dependsOn: redactStringList(task.depends_on),
-            dependsPolicy: typeof task.dependsPolicy === "string" ? task.dependsPolicy : null,
-            failureAwareDependsOn: redactStringList(task.failureAwareDependsOn),
-            runIf: typeof task.runIf === "string" ? redactSecrets(task.runIf) : null,
-        },
-        prompt: {
-            format: "markdown",
-            text: promptBody.text,
-            truncated: promptBody.truncated,
-            maxBytes: promptBody.maxBytes,
-            source: promptSource,
-        },
-        executorInput: {
-            kind,
-            skills,
-            modelHint: resolveModelHint(spec, task),
-            shell,
-            static: staticBlock,
-        },
-        boundaries: {
-            allowedPaths: redactStringList(task.allowedPaths),
-            forbiddenPaths: redactStringList(task.forbiddenPaths),
-            writeSet: redactStringList(task.writeSet),
-            outputContract: typeof task.outputContract === "string"
-                ? truncatedField(task.outputContract).text
-                : null,
-            outputMode: typeof task.outputMode === "string" ? task.outputMode : null,
-            firstProtocolLine: typeof task.firstProtocolLine === "string"
-                ? redactSecrets(task.firstProtocolLine)
-                : null,
-        },
-        promptFingerprint: fingerprint,
-        warnings,
-    };
-}
-async function loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings) {
-    const resolved = resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId);
-    if (!resolved.ok) {
-        if (resolved.reason === "ambiguous") {
-            warnings.push("Ambiguous prompt.redacted.md lifecycle copies.");
-        }
-        return {
-            exists: false,
-            sha256Prefix: null,
-            lengthChars: null,
-            artifact: null,
-        };
-    }
-    const artifact = path.posix.join(nodeId, "prompt.redacted.md");
-    try {
-        const markdown = await readFile(resolved.result.absolutePath, "utf-8");
-        const parsed = parsePromptRedactedFingerprint(markdown);
-        if (!parsed.ok) {
-            warnings.push(`prompt.redacted.md parse failed: ${parsed.error}`);
-            return {
-                exists: true,
-                sha256Prefix: null,
-                lengthChars: null,
-                artifact,
-                parseError: parsed.error,
-            };
-        }
-        return {
-            exists: true,
-            sha256Prefix: parsed.sha256Prefix,
-            lengthChars: parsed.lengthChars,
-            artifact,
-        };
-    }
-    catch {
-        warnings.push("prompt.redacted.md could not be read.");
-        return {
-            exists: true,
-            sha256Prefix: null,
-            lengthChars: null,
-            artifact,
-            parseError: "read-failed",
-        };
-    }
-}
-/**
- * Build schemaVersion 1 node-input projection for Observe / Inspect.
- * Never returns the raw task object.
- */
-export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
-    const runResolved = resolveDagRunJson(repoRoot, dagRunId);
-    if (!runResolved.ok) {
-        if (runResolved.reason === "invalid-id") {
-            return {
-                ok: false,
-                status: 400,
-                body: { error: "Invalid dag run or node identifier" },
-            };
-        }
-        if (runResolved.reason === "ambiguous") {
-            return {
-                ok: false,
-                status: 409,
-                body: { error: "Ambiguous dag run lifecycle" },
-            };
-        }
-        if (runResolved.reason === "not-found") {
-            return {
-                ok: false,
-                status: 404,
-                body: { error: "DAG run not found" },
-            };
-        }
-        return {
-            ok: false,
-            status: 400,
-            body: { error: "Invalid or unsafe path" },
-        };
-    }
-    let raw;
-    try {
-        raw = JSON.parse(await readFile(runResolved.result.absolutePath, "utf-8"));
-    }
-    catch {
-        return {
-            ok: false,
-            status: 422,
-            body: { error: "run.json is unreadable or invalid JSON" },
-        };
-    }
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return {
-            ok: false,
-            status: 422,
-            body: { error: "run.json is not a DAG spec object" },
-        };
-    }
-    const spec = raw;
-    const tasks = Array.isArray(spec.tasks) ? spec.tasks : null;
-    if (!tasks) {
-        return {
-            ok: true,
-            status: 200,
-            body: unavailableBody(dagRunId, nodeId, "run-spec-unavailable", [
-                "run.json has no tasks[] array.",
-            ]),
-        };
-    }
-    const taskRecords = tasks.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
-    const task = taskRecords.find((item) => typeof item.id === "string" && item.id === nodeId);
-    if (!task) {
-        if (isLikelyDynamicExpandedNode(nodeId, taskRecords)) {
-            return {
-                ok: true,
-                status: 200,
-                body: unavailableBody(dagRunId, nodeId, "unsupported-dynamic-node", [
-                    "Runtime-expanded node input is not projected in schemaVersion 1.",
-                ]),
-            };
-        }
-        return {
-            ok: true,
-            status: 200,
-            body: unavailableBody(dagRunId, nodeId, "task-not-found"),
-        };
-    }
-    const warnings = [];
-    const fingerprint = await loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings);
-    // Reject unknown nested leakage by projecting only through allowlist helpers.
-    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, warnings);
-    // Defense-in-depth: ensure raw task never sneaks in.
-    if ("task" in body) {
-        return {
-            ok: false,
-            status: 422,
-            body: { error: "projection leaked raw task" },
-        };
-    }
-    return { ok: true, status: 200, body };
-}
-/** Test helper: ensure response JSON never contains raw task keys. */
-export function assertNoRawTaskLeak(body) {
-    if (!body || typeof body !== "object")
-        return true;
-    const record = body;
-    if ("task" in record)
-        return false;
-    if ("subtask_prompt" in record)
-        return false;
-    const serialized = JSON.stringify(body);
-    return !serialized.includes('"subtask_prompt":');
-}