@tea-agent/loop-agent 0.36.0 → 0.36.1

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [0.36.1] - 2026-08-16
+
+### 新增
+
+- cooperative live DAG interrupt and recovery UX
+
+### 修复
+
+- move interrupt eligibility to observability to honor kernel import boundary
+- retry semantic intake across Pi tiers with 300s timeout
+
 ## [0.36.0] - 2026-08-15
 
 ### 新增

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.36.0",
-  "gitSha": "4737885305b1a168317cfc97ae06596ae7a39512",
-  "builtAt": "2026-08-15T20:30:11.790Z"
+  "version": "0.36.1",
+  "gitSha": "e023c82feae11ad8a6f5f9e50e8553cc38512f5e",
+  "builtAt": "2026-08-16T09:24:03.417Z"
 }

package/dist/cli/command-definitions.js

@@ -32,6 +32,7 @@ import { runDagApprove } from "../commands/dag-approve.js";
 import { runDagReject } from "../commands/dag-reject.js";
 import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
+import { runDagRequestInterrupt } from "../commands/dag-request-interrupt.js";
 import { runDagRerunTask } from "../commands/dag-rerun-task.js";
 import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagResume } from "../commands/dag-resume.js";
@@ -129,6 +130,7 @@ const DAG_SUBCOMMANDS = [
     "report",
     "closeout-draft",
     "reconcile-run",
+    "request-interrupt",
     "rerun",
     "rerun-task",
     "reconcile-tasks",
@@ -549,6 +551,11 @@ export const COMMAND_DEFINITIONS = [
                 await runDagReconcileRun(repoRoot, reconcileRunArgs);
                 return;
             }
+            if (subcommand === "request-interrupt") {
+                const interruptArgs = rest.filter((arg) => Boolean(arg));
+                await runDagRequestInterrupt(repoRoot, interruptArgs);
+                return;
+            }
             if (subcommand === "rerun") {
                 const rerunArgs = rest.filter((arg) => Boolean(arg));
                 await runDagRerun(repoRoot, rerunArgs);

package/dist/cli/program.js

@@ -11,6 +11,7 @@ import { runDagFinalVerification } from "../commands/dag-final-verification.js";
 import { runDagInitHybrid } from "../commands/dag-init-hybrid.js";
 import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
+import { runDagRequestInterrupt } from "../commands/dag-request-interrupt.js";
 import { runDagRerunTask } from "../commands/dag-rerun-task.js";
 import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagReject } from "../commands/dag-reject.js";
@@ -331,6 +332,9 @@ async function runDagAction(repoRoot, subcommand, rest) {
         case "reconcile-run":
             await runDagReconcileRun(repoRoot, args);
             return;
+        case "request-interrupt":
+            await runDagRequestInterrupt(repoRoot, args);
+            return;
         case "rerun":
             await runDagRerun(repoRoot, args);
             return;
@@ -356,7 +360,7 @@ async function runDagAction(repoRoot, subcommand, rest) {
             throw new Error("usage: dag decision <inspect|validate> --run-id <id> [--node-id <node-id>]");
         }
         default:
-            throw new Error("usage: dag <init-hybrid|execute|validate|workflow-plan|workflow-validate|workflow-compile|approve|reject|resume|status|doctor|report|closeout-draft|reconcile-run|rerun|rerun-task|reconcile-tasks|final-verification|decision> ...");
+            throw new Error("usage: dag <init-hybrid|execute|validate|workflow-plan|workflow-validate|workflow-compile|approve|reject|resume|status|doctor|report|closeout-draft|reconcile-run|request-interrupt|rerun|rerun-task|reconcile-tasks|final-verification|decision> ...");
     }
 }
 function compactArgs(args) {
@@ -493,6 +497,7 @@ function addDagCommand(program, defaultRepoRoot) {
         "report",
         "closeout-draft",
         "reconcile-run",
+        "request-interrupt",
         "rerun",
         "rerun-task",
         "reconcile-tasks",

package/dist/commands/dag-request-interrupt.js

@@ -0,0 +1,20 @@
+import { DagInterruptError, executeDagRequestInterrupt, parseDagRequestInterruptArgs, } from "../workflows/dag/interrupt-request.js";
+export { parseDagRequestInterruptArgs, executeDagRequestInterrupt };
+export async function runDagRequestInterrupt(repoRoot, rawArgs) {
+    try {
+        const result = await executeDagRequestInterrupt(repoRoot, rawArgs);
+        console.log(JSON.stringify(result, null, 2));
+    }
+    catch (error) {
+        if (error instanceof DagInterruptError) {
+            console.log(JSON.stringify({
+                ok: false,
+                code: error.code,
+                message: error.message,
+            }, null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+}

package/dist/executors/pi-sdk-executor.js

@@ -78,6 +78,40 @@ export async function checkPiSdkAvailability(_repoRoot) {
         return { ok: false, detail: `pi SDK not available: ${message}` };
     }
 }
+/**
+ * Best-effort Pi SDK model catalog (credentialed providers first).
+ * Empty on SDK/auth/runtime failure — callers must fall back to harness tiers.
+ */
+export async function listPiSdkAvailableModels() {
+    try {
+        const imported = sdkImportOverrideForTests
+            ? await sdkImportOverrideForTests()
+            : await loadPiSdkModule();
+        const sdk = imported;
+        const getAgentDir = sdk.getAgentDir;
+        const ModelRuntime = sdk.ModelRuntime;
+        if (typeof getAgentDir !== "function" || typeof ModelRuntime?.create !== "function") {
+            return [];
+        }
+        const agentDir = getAgentDir();
+        const runtime = await ModelRuntime.create({
+            authPath: path.join(agentDir, "auth.json"),
+            modelsPath: path.join(agentDir, "models.json"),
+        });
+        const snapshot = runtime.snapshot ?? {};
+        const configured = snapshot.configuredProviders;
+        const isConfigured = (provider) => configured instanceof Set ? configured.has(provider) : false;
+        return (snapshot.available ?? []).map((entry) => ({
+            provider: entry.provider,
+            id: entry.id,
+            name: entry.name,
+            hasCredentials: isConfigured(entry.provider),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
 /** Fail-closed probe for the SDK-only structured custom-tool surface. */
 export async function checkPiSdkCustomToolCapability(_repoRoot) {
     if (sdkSessionFactoryOverride) {

package/dist/shared/operator/capabilities.js

@@ -1102,7 +1102,7 @@ export function buildOperatorCapabilitiesDocument() {
             resultSchemaVersion: 1,
             envelopeSchemaVersion: 1,
             requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
-            description: "Read-only R1 subgraph plan (no mutation). Call before dagRerun. Prefer primaryFailure.nodeId from dagReport. If eligible=false (writer/decision/fingerprint, or subgraph contains unsafe shell nodes), do not force execute — fall back to standaloneTaskRerun or same-task advance after fixing the root cause (contract changes must be adopted first). Returns planHash required by execute.",
+            description: "Read-only R1 subgraph plan (no mutation). Call before dagRerun. Prefer primaryFailure.nodeId from dagReport. If eligible=false (writer/decision/fingerprint, unsafe shell, worker-managed, workspace/controller drift), do not force execute — Worker-owned runs use workerTaskRetry; standalone runs use standaloneTaskRerun or same-task advance after fixing the root cause (contract changes must be adopted first). Returns planHash required by execute.",
             inputParams: [
                 {
                     name: "runId",
@@ -1165,6 +1165,73 @@ export function buildOperatorCapabilitiesDocument() {
             modelCallable: "always",
             humanConfirmation: "none",
         },
+        {
+            action: "dagInterruptEligibility",
+            cli: "console dag-interrupt-eligibility",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
+            description: "Read-only eligibility for cooperative live-DAG interrupt. v1 only Console-owned active running operations. Worker-managed / unknown owner / orphaned / terminal runs return eligible=false with stable reasonCodes. Does not create a Human Gate receipt or mutate the run.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "active dag run id to inspect for interrupt eligibility",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagRequestInterrupt",
+            cli: "loop-agent dag request-interrupt --run-id <id> --request-id <id> --target-operation-id <id> --reason-code <code> --reason <detail> --json",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "HUMAN_CONFIRMATION_REQUIRED",
+                "RUN_NOT_ACTIVE",
+                "RUN_NOT_CONSOLE_OWNED",
+                "RUNNER_IDENTITY_MISMATCH",
+                "INTERRUPT_ALREADY_PENDING",
+                "RUN_ALREADY_TERMINAL",
+                "INTERRUPT_NEEDS_RECONCILE",
+            ],
+            description: "Request cooperative abort of a Console-owned running DAG. Success means interrupt.json is requested, not that the run has already stopped. Browser Human Gate only; model must not call this action.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "active dag run id",
+                },
+                {
+                    name: "reasonCode",
+                    type: "string",
+                    required: true,
+                    description: "requirements-changed | suspected-runaway | resource-protection | operator-request | other",
+                },
+                {
+                    name: "reasonDetail",
+                    type: "string",
+                    required: true,
+                    description: "10–500 character operator reason; do not auto-fill placeholders",
+                },
+                {
+                    name: "confirmationId",
+                    type: "string",
+                    required: true,
+                    description: "human confirmation receipt id from prepareMutationGate",
+                },
+            ],
+            modelCallable: "prepare-only",
+            humanConfirmation: "required",
+        },
         {
             action: "prepareMutationGate",
             cli: "console prepare-mutation-gate",
@@ -1173,13 +1240,13 @@ export function buildOperatorCapabilitiesDocument() {
             resultSchemaVersion: 1,
             envelopeSchemaVersion: 1,
             requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
-            description: "Prepare a one-shot Human Gate receipt for Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume.",
+            description: "Prepare a one-shot Human Gate receipt for destructive reconcile, live DAG interrupt, and Night Scheduler mutations. Model may prepare; only the browser mutation gate may consume. Do not use for dagRerun / standaloneTaskRerun / workerTaskRetry.",
             inputParams: [
                 {
                     name: "action",
                     type: "string",
                     required: true,
-                    description: "target action: workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard",
+                    description: "target action: dagReconcileRun | dagRequestInterrupt | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard. Not for standaloneTaskRerun / workerTaskRetry / dagRerun (those are autonomous).",
                 },
                 {
                     name: "actionParams",
@@ -1992,6 +2059,12 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
         action: "dagReconcileRun",
         source: "loop-agent",
     },
+    {
+        command: "loop-agent dag request-interrupt",
+        coverage: "human-gated-required",
+        action: "dagRequestInterrupt",
+        source: "loop-agent",
+    },
     {
         command: "loop-agent dag rerun",
         coverage: "model-callable",

package/dist/task/source-prepare/semantic-intake.js

@@ -13,6 +13,7 @@ import { z } from "zod";
 import { executePiStep } from "../../executors/pi-executor.js";
 import { resolveDagPiModelConfig } from "../../executors/dag-pi-executor.js";
 import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
+import { listPiSdkAvailableModels } from "../../executors/pi-sdk-executor.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
 import { TASK_CONTRACT_DRAFT_SCHEMA_VERSION } from "../contract/constants.js";
 import { getTaskPaths } from "../runtime.js";
@@ -20,6 +21,14 @@ import { detectProductArtifactMeta } from "./artifact-meta.js";
 import { filterPlaceholderPaths } from "./placeholder-paths.js";
 export const SEMANTIC_INTAKE_ARTIFACT_REL = "artifacts/intake/semantic-draft.json";
 export const SEMANTIC_INTAKE_ATTEMPT_MARKER = "artifacts/intake/semantic-intake-attempted.json";
+/** Per-model wall clock for one semantic-intake Pi attempt. */
+export const SEMANTIC_INTAKE_ATTEMPT_TIMEOUT_MS = 300_000;
+/** Extra Pi-catalog models after MED → HIGH → LOW. */
+export const SEMANTIC_INTAKE_MAX_EXTRA_MODELS = 5;
+/** Parent CLI budget covering harness tiers plus extra catalog models. */
+export const SEMANTIC_INTAKE_CLI_TIMEOUT_MS = SEMANTIC_INTAKE_ATTEMPT_TIMEOUT_MS *
+    (3 + SEMANTIC_INTAKE_MAX_EXTRA_MODELS);
+const NON_CHAT_MODEL = /embed|whisper|tts|dall-e|dalle|image|rerank|moderation/i;
 const productArtifactBlockers = new Set([
     "PRODUCT_ANALYSIS_NOT_EXECUTABLE",
     "PRODUCT_CLARIFICATION_NOT_EXECUTABLE",
@@ -126,6 +135,58 @@ export function evaluateSemanticIntakeEligibility(input) {
         reason: "structural or engineering-boundary gaps with imported sources",
     };
 }
+function intakeModelKey(ref) {
+    return ref.trim().replace(/\\/g, "/").toLowerCase();
+}
+function intakeModelRef(provider, id) {
+    const trimmedId = id.trim();
+    if (trimmedId.includes("/"))
+        return trimmedId.replace(/\\/g, "/");
+    return `${provider.trim()}/${trimmedId}`;
+}
+/**
+ * MED → HIGH → LOW from harness, then Pi-supported catalog models
+ * (credentialed first). Duplicates and non-chat ids are skipped.
+ */
+export function buildSemanticIntakeModelQueue(input) {
+    const seen = new Set();
+    const queue = [];
+    const push = (raw) => {
+        const ref = raw?.trim().replace(/\\/g, "/");
+        if (!ref)
+            return;
+        const key = intakeModelKey(ref);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        queue.push(ref);
+    };
+    push(input.harness.MED);
+    push(input.harness.HIGH);
+    push(input.harness.LOW);
+    const extras = [...(input.available ?? [])]
+        .filter((entry) => {
+        const hay = `${entry.id} ${entry.name ?? ""} ${entry.provider}`;
+        return !NON_CHAT_MODEL.test(hay);
+    })
+        .sort((left, right) => {
+        const leftCred = left.hasCredentials === true ? 0 : 1;
+        const rightCred = right.hasCredentials === true ? 0 : 1;
+        if (leftCred !== rightCred)
+            return leftCred - rightCred;
+        return intakeModelRef(left.provider, left.id).localeCompare(intakeModelRef(right.provider, right.id));
+    });
+    let extraCount = 0;
+    for (const entry of extras) {
+        if (extraCount >= SEMANTIC_INTAKE_MAX_EXTRA_MODELS)
+            break;
+        const before = queue.length;
+        push(intakeModelRef(entry.provider, entry.id));
+        if (queue.length > before)
+            extraCount += 1;
+    }
+    return queue;
+}
 export function extractJsonObject(text) {
     const fenced = /```(?:json)?\s*([\s\S]*?)```/iu.exec(text);
     const candidate = fenced?.[1]?.trim() || text.trim();
@@ -493,6 +554,7 @@ export async function runSemanticIntake(input) {
         };
     }
     let assistantText;
+    let attemptedModels = [];
     if (input.fixtureAssistantText !== undefined) {
         assistantText = input.fixtureAssistantText;
     }
@@ -500,7 +562,33 @@ export async function runSemanticIntake(input) {
         const execute = input.executePi ?? executePiStep;
         const manifest = await loadHarnessManifest(input.repoRoot);
         const models = resolveExecutorModelMatrices(manifest);
-        const model = models.pi.MED;
+        let available = [];
+        try {
+            available = input.listAvailableModels
+                ? await input.listAvailableModels()
+                : await listPiSdkAvailableModels();
+        }
+        catch {
+            available = [];
+        }
+        const queue = buildSemanticIntakeModelQueue({
+            harness: models.pi,
+            available,
+        });
+        if (queue.length === 0) {
+            await writeAttemptMarker(input.repoRoot, input.taskId, {
+                ok: false,
+                code: "SEMANTIC_INTAKE_PI_FAILED",
+                failureCategory: "unavailable",
+                at: new Date().toISOString(),
+                attemptedModels: [],
+            });
+            return {
+                ok: false,
+                code: "SEMANTIC_INTAKE_PI_FAILED",
+                message: "semantic intake has no MED/HIGH/LOW or Pi-supported models to try",
+            };
+        }
         const attached = usableDocs
             .map((d) => d.absolutePath)
             .filter((p) => Boolean(p));
@@ -510,39 +598,71 @@ export async function runSemanticIntake(input) {
             documents: usableDocs,
             repoRoot: input.repoRoot,
         });
-        const result = await execute({
-            attachedFiles: attached,
-            modelConfig: resolveDagPiModelConfig(model),
-            prompt,
-            repoRoot: input.repoRoot,
-            step: "analyze",
-            toolNames: ["read", "grep", "find", "ls"],
-            userMessage: "Structure the imported requirement documents into the required JSON only.",
-            validateOutput: (text) => {
-                try {
-                    const parsed = parseSemanticRequirementDraft(text);
-                    assertSemanticDraftAcceptable(parsed);
-                    return [];
-                }
-                catch (error) {
-                    return [error instanceof Error ? error.message : String(error)];
+        const attempted = [];
+        let lastFailure = "";
+        let chosenText;
+        for (const modelRef of queue) {
+            try {
+                const result = await execute({
+                    attachedFiles: attached,
+                    modelConfig: resolveDagPiModelConfig(modelRef),
+                    prompt,
+                    repoRoot: input.repoRoot,
+                    step: "analyze",
+                    toolNames: ["read", "grep", "find", "ls"],
+                    timeoutMs: SEMANTIC_INTAKE_ATTEMPT_TIMEOUT_MS,
+                    stallTimeoutMs: SEMANTIC_INTAKE_ATTEMPT_TIMEOUT_MS,
+                    userMessage: "Structure the imported requirement documents into the required JSON only.",
+                    validateOutput: (text) => {
+                        try {
+                            const parsed = parseSemanticRequirementDraft(text);
+                            assertSemanticDraftAcceptable(parsed);
+                            return [];
+                        }
+                        catch (error) {
+                            return [error instanceof Error ? error.message : String(error)];
+                        }
+                    },
+                });
+                attempted.push({
+                    model: result.modelDisplay || modelRef,
+                    ok: result.ok,
+                    failureCategory: result.failureCategory,
+                    timedOut: result.timedOut,
+                });
+                if (result.ok) {
+                    chosenText = result.assistantText;
+                    break;
                 }
-            },
-        });
-        if (!result.ok) {
+                lastFailure =
+                    `${result.failureCategory}: ${result.stderr || result.assistantText}`.slice(0, 2000);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                attempted.push({
+                    model: modelRef,
+                    ok: false,
+                    failureCategory: "unknown",
+                });
+                lastFailure = message.slice(0, 2000);
+            }
+        }
+        attemptedModels = attempted;
+        if (chosenText === undefined) {
             await writeAttemptMarker(input.repoRoot, input.taskId, {
                 ok: false,
                 code: "SEMANTIC_INTAKE_PI_FAILED",
-                failureCategory: result.failureCategory,
+                failureCategory: attempted.at(-1)?.failureCategory,
                 at: new Date().toISOString(),
+                attemptedModels: attempted,
             });
             return {
                 ok: false,
                 code: "SEMANTIC_INTAKE_PI_FAILED",
-                message: `semantic intake pi failed: ${result.failureCategory}: ${result.stderr || result.assistantText}`.slice(0, 2000),
+                message: `semantic intake pi failed after ${attempted.length} model(s): ${lastFailure}`.slice(0, 2000),
             };
         }
-        assistantText = result.assistantText;
+        assistantText = chosenText;
     }
     try {
         const semantic = parseSemanticRequirementDraft(assistantText);
@@ -576,6 +696,7 @@ export async function runSemanticIntake(input) {
             code: "SEMANTIC_INTAKE_OK",
             artifactPath: SEMANTIC_INTAKE_ARTIFACT_REL,
             at: new Date().toISOString(),
+            ...(attemptedModels.length > 0 ? { attemptedModels } : {}),
         });
         return { ok: true, draft, artifactPath, semantic };
     }

package/dist/worker/console/chat/semantic-activity.js

@@ -39,6 +39,7 @@ const OPERATION_TITLES = {
     dagDoctor: "执行诊断",
     dagReport: "执行结果",
     dagRerunPlan: "恢复评估",
+    dagInterruptEligibility: "中止资格",
     standaloneTaskRerun: "恢复执行",
     workerTaskRetry: "重试任务",
     promoteRun: "任务推进",
@@ -90,6 +91,11 @@ const TOOL_SEMANTICS = {
         success: "恢复条件评估已经完成",
         error: "暂时无法确定安全的恢复方式",
     },
+    dagInterruptEligibility: {
+        running: "正在检查能否协作中止此运行",
+        success: "中止资格已经确认",
+        error: "当前运行不能协作中止",
+    },
     standaloneTaskRerun: {
         running: "正在从失败位置恢复执行",
         success: "已经从失败位置继续执行",

package/dist/worker/console/chat/workspace-landing.js

@@ -27,6 +27,7 @@ function readWorkspaceParams(query) {
         ...(read("dagRunId") ? { dagRunId: read("dagRunId") } : {}),
         ...(read("fromNodeId") ? { fromNodeId: read("fromNodeId") } : {}),
         ...(read("featureId") ? { featureId: read("featureId") } : {}),
+        ...(read("intent") ? { intent: read("intent") } : {}),
     };
 }
 /** Parse `#/tasks?taskId=…` hash routes (Observe-style virtual paths). */

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

@@ -241,6 +241,9 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
     });
     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. */
@@ -303,3 +306,48 @@ 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 } : {}) },
+    });
+}

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

@@ -158,6 +158,7 @@ export async function waitForOperationChange(input) {
     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;
@@ -166,6 +167,10 @@ export async function waitForOperationChange(input) {
                 clearTimeout(timer);
                 timer = undefined;
             }
+            if (pollTimer !== undefined) {
+                clearInterval(pollTimer);
+                pollTimer = undefined;
+            }
             if (unsubscribe) {
                 unsubscribe();
                 unsubscribe = undefined;
@@ -303,6 +308,42 @@ export async function waitForOperationChange(input) {
                     })();
                 }, 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