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

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

@@ -1,6 +1,5 @@
 import { clipPreview, } from "./operation-store.js";
 import { stateEvent } from "./operation-sse.js";
-import { extractTrustedRunFacts } from "./operation-run-facts.js";
 /**
  * Execute a queued operation via LoopAgentClient (or inject).
  * Timeout without proven exit → needs-reconcile (never Cancel).
@@ -75,30 +74,6 @@ export async function runOperation(operationId, deps) {
                     message: chunk,
                 });
             },
-            onHeartbeat: (info) => {
-                // P1 (2026-08-13): project sibling CLI heartbeats into canonical
-                // operation events so operationWait/operationEventSummary can consume
-                // them. The projection is best-effort: a failed append must never
-                // terminate the sibling CLI execution (AC-002). The injected test
-                // runCommand path has no LoopAgentClient callback guard, so the
-                // runner protects itself here.
-                try {
-                    deps.events.append(operationId, {
-                        at: info.at,
-                        kind: "heartbeat",
-                        message: `heartbeat elapsedMs=${info.elapsedMs}`,
-                        data: {
-                            elapsedMs: info.elapsedMs,
-                            action: op.action,
-                            ...(op.taskId ? { taskId: op.taskId } : {}),
-                            ...(op.dagRunId ? { dagRunId: op.dagRunId } : {}),
-                        },
-                    });
-                }
-                catch {
-                    // Heartbeat is derived telemetry; ignore projection failures.
-                }
-            },
         });
         await spawnUpdate;
         finished = await finalizeFromWorkerResult(operationId, result, deps);
@@ -122,38 +97,6 @@ export async function runOperation(operationId, deps) {
     }
     return finished;
 }
-function taskAdvanceBusinessBlock(operation, envelope) {
-    if (!operation || !envelope)
-        return undefined;
-    if (operation.action !== "taskAdvance" && operation.action !== "dagRunTask") {
-        return undefined;
-    }
-    const result = envelope.result && typeof envelope.result === "object"
-        ? envelope.result
-        : undefined;
-    const lifecycleState = typeof result?.lifecycleState === "string"
-        ? result.lifecycleState
-        : undefined;
-    const blockers = Array.isArray(result?.blockers)
-        ? result.blockers
-        : [];
-    const expectedGateStop = lifecycleState === "awaiting-write-set-approval" && blockers.length === 0;
-    if (expectedGateStop)
-        return undefined;
-    if (lifecycleState !== "intake-incomplete" &&
-        blockers.length === 0 &&
-        envelope.outcome !== "blocked") {
-        return undefined;
-    }
-    const firstBlocker = blockers[0];
-    const code = typeof firstBlocker?.code === "string"
-        ? firstBlocker.code
-        : "TASK_ADVANCE_BLOCKED";
-    const message = typeof firstBlocker?.message === "string"
-        ? firstBlocker.message
-        : `task advance stopped before runnable DAG completion (lifecycleState=${lifecycleState ?? "unknown"})`;
-    return { code, message };
-}
 async function finalizeFromWorkerResult(operationId, result, deps) {
     const previewStdout = clipPreview(result.stdout ?? "");
     const previewStderr = clipPreview(result.stderr ?? "");
@@ -163,8 +106,6 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
         resultPath: result.artifacts.resultPath,
         dir: result.artifacts.dir,
     };
-    // Trusted structured run facts only (AC-003): never scanned from free text.
-    const runFacts = extractTrustedRunFacts(result);
     if (result.timedOut) {
         // Supervisory timeout without classified CLI timeout → needs-reconcile
         // Only mark timed-out when we have a machine timeout result after exit.
@@ -180,35 +121,12 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
                 ? "CLI timed out with process exit"
                 : "timeout reached without proven process exit; needs reconcile (not cancelled)",
             result: coerceEnvelope(result),
-            ...(runFacts
-                ? {
-                    dagRunId: runFacts.runId,
-                    ...(runFacts.runSummary ? { runSummary: runFacts.runSummary } : {}),
-                }
-                : {}),
         });
         stateEvent(deps.events, updated, state, updated.errorMessage);
-        if (runFacts) {
-            appendSafeResultEvent(deps, operationId, state, {
-                ok: false,
-                exitCode: result.exitCode,
-            }, runFacts);
-        }
-        else {
-            deps.events.append(operationId, {
-                at: new Date().toISOString(),
-                kind: "result",
-                state,
-                data: { ok: false, exitCode: result.exitCode },
-            });
-        }
         return updated;
     }
     const envelope = coerceEnvelope(result);
-    const operation = await deps.store.get(operationId);
-    const businessBlock = taskAdvanceBusinessBlock(operation, envelope);
-    const processOk = envelope?.ok === true || (result.ok && result.exitCode === 0);
-    const ok = processOk && !businessBlock;
+    const ok = envelope?.ok === true || (result.ok && result.exitCode === 0);
     const state = ok ? "succeeded" : "failed";
     const updated = await deps.store.update(operationId, {
         state,
@@ -220,43 +138,21 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
             stdout: previewStdout,
             stderr: previewStderr,
         }),
-        errorCode: ok
-            ? undefined
-            : (businessBlock?.code ?? envelope?.error?.code ?? "INTERNAL_ERROR"),
+        errorCode: ok ? undefined : (envelope?.error?.code ?? "INTERNAL_ERROR"),
         errorMessage: ok
             ? undefined
-            : (businessBlock?.message ??
-                envelope?.error?.message ??
+            : (envelope?.error?.message ??
                 (previewStderr.trim() ||
                     `command failed with exit ${result.exitCode}`)),
-        // Atomic final patch: state/result + trusted dagRunId + safe runSummary
-        // in a single per-op write-locked update (AC-004). The runSummary is a
-        // projection and never launders the envelope/exit-decided state.
-        ...(runFacts
-            ? {
-                dagRunId: runFacts.runId,
-                ...(runFacts.runSummary ? { runSummary: runFacts.runSummary } : {}),
-            }
-            : {}),
     });
-    stateEvent(deps.events, updated, state, updated.errorMessage);
-    appendSafeResultEvent(deps, operationId, state, { ok, exitCode: result.exitCode }, runFacts);
-    if (ok && operation?.action === "dagRequestInterrupt") {
-        await projectInterruptRequestOntoTarget(operation, result.json, deps);
-    }
-    return updated;
-}
-/** Result event carries the same safe summary persisted on the record. */
-function appendSafeResultEvent(deps, operationId, state, base, runFacts) {
+    stateEvent(deps.events, updated, state);
     deps.events.append(operationId, {
         at: new Date().toISOString(),
         kind: "result",
         state,
-        data: {
-            ...base,
-            ...(runFacts?.runSummary ? { runSummary: runFacts.runSummary } : {}),
-        },
+        data: { ok, exitCode: result.exitCode },
     });
+    return updated;
 }
 function coerceEnvelope(result) {
     const json = result.json;
@@ -306,48 +202,3 @@ export function scheduleOperation(operationId, deps) {
         });
     });
 }
-async function projectInterruptRequestOntoTarget(operation, json, deps) {
-    const params = operation.actionParams ?? {};
-    const targetOperationId = typeof params.targetOperationId === "string"
-        ? params.targetOperationId.trim()
-        : "";
-    const runId = typeof params.runId === "string" ? params.runId.trim() : "";
-    if (!targetOperationId)
-        return;
-    const rec = json && typeof json === "object" ? json : {};
-    const request = rec.request && typeof rec.request === "object"
-        ? rec.request
-        : rec;
-    const status = (typeof rec.interruptStatus === "string" && rec.interruptStatus) ||
-        (typeof request.status === "string" && request.status) ||
-        "requested";
-    if (status !== "requested" &&
-        status !== "acknowledged" &&
-        status !== "settled" &&
-        status !== "needs-reconcile") {
-        return;
-    }
-    const target = await deps.store.get(targetOperationId);
-    if (!target)
-        return;
-    await deps.store.update(targetOperationId, {
-        ...(runId && !target.dagRunId ? { dagRunId: runId } : {}),
-        interrupt: {
-            status,
-            ...(typeof request.requestId === "string"
-                ? { requestId: request.requestId }
-                : {}),
-            ...(typeof request.reasonCode === "string"
-                ? { reasonCode: request.reasonCode }
-                : {}),
-            ...(typeof request.requestedAt === "string"
-                ? { requestedAt: request.requestedAt }
-                : {}),
-        },
-    });
-    deps.events.append(targetOperationId, {
-        kind: "state",
-        message: `interrupt ${status}`,
-        data: { interruptStatus: status, ...(runId ? { runId } : {}) },
-    });
-}