@tea-agent/loop-agent 0.34.0 → 0.34.2

package/dist/worker/console/prd-intake-bridge.js

@@ -0,0 +1,393 @@
+/**
+ * Console PRD Intake Bridge (design 2026-08-11-console-prd-intake-bridge).
+ * Maps task-side intake artifacts / projected source into Console DraftStore
+ * fields. Does not run Semantic Intake itself — that stays in task advance.
+ */
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import { getTaskPaths } from "../../task/runtime.js";
+import { SEMANTIC_INTAKE_ARTIFACT_REL, } from "../../task/source-prepare/semantic-intake.js";
+import { extractRequirementFactsFromMarkdown } from "../../task/source-prepare/parse-intent.js";
+import { emptyDraft } from "./interview/grill-me.js";
+import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
+function asStringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (typeof item === "string")
+            return item.trim();
+        if (item && typeof item === "object") {
+            const record = item;
+            if (typeof record.text === "string")
+                return record.text.trim();
+            if (typeof record.message === "string")
+                return record.message.trim();
+        }
+        return String(item ?? "").trim();
+    })
+        .filter(Boolean);
+}
+function asAcceptance(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (let i = 0; i < value.length; i += 1) {
+        const item = value[i];
+        if (typeof item === "string" && item.trim()) {
+            out.push({ id: `AC-${i + 1}`, text: item.trim() });
+            continue;
+        }
+        if (item && typeof item === "object") {
+            const record = item;
+            const text = typeof record.text === "string" ? record.text.trim() : "";
+            if (!text)
+                continue;
+            const id = typeof record.id === "string" && record.id.trim()
+                ? record.id.trim()
+                : `AC-${i + 1}`;
+            out.push({ id, text });
+        }
+    }
+    return out;
+}
+function warningList(json) {
+    if (!json || typeof json !== "object")
+        return [];
+    const root = json;
+    const raw = Array.isArray(root.warnings)
+        ? root.warnings
+        : Array.isArray(root.result?.warnings)
+            ? root.result?.warnings
+            : [];
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object")
+            continue;
+        const record = item;
+        const code = typeof record.code === "string" && record.code.trim()
+            ? record.code.trim()
+            : "UNKNOWN";
+        const message = typeof record.message === "string" ? record.message : code;
+        out.push({ code, message });
+    }
+    return out;
+}
+function lifecycleFromAdvanceJson(json) {
+    if (!json || typeof json !== "object")
+        return undefined;
+    const root = json;
+    const value = root.result?.lifecycleState ?? root.lifecycleState;
+    return typeof value === "string" ? value : undefined;
+}
+async function readJsonIfExists(filePath) {
+    try {
+        await access(filePath);
+        const raw = await readFile(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function hasRequirementStructure(draft) {
+    const req = draft.requirement ?? {};
+    return Boolean(typeof req.objective === "string" &&
+        req.objective.trim() &&
+        Array.isArray(req.scope) &&
+        req.scope.length > 0 &&
+        Array.isArray(req.acceptanceCriteria) &&
+        req.acceptanceCriteria.length > 0);
+}
+/** Normalize path / verify lists from operator params (arrays or newline/comma text). */
+export function parseEngineeringBoundaryFromParams(p) {
+    const asList = (value) => {
+        if (Array.isArray(value)) {
+            return value
+                .map((item) => (typeof item === "string" ? item.trim() : ""))
+                .filter(Boolean);
+        }
+        if (typeof value === "string") {
+            return value
+                .split(/[\n,;，；]+/)
+                .map((s) => s.trim())
+                .filter(Boolean);
+        }
+        return [];
+    };
+    const allowedPaths = asList(p.allowedPaths ?? p.allowedPath);
+    const forbiddenPaths = asList(p.forbiddenPaths ?? p.forbiddenPath);
+    const verifyRaw = p.verifyCommands ?? p.verify;
+    const verifyCommands = [];
+    if (Array.isArray(verifyRaw)) {
+        for (let i = 0; i < verifyRaw.length; i += 1) {
+            const item = verifyRaw[i];
+            if (typeof item === "string" && item.trim()) {
+                const trimmed = item.trim();
+                const idx = trimmed.indexOf(":");
+                if (idx > 0 && idx < trimmed.length - 1 && !trimmed.slice(0, idx).includes(" ")) {
+                    verifyCommands.push({
+                        label: trimmed.slice(0, idx),
+                        command: trimmed.slice(idx + 1).trim(),
+                    });
+                }
+                else {
+                    verifyCommands.push({
+                        label: `verify-${i + 1}`,
+                        command: trimmed,
+                    });
+                }
+            }
+            else if (item && typeof item === "object") {
+                const rec = item;
+                const command = typeof rec.command === "string" ? rec.command.trim() : "";
+                if (!command)
+                    continue;
+                verifyCommands.push({
+                    label: typeof rec.label === "string" && rec.label.trim()
+                        ? rec.label.trim()
+                        : `verify-${i + 1}`,
+                    command,
+                    ...(typeof rec.timeoutMs === "number"
+                        ? { timeoutMs: rec.timeoutMs }
+                        : {}),
+                });
+            }
+        }
+    }
+    else if (typeof verifyRaw === "string" && verifyRaw.trim()) {
+        for (const [i, line] of asList(verifyRaw).entries()) {
+            const idx = line.indexOf(":");
+            if (idx > 0 && idx < line.length - 1 && !line.slice(0, idx).includes(" ")) {
+                verifyCommands.push({
+                    label: line.slice(0, idx),
+                    command: line.slice(idx + 1).trim(),
+                });
+            }
+            else {
+                verifyCommands.push({ label: `verify-${i + 1}`, command: line });
+            }
+        }
+    }
+    return {
+        ...(allowedPaths.length > 0 ? { allowedPaths } : {}),
+        ...(forbiddenPaths.length > 0 ? { forbiddenPaths } : {}),
+        ...(verifyCommands.length > 0 ? { verifyCommands } : {}),
+    };
+}
+export function appendEngineeringCliArgs(args, boundary) {
+    for (const pathGlob of boundary.allowedPaths ?? []) {
+        args.push("--allowed-path", pathGlob);
+    }
+    for (const pathGlob of boundary.forbiddenPaths ?? []) {
+        args.push("--forbidden-path", pathGlob);
+    }
+    for (const cmd of boundary.verifyCommands ?? []) {
+        args.push("--verify", `${cmd.label}:${cmd.command}`);
+    }
+}
+export function applyEngineeringBoundaryToDraft(draft, boundary) {
+    if (!(boundary.allowedPaths?.length) &&
+        !(boundary.forbiddenPaths?.length) &&
+        !(boundary.verifyCommands?.length)) {
+        return draft;
+    }
+    return {
+        ...draft,
+        constraints: {
+            invariants: draft.constraints?.invariants ?? [],
+            allowedPaths: boundary.allowedPaths?.length
+                ? boundary.allowedPaths
+                : (draft.constraints?.allowedPaths ?? []),
+            forbiddenPaths: boundary.forbiddenPaths?.length
+                ? boundary.forbiddenPaths
+                : (draft.constraints?.forbiddenPaths ?? []),
+        },
+        verification: {
+            commands: boundary.verifyCommands?.length
+                ? boundary.verifyCommands
+                : (draft.verification?.commands ?? []),
+        },
+    };
+}
+export async function buildDraftFromTaskIntake(input) {
+    const taskKind = normalizeConsoleWorkflowKind(input.taskKind, "standard");
+    const paths = getTaskPaths(input.repoRoot, input.taskId);
+    const warnings = warningList(input.advanceJson);
+    const lifecycleState = lifecycleFromAdvanceJson(input.advanceJson);
+    const semanticApplied = warnings.some((w) => w.code === "SEMANTIC_INTAKE_APPLIED");
+    const semanticFailed = warnings.find((w) => w.code === "SEMANTIC_INTAKE_PI_FAILED" ||
+        w.code === "SEMANTIC_INTAKE_INVALID_OUTPUT" ||
+        w.code === "SEMANTIC_INTAKE_FAILED" ||
+        w.code === "SEMANTIC_INTAKE_NO_DOCUMENTS" ||
+        w.code === "SEMANTIC_INTAKE_REFUSED_NON_EXECUTABLE");
+    const semanticSkipped = warnings.find((w) => w.code === "SEMANTIC_INTAKE_SKIPPED");
+    const artifactPath = path.join(paths.taskDir, SEMANTIC_INTAKE_ARTIFACT_REL);
+    const artifact = await readJsonIfExists(artifactPath);
+    let draft = {
+        ...emptyDraft(input.taskId, input.title, { taskKind }),
+        requirement: {
+            objective: input.title,
+        },
+    };
+    let parseStatus = "pending";
+    let semanticIntake = {
+        applied: false,
+        code: semanticFailed?.code ?? semanticSkipped?.code,
+        message: semanticFailed?.message ?? semanticSkipped?.message,
+    };
+    const semanticReq = artifact?.draft?.requirement ??
+        (artifact?.semantic
+            ? {
+                objective: artifact.semantic.objective,
+                scope: artifact.semantic.scope,
+                nonGoals: artifact.semantic.nonGoals,
+                acceptanceCriteria: artifact.semantic.acceptanceCriteria,
+            }
+            : undefined);
+    // An artifact is authoritative only when this exact advance invocation reports
+    // SEMANTIC_INTAKE_APPLIED. Tasks may import newer immutable PRD revisions while
+    // an older per-task semantic artifact remains on disk; never project it as the
+    // current Console draft.
+    if (semanticApplied && semanticReq?.objective?.trim()) {
+        const title = artifact?.draft?.title?.trim() ||
+            artifact?.semantic?.title?.trim() ||
+            input.title;
+        draft = {
+            ...draft,
+            title,
+            requirement: {
+                objective: semanticReq.objective.trim(),
+                scope: asStringList(semanticReq.scope),
+                nonGoals: asStringList(semanticReq.nonGoals),
+                acceptanceCriteria: asAcceptance(semanticReq.acceptanceCriteria),
+            },
+            openQuestions: asStringList(artifact?.draft?.openQuestions ?? artifact?.semantic?.openQuestions) || undefined,
+            assumptions: asStringList(artifact?.draft?.assumptions ?? artifact?.semantic?.assumptions) || undefined,
+            references: artifact?.draft?.references,
+        };
+        parseStatus = "semantic";
+        semanticIntake = {
+            applied: true,
+            code: "SEMANTIC_INTAKE_APPLIED",
+            message: "structured from artifacts/intake/semantic-draft.json",
+        };
+    }
+    else {
+        // Deterministic path. When the current intake is incomplete/failed/skipped,
+        // prefer the newest imported reference over an older projected 需求.md.
+        // Successful deterministic projection still prefers canonical 需求.md.
+        const projectedRequirementPath = path.join(paths.sourceDir, "需求.md");
+        const referenceCandidates = [];
+        try {
+            const manifestPath = path.join(paths.sourceDir, "source-manifest.json");
+            const manifest = await readJsonIfExists(manifestPath);
+            for (const doc of manifest?.documents ?? []) {
+                if ((doc.role === "requirement" || doc.role === "acceptance") &&
+                    typeof doc.materializedPath === "string") {
+                    referenceCandidates.push({
+                        filePath: path.join(paths.sourceDir, doc.materializedPath),
+                        importedAt: typeof doc.importedAt === "string" ? doc.importedAt : "",
+                    });
+                }
+            }
+        }
+        catch {
+            // ignore manifest read errors
+        }
+        referenceCandidates.sort((left, right) => right.importedAt.localeCompare(left.importedAt));
+        const preferImportedReferences = Boolean(semanticFailed ||
+            semanticSkipped ||
+            lifecycleState === "intake-incomplete");
+        const candidates = preferImportedReferences
+            ? [
+                ...referenceCandidates.map((candidate) => candidate.filePath),
+                projectedRequirementPath,
+            ]
+            : [
+                projectedRequirementPath,
+                ...referenceCandidates.map((candidate) => candidate.filePath),
+            ];
+        for (const filePath of candidates) {
+            try {
+                const markdown = await readFile(filePath, "utf8");
+                const facts = extractRequirementFactsFromMarkdown(markdown);
+                if (!facts.objective?.trim())
+                    continue;
+                draft = {
+                    ...draft,
+                    title: facts.title?.trim() || input.title,
+                    requirement: {
+                        objective: facts.objective.trim(),
+                        scope: facts.scope,
+                        nonGoals: facts.nonGoals,
+                        acceptanceCriteria: facts.acceptanceCriteria,
+                    },
+                    openQuestions: facts.openQuestions.length > 0
+                        ? facts.openQuestions
+                        : undefined,
+                    assumptions: facts.assumptions.length > 0
+                        ? facts.assumptions
+                        : undefined,
+                };
+                parseStatus = hasRequirementStructure(draft)
+                    ? "deterministic"
+                    : "incomplete";
+                if (hasRequirementStructure(draft))
+                    break;
+            }
+            catch {
+                // try next candidate
+            }
+        }
+        // Fallback: title-only objective (never invent scope/AC templates).
+        if (!draft.requirement?.objective?.trim()) {
+            draft = {
+                ...draft,
+                requirement: { objective: input.title },
+            };
+            parseStatus = "incomplete";
+        }
+        else if (parseStatus === "pending") {
+            parseStatus = hasRequirementStructure(draft)
+                ? "deterministic"
+                : "incomplete";
+        }
+    }
+    // Engineering gaps remain as draft gaps; do not invent paths/AC templates.
+    const gaps = warnings.filter((w) => w.code === "EMPTY_ALLOWED_PATHS" ||
+        w.code === "EMPTY_ACCEPTANCE" ||
+        w.code === "EMPTY_OBJECTIVE" ||
+        w.code === "EMPTY_FORBIDDEN_PATHS" ||
+        w.code === "INTAKE_INCOMPLETE" ||
+        w.code === "BOUNDARY_REQUIRED" ||
+        w.code.startsWith("SEMANTIC_INTAKE_") ||
+        w.code === "NO_PARSEABLE_REQUIREMENT");
+    if (semanticFailed && !semanticIntake.applied) {
+        if (!hasRequirementStructure(draft)) {
+            parseStatus = "failed";
+        }
+        semanticIntake = {
+            applied: false,
+            code: semanticFailed.code,
+            message: semanticFailed.message,
+        };
+    }
+    else if (!hasRequirementStructure(draft) && parseStatus !== "semantic") {
+        parseStatus = "incomplete";
+    }
+    if (input.engineering) {
+        draft = applyEngineeringBoundaryToDraft(draft, input.engineering);
+    }
+    return {
+        draft,
+        parseStatus,
+        semanticIntake,
+        gaps,
+        lifecycleState,
+    };
+}
+/** True when requirement structure is filled enough that Skip should not invent AC/scope. */
+export function requirementStructurallyReady(draft) {
+    return hasRequirementStructure(draft);
+}

package/dist/worker/console/recovery-cta.js

@@ -37,9 +37,10 @@ const CTA = {
         id: "reconcile",
         label: "对账 / reconcile",
         requiresReason: true,
+        action: "dagReconcileRun",
         lane: "dag",
-        guide: "状态不一致时先对账，再决定是否重跑（需原因）",
-        commandHint: "loop-agent dag reconcile-run --run-id <run-id> --reason <structured-reason>",
+        guide: "Orphan/中断时先对账归档（默认 supersede）；runner 仍存活时勿盲 supersede",
+        commandHint: "loop-agent dag reconcile-run --run-id <run-id> --action supersede --reason <structured-reason>",
     },
     regenerate: {
         id: "regenerate",
@@ -97,7 +98,9 @@ const MATRIX = {
         "resume",
         "regenerate",
     ],
-    "orphan-unknown": ["report", "doctor", "reconcile"],
+    // Stall/quiet/unknown: observe + doctor only — do not offer supersede while
+    // runner may still be alive (eligibility fail-closes, but UI should not tease).
+    "orphan-unknown": ["report", "doctor"],
     "terminal-failed": [
         "report",
         "doctor",
@@ -137,8 +140,9 @@ export function partitionRecoveryCtas(ctas) {
 }
 /**
  * Console only shows CTAs that actually dispatch an operator action.
- * Pure CLI-hint rows (regenerate / decision / resume / reconcile) stay in the
- * policy matrix for docs, but must not appear as dead buttons.
+ * Pure CLI-hint rows (regenerate / decision / resume) stay in the policy
+ * matrix for docs, but must not appear as dead buttons. reconcile is wired
+ * to dagReconcileRun (structured reason required).
  */
 export function isConsoleExecutableRecoveryCta(cta) {
     return typeof cta.action === "string" && cta.action.trim().length > 0;
@@ -167,6 +171,8 @@ export function recommendedRecoveryCtaId(factClass) {
         case "pause-on-human":
             return pick("doctor", "report");
         case "needs-reconcile":
+            // Prefer doctor first; reconcile is available when operator confirms reason.
+            return pick("doctor", "reconcile", "report");
         case "runtime-mismatch":
         case "contract-drift":
             return pick("doctor", "report");
@@ -201,6 +207,7 @@ export function classifyRecoveryFact(input) {
     const code = (input.errorCode ?? "").toLowerCase();
     const state = (input.operationState ?? "").toLowerCase();
     const dag = (input.dagStatus ?? "").toLowerCase();
+    const failure = (input.failureCategory ?? "").toLowerCase();
     if (code.includes("validation") ||
         code.includes("invalid") ||
         state.includes("validation")) {
@@ -225,15 +232,37 @@ export function classifyRecoveryFact(input) {
     if (code.includes("verif") || state.includes("verif")) {
         return "verification-failed";
     }
+    // Controller interrupt / orphaned mid-run: reconcile first (not blind rerun).
+    if (failure === "controller-interrupted" ||
+        code.includes("controller-interrupted") ||
+        code.includes("interrupted") ||
+        dag === "interrupted" ||
+        dag === "orphaned" ||
+        state.includes("controller-interrupted") ||
+        state.includes("interrupted")) {
+        return "needs-reconcile";
+    }
+    // Live stall / quiet while runner lease may still be fresh — observe/doctor only
+    // (Console executable CTAs: report + doctor; reconcile stays CLI-hint).
+    if (dag === "running-suspected-stall" ||
+        dag === "running-quiet" ||
+        dag === "suspected-stall" ||
+        dag.includes("suspected-stall") ||
+        state.includes("suspected-stall")) {
+        return "orphan-unknown";
+    }
     if (state === "succeeded" ||
         state === "completed" ||
+        state === "finished" ||
         dag === "succeeded" ||
-        dag === "completed") {
+        dag === "completed" ||
+        dag === "finished") {
         return "terminal-succeeded";
     }
     if (state === "failed" ||
         state.includes("fail") ||
         dag === "failed" ||
+        dag === "partial_failed" ||
         code.includes("fail")) {
         return "terminal-failed";
     }

package/dist/worker/console/server.js

@@ -4,6 +4,7 @@ import { createServer } from "node:http";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
+import { DAG_ABSOLUTE_MAX_WALL_CLOCK_MS } from "../../shared/timeout-policy.js";
 import { openConsoleAppData } from "./app-data.js";
 import { DagConfirmationStore } from "./dag-confirmation.js";
 import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
@@ -24,6 +25,30 @@ import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 import { NightAuxTicker } from "./night-aux-ticker.js";
 import { deriveObserveRouteCapabilities } from "../observe/health.js";
 import { createObserveRouteContext, defaultObserveStaticDir, handleMatchedObserveRoute, matchObserveGetRoute, ROUTES, serveObserveStatic, } from "../observe/routes.js";
+/**
+ * Default hard timeout for the Console-owned LoopAgentClient.
+ *
+ * Console task-nav operations (`dag execute`, `task advance --approve-gate`,
+ * etc.) spawn a long-lived sibling runner via the operation runner. The
+ * worker client hard-kills children after `defaultTimeoutMs` (default 120s),
+ * which is far below multi-node DAG wall clocks and leaves `state.json`
+ * stuck in `running` with no error. Align with shared `DAG_ABSOLUTE_MAX_WALL_CLOCK_MS`
+ * (4h) so the client is a safety net, not a false deadline.
+ */
+export const DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS = DAG_ABSOLUTE_MAX_WALL_CLOCK_MS;
+/**
+ * Resolve the Console LoopAgentClient default timeout.
+ * `0` disables the client hard timeout (DAG kernel owns wall clock).
+ */
+export function resolveConsoleDefaultTimeoutMs(override) {
+    if (override === undefined) {
+        return DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS;
+    }
+    if (!Number.isFinite(override) || override < 0) {
+        throw new Error(`console serve: invalid defaultTimeoutMs ${String(override)} (expected >= 0)`);
+    }
+    return override;
+}
 /** Built static assets live next to the compiled server under dist/worker/console/static. */
 export function defaultConsoleStaticDir(fromFileUrl = import.meta.url) {
     return path.join(path.dirname(fileURLToPath(fromFileUrl)), "static");
@@ -74,6 +99,9 @@ export async function createConsoleServer(options) {
             loopAgentBin: resolveSiblingLoopAgentBin(),
             artifactRoot,
             resolveIdentity: true,
+            // See DEFAULT_CONSOLE_CLIENT_TIMEOUT_MS: dag execute / task advance
+            // must not inherit the 120s worker-command default.
+            defaultTimeoutMs: resolveConsoleDefaultTimeoutMs(options.defaultTimeoutMs),
         });
     if (!options.skipReconcile) {
         await operations.reconcileOnBoot();