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

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 };

package/dist/workflows/dag/frontend-recovery-root-manifest.js

@@ -1,123 +0,0 @@
-import { mkdir, readFile } from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
-/**
- * Phase 6: frontend recovery root manifest — the single final read model for a
- * frontend recovery chain. A "root" is the first physical run of a
- * frontend-implementation attempt; its parent/child lineage is counted once
- * under `recoveryRootRunId`. report/Console read the manifest for dedup and
- * final-status display instead of scanning parent/child fields (P1-4).
- */
-export const FRONTEND_RECOVERY_ROOT_MANIFEST_SCHEMA_ID = "frontend-recovery-root-manifest-v1";
-export const frontendRecoveryRootManifestSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    schemaId: z.literal(FRONTEND_RECOVERY_ROOT_MANIFEST_SCHEMA_ID),
-    recoveryRootRunId: z.string().min(1),
-    /** Terminal logical status for the whole chain (finished/partial_failed/failed). */
-    status: z.enum(["finished", "partial_failed", "failed"]),
-    outcome: z.enum([
-        "none",
-        "recovered",
-        "candidate-contract-invalid",
-        "prewrite-blocked",
-        "repair-exhausted",
-        "auto-recovery-blocked",
-    ]),
-    attempts: z.array(z
-        .object({
-        runId: z.string().min(1),
-        role: z.enum(["root", "child"]),
-        attemptIndex: z.number().int().min(0),
-        outcome: z.enum([
-            "none",
-            "recovered",
-            "candidate-contract-invalid",
-            "prewrite-blocked",
-            "repair-exhausted",
-            "auto-recovery-blocked",
-        ]),
-        status: z.enum(["finished", "partial_failed", "failed"]),
-    })
-        .strict()),
-    evidenceRefs: z.array(z
-        .object({
-        runId: z.string().min(1),
-        relativePath: z.string().min(1),
-        sha256: z.string().min(1),
-    })
-        .strict()),
-    createdAt: z.string().min(1),
-})
-    .strict();
-/** Relative path of the root manifest inside a run dir. */
-export const FRONTEND_RECOVERY_ROOT_MANIFEST_REL = "contracts/frontend-recovery-root-manifest.json";
-export function frontendRecoveryRootManifestAbsPath(runDir) {
-    return path.join(runDir, FRONTEND_RECOVERY_ROOT_MANIFEST_REL);
-}
-export async function writeFrontendRecoveryRootManifest(runDir, manifest) {
-    const abs = frontendRecoveryRootManifestAbsPath(runDir);
-    await mkdir(path.dirname(abs), { recursive: true });
-    await writeJsonAtomic(abs, manifest);
-    return abs;
-}
-export async function readFrontendRecoveryRootManifest(runDir) {
-    try {
-        const raw = JSON.parse(await readFile(frontendRecoveryRootManifestAbsPath(runDir), "utf8"));
-        const parsed = frontendRecoveryRootManifestSchema.safeParse(raw);
-        return parsed.success ? parsed.data : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Build a root manifest from a converged root run's lineage. The manifest is the
- * single authority for final status/outcome: parent keeps its raw failure status,
- * the chain's logical status is only `finished` when a child finished and the
- * outcome is `recovered`.
- */
-export function buildFrontendRecoveryRootManifest(input) {
-    const status = input.outcome === "recovered" ? "finished" : "failed";
-    return {
-        schemaVersion: 1,
-        schemaId: FRONTEND_RECOVERY_ROOT_MANIFEST_SCHEMA_ID,
-        recoveryRootRunId: input.recoveryRootRunId,
-        status,
-        outcome: input.outcome,
-        attempts: input.attempts,
-        evidenceRefs: input.evidenceRefs ?? [],
-        createdAt: input.createdAt ?? new Date().toISOString(),
-    };
-}
-/**
- * Dedup a set of DAG runs by recovery root (P1-4): each root contributes exactly
- * one summary; parent/child physical runs are folded into the root's attempts.
- * A run with no `frontendRecoveryState` is its own single-attempt root.
- */
-export function aggregateFrontendRecoveryRoots(runs) {
-    const byRoot = new Map();
-    for (const run of runs) {
-        const rootId = run.frontendRecoveryState?.recoveryRootRunId ?? run.runId;
-        const list = byRoot.get(rootId) ?? [];
-        list.push(run);
-        byRoot.set(rootId, list);
-    }
-    const result = [];
-    for (const [rootId, list] of byRoot) {
-        const sorted = [...list].sort((a, b) => (a.frontendRecoveryState?.attemptIndex ?? 0) -
-            (b.frontendRecoveryState?.attemptIndex ?? 0));
-        // The root's displayed status is the last attempt's status, unless the
-        // root run itself finished (a child recovered only surfaces `finished`
-        // via the manifest, not via the raw root run status).
-        const last = sorted[sorted.length - 1];
-        result.push({
-            recoveryRootRunId: rootId,
-            status: last.status,
-            attemptCount: sorted.length,
-            runIds: sorted.map((run) => run.runId),
-        });
-    }
-    return result;
-}