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

package/dist/worker/console/static-src/operator-chat/activity-rail-presentation.js

@@ -1,73 +0,0 @@
-import { useLayoutEffect, useState } from "react";
-export const ACTIVITY_RAIL_WIDTH = 420;
-export const ACTIVITY_RAIL_GAP = 12;
-/**
- * Resolve Activity Rail placement from the actual free space to the right of
- * ChatMain. Activity presence is deliberately not an input: session data may
- * show/hide the Rail, but it must never change the conversation geometry.
- */
-export function resolveActivityRailPresentation(input) {
-    if (input.layoutMode === "narrow")
-        return "sheet";
-    const railWidth = input.railWidth ?? ACTIVITY_RAIL_WIDTH;
-    const gap = input.gap ?? ACTIVITY_RAIL_GAP;
-    const available = input.viewportWidth - input.mainRight;
-    return available >= railWidth + gap ? "sidecar" : "drawer";
-}
-const INITIAL = {
-    presentation: "drawer",
-    sidecarRect: null,
-};
-/** Measure ChatMain without feeding Activity state back into the page layout. */
-export function useActivityRailPresentation(mainRef, layoutMode, refreshKey) {
-    const [snapshot, setSnapshot] = useState(INITIAL);
-    useLayoutEffect(() => {
-        const main = mainRef.current;
-        if (!main)
-            return;
-        const verticalAnchor = main.closest(".panel--chat") ?? main;
-        let frame = 0;
-        const measure = () => {
-            window.cancelAnimationFrame(frame);
-            frame = window.requestAnimationFrame(() => {
-                const rect = main.getBoundingClientRect();
-                const verticalRect = verticalAnchor.getBoundingClientRect();
-                const presentation = resolveActivityRailPresentation({
-                    layoutMode,
-                    viewportWidth: window.innerWidth,
-                    mainRight: rect.right,
-                });
-                const sidecarRect = presentation === "sidecar"
-                    ? {
-                        top: verticalRect.top,
-                        left: rect.right + ACTIVITY_RAIL_GAP,
-                        height: verticalRect.height,
-                        width: ACTIVITY_RAIL_WIDTH,
-                    }
-                    : null;
-                setSnapshot((current) => {
-                    if (current.presentation === presentation &&
-                        current.sidecarRect?.top === sidecarRect?.top &&
-                        current.sidecarRect?.left === sidecarRect?.left &&
-                        current.sidecarRect?.height === sidecarRect?.height &&
-                        current.sidecarRect?.width === sidecarRect?.width) {
-                        return current;
-                    }
-                    return { presentation, sidecarRect };
-                });
-            });
-        };
-        measure();
-        const observer = new ResizeObserver(measure);
-        observer.observe(main);
-        if (verticalAnchor !== main)
-            observer.observe(verticalAnchor);
-        window.addEventListener("resize", measure);
-        return () => {
-            window.cancelAnimationFrame(frame);
-            observer.disconnect();
-            window.removeEventListener("resize", measure);
-        };
-    }, [layoutMode, mainRef, refreshKey]);
-    return snapshot;
-}

package/dist/worker/console/static-src/operator-chat/activity-references.js

@@ -1,20 +0,0 @@
-export function operationActivityRefs(operation) {
-    return [
-        operation.activityRef ?? `operation:${operation.operationId}`,
-        `operation:${operation.operationId}`,
-        ...(operation.toolCallId ? [`tool:${operation.toolCallId}`] : []),
-    ];
-}
-export function humanGateActivityRefs(card) {
-    return [card.activityRef ?? `gate:${card.cardId}`];
-}
-export function artifactActivityRefs(card) {
-    return [card.activityRef ?? `artifact:${card.artifactId}`];
-}
-export function buildActivityTargetRefs(input) {
-    return new Set([
-        ...input.operations.flatMap(operationActivityRefs),
-        ...input.gates.flatMap(humanGateActivityRefs),
-        ...input.artifacts.flatMap(artifactActivityRefs),
-    ]);
-}

package/dist/worker/console/static-src/operator-chat/slash-palette-layout.js

@@ -1,24 +0,0 @@
-export const SHORTCUT_PALETTE_AVAILABLE_HEIGHT_VAR = "--oc-shortcut-palette-available-height";
-export const SHORTCUT_PALETTE_TOP_INSET = 8;
-export const SHORTCUT_PALETTE_ANCHOR_GAP = 8;
-/**
- * Resolve the real vertical room above the composer anchor. The palette is
- * clipped by `.oc-main`, while a shifted VisualViewport (for example when the
- * browser UI or virtual keyboard changes) can impose a lower visible top edge.
- */
-export function resolveShortcutPaletteAvailableHeight(geometry) {
-    const viewportTop = geometry.viewportTop ?? 0;
-    const topInset = geometry.topInset ?? SHORTCUT_PALETTE_TOP_INSET;
-    const anchorGap = geometry.anchorGap ?? SHORTCUT_PALETTE_ANCHOR_GAP;
-    const values = [
-        geometry.boundaryTop,
-        geometry.anchorTop,
-        viewportTop,
-        topInset,
-        anchorGap,
-    ];
-    if (values.some((value) => !Number.isFinite(value)))
-        return null;
-    const visibleTop = Math.max(geometry.boundaryTop, viewportTop);
-    return Math.max(0, Math.floor(geometry.anchorTop - visibleTop - topInset - anchorGap));
-}

package/dist/worker/console/static-src/operator-chat/slash-palette-nav.js

@@ -1,141 +0,0 @@
-/**
- * Slash palette display + navigation model (UI-12 card grid).
- *
- * Display order (SLASH_GROUP_DISPLAY_ORDER) is intentionally decoupled from
- * the conflict/priority order in shortcuts.ts (SOURCE_PRIORITY): merge and
- * dedupe keep SOURCE_PRIORITY semantics (skill 3 < prompt 4), while rendering
- * follows the display order (prompt group before skill group). buildPaletteModel
- * models that divergence explicitly — every card carries its flat-list
- * globalIndex so keyboard/AT state round-trips from the rendered position back
- * to filteredShortcuts[globalIndex]. shortcuts.ts itself stays untouched.
- *
- * All functions here are pure/DOM-free so the geometric and row-aware
- * navigation can be unit-tested in node with fixture rects.
- */
-import { SLASH_SOURCE_LABEL, } from "../../chat/shortcuts.js";
-/** Group render order (independent from SOURCE_PRIORITY conflict order). */
-export const SLASH_GROUP_DISPLAY_ORDER = [
-    "operator",
-    "web",
-    "extension",
-    "prompt",
-    "skill",
-];
-/** Group filtered candidates by display order, skipping empty groups. */
-export function buildPaletteModel(entries) {
-    const groups = [];
-    for (const source of SLASH_GROUP_DISPLAY_ORDER) {
-        const items = [];
-        for (let i = 0; i < entries.length; i += 1) {
-            if (entries[i].source === source) {
-                items.push({ entry: entries[i], globalIndex: i });
-            }
-        }
-        if (items.length === 0)
-            continue;
-        groups.push({ source, label: SLASH_SOURCE_LABEL[source], items });
-    }
-    return groups;
-}
-/** Keep the active option index inside the current candidate range. */
-export function clampShortcutIndex(index, length) {
-    if (!Number.isFinite(length) || length <= 0)
-        return 0;
-    if (!Number.isFinite(index) || index < 0)
-        return 0;
-    if (index >= length)
-        return length - 1;
-    return index;
-}
-/** CSS grid columns per workspace layout mode (single source: layoutMode). */
-export function paletteColumnCount(mode) {
-    if (mode === "comfortable")
-        return 3;
-    if (mode === "compact")
-        return 2;
-    return 1;
-}
-/**
- * Group- and row-aware movement on the displayed card grid.
- *
- * Left/Right move to the adjacent card in the current row and stay inside the
- * current group (row start/end stick; group headers are never entered; narrow
- * 1-column layout is a no-op). Up/Down move within the same column to the
- * adjacent row, may cross group boundaries, and stick at grid edges — never
- * wrapping around and never leaving [0, entries.length - 1].
- */
-export function movePaletteIndex(currentIndex, model, columns, direction) {
-    const groupPos = model.findIndex((group) => group.items.some((card) => card.globalIndex === currentIndex));
-    if (groupPos < 0)
-        return currentIndex;
-    const group = model[groupPos];
-    const offset = group.items.findIndex((card) => card.globalIndex === currentIndex);
-    if (offset < 0)
-        return currentIndex;
-    const row = Math.floor(offset / columns);
-    const col = offset % columns;
-    if (direction === "left" || direction === "right") {
-        if (columns <= 1)
-            return currentIndex;
-        const delta = direction === "left" ? -1 : 1;
-        const targetOffset = offset + delta;
-        if (targetOffset < 0 || targetOffset >= group.items.length) {
-            return currentIndex;
-        }
-        if (Math.floor(targetOffset / columns) !== row)
-            return currentIndex;
-        return group.items[targetOffset].globalIndex;
-    }
-    const delta = direction === "up" ? -1 : 1;
-    const targetOffset = offset + delta * columns;
-    if (targetOffset >= 0 && targetOffset < group.items.length) {
-        return group.items[targetOffset].globalIndex;
-    }
-    // Cross-group: walk to the previous/next non-empty group and target the
-    // same column on its last (up) / first (down) row; stick when that column
-    // does not exist in the partial edge row.
-    for (let cursor = groupPos + delta; cursor >= 0 && cursor < model.length; cursor += delta) {
-        const candidate = model[cursor];
-        if (candidate.items.length === 0)
-            continue;
-        const lastRowStart = Math.floor((candidate.items.length - 1) / columns) * columns;
-        const target = direction === "up" ? lastRowStart + col : col;
-        if (target >= candidate.items.length)
-            return currentIndex;
-        return candidate.items[target].globalIndex;
-    }
-    return currentIndex;
-}
-/**
- * Geometry-first Up/Down targeting: from the active card's measured rect,
- * pick the adjacent row's candidate whose horizontal center is nearest the
- * active card's center (group boundaries may be crossed). Returns null when
- * no candidate exists above/below (or the layout was not measured), so the
- * caller falls back to movePaletteIndex. globalIndex comes from
- * data-shortcut-index — never from the DOM list position.
- */
-export function pickAdjacentRowTarget(activeRect, cells, direction) {
-    const activeCenterX = (activeRect.left + activeRect.right) / 2;
-    let best = null;
-    for (const cell of cells) {
-        if (cell.globalIndex === activeRect.globalIndex)
-            continue;
-        const gap = direction === "up"
-            ? activeRect.top - cell.bottom
-            : cell.top - activeRect.bottom;
-        // Same-row cells overlap vertically (gap < 0) and must be ignored.
-        if (gap < 0)
-            continue;
-        const centerX = (cell.left + cell.right) / 2;
-        const dist = Math.abs(centerX - activeCenterX);
-        if (best === null ||
-            gap < best.gap ||
-            (gap === best.gap && dist < best.dist) ||
-            (gap === best.gap &&
-                dist === best.dist &&
-                cell.globalIndex < best.index)) {
-            best = { gap, dist, index: cell.globalIndex };
-        }
-    }
-    return best?.index ?? null;
-}

package/dist/worker/console/static-src/operator-chat/useActivityRailTransition.js

@@ -1,59 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from "react";
-export const ACTIVITY_RAIL_ENTER_MS = 160;
-export const ACTIVITY_RAIL_LEAVE_MS = 120;
-export const ACTIVITY_RAIL_SWITCH_MS = 120;
-export function activityRailSnapshotTotal(snapshot) {
-    if (!snapshot)
-        return 0;
-    return (snapshot.operationCards.length +
-        snapshot.humanGateCards.length +
-        snapshot.artifactCards.length);
-}
-/**
- * Keep the Rail shell independent from ChatMain while sessions change. Old
- * content is non-interactive during the short switching/leaving phase, then is
- * replaced or removed without ever changing conversation geometry.
- */
-export function useActivityRailTransition(current) {
-    const currentTotal = activityRailSnapshotTotal(current);
-    const [state, setState] = useState(() => currentTotal > 0
-        ? { phase: "visible", snapshot: current }
-        : { phase: "hidden", snapshot: null });
-    const stateRef = useRef(state);
-    stateRef.current = state;
-    const currentKey = useMemo(() => `${current?.sessionId ?? "none"}:${currentTotal}`, [current?.sessionId, currentTotal]);
-    useEffect(() => {
-        const timers = [];
-        const displayed = stateRef.current.snapshot;
-        if (!current || currentTotal === 0) {
-            if (!displayed) {
-                setState({ phase: "hidden", snapshot: null });
-                return;
-            }
-            setState({ phase: "leaving", snapshot: displayed });
-            timers.push(window.setTimeout(() => {
-                setState({ phase: "hidden", snapshot: null });
-            }, ACTIVITY_RAIL_LEAVE_MS));
-        }
-        else if (!displayed) {
-            setState({ phase: "entering", snapshot: current });
-            timers.push(window.setTimeout(() => {
-                setState({ phase: "visible", snapshot: current });
-            }, ACTIVITY_RAIL_ENTER_MS));
-        }
-        else if (displayed.sessionId !== current.sessionId) {
-            setState({ phase: "switching", snapshot: current });
-            timers.push(window.setTimeout(() => {
-                setState({ phase: "visible", snapshot: current });
-            }, ACTIVITY_RAIL_SWITCH_MS));
-        }
-        else {
-            setState({ phase: "visible", snapshot: current });
-        }
-        return () => {
-            for (const timer of timers)
-                window.clearTimeout(timer);
-        };
-    }, [current, currentKey, currentTotal]);
-    return state;
-}

package/dist/worker/observability/interrupt-eligibility.js

@@ -1,264 +0,0 @@
-import { hostname as localHostname } from "node:os";
-import { DagInterruptError, INTERRUPT_ERROR_MESSAGES, projectedInterruptStatus, readInterruptRequest, runnerIdentitiesMatch, runnerIdentityFromState, } from "../../workflows/dag/interrupt-request.js";
-import { assessDagRunLiveness, locateDagRun, readDagRunState, } from "../../workflows/dag/lifecycle.js";
-function operationControllerFingerprint(operation) {
-    const identity = operation.controllerIdentity;
-    if (!identity)
-        return undefined;
-    if ("fingerprint" in identity && typeof identity.fingerprint === "string") {
-        const value = identity.fingerprint.trim();
-        return value || undefined;
-    }
-    if ("packageFingerprint" in identity &&
-        identity.packageFingerprint &&
-        typeof identity.packageFingerprint === "object" &&
-        "value" in identity.packageFingerprint &&
-        typeof identity.packageFingerprint.value === "string") {
-        const value = identity.packageFingerprint.value.trim();
-        return value || undefined;
-    }
-    return undefined;
-}
-function ineligible(partial) {
-    const code = partial.reasonCodes[0] ?? "RUN_NOT_ACTIVE";
-    return {
-        ...partial,
-        eligible: false,
-        message: partial.message ?? INTERRUPT_ERROR_MESSAGES[code],
-    };
-}
-function bindLiveOperations(input) {
-    return input.operations.filter((operation) => {
-        if (operation.state !== "running" && operation.state !== "starting") {
-            return false;
-        }
-        if (operation.pid !== input.runner.pid)
-            return false;
-        if (operation.dagRunId && operation.dagRunId !== input.runId)
-            return false;
-        const fingerprint = operationControllerFingerprint(operation);
-        if (!fingerprint || fingerprint !== input.runner.controllerFingerprint) {
-            return false;
-        }
-        return true;
-    });
-}
-export async function evaluateConsoleDagInterruptEligibility(input) {
-    const runId = input.runId.trim();
-    if (!runId) {
-        return ineligible({
-            runId: "",
-            ownerKind: "unknown",
-            reasonCodes: ["INVALID_INPUT"],
-            interruptStatus: "none",
-        });
-    }
-    const located = await locateDagRun(input.repoRoot, runId);
-    if (!located) {
-        return ineligible({
-            runId,
-            ownerKind: "unknown",
-            reasonCodes: ["RUN_NOT_ACTIVE"],
-            interruptStatus: "none",
-        });
-    }
-    let state;
-    try {
-        state = await readDagRunState(located.runDir);
-    }
-    catch {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            ownerKind: "unknown",
-            reasonCodes: ["RUN_NOT_ACTIVE"],
-            interruptStatus: "none",
-        });
-    }
-    let interrupt;
-    try {
-        interrupt = await readInterruptRequest(located.runDir);
-    }
-    catch {
-        interrupt = undefined;
-    }
-    const interruptStatus = projectedInterruptStatus(interrupt);
-    if (state.workerAssociation) {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            ownerKind: "worker-managed",
-            reasonCodes: ["RUN_NOT_CONSOLE_OWNED"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    if (located.lifecycle !== "active" || state.status !== "running") {
-        const terminal = located.lifecycle === "completed" ||
-            located.lifecycle === "paused" ||
-            state.status === "paused" ||
-            state.status === "finished" ||
-            state.status === "failed" ||
-            state.status === "partial_failed" ||
-            state.status === "superseded" ||
-            state.status === "abandoned";
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            ownerKind: "external-local",
-            reasonCodes: [terminal ? "RUN_ALREADY_TERMINAL" : "RUN_NOT_ACTIVE"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    const runner = runnerIdentityFromState(state);
-    if (!runner) {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            ownerKind: "unknown",
-            reasonCodes: ["RUNNER_IDENTITY_MISMATCH"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    if (runner.hostname !== (input.hostname ?? localHostname())) {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            ownerKind: "external-local",
-            reasonCodes: ["RUN_NOT_CONSOLE_OWNED"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    const liveness = assessDagRunLiveness({
-        state,
-        hostname: input.hostname ?? localHostname(),
-    });
-    if (liveness.status === "orphaned" || liveness.status === "unknown-host") {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            ownerKind: "unknown",
-            reasonCodes: ["RUN_NOT_ACTIVE"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    const liveOps = await input.operations.list();
-    const matches = bindLiveOperations({
-        operations: liveOps,
-        runId,
-        runner,
-    });
-    const targetFromInterrupt = interrupt?.targetOperationId
-        ? (liveOps.find((op) => op.operationId === interrupt.targetOperationId) ??
-            (await input.operations.get(interrupt.targetOperationId)))
-        : undefined;
-    const targetOperationState = (matches.length === 1 ? matches[0]?.state : undefined) ??
-        targetFromInterrupt?.state;
-    const expected = {
-        pid: runner.pid,
-        hostname: runner.hostname,
-        startedAt: runner.startedAt,
-        controllerFingerprint: runner.controllerFingerprint,
-    };
-    if (interrupt &&
-        (interrupt.status === "requested" || interrupt.status === "acknowledged")) {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            failureCategory: state.failureCategory,
-            ownerKind: "console-operation",
-            targetOperationId: interrupt.targetOperationId,
-            targetOperationState,
-            expectedRunnerIdentity: runner,
-            reasonCodes: ["INTERRUPT_ALREADY_PENDING"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    if (interrupt?.status === "needs-reconcile") {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            failureCategory: state.failureCategory,
-            ownerKind: "console-operation",
-            targetOperationId: interrupt.targetOperationId,
-            targetOperationState,
-            expectedRunnerIdentity: runner,
-            reasonCodes: ["INTERRUPT_NEEDS_RECONCILE"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    if (matches.length === 0) {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            failureCategory: state.failureCategory,
-            ownerKind: "external-local",
-            reasonCodes: ["RUN_NOT_CONSOLE_OWNED"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    if (matches.length > 1) {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            failureCategory: state.failureCategory,
-            ownerKind: "unknown",
-            reasonCodes: ["RUNNER_IDENTITY_MISMATCH"],
-            message: "找到多个可能持有该运行的 Console operation，无法无歧义绑定。请用 Doctor 查看，不要猜测。",
-            interruptStatus,
-            interrupt,
-        });
-    }
-    const target = matches[0];
-    if (target.pid !== expected.pid ||
-        !runnerIdentitiesMatch(expected, runner)) {
-        return ineligible({
-            runId,
-            lifecycle: located.lifecycle,
-            dagStatus: state.status,
-            failureCategory: state.failureCategory,
-            ownerKind: "unknown",
-            reasonCodes: ["RUNNER_IDENTITY_MISMATCH"],
-            interruptStatus,
-            interrupt,
-        });
-    }
-    return {
-        eligible: true,
-        runId,
-        lifecycle: located.lifecycle,
-        dagStatus: state.status,
-        failureCategory: state.failureCategory,
-        ownerKind: "console-operation",
-        targetOperationId: target.operationId,
-        targetOperationState: target.state,
-        expectedRunnerIdentity: expected,
-        reasonCodes: [],
-        message: "可以由当前 Console 协作中止此运行。",
-        interruptStatus,
-        interrupt,
-    };
-}
-export function interruptEligibilityError(eligibility) {
-    const code = eligibility.reasonCodes[0] ?? "RUN_NOT_ACTIVE";
-    return new DagInterruptError(code, eligibility.message);
-}
-// Console-side re-exports: keep the console layer free of direct workflows/dag
-// kernel imports (see test/worker/console/security-and-tools.test.ts).
-export { INTERRUPT_ERROR_MESSAGES, isInterruptReasonCode, normalizeInterruptReasonDetail, } from "../../workflows/dag/interrupt-request.js";

package/dist/workflows/dag/contract-output-registry.js

@@ -1,14 +0,0 @@
-import { structuredContractOutputSchemaIds, } from "./types.js";
-const validators = new Map();
-export function registerStructuredContractValidator(schemaId, validator) {
-    if (validators.has(schemaId)) {
-        throw new Error(`structured contract validator already registered for ${schemaId}`);
-    }
-    validators.set(schemaId, validator);
-}
-export function getStructuredContractValidator(schemaId) {
-    if (structuredContractOutputSchemaIds.includes(schemaId)) {
-        return validators.get(schemaId);
-    }
-    return undefined;
-}

package/dist/workflows/dag/contract-validator-registrations.js

@@ -1,8 +0,0 @@
-/**
- * Side-effect module: registers every structured contract validator against
- * its schemaId in the contract output registry. Imported once by the node
- * executor; keeps per-contract imports out of the executor.
- */
-import { validateFrontendContractNodeOutput } from "./frontend-implementation-contract.js";
-import { registerStructuredContractValidator } from "./contract-output-registry.js";
-registerStructuredContractValidator("frontend-implementation-contract-v1", validateFrontendContractNodeOutput);

package/dist/workflows/dag/frontend-recovery-plan.js

@@ -1,73 +0,0 @@
-import { computeResetClosure } from "./rerun-plan.js";
-/**
- * Frontend-only candidate-continuation recovery planning (AC-5).
- *
- * Distinct from the generic `dag rerun` reset closure: the failure source is
- * derived from the prewrite-result's `selectedPlanNodeId` rather than an
- * operator-selected node, and the closure starts at the specific frontend
- * candidate producer that failed.
- */
-/** Idempotency namespace for requestId-keyed recovery intents (D2). */
-export const FRONTEND_RECOVERY_INTENT_REL_DIR = ".runtime/frontend-recovery";
-/** Import manifest path inside the child run dir; hashed into the activation marker. */
-export const FRONTEND_RECOVERY_IMPORT_MANIFEST_REL_PATH = ".runtime/import-manifest.json";
-/** Staging directory prefix under `active/` for in-flight child materialization. */
-export const FRONTEND_RECOVERY_STAGING_PREFIX = ".frontend-recovery-staging-";
-export function deriveFrontendRecoveryFailureSource(result) {
-    if (result.selectedPlanNodeId === "frontend-plan-revision-pi") {
-        return "frontend-plan-revision-pi";
-    }
-    if (result.selectedPlanNodeId === "frontend-plan-pi") {
-        return "frontend-plan-pi";
-    }
-    return "frontend-prewrite-gate-shell";
-}
-/**
- * Compute the frontend candidate-continuation reset partition:
- * - `frontend-plan-pi` failure → reset plan + design-review + prewrite (+ descendants);
- * - `frontend-plan-revision-pi` failure → reset revision + final-review + prewrite (+ descendants);
- * - prewrite-only materialization → reset prewrite (+ descendants), reuse verified plan/review.
- *
- * Everything upstream of the failure source is imported as verified parent facts.
- */
-export function computeFrontendRecoveryPlan(input) {
-    const failureSource = deriveFrontendRecoveryFailureSource(input.result);
-    return computeFrontendRecoveryPlanForSource({
-        spec: input.spec,
-        parentRunId: input.parentRunId,
-        requestId: input.requestId,
-        failureSource,
-    });
-}
-/**
- * Phase 5: writer transient partial-write recovery plan. The writer itself
- * failed after some bounded writes, so the child re-runs `frontend-implement-pi`
- * (and its descendants) while importing the verified contract/scout/plan/prewrite
- * facts. Everything upstream of the writer is imported; the writer + descendants
- * are reset.
- */
-export function computeFrontendWriterRecoveryPlan(input) {
-    return computeFrontendRecoveryPlanForSource({
-        spec: input.spec,
-        parentRunId: input.parentRunId,
-        requestId: input.requestId,
-        failureSource: "frontend-implement-pi",
-    });
-}
-function computeFrontendRecoveryPlanForSource(input) {
-    const resetNodeIds = computeResetClosure(input.spec, input.failureSource);
-    const resetSet = new Set(resetNodeIds);
-    const importedNodeIds = input.spec.tasks
-        .map((task) => task.id)
-        .filter((nodeId) => !resetSet.has(nodeId))
-        .sort();
-    return {
-        schemaVersion: 1,
-        parentRunId: input.parentRunId,
-        requestId: input.requestId,
-        failureSource: input.failureSource,
-        resetNodeIds,
-        importedNodeIds,
-    };
-}
-export { computeFrontendRecoveryPlanForSource };