@tea-agent/loop-agent 0.35.1-beta.0 → 0.35.1-beta.2

package/dist/commands/pi-reuse-benchmark.js

@@ -106,22 +106,22 @@ export function parsePiReuseBenchmarkArgs(args) {
     };
 }
 export function printPiReuseBenchmarkUsage() {
-    console.log(`usage: pi-reuse-benchmark [options]
-
-Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
-
-Options:
-  --report <path>         Benchmark report markdown (approval status)
-  --approval <path>       Explicit approval JSON artifact
-  --off-executor <path>   Baseline executor.jsonl (reuse off)
-  --on-executor <path>    Treatment executor.jsonl (reuse on)
-  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
-  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
-  --json                  Emit JSON (default when no format flag is set)
-  --markdown              Emit Markdown summary
-  -h, --help              Show this help
-
-Recommendations: defer | maintain-opt-in | eligible-for-human-review
+    console.log(`usage: pi-reuse-benchmark [options]
+
+Deterministic Pi runtime reuse benchmark/decision summary (no live Pi calls).
+
+Options:
+  --report <path>         Benchmark report markdown (approval status)
+  --approval <path>       Explicit approval JSON artifact
+  --off-executor <path>   Baseline executor.jsonl (reuse off)
+  --on-executor <path>    Treatment executor.jsonl (reuse on)
+  --off-task <task-id>    Resolve baseline from .harness/tasks/<id>/logs/executor.jsonl
+  --on-task <task-id>     Resolve treatment from .harness/tasks/<id>/logs/executor.jsonl
+  --json                  Emit JSON (default when no format flag is set)
+  --markdown              Emit Markdown summary
+  -h, --help              Show this help
+
+Recommendations: defer | maintain-opt-in | eligible-for-human-review
 Never changes CODE_AGENT_PI_REUSE_RUNTIME default (off).`);
 }
 function resolveRepoRelative(repoRoot, filePath) {

package/dist/commands/run-dag-progress.js

@@ -1,18 +1,4 @@
 export const DEFAULT_RUN_DAG_PROGRESS_INTERVAL_MS = 30_000;
-/**
- * Contract floor for periodic progress output. Values below this are rejected
- * at CLI parse time (aligned with `dag execute`'s parseProgressIntervalMs).
- * Lives here (not src/application/dag/args.ts) because task-advance shares it
- * and src/application/dag/args.ts is outside the task-advance write boundary.
- */
-export const MIN_RUN_DAG_PROGRESS_INTERVAL_MS = 1_000;
-/** Validate a progress interval; throws with the dag execute error contract. */
-export function validateRunDagProgressIntervalMs(value) {
-    if (!Number.isInteger(value) || value < MIN_RUN_DAG_PROGRESS_INTERVAL_MS) {
-        throw new Error("progress-interval-ms must be an integer >= 1000");
-    }
-    return value;
-}
 function formatDuration(durationMs) {
     const totalSeconds = Math.max(0, Math.floor(durationMs / 1_000));
     const hours = Math.floor(totalSeconds / 3_600);

package/dist/commands/task-advance.js

@@ -1,6 +1,5 @@
 import { advanceTaskLifecycle, } from "../application/task-lifecycle/index.js";
 import { buildOperatorResult, operatorFailed, processExitCodeForOutcome, writeOperatorJson, } from "../shared/operator/index.js";
-import { createRunDagProgressObserver, validateRunDagProgressIntervalMs, } from "./run-dag-progress.js";
 const COMMAND = "task advance";
 const USAGE = `usage:
   task advance <task-id> [title]
@@ -25,8 +24,6 @@ const USAGE = `usage:
     [--dag-output <path>]
     [--skip-finalize]
     [--no-strict-models]
-    [--quiet]
-    [--progress-interval-ms <ms>]
     [--dry-run]
     [--json]`;
 function pushList(target, value) {
@@ -173,19 +170,6 @@ export function parseTaskAdvanceArgs(args) {
             options.strictModels = false;
             continue;
         }
-        if (token === "--quiet") {
-            options.quiet = true;
-            continue;
-        }
-        if (token === "--progress-interval-ms") {
-            const raw = next();
-            const parsed = Number(raw);
-            if (!Number.isFinite(parsed)) {
-                throw new Error(`progress-interval-ms must be an integer >= 1000\n${USAGE}`);
-            }
-            options.progressIntervalMs = validateRunDagProgressIntervalMs(parsed);
-            continue;
-        }
         if (token === "--help" || token === "-h") {
             throw new Error(USAGE);
         }
@@ -224,7 +208,7 @@ function mapOutcome(result) {
         return "blocked";
     return "succeeded";
 }
-export function toUseCaseInput(repoRoot, taskId, options, observer) {
+function toUseCaseInput(repoRoot, taskId, options) {
     const timeouts = new Map((options.verifyTimeout ?? []).map((entry) => {
         const parsed = parseVerifyTimeout(entry);
         return [parsed.label, parsed.timeoutMs];
@@ -286,8 +270,7 @@ export function toUseCaseInput(repoRoot, taskId, options, observer) {
         dagOutputPath: options.dagOutputPath,
         skipFinalize: options.skipFinalize,
         strictModels: options.strictModels,
-        ...(observer ? { observer } : {}),
-        onProgress: options.quiet
+        onProgress: options.json
             ? undefined
             : (message) => {
                 process.stderr.write(`[task advance] ${message}\n`);
@@ -312,18 +295,8 @@ export async function runTaskAdvance(repoRoot, args) {
         process.exitCode = processExitCodeForOutcome(envelope.outcome);
         return;
     }
-    let progress;
     try {
-        // AC-006/AC-007: periodic DAG progress goes to stderr only (stdout stays
-        // the single final OperatorCommandResultV1 JSON). The observer is created
-        // ONLY for the approve-gate execution path and disposed on every exit;
-        // its timer starts only after onRunStart (double guard, no stray timer).
-        if (options.approveGate && !options.dryRun && !options.quiet) {
-            progress = createRunDagProgressObserver({
-                intervalMs: options.progressIntervalMs,
-            });
-        }
-        const result = await advanceTaskLifecycle(toUseCaseInput(repoRoot, taskId, options, progress?.observer));
+        const result = await advanceTaskLifecycle(toUseCaseInput(repoRoot, taskId, options));
         const outcome = mapOutcome(result);
         const gateStop = result.lifecycleState === "awaiting-write-set-approval" &&
             result.blockers.length === 0;
@@ -359,7 +332,4 @@ export async function runTaskAdvance(repoRoot, args) {
         writeOperatorJson(envelope);
         process.exitCode = processExitCodeForOutcome(envelope.outcome);
     }
-    finally {
-        progress?.dispose();
-    }
 }

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

@@ -520,6 +520,33 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     }
     let result;
     try {
+        // Phase 5 (P1-9): capture the writeSet baseline BEFORE the writer provider
+        // call so a transient partial write can be rolled back and recovered via a
+        // staged child. Only frontend-implementation writers; a failed capture is a
+        // hard fail (no baseline → no rollback → no recovery). Dynamic import avoids
+        // an executor ↔ scheduler static cycle.
+        if (isWriteTask &&
+            (input.task.id === "frontend-implement-pi" ||
+                input.task.id === "frontend-repair-pi") &&
+            (input.task.writeSet?.length ?? 0) > 0) {
+            try {
+                const { captureFrontendWriterAttemptIntent } = await import("../workflows/dag/frontend-writer-recovery.js");
+                await captureFrontendWriterAttemptIntent({
+                    cwd: input.cwd,
+                    runDir: meta.runDir,
+                    writeSet: input.task.writeSet,
+                });
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    stdout: "",
+                    stderr: `frontend writer attempt baseline capture failed: ${error instanceof Error ? error.message : String(error)}`,
+                    failureCategory: "write-guard",
+                    durationMs: Date.now() - started,
+                };
+            }
+        }
         result = await piStepFn({
             attachedFiles: [],
             modelConfig: resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined),
@@ -691,6 +718,23 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             const changedFiles = pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), afterSnapshot, beforePathFingerprints, afterPathFingerprints);
             changeManifestAfterStatus = afterStatus;
             changeManifestChangedFiles = changedFiles;
+            // Phase 5: record the attempt changed paths/hashes into the rollback
+            // intent so a transient partial write can be CAS-restored.
+            if ((input.task.id === "frontend-implement-pi" ||
+                input.task.id === "frontend-repair-pi") &&
+                (input.task.writeSet?.length ?? 0) > 0) {
+                try {
+                    const { recordFrontendWriterAttempt } = await import("../workflows/dag/frontend-writer-recovery.js");
+                    await recordFrontendWriterAttempt({
+                        cwd: input.cwd,
+                        runDir: meta.runDir,
+                        changedPaths: changedFiles,
+                    });
+                }
+                catch {
+                    // best-effort: a missing intent (no baseline captured) is a no-op
+                }
+            }
             const guard = validateShellWriteGuardFromDiff({
                 changedFiles,
                 task: input.task,

package/dist/shared/operator/capabilities.js

@@ -445,43 +445,6 @@ export function buildOperatorCapabilitiesDocument() {
             modelCallable: "always",
             humanConfirmation: "none",
         },
-        {
-            action: "operationWait",
-            cli: "console canonical operation wait (read-only event-driven long poll)",
-            kind: "read",
-            inputSchemaVersion: 1,
-            resultSchemaVersion: 1,
-            resultPolicy: { readOnly: true, bounded: true, redacted: true },
-            envelopeSchemaVersion: 1,
-            requiredErrorCodes: [
-                "NOT_FOUND",
-                "INVALID_INPUT",
-                "EVENT_CURSOR_EXPIRED",
-            ],
-            description: "Read-only event-driven wait on the canonical operation event ring. Returns immediately on existing events, terminal state or needs-reconcile; otherwise resolves on the first new event/state change or after maxWaitMs with timedOut:true (a success summary, not a command failure).",
-            inputParams: [
-                {
-                    name: "operationId",
-                    type: "string",
-                    required: true,
-                    description: "canonical operation id",
-                },
-                {
-                    name: "afterSeq",
-                    type: "number",
-                    required: false,
-                    description: "event cursor; only events with seq > afterSeq count (default 0, >= 0)",
-                },
-                {
-                    name: "maxWaitMs",
-                    type: "number",
-                    required: false,
-                    description: "bounded wait budget; clamped server-side (default 180000, floor 60000)",
-                },
-            ],
-            modelCallable: "always",
-            humanConfirmation: "none",
-        },
         {
             action: "contractShow",
             cli: "loop-agent task status <taskId> --json",
@@ -1002,7 +965,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "CONTROLLER_MISMATCH",
                 "INVALID_INPUT",
             ],
-            description: "Consume a single-use execution receipt and execute the reviewed DAG (prefer task advance --approve-gate when gate token present). accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor/operationWait.",
+            description: "Consume a single-use execution receipt and execute the reviewed DAG (prefer task advance --approve-gate when gate token present). accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor.",
             inputParams: [
                 {
                     name: "executionId",

package/dist/shared/package-metadata.js

@@ -45,6 +45,48 @@ export function readPackageName(packageDir) {
     }
     return undefined;
 }
+/**
+ * Read the build stamp (git SHA + build time) written by the build pipeline
+ * into `<packageDir>/dist/build-stamp.json`. `undefined` when absent (e.g.
+ * running from source via tsx, or a hand-assembled package), which callers
+ * treat as "no stamp available".
+ */
+export function readBuildStamp(packageDir) {
+    try {
+        const raw = readFileSync(path.join(packageDir, "dist", "build-stamp.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed.schemaVersion !== 1 ||
+            typeof parsed.version !== "string" ||
+            typeof parsed.builtAt !== "string")
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Human-readable CLI version label: plain version, enriched with the build
+ * stamp (short git SHA + build date) when available so a stale dist/ that was
+ * built from an old commit is immediately recognizable in `--version`.
+ */
+export function readCliVersionLabel(packageDir) {
+    const version = readPackageVersion(packageDir) ?? "0.0.0";
+    const stamp = readBuildStamp(packageDir);
+    if (!stamp?.gitSha)
+        return version;
+    return `${version} (build ${stamp.gitSha.slice(0, 8)} ${stamp.builtAt.slice(0, 10)})`;
+}
+/**
+ * Strip the build-stamp suffix from a CLI `--version` label, returning the bare
+ * SemVer. Controller-identity/preflight comparisons must use this rather than
+ * the raw label so a build-stamped `0.35.0 (build 7f8c5b5b …)` still matches
+ * `packageVersion === "0.35.0"`.
+ */
+export function normalizeCliVersionLabel(label) {
+    const match = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/.exec(label.trim());
+    return match ? match[0] : label.trim();
+}
 /**
  * Compute the SHA-256 hash of a file on disk.
  *

package/dist/sidecars/cursor-prompt/executor.js

@@ -29,7 +29,7 @@ export function resolveArtifactWriteDir(options) {
 }
 export function buildArtifactPathPrompt(writeDir) {
     if (!writeDir)
-        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
+        return `After changes, write artifacts/修改记录.md and artifacts/验证结果.md with verification evidence.
 ${ARTIFACT_INSTRUCTIONS}`;
     return [
         `After changes, write the following files:`,

package/dist/worker/console/chat/pi-runtime.js

@@ -58,11 +58,11 @@ import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.
  */
 export const OPERATOR_CHAT_SYSTEM_PROMPT_BASE = [
     "You are the General Operator Chat for loop-agent / agent-worker.",
-    "Operate through operator_* tools first. Pi read/write/edit/bash/grep/find/ls are available; obey the loaded repository AGENTS.md. apply_patch, full-tools, shell, coding-chat are denied. Prefer safe-read/safe-grep for sensitive probes.",
-    "If a repository has no loop-agent harness and the user requests initialization, run `loop-agent init instructions --repo-root .` then `loop-agent init --repo-root . --profile full --merge`; finish with init doctor, inspect, docs audit, quick verification. For updates use `loop-agent init upgrade --repo-root . --json` until stable; init check-update only for explicitly read-only requests.",
-    "Long-running DAGs must run via prepareDagExecution → runDag → operationId held by a Console operation; never foreground-Bash `task advance --approve-gate`, no tail/head pipes, no hand-rolled nohup/Start-Process/start; do not end on accepted/queued/running or an operationId — NOT completion. Supervise via operationGet/status/dagReport/dagDoctor/operationWait: 60s → 90s → 120s → 180s backoff; reset to 60s on state change; 30-60s re-checks when stall suspected. Report only meaningful node/rank changes, review/verify/closeout, recovery, liveness, terminal outcomes.",
-    "On failure read primaryFailure, primaryRecovery, doctor evidence. If meaningful progress exists, wait. Else use a fresh eligible dagRerunPlan and rerun its safe node; when ineligible follow AGENTS.md/runtime recovery for same-task rerun/advance, resume, or Worker retry. Auto-approve only a bounded writeSet inside allowedPaths, outside forbiddenPaths, without broad/destructive risk, with structured verification.",
-    "Continue until success, user stop, or no safe eligible recovery remains (limits, bindings, auth/quota, external authorization exhausted). Never create a new task for a transient failure or replace repair-pi with direct edits.",
+    "Operate through operator_* tools first. Pi read/write/edit/bash/grep/find/ls are available, but obey the loaded repository AGENTS.md. apply_patch, full-tools, shell, and coding-chat are denied alternate runtimes. Prefer safe-read/safe-grep for sensitive probes.",
+    "If a repository has no loop-agent harness and the user requests initialization, run `loop-agent init instructions --repo-root .` then `loop-agent init --repo-root . --profile full --merge`; finish the generated setup, init doctor, inspect, docs audit, and quick verification. For updates use `loop-agent init upgrade --repo-root . --json` until stable; use init check-update only for an explicitly read-only request.",
+    "After a DAG is started or accepted, do not end on accepted/queued/running or an operationId. Supervise it to a terminal outcome. Poll operationGet, task status, dagReport, and dagDoctor after about 15 seconds on start/change, every 30 seconds during progress, and every 60 seconds after 3 minutes unchanged. Report only meaningful node/rank changes, review/verify/closeout, recovery, liveness concerns, and terminal outcomes.",
+    "On failure read primaryFailure, primaryRecovery, and doctor evidence. If meaningful progress exists, wait. Otherwise use a fresh eligible dagRerunPlan and rerun its safe node; when ineligible follow AGENTS.md/runtime recovery for same-task rerun/advance, resume, or Worker retry. Auto-approve only a bounded writeSet inside allowedPaths, outside forbiddenPaths, without broad/destructive risk, and with structured verification.",
+    "Continue until success, user stop, or no safe eligible recovery remains because limits, bindings, auth/quota recovery, or required external authorization are exhausted. Never create a new task for a transient failure or replace repair-pi with direct edits.",
 ].join("\n");
 /** Compose the inspectable system prompt actually injected into Operator Chat. */
 export function composeOperatorChatSystemPrompt(input) {
@@ -1280,7 +1280,6 @@ export class ConsolePiRuntime {
      * session is not active — callers fail closed instead of fabricating data.
      */
     /**
-     * ConsolePiRuntime.listSlashCommands
      * Browser-safe slash command projection for UI-11.
      * Sources: current Session extension commands, prompt templates, skills.
      * Never returns prompt/skill file bodies.
@@ -1293,36 +1292,29 @@ export class ConsolePiRuntime {
                 .replace(/[A-Za-z]:\\Users\\[^\s]+/gi, "~")
                 .slice(0, 240);
         };
-        // Fail soft at the HTTP layer: bubble readiness errors so routes can attach
-        // a compact warning while the UI keeps local Operator/Pi Web commands.
-        await this.ensureSessionReady(sessionId);
+        try {
+            await this.ensureSessionReady(sessionId);
+        }
+        catch {
+            return [];
+        }
         const session = this.sessions.get(sessionId);
         if (!session)
-            return { commands: [] };
-        // Same-name conflict priority (AC-3): extension > skill > prompt.
-        // Enum order must not decide the winner — prompt-before-skill still loses.
-        const SOURCE_RANK = {
-            extension: 0,
-            skill: 1,
-            prompt: 2,
-        };
-        const byKey = new Map();
-        const sourceWarnings = [];
+            return [];
+        const out = [];
+        const seen = new Set();
         const push = (command, label, description, source) => {
             const name = command.startsWith("/") ? command : `/${command}`;
             const key = name.toLowerCase();
-            if (!key || key === "/")
+            if (!key || key === "/" || seen.has(key))
                 return;
-            const next = {
+            seen.add(key);
+            out.push({
                 command: name,
                 label: (label || name).slice(0, 80),
                 description: scrub(description),
                 source,
-            };
-            const existing = byKey.get(key);
-            if (!existing || SOURCE_RANK[source] < SOURCE_RANK[existing.source]) {
-                byKey.set(key, next);
-            }
+            });
         };
         try {
             const cmds = session.extensionRunner?.getRegisteredCommands?.() ?? [];
@@ -1333,20 +1325,18 @@ export class ConsolePiRuntime {
                 push(String(name), String(cmd.name || name), String(cmd.description || ""), "extension");
             }
         }
-        catch (error) {
-            // Source isolation: keep other sources; surface compact warning (AC-3).
-            sourceWarnings.push(`extension: ${scrub(error instanceof Error ? error.message : String(error))}`);
+        catch {
+            // non-blocking
         }
         try {
-            // Enumerate prompts before skills on purpose: priority must still let skill win.
             for (const tpl of session.promptTemplates ?? []) {
                 if (!tpl?.name)
                     continue;
                 push(String(tpl.name), String(tpl.name), String(tpl.description || ""), "prompt");
             }
         }
-        catch (error) {
-            sourceWarnings.push(`prompt: ${scrub(error instanceof Error ? error.message : String(error))}`);
+        catch {
+            // non-blocking
         }
         try {
             const services = this.serviceScopes.get(sessionId);
@@ -1361,16 +1351,10 @@ export class ConsolePiRuntime {
                 push(command, skill.name, String(skill.description || ""), "skill");
             }
         }
-        catch (error) {
-            sourceWarnings.push(`skill: ${scrub(error instanceof Error ? error.message : String(error))}`);
+        catch {
+            // non-blocking
         }
-        const warning = sourceWarnings.length > 0
-            ? sourceWarnings.join("; ").slice(0, 160)
-            : undefined;
-        return {
-            commands: [...byKey.values()],
-            ...(warning ? { warning } : {}),
-        };
+        return out;
     }
     async getRuntimeSnapshot(sessionId, options) {
         try {

package/dist/worker/console/chat/routes.js

@@ -1645,24 +1645,14 @@ async function handleChatFiles(res, deps, sessionId, query) {
 }
 export async function handleChatCommands(res, deps, sessionId) {
     try {
-        const listed = typeof deps.runtime.listSlashCommands === "function"
+        const commands = typeof deps.runtime.listSlashCommands === "function"
             ? await deps.runtime.listSlashCommands(sessionId)
-            : { commands: [] };
-        // Partial single-source failures keep successful commands + compact warning (AC-3).
-        const commands = listed.commands ?? [];
-        const warning = typeof listed.warning === "string" && listed.warning.trim()
-            ? listed.warning.trim().slice(0, 160)
-            : undefined;
+            : [];
         res.statusCode = 200;
         res.setHeader("content-type", "application/json; charset=utf-8");
-        res.end(JSON.stringify({
-            ok: true,
-            commands,
-            ...(warning ? { warning } : {}),
-        }));
+        res.end(JSON.stringify({ ok: true, commands }));
     }
     catch (error) {
-        // Whole-list / readiness failures stay fail-soft with empty commands + warning.
         res.statusCode = 200;
         res.setHeader("content-type", "application/json; charset=utf-8");
         res.end(JSON.stringify({
@@ -2809,21 +2799,8 @@ export async function handleChatCompact(req, res, deps, sessionId) {
             return;
         }
     }
-    let body = {};
-    try {
-        body = await readJsonBody(req);
-    }
-    catch {
-        sendJson(res, 400, {
-            ok: false,
-            error: { code: "INVALID_INPUT", message: "invalid json body" },
-        });
-        return;
-    }
-    const rawInstructions = typeof body.instructions === "string" ? body.instructions : undefined;
-    const customInstructions = rawInstructions?.trim() || undefined;
     try {
-        const snapshot = await deps.runtime.compact(sessionId, customInstructions);
+        const snapshot = await deps.runtime.compact(sessionId);
         const event = deps.events.append(sessionId, deps.events.latestTurnId(sessionId) ?? `${sessionId}:compact`, { kind: "compact", data: snapshot });
         sendJson(res, 200, { ok: true, snapshot, eventId: event.eventId });
     }

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

@@ -74,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);

package/dist/worker/console/operator-actions.js

@@ -19,7 +19,6 @@ import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.j
 import { appendEngineeringCliArgs, buildDraftFromTaskIntake, parseEngineeringBoundaryFromParams, } from "./prd-intake-bridge.js";
 import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
 import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
-import { OperationWaitError, waitForOperationChange, } from "./operation-wait.js";
 import { MutationGateReceiptStore } from "./mutation-gate-receipt-store.js";
 import { assessAutonomousExecutionEligibility, deriveEligibilityFactsFromDagSpec, } from "./dag-execution-receipt.js";
 import { issueHumanGateToken, mutationGatePayloadHash, verifyHumanGateToken, } from "./human-gate-token.js";
@@ -517,63 +516,6 @@ export async function dispatchOperatorAction(ctx, req) {
                 }),
             };
         }
-        case "operationWait": {
-            const operationId = str(p.operationId);
-            if (!operationId)
-                return invalid(action, "operationId is required");
-            const rawAfterSeq = p.afterSeq ?? 0;
-            const afterSeq = typeof rawAfterSeq === "number" ? rawAfterSeq : Number(rawAfterSeq);
-            const rawMaxWaitMs = p.maxWaitMs;
-            const maxWaitMs = typeof rawMaxWaitMs === "number"
-                ? rawMaxWaitMs
-                : rawMaxWaitMs === undefined
-                    ? undefined
-                    : Number(rawMaxWaitMs);
-            try {
-                const result = await waitForOperationChange({
-                    operations: ctx.operations,
-                    events: ctx.events,
-                    operationId,
-                    afterSeq,
-                    maxWaitMs,
-                });
-                return {
-                    kind: "sync",
-                    status: 200,
-                    body: operatorSucceeded(action, result),
-                };
-            }
-            catch (error) {
-                if (error instanceof OperationWaitError) {
-                    if (error.code === "NOT_FOUND") {
-                        return {
-                            kind: "error",
-                            status: 404,
-                            body: operatorFailed({
-                                command: action,
-                                outcome: "not-found",
-                                code: "NOT_FOUND",
-                                message: error.message,
-                            }),
-                        };
-                    }
-                    if (error.code === "EVENT_CURSOR_EXPIRED") {
-                        return {
-                            kind: "error",
-                            status: 410,
-                            body: operatorFailed({
-                                command: action,
-                                outcome: "blocked",
-                                code: "EVENT_CURSOR_EXPIRED",
-                                message: error.message,
-                            }),
-                        };
-                    }
-                    return invalid(action, error.message);
-                }
-                throw error;
-            }
-        }
         case "inspect": {
             const body = await runReadCli(ctx, ["inspect", "--json"], "inspect");
             return { kind: "sync", status: body.ok ? 200 : 400, body };