@tea-agent/loop-agent 0.36.4-beta.0 → 0.37.1-beta.0

package/dist/worker/console/operation-wait.js

@@ -1,355 +0,0 @@
-import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
-import { isTerminalOperationState, } from "./operation-store.js";
-/**
- * P2: read-only event-driven long poll on the canonical operation event ring
- * (2026-08-13 Operator Chat long-run supervision). Server contract bounds:
- * the model-facing `maxWaitMs` is clamped to [minWaitMs, maxWaitMsBound];
- * defaults allow the 60–180s model supervision cadence and tests may inject
- * short bounds.
- */
-export const DEFAULT_OPERATION_WAIT_MIN_MS = 60_000;
-export const DEFAULT_OPERATION_WAIT_MAX_MS = 180_000;
-export class OperationWaitError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = "OperationWaitError";
-    }
-}
-/**
- * Pure wake classification: heartbeats are liveness telemetry, not progress.
- * Everything else (state/result/stdout/stderr/error/reconcile) is meaningful.
- *
- * Exception (2026-08-15): stderr/stdout events whose payload is a DAG-runner
- * telemetry log line (`[dag execute] heartbeat ...` / `[task advance] heartbeat
- * ...` / bare `heartbeat ...`) are also liveness, not progress. Without this,
- * a long run's periodic stderr heartbeat logs settle every operationWait
- * immediately (55/55 observed instant returns) and force the model back into
- * high-frequency bash polling — defeating the 60-180s backoff contract.
- */
-const RUNNER_TELEMETRY_LOG = /^\s*\[?(?:dag execute|task advance|run-dag)\]?\s*heartbeat\b/i;
-const BARE_HEARTBEAT_LOG = /^\s*heartbeat\b/i;
-export function isMeaningfulOperationEvent(event) {
-    if (event.kind === "heartbeat")
-        return false;
-    if (event.kind === "stderr" || event.kind === "stdout") {
-        const message = typeof event.message === "string"
-            ? event.message
-            : "";
-        // Multi-line chunks: only telemetry-only chunks are classified liveness.
-        const lines = message.split("\n").filter((line) => line.trim() !== "");
-        if (lines.length > 0 && lines.every((line) => RUNNER_TELEMETRY_LOG.test(line) || BARE_HEARTBEAT_LOG.test(line))) {
-            return false;
-        }
-    }
-    return true;
-}
-function isFocusedOperation(operation) {
-    return (isTerminalOperationState(operation.state) ||
-        operation.state === "needs-reconcile");
-}
-function settledSummary(input) {
-    const projectedEvents = input.newEvents.length > 0
-        ? input.newEvents.map(projectOperationEventSummary)
-        : [];
-    // Cursor safety: nextSeq always covers every observed seq so heartbeats
-    // filtered out of the payload are never replayed on the next round.
-    const nextSeq = Math.max(input.afterSeq, input.observedSeq);
-    return {
-        operationId: input.operationId,
-        state: input.operation.state,
-        changed: input.changed,
-        timedOut: input.timedOut,
-        events: projectedEvents,
-        nextSeq,
-        recommendedNextCall: {
-            operationId: input.operationId,
-            afterSeq: nextSeq,
-            wakeOn: "meaningful",
-        },
-        operation: projectOperationForChat(input.operation),
-    };
-}
-/**
- * Deterministic read-only wait over the canonical operation event stream
- * (AC-003 / AC-004). Completion paths (wakeOn=meaningful default):
- *  - existing meaningful events (seq > afterSeq) → immediate (changed: true);
- *  - operation terminal/needs-reconcile → immediate flush of meaningful events;
- *  - first subscribed meaningful event → immediate settle;
- *  - maxWaitMs elapsed without meaningful change → timedOut summary whose
- *    nextSeq still covers every observed (heartbeat) seq.
- *
- * wakeOn=all preserves the legacy diagnostic semantics: any first event,
- * heartbeat included, settles and is returned.
- *
- * Race safety: the listener is registered BEFORE listFrom, closing the
- * listFrom/subscribe gap; every path settles exactly once through a guarded
- * `finish`, and listener + timer are always cleaned up on settle.
- */
-export async function waitForOperationChange(input) {
-    const operationId = input.operationId?.trim();
-    if (!operationId) {
-        throw new OperationWaitError("INVALID_INPUT", "operationId is required");
-    }
-    if (!Number.isInteger(input.afterSeq) || input.afterSeq < 0) {
-        throw new OperationWaitError("INVALID_INPUT", "afterSeq must be a non-negative integer");
-    }
-    const wakeOn = input.wakeOn ?? "meaningful";
-    if (wakeOn !== "meaningful" && wakeOn !== "all") {
-        throw new OperationWaitError("INVALID_INPUT", "wakeOn must be 'meaningful' or 'all'");
-    }
-    const minWaitMs = input.minWaitMs ?? DEFAULT_OPERATION_WAIT_MIN_MS;
-    const maxWaitMsBound = input.maxWaitMsBound ?? DEFAULT_OPERATION_WAIT_MAX_MS;
-    if (!Number.isFinite(minWaitMs) ||
-        !Number.isFinite(maxWaitMsBound) ||
-        minWaitMs < 0 ||
-        maxWaitMsBound < minWaitMs) {
-        throw new OperationWaitError("INVALID_INPUT", "invalid wait bounds");
-    }
-    const rawMaxWaitMs = input.maxWaitMs ?? maxWaitMsBound;
-    if (!Number.isFinite(rawMaxWaitMs) || rawMaxWaitMs < 0) {
-        throw new OperationWaitError("INVALID_INPUT", "maxWaitMs must be a non-negative number");
-    }
-    const maxWaitMs = Math.max(minWaitMs, Math.min(maxWaitMsBound, Math.floor(rawMaxWaitMs)));
-    const afterSeq = input.afterSeq;
-    /** Wake filter per policy: meaningful drops heartbeat payload entirely. */
-    const wakeFilter = (events) => wakeOn === "meaningful"
-        ? events.filter((event) => isMeaningfulOperationEvent(event))
-        : events;
-    const operation = await input.operations.get(operationId);
-    if (!operation) {
-        throw new OperationWaitError("NOT_FOUND", `operation not found: ${operationId}`);
-    }
-    const events = input.events;
-    if (isFocusedOperation(operation)) {
-        // Flush unconsumed events before the terminal summary: the caller's
-        // cursor must advance past every retained canonical event (observed
-        // seq includes heartbeats even when their payload is filtered out).
-        const listed = events.listFrom(operationId, afterSeq);
-        if ("error" in listed) {
-            throw new OperationWaitError("EVENT_CURSOR_EXPIRED", "event cursor expired; re-read operation snapshot");
-        }
-        const wake = wakeFilter(listed.events);
-        const observedSeq = listed.events.length > 0
-            ? listed.events[listed.events.length - 1].seq
-            : afterSeq;
-        if (wake.length > 0) {
-            return settledSummary({
-                operationId,
-                operation,
-                afterSeq,
-                changed: true,
-                timedOut: false,
-                newEvents: wake,
-                observedSeq,
-            });
-        }
-        return settledSummary({
-            operationId,
-            operation,
-            afterSeq,
-            changed: false,
-            timedOut: false,
-            newEvents: [],
-            observedSeq,
-        });
-    }
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        let timer;
-        let pollTimer;
-        let unsubscribe;
-        /** Highest seq observed via listener/listFrom during this wait. */
-        let observedSeq = afterSeq;
-        const cleanup = () => {
-            if (timer !== undefined) {
-                clearTimeout(timer);
-                timer = undefined;
-            }
-            if (pollTimer !== undefined) {
-                clearInterval(pollTimer);
-                pollTimer = undefined;
-            }
-            if (unsubscribe) {
-                unsubscribe();
-                unsubscribe = undefined;
-            }
-        };
-        const finish = (result) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            if (result instanceof OperationWaitError)
-                reject(result);
-            else
-                resolve(result);
-        };
-        const settleWithEvent = (event) => {
-            // Future-cursor guard: events at or below the caller's afterSeq are
-            // already consumed and must not settle this wait.
-            if (event.seq <= afterSeq)
-                return;
-            // Heartbeats only advance the observed cursor in meaningful mode.
-            if (wakeOn === "meaningful" && !isMeaningfulOperationEvent(event)) {
-                observedSeq = Math.max(observedSeq, event.seq);
-                return;
-            }
-            observedSeq = Math.max(observedSeq, event.seq);
-            // Listener path: async re-read of the operation for a fresh summary.
-            void (async () => {
-                try {
-                    const current = await input.operations.get(operationId);
-                    finish(settledSummary({
-                        operationId,
-                        operation: current ?? operation,
-                        afterSeq,
-                        changed: true,
-                        timedOut: false,
-                        newEvents: [event],
-                        observedSeq,
-                    }));
-                }
-                catch (error) {
-                    finish(error instanceof OperationWaitError
-                        ? error
-                        : new OperationWaitError("INVALID_INPUT", error instanceof Error ? error.message : String(error)));
-                }
-            })();
-        };
-        // Terminal recheck before subscribing: events landing during this await
-        // are still in the ring and are caught by listFrom below.
-        void (async () => {
-            try {
-                const current = await input.operations.get(operationId);
-                if (current && isFocusedOperation(current)) {
-                    // Same terminal flush as the initial path: events landing during
-                    // the await are still in the retained ring.
-                    const listed = events.listFrom(operationId, afterSeq);
-                    if ("error" in listed) {
-                        finish(new OperationWaitError("EVENT_CURSOR_EXPIRED", "event cursor expired; re-read operation snapshot"));
-                        return;
-                    }
-                    const wake = wakeFilter(listed.events);
-                    observedSeq = Math.max(observedSeq, listed.events.length > 0
-                        ? listed.events[listed.events.length - 1].seq
-                        : afterSeq);
-                    if (wake.length > 0) {
-                        finish(settledSummary({
-                            operationId,
-                            operation: current,
-                            afterSeq,
-                            changed: true,
-                            timedOut: false,
-                            newEvents: wake,
-                            observedSeq,
-                        }));
-                        return;
-                    }
-                    finish(settledSummary({
-                        operationId,
-                        operation: current,
-                        afterSeq,
-                        changed: false,
-                        timedOut: false,
-                        newEvents: [],
-                        observedSeq,
-                    }));
-                    return;
-                }
-                // Subscribe BEFORE listFrom: any event appended after this point
-                // reaches the listener, closing the listFrom/subscribe race.
-                unsubscribe = events.subscribe(operationId, settleWithEvent);
-                const listed = events.listFrom(operationId, afterSeq);
-                if ("error" in listed) {
-                    finish(new OperationWaitError("EVENT_CURSOR_EXPIRED", "event cursor expired; re-read operation snapshot"));
-                    return;
-                }
-                observedSeq = Math.max(observedSeq, listed.events.length > 0
-                    ? listed.events[listed.events.length - 1].seq
-                    : afterSeq);
-                const wake = wakeFilter(listed.events);
-                if (wake.length > 0) {
-                    finish(settledSummary({
-                        operationId,
-                        operation: current ?? operation,
-                        afterSeq,
-                        changed: true,
-                        timedOut: false,
-                        newEvents: wake,
-                        observedSeq,
-                    }));
-                    return;
-                }
-                // No wake events: arm the bounded wait; the listener settles on
-                // the first new wake event, the timer settles on timeout. The
-                // timeout summary returns observedSeq so heartbeat-only progress
-                // advances the cursor without replaying heartbeat payloads.
-                timer = setTimeout(() => {
-                    void (async () => {
-                        try {
-                            const latest = await input.operations.get(operationId);
-                            finish(settledSummary({
-                                operationId,
-                                operation: latest ?? operation,
-                                afterSeq,
-                                changed: false,
-                                timedOut: true,
-                                newEvents: [],
-                                observedSeq,
-                            }));
-                        }
-                        catch (error) {
-                            finish(error instanceof OperationWaitError
-                                ? error
-                                : new OperationWaitError("INVALID_INPUT", error instanceof Error ? error.message : String(error)));
-                        }
-                    })();
-                }, maxWaitMs);
-                timer.unref?.();
-                if (input.poll) {
-                    pollTimer = setInterval(() => {
-                        void (async () => {
-                            if (settled)
-                                return;
-                            try {
-                                const changed = await input.poll?.();
-                                if (!changed || settled)
-                                    return;
-                                const relisted = events.listFrom(operationId, afterSeq);
-                                if ("error" in relisted)
-                                    return;
-                                const nextWake = wakeFilter(relisted.events);
-                                observedSeq = Math.max(observedSeq, relisted.events.length > 0
-                                    ? relisted.events[relisted.events.length - 1].seq
-                                    : afterSeq);
-                                if (nextWake.length === 0)
-                                    return;
-                                const latest = await input.operations.get(operationId);
-                                finish(settledSummary({
-                                    operationId,
-                                    operation: latest ?? operation,
-                                    afterSeq,
-                                    changed: true,
-                                    timedOut: false,
-                                    newEvents: nextWake,
-                                    observedSeq,
-                                }));
-                            }
-                            catch {
-                                // Poll is best-effort; the wait still times out.
-                            }
-                        })();
-                    }, 1_000);
-                    pollTimer.unref?.();
-                }
-            }
-            catch (error) {
-                finish(error instanceof OperationWaitError
-                    ? error
-                    : new OperationWaitError("INVALID_INPUT", error instanceof Error ? error.message : String(error)));
-            }
-        })();
-    });
-}

package/dist/worker/console/recovery-error-copy.js

@@ -1,198 +0,0 @@
-/**
- * Operator-facing Chinese copy for recovery failures.
- * Reason codes stay in plan JSON; flash / chat must not dump them raw.
- */
-const REASON_LABELS = {
-    "worker-managed-rerun-unsupported": "这次运行由 Console/Worker 启动，不能只从某个节点续跑",
-    "workspace-drift": "工作区在上次运行后又改过文件，旧结果不能接着用",
-    "controller-drift": "控制器版本已变化，不能接到上次运行上继续",
-    "binding-drift": "任务契约或源文件已变化，不能只续跑旧计划",
-    "restart-subgraph-contains-unsafe-shell": "下游包含会执行命令的验证步骤，不能只重跑这一段",
-    "restart-subgraph-contains-writer": "下游包含会改代码的写入步骤，不能只重跑这一段",
-    "restart-subgraph-contains-decision-gate": "下游包含需要人工决策的门禁，不能只重跑这一段",
-    "dynamic-rerun-unsupported": "这次运行含动态展开节点，不支持从节点续跑",
-    "parent-lifecycle-ineligible": "当前运行状态不允许从节点续跑",
-    "convergence-rerun-unsupported": "收敛型运行不支持从节点续跑",
-    "evaluation-rerun-unsupported": "带评估的运行不支持从节点续跑",
-    "budget-rerun-unsupported": "硬预算运行不支持从节点续跑",
-    "workspace-checkpoint-missing": "缺少工作区快照，无法安全地只续跑一段",
-    "skill-snapshot-invalid": "技能快照缺失或损坏，不能接到上次运行上继续",
-    "unresolved-errors-outside-reset-closure": "选中节点之外还有未解决的失败，只重跑这一段不够",
-    "selected-node-missing": "找不到要续跑的起始节点",
-    "ambiguous-skipped-rewrite": "跳过的节点有多个上游失败，无法自动选定起点",
-    "skipped-without-upstream-error": "该节点被跳过且没有明确的上游失败",
-    "parent-facts-invalid": "上次运行的证据不完整或已损坏，不能只续跑一段",
-    RUN_NOT_ACTIVE: "这次运行不在活动状态，不能协作中止",
-    RUN_NOT_CONSOLE_OWNED: "此运行不由当前 Console 持有，暂不支持协作中止",
-    RUNNER_IDENTITY_MISMATCH: "运行身份已变化，不能中止这份过期请求",
-    INTERRUPT_ALREADY_PENDING: "已有一条中止请求等待结算",
-    RUN_ALREADY_TERMINAL: "运行已经结束，没有可中止的活 runner",
-    INTERRUPT_NEEDS_RECONCILE: "中止请求已登记但无法确认 runner 已处理，需要对账",
-};
-function knownCodes() {
-    return Object.keys(REASON_LABELS);
-}
-export function parseIneligibleReasonToken(token) {
-    const trimmed = token.trim().replace(/[.…]+$/, "");
-    if (!trimmed)
-        return null;
-    if (REASON_LABELS[trimmed])
-        return { code: trimmed };
-    const colon = trimmed.lastIndexOf(":");
-    if (colon > 0) {
-        const code = trimmed.slice(colon + 1);
-        const nodeId = trimmed.slice(0, colon);
-        if (REASON_LABELS[code])
-            return { code, nodeId };
-        const match = knownCodes().find((known) => code.length >= 3 && known.startsWith(code));
-        if (match)
-            return { code: match, nodeId };
-    }
-    return REASON_LABELS[trimmed] ? { code: trimmed } : null;
-}
-function collectParsedReasons(input) {
-    const parsed = [];
-    for (const token of input.blockedReasons ?? []) {
-        const item = parseIneligibleReasonToken(String(token));
-        if (item)
-            parsed.push(item);
-    }
-    for (const node of input.blockingNodes ?? []) {
-        const code = node.reasonCode?.trim();
-        if (!code)
-            continue;
-        const item = parseIneligibleReasonToken(node.nodeId ? `${node.nodeId}:${code}` : code);
-        if (item)
-            parsed.push(item);
-    }
-    if (parsed.length === 0 && input.fallbackMessage?.trim()) {
-        const raw = input.fallbackMessage
-            .trim()
-            .replace(/^从节点重跑不具备安全资格[：:]?\s*/, "")
-            .replace(/[。．.]+$/, "");
-        for (const part of raw.split(/[;；]/)) {
-            const item = parseIneligibleReasonToken(part);
-            if (item)
-                parsed.push(item);
-        }
-    }
-    return parsed;
-}
-function uniqueReasonLines(parsed) {
-    const nodesByCode = new Map();
-    for (const item of parsed) {
-        const nodes = nodesByCode.get(item.code) ?? [];
-        if (item.nodeId && !nodes.includes(item.nodeId))
-            nodes.push(item.nodeId);
-        nodesByCode.set(item.code, nodes);
-    }
-    const lines = [];
-    for (const [code, nodes] of nodesByCode) {
-        const label = REASON_LABELS[code];
-        if (!label)
-            continue;
-        if (nodes.length > 0 && code.startsWith("restart-subgraph-contains-")) {
-            lines.push(`${label}（${nodes.join("、")}）`);
-        }
-        else {
-            lines.push(label);
-        }
-    }
-    return lines;
-}
-export function nextActionForIneligibleRerun(reasons) {
-    const haystack = reasons.join("; ");
-    if (haystack.includes("worker-managed-rerun-unsupported") ||
-        reasons.some((reason) => parseIneligibleReasonToken(reason)?.code ===
-            "worker-managed-rerun-unsupported")) {
-        return "下一步：请点下方「重新排队 Worker Task」，从头完整执行。";
-    }
-    return "下一步：请改用「完整重跑任务」，从头完整执行。";
-}
-export function formatIneligibleRerunMessage(input) {
-    const fallback = input.fallbackMessage?.trim();
-    if (fallback?.startsWith("无法从该节点续跑"))
-        return fallback;
-    const parsed = collectParsedReasons(input);
-    const lines = uniqueReasonLines(parsed);
-    const reasonTokens = parsed.map((item) => item.code);
-    const next = nextActionForIneligibleRerun(reasonTokens.length > 0 ? reasonTokens : [fallback ?? ""]);
-    if (lines.length === 0) {
-        return [
-            "无法从该节点续跑。这次续跑不够安全（工作区、控制器或下游步骤不允许只重跑一段）。",
-            next,
-        ].join("\n");
-    }
-    return [
-        "无法从该节点续跑，因为：",
-        ...lines.map((line) => `• ${line}`),
-        "",
-        next,
-    ].join("\n");
-}
-/** Returns rewritten copy when `raw` is a known recovery failure; otherwise null. */
-export function rewriteRecoveryOperatorError(raw) {
-    const text = raw.trim();
-    if (!text)
-        return null;
-    if (text.startsWith("无法从该节点续跑"))
-        return text;
-    if (/从节点重跑不具备安全资格|worker-managed-rerun-unsupported|restart-subgraph-contains-|workspace-drift|controller-drift|binding-drift/.test(text)) {
-        return formatIneligibleRerunMessage({ fallbackMessage: text });
-    }
-    if (/action must be a mutation-gate target/i.test(text)) {
-        return "这个操作不能再走确认门。Worker 启动的任务请直接点「重新排队 Worker Task」；独立运行请点「完整重跑任务」。";
-    }
-    if (/cannot read dagReport run facts/i.test(text)) {
-        return "读不到这次运行的失败报告，不能完整重跑。请先点「查看报告」或「Doctor 诊断」。";
-    }
-    if (/dagRerunPlan run facts unavailable/i.test(text)) {
-        return "读不到从节点续跑的资格结果，不能改走完整重跑。请先点「从节点重跑」查看资格，或先「查看报告」。";
-    }
-    if (/node rerun plan is eligible/i.test(text)) {
-        return "从节点续跑是安全的，请改用「从节点重跑」，不必完整重跑整单。";
-    }
-    if (/does not support autonomous standaloneTaskRerun/i.test(text)) {
-        return "当前失败不适合自动完整重跑。请先点「查看报告」，按建议操作。";
-    }
-    if (/primaryRecovery requires a human decision/i.test(text)) {
-        return "这次失败需要人工决策，不能自动重跑。请先点「查看报告」。";
-    }
-    if (/is not bound to run/i.test(text)) {
-        return "填写的任务 ID 与这次运行不匹配。请使用该运行绑定的原任务 ID。";
-    }
-    if (/cannot read pool doctor/i.test(text)) {
-        return "读不到任务队列状态，暂时不能重新排队。请稍后重试，或先跑 Doctor 诊断。";
-    }
-    if (/not found in the pool doctor inventory/i.test(text)) {
-        return "任务队列里找不到这个任务，不能重新排队。请确认 Task ID 来自 Worker 队列，而不是只填了 DAG 运行 ID。";
-    }
-    if (/only Failed tasks are retry-eligible/i.test(text)) {
-        const status = text.match(/is ([A-Za-z_]+); only Failed/)?.[1];
-        return status
-            ? `该任务当前是「${status}」，只有失败（Failed）的任务才能重新排队。`
-            : "只有失败（Failed）的任务才能重新排队。请先确认任务已失败。";
-    }
-    if (/featureId .+ does not match the pool task/i.test(text)) {
-        return "Feature ID 与队列中的任务不一致。请改用队列里记录的 Feature ID，或留空后重试。";
-    }
-    if (/RUN_NOT_CONSOLE_OWNED|不由当前 Console 持有/.test(text)) {
-        return "此运行不由当前 Console 持有，暂不支持协作中止。请用 Doctor / 报告查看。";
-    }
-    if (/RUNNER_IDENTITY_MISMATCH|运行身份已变化/.test(text)) {
-        return "运行身份已变化，不能中止这份过期请求。请刷新后再试。";
-    }
-    if (/INTERRUPT_ALREADY_PENDING|已有一条中止请求/.test(text)) {
-        return "已有一条中止请求等待当前节点安全收敛。请稍候刷新，不要重复提交。";
-    }
-    if (/RUN_ALREADY_TERMINAL|运行已经结束/.test(text)) {
-        return "运行已经结束，没有可中止的活 runner。请改用报告或对账。";
-    }
-    if (/INTERRUPT_NEEDS_RECONCILE|无法确认 runner 已处理/.test(text)) {
-        return "中止请求已登记，但无法确认 runner 已处理。请用 Doctor 对账，不要当成已经中止。";
-    }
-    if (/RUN_NOT_ACTIVE/.test(text)) {
-        return "这次运行不在本机活动目录，或已经不是 running，不能协作中止。";
-    }
-    return null;
-}