@tea-agent/loop-agent 0.43.0-next.8 → 0.43.0

package/dist/worker/console/chat/terminal-sessions.js

@@ -16,6 +16,7 @@
 import { spawn as ptySpawn } from "node-pty";
 import { existsSync } from "node:fs";
 import { randomBytes } from "node:crypto";
+import { release as osRelease } from "node:os";
 /** Bounded ring buffer of raw output chunks (bytes preserved as utf8 text). */
 const MAX_BUFFER_CHARS = 200_000;
 export class TerminalSessionError extends Error {
@@ -97,6 +98,51 @@ function resolveZsh() {
     const file = firstExisting(["/bin/zsh", "/usr/bin/zsh", "/usr/local/bin/zsh", "/opt/homebrew/bin/zsh"]);
     return file ? { file, args: ["-i"] } : undefined;
 }
+/** Windows `cmd.exe`. Always present on Windows; offered alongside
+ * PowerShell so users can use native Windows tooling (`dir`, `where`,
+ * `mklink`, `net user`, etc.) without leaving the terminal panel.
+ *  - `/Q` turns off command echo (otherwise cmd echoes every input line,
+ *    doubling every prompt in PTY output).
+ *  - `/D` disables AutoRun execution from the registry (avoid running the
+ *    user's HKCU\...\RunOnce / autorun scripts on every fresh shell).
+ *  - `/K "prompt $P$G"` keeps the shell alive across tool calls (cwd/env
+ *    survive) and uses the classic cmd prompt `C:\path>` instead of the
+ *    bare `>`, so the user can see the working directory at a glance —
+ *    matching the default `cmd.exe` window. */
+function resolveCmd() {
+    if (!IS_WINDOWS)
+        return undefined;
+    const file = firstExisting([
+        "C:\\Windows\\System32\\cmd.exe",
+        // Wine / uncommon layouts
+        "C:\\Windows\\Sysnative\\cmd.exe",
+    ]);
+    if (!file)
+        return undefined;
+    return {
+        file,
+        args: ["/Q", "/D", "/K", "prompt $P$G"],
+    };
+}
+/** Synthesize the cmd.exe startup banner that node-pty drops. cmd prints
+ * `Microsoft Windows [版本 10.0.26200]\n(c) Microsoft Corporation。保留所有权利。`
+ * via `WriteConsole` BEFORE ConPTY attaches to its stdio handles, so
+ * node-pty / ConPTY never sees those writes. We re-emit an equivalent
+ * banner using `os.release()` (kernel build, e.g. "10.0.26200") so the
+ * console terminal looks like a real cmd window. The leading \r\n avoids
+ * the banner colliding with whatever ANSI preamble ConPTY already sent.
+ *
+ * Only meaningful for the cmd shell — bash and PowerShell on Windows have
+ * their own startup output that we must NOT paper over with a Windows
+ * banner they don't print. */
+function makeCmdBanner(shell) {
+    if (!IS_WINDOWS)
+        return undefined;
+    if (shell !== "cmd")
+        return undefined;
+    const build = osRelease();
+    return `\r\nMicrosoft Windows [版本 ${build}]\r\n(c) Microsoft Corporation。保留所有权利。\r\n\r\n`;
+}
 let cachedCatalog;
 /** Platform shell catalog, computed once per process. Drives both the UI
  * button set and the model tool's shell parameter enum. */
@@ -113,6 +159,9 @@ export function availableShellKinds() {
     const zsh = resolveZsh();
     if (zsh)
         resolved.set("zsh", zsh);
+    const cmd = resolveCmd();
+    if (cmd)
+        resolved.set("cmd", cmd);
     cachedCatalog = { kinds: [...resolved.keys()], resolved };
     return cachedCatalog;
 }
@@ -165,10 +214,18 @@ export class TerminalSessionRegistry {
             bufferChars: 0,
             subscribers: new Set(),
             disposing: undefined,
+            pendingBanner: makeCmdBanner(options.shell) ?? undefined,
         };
         this.entries.set(sessionId, entry);
         pty.onData((chunk) => {
             entry.info.totalOutputChars += chunk.length;
+            // Inject the synthesized cmd banner into the FIRST chunk the
+            // subscribers see, so SSE/streaming attaches still see it even
+            // though node-pty already missed cmd's real banner.
+            if (entry.pendingBanner !== undefined) {
+                chunk = entry.pendingBanner + chunk;
+                entry.pendingBanner = undefined;
+            }
             entry.buffer.push(chunk);
             entry.bufferChars += chunk.length;
             while (entry.bufferChars > MAX_BUFFER_CHARS && entry.buffer.length > 1) {
@@ -219,8 +276,15 @@ export class TerminalSessionRegistry {
     /** Full buffered output (post-trim prefix may be incomplete). */
     readAll(sessionId) {
         const entry = this.mustGet(sessionId);
+        let text = entry.buffer.join("");
+        // If the caller reads before any real PTY output has arrived, the
+        // banner injection in onData hasn't fired yet — fold it in here.
+        if (entry.pendingBanner !== undefined) {
+            text = entry.pendingBanner + text;
+            entry.pendingBanner = undefined;
+        }
         return {
-            text: entry.buffer.join(""),
+            text,
             truncated: entry.info.totalOutputChars > entry.bufferChars,
             totalOutputChars: entry.info.totalOutputChars,
         };

package/dist/worker/console/chat/terminal-tools.js

@@ -48,10 +48,16 @@ export async function buildPersistentTerminalTools(deps) {
         const marker = `${MARKER_PREFIX}${Date.now().toString(36)}${Math.random()
             .toString(36)
             .slice(2, 8)}`;
-        // Exit-code echo: PowerShell uses $LASTEXITCODE; bash/zsh use $?.
+        // Exit-code echo per shell:
+        //  - PowerShell: $LASTEXITCODE
+        //  - bash / zsh: $?
+        //  - cmd.exe: %ERRORLEVEL% (interpolation happens before echo runs,
+        //    so we use `prompt` substitution style `echo MARKER:%ERRORLEVEL%`).
         const exitEcho = kind === "powershell"
             ? `Write-Host "${marker}:$LASTEXITCODE"`
-            : `echo "${marker}:$?"`;
+            : kind === "cmd"
+                ? `echo ${marker}:%ERRORLEVEL%`
+                : `echo "${marker}:$?"`;
         const wrapped = `${command}\n${exitEcho}\n`;
         // Capture output from the moment of send until the marker line shows up.
         const pending = [];
@@ -122,15 +128,21 @@ export async function buildPersistentTerminalTools(deps) {
         });
     };
     const kinds = availableShellKinds().kinds;
+    // Default precedence: bash (most posix-feel for cross-platform models) →
+    // cmd (native Windows shell, offered when bash is absent) → zsh (macOS
+    // default on some dev boxes) → powershell (universal Windows fallback).
     const defaultKind = kinds.includes("bash")
         ? "bash"
-        : kinds.includes("zsh")
-            ? "zsh"
-            : "powershell";
+        : kinds.includes("cmd")
+            ? "cmd"
+            : kinds.includes("zsh")
+                ? "zsh"
+                : "powershell";
     const kindLabels = {
         powershell: "PowerShell",
         bash: "bash",
         zsh: "zsh",
+        cmd: "cmd",
     };
     const tool = defineTool({
         name: "terminal",

package/dist/worker/console/chat/tool-preview.js

@@ -148,6 +148,115 @@ export function getToolPreview(args, options) {
         return "";
     return s.length > maxLen ? `${s.slice(0, maxLen)}…` : s;
 }
+/** DSH-style human-readable ask_user_question row (rowTitle「提问」). */
+export function isAskUserQuestionTool(toolName) {
+    return (toolName ?? "").trim().toLowerCase() === "ask_user_question";
+}
+function normalizeOptionLabel(value) {
+    const record = asRecord(value);
+    if (!record)
+        return undefined;
+    const label = typeof record.label === "string" ? record.label.trim() : "";
+    return label || undefined;
+}
+function normalizeAskQuestion(value) {
+    const record = asRecord(value);
+    if (!record)
+        return undefined;
+    const id = typeof record.id === "string" ? record.id.trim() : "";
+    const question = typeof record.question === "string" ? record.question.trim() : "";
+    if (!id || !question)
+        return undefined;
+    const options = Array.isArray(record.options)
+        ? record.options
+            .map((item) => {
+            const label = normalizeOptionLabel(item);
+            if (!label)
+                return undefined;
+            const description = typeof item === "object" && item !== null &&
+                "description" in item && typeof item.description === "string"
+                ? item.description
+                : undefined;
+            return { label, ...(description && description.trim() ? { description: description.trim() } : {}) };
+        })
+            .filter((item) => Boolean(item))
+        : undefined;
+    return {
+        id,
+        question,
+        ...(typeof record.header === "string" && record.header.trim()
+            ? { header: record.header.trim() }
+            : {}),
+        ...(typeof record.detail === "string" && record.detail.trim()
+            ? { detail: record.detail.trim() }
+            : {}),
+        ...(options && options.length > 0 ? { options } : {}),
+        ...(record.multi_select === true || record.multiSelect === true
+            ? { multiSelect: true }
+            : {}),
+    };
+}
+/** Project ask_user_question args (questions array) into readable views. */
+export function parseAskUserQuestions(args) {
+    const input = parseArgs(args);
+    if (!input)
+        return [];
+    const raw = Array.isArray(input)
+        ? input
+        : Array.isArray(input.questions)
+            ? input.questions
+            : [];
+    return raw
+        .map(normalizeAskQuestion)
+        .filter((item) => Boolean(item));
+}
+/** Project ask_user_question ToolResult into answer views keyed by question id. */
+export function parseAskUserAnswers(result) {
+    if (result === undefined || result === null)
+        return [];
+    const text = extractToolResultText(result);
+    if (!text)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const record = asRecord(parsed);
+    const raw = record && Array.isArray(record.answers) ? record.answers : undefined;
+    if (!raw)
+        return [];
+    const out = [];
+    for (const entry of raw) {
+        const rec = entry && typeof entry === "object" && !Array.isArray(entry)
+            ? entry
+            : undefined;
+        if (!rec || typeof rec.id !== "string")
+            continue;
+        const selected = Array.isArray(rec.selected)
+            ? rec.selected.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean)
+            : [];
+        const custom = typeof rec.custom === "string" ? rec.custom.trim() : "";
+        out.push({ id: rec.id, selected, ...(custom ? { custom } : {}) });
+    }
+    return out;
+}
+/** "{answered}/{total} 已回答" summary; total from args questions, answered from result answers. */
+export function getAskUserQuestionSummary(args, result) {
+    const questions = parseAskUserQuestions(args);
+    if (questions.length === 0)
+        return null;
+    const answers = parseAskUserAnswers(result);
+    let answered = 0;
+    for (const question of questions) {
+        const answer = answers.find((item) => item.id === question.id);
+        if (answer && (answer.selected.length > 0 || answer.custom))
+            answered += 1;
+    }
+    return { answered, total: questions.length };
+}
 /** Stable DSH-style tool row identity; unknown tools keep their real name. */
 export function getToolPresentation(toolName) {
     const raw = toolName?.trim() || "Tool";
@@ -191,6 +300,9 @@ export function getToolPresentation(toolName) {
     if (name === "agent") {
         return { kind: "search", label: "Explore" };
     }
+    if (isAskUserQuestionTool(toolName)) {
+        return { kind: "tool", label: "提问" };
+    }
     return { kind: "tool", label: raw };
 }
 /** A tool call that failed on its own. A call interrupted by Stop carries
@@ -213,6 +325,9 @@ export function getToolSectionLabels(toolName) {
     if (name === "mcp" || name.startsWith("mcp_")) {
         return { argsLabel: "参数", resultLabel: "结果" };
     }
+    if (isAskUserQuestionTool(toolName)) {
+        return { argsLabel: "提问", resultLabel: "您的回答" };
+    }
     return { argsLabel: "入参", resultLabel: "结果" };
 }
 /**

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

@@ -25,6 +25,16 @@ export const OPERATOR_CHAT_BUILTIN_CUSTOM_TOOLS = Object.freeze([
     OPERATOR_CHAT_AGENT_TOOL_NAME,
     "terminal",
     "scm",
+    "browser_navigate",
+    "browser_search",
+    "browser_snapshot",
+    "browser_act",
+    "browser_tabs",
+    "browser_scroll",
+    "browser_press",
+    "browser_dialog",
+    "browser_wait",
+    "browser_screenshot",
 ]);
 /**
  * Actions the model MAY invoke. Derived from the registry but filtered by the

package/dist/worker/console/chat/turn-order.js

@@ -0,0 +1,13 @@
+export function compareChatOrder(a, b) {
+    if (a.eventSeq !== undefined &&
+        b.eventSeq !== undefined &&
+        a.eventSeq !== b.eventSeq) {
+        return a.eventSeq - b.eventSeq;
+    }
+    if (a.createdAt !== b.createdAt)
+        return a.createdAt - b.createdAt;
+    // Same timestamp with mismatched sequence presence: keep the original
+    // insertion order (stable sort). Deciding here would re-order live SSE
+    // frames that happen to share a millisecond with a tool row.
+    return 0;
+}

package/dist/worker/console/chat/turn-process.js

@@ -1,6 +1,7 @@
 /**
  * Turn grouping for Operator Chat inline process UX (pi-web ProcessDetails mind).
  */
+import { compareChatOrder } from "./turn-order.js";
 import { getDisplayableAssistantBlocks, joinAssistantText, parseAssistantContent, splitFinalAssistantBlocks, } from "./assistant-content.js";
 import { dagProgressActivityForTool, semanticActivityForTool, } from "./semantic-activity.js";
 function emptyGroup(key) {
@@ -264,13 +265,14 @@ function fillProcessDetails(group) {
             items,
         });
     }
-    const fullySequenced = nodes.every((node) => node.eventSeq !== undefined);
+    // Unified order (DSH rule): server seq is the single authoritative key,
+    // createdAt falls back, insertion order breaks remaining ties. No
+    // "fullySequenced" switch — a partially-sequenced group must not
+    // silently re-sort its peers by wall clock when most nodes carry seq.
     nodes.sort((a, b) => {
-        if (fullySequenced && a.eventSeq !== b.eventSeq) {
-            return a.eventSeq - b.eventSeq;
-        }
-        if (a.createdAt !== b.createdAt)
-            return a.createdAt - b.createdAt;
+        const byOrder = compareChatOrder(a, b);
+        if (byOrder !== 0)
+            return byOrder;
         return a.insertionOrder - b.insertionOrder;
     });
     const processItems = nodes.flatMap((node) => node.items);
@@ -301,20 +303,7 @@ function fillProcessDetails(group) {
 export function buildTurnProcessGroups(input) {
     const visible = input.messages
         .filter((m) => m.role === "user" || m.role === "assistant")
-        .sort((a, b) => {
-        if (a.eventSeq !== undefined &&
-            b.eventSeq !== undefined &&
-            a.eventSeq !== b.eventSeq) {
-            return a.eventSeq - b.eventSeq;
-        }
-        if (a.createdAt !== b.createdAt)
-            return a.createdAt - b.createdAt;
-        if (a.eventSeq !== undefined && b.eventSeq === undefined)
-            return 1;
-        if (a.eventSeq === undefined && b.eventSeq !== undefined)
-            return -1;
-        return 0;
-    });
+        .sort(compareChatOrder);
     const groups = [];
     let current = null;
     const startGroup = (key) => {
@@ -326,6 +315,8 @@ export function buildTurnProcessGroups(input) {
         if (message.role === "user") {
             current = startGroup(`user-${message.id}`);
             current.user = message;
+            if (message.turnId)
+                current.turnId = message.turnId;
             continue;
         }
         if (message.kind === "compaction") {
@@ -333,12 +324,16 @@ export function buildTurnProcessGroups(input) {
             // prevents it from replacing the previous turn's assistant answer.
             current = startGroup(`compaction-${message.id}`);
             current.assistants.push(message);
+            if (message.turnId)
+                current.turnId = message.turnId;
             current = null;
             continue;
         }
         if (!current)
             current = startGroup(`assistant-${message.id}`);
         current.assistants.push(message);
+        if (current.turnId === undefined && message.turnId)
+            current.turnId = message.turnId;
     }
     const assigned = new Set();
     const assistantToGroup = new Map();
@@ -360,10 +355,10 @@ export function buildTurnProcessGroups(input) {
         if (assigned.has(tool.id))
             continue;
         if (tool.turnId) {
-            const byTurn = groups.find((group) => group.user?.turnId === tool.turnId ||
+            const byTurn = groups.find((group) => group.turnId === tool.turnId ||
+                group.user?.turnId === tool.turnId ||
                 group.assistants.some((assistant) => assistant.turnId === tool.turnId) ||
                 group.tools.some((t) => t.turnId === tool.turnId) ||
-                group.key === `turn-${tool.turnId}` ||
                 (group.user && `restored-${group.user.id}` === tool.turnId));
             if (byTurn) {
                 byTurn.tools.push(tool);
@@ -379,13 +374,25 @@ export function buildTurnProcessGroups(input) {
             }
         }
     }
+    // Time-window fallback for legacy rows with neither assistantMessageId nor
+    // turnId. The window ends at the NEXT group's first anchor (user OR first
+    // assistant) — using POSITIVE_INFINITY would swallow every later group's
+    // tools when the very next group has no user message (e.g. compaction or a
+    // stand-alone assistant row), dumping one turn's bash cards into another.
     for (const tool of input.toolCalls) {
         if (assigned.has(tool.id))
             continue;
         const windowGroup = groups.find((group, index) => {
             const start = group.user?.createdAt ?? group.assistants[0]?.createdAt ?? 0;
-            const next = groups[index + 1];
-            const end = next?.user?.createdAt ?? Number.POSITIVE_INFINITY;
+            let end = Number.POSITIVE_INFINITY;
+            for (let i = index + 1; i < groups.length; i += 1) {
+                const next = groups[i];
+                const nextAnchor = next?.user?.createdAt ?? next?.assistants[0]?.createdAt;
+                if (nextAnchor !== undefined) {
+                    end = nextAnchor;
+                    break;
+                }
+            }
             return tool.createdAt >= start && tool.createdAt < end;
         });
         // Time window only. Never dump unmatched tools onto the latest group:
@@ -396,12 +403,7 @@ export function buildTurnProcessGroups(input) {
         }
     }
     for (const group of groups) {
-        group.tools.sort((a, b) => {
-            if (a.eventSeq !== undefined && b.eventSeq !== undefined) {
-                return a.eventSeq - b.eventSeq;
-            }
-            return a.createdAt - b.createdAt;
-        });
+        group.tools.sort(compareChatOrder);
         group.live =
             input.streaming &&
                 input.activeAssistantId !== null &&

package/dist/worker/console/console-update-and-init.js

@@ -67,29 +67,11 @@ export async function performConsoleUpdateAndInit(deps, channel = "latest") {
                 return failed("INSTALL_VERIFICATION_FAILED", verified.reason, maintenance);
             }
         }
-        const initResult = await deps.applySafeInit();
-        maintenance.initialization = initResult.ok
-            ? { status: "clean", pendingPaths: initResult.pendingPaths }
-            : {
-                status: "needs-reconcile",
-                pendingPaths: initResult.pendingPaths,
-                message: initResult.message,
-            };
         if (!packageChanged) {
-            return {
-                state: initResult.ok ? "succeeded" : "needs-reconcile",
-                maintenance,
-                ...(initResult.ok
-                    ? {}
-                    : {
-                        errorCode: "INIT_NEEDS_RECONCILE",
-                        errorMessage: initResult.message,
-                    }),
-            };
+            return { state: "succeeded", maintenance };
         }
         const handoff = await deps.requestHandoff({
             targetVersion: target.version,
-            initResult,
         });
         if (!handoff.ok) {
             maintenance.handoff = {

package/dist/worker/console/console-update-runtime.js

@@ -28,14 +28,13 @@ export function createConsoleUpdateExecutor(input) {
         return performConsoleUpdateAndInit({
             currentVersion,
             preflight: async () => {
-                const [activity, operations] = await Promise.all([
-                    readInitRuntimeActivity(input.repoRoot),
-                    input.operations.list(),
-                ]);
-                if (activity.workerProjectionError ||
+                const scopes = await input.workspaceActivity?.() ?? [input];
+                const activities = await Promise.all(scopes.map(scope => readInitRuntimeActivity(scope.repoRoot)));
+                const operations = (await Promise.all(scopes.map(scope => scope.operations.list()))).flat();
+                if (activities.some(activity => activity.workerProjectionError ||
                     activity.activeDagRunIds.length > 0 ||
                     activity.activeWorkerTasks > 0 ||
-                    activity.activeWorkerBatches > 0) {
+                    activity.activeWorkerBatches > 0)) {
                     return {
                         ok: false,
                         code: "ACTIVE_RUNTIME",
@@ -64,20 +63,6 @@ export function createConsoleUpdateExecutor(input) {
             canAutoInstall: () => npm.canAutoInstall(),
             installExact: (version, selectedChannel) => npm.installExact(version, selectedChannel),
             verifyInstalled: (version) => npm.verifyInstalled(version),
-            applySafeInit: async () => {
-                const result = await input.client.runExternal("loop-agent", ["init", "update", "--apply-safe", "--repo-root", input.repoRoot], {
-                    cwd: input.repoRoot,
-                    artifactName: "console-update-safe-init",
-                    timeoutMs: 120_000,
-                });
-                return result.ok
-                    ? { ok: true, pendingPaths: [] }
-                    : {
-                        ok: false,
-                        message: result.stderr || result.stdout || "safe initialization failed",
-                        pendingPaths: [],
-                    };
-            },
             requestHandoff: async ({ targetVersion }) => input.requestHandoff(targetVersion),
         }, channel);
     };

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

@@ -1,3 +1,6 @@
+import { prepareScheduledTask } from "./chat/scheduled-goal-request.js";
+import { ScheduledGoalStore } from "../scheduler/scheduled-goal-store.js";
+import { prepareScheduledGoalBooking, confirmScheduledGoalBooking, getScheduledGoalBooking } from "./chat/scheduled-goal-booking.js";
 import { access, readFile } from "node:fs/promises";
 import { buildOperatorCapabilitiesDocument, OFFICIAL_TAIL_ACTION_IDS, } from "../../shared/operator/capabilities.js";
 import { DAG_RERUN_PROMPT_OVERRIDE_ENV, isDagRerunPromptOverrideEnabled, MAX_DAG_RERUN_PROMPT_OVERRIDE_CHARS, } from "../../shared/dag-prompt-override.js";
@@ -772,7 +775,7 @@ async function acceptConsoleUpdateAndInit(ctx, clientRequestId, channel) {
                 at: new Date().toISOString(),
                 kind: "state",
                 state: "running",
-                message: `checking runtime, npm ${channel}, and safe initialization`,
+                message: `checking runtime and npm ${channel}`,
             });
             try {
                 const result = await ctx.consoleUpdateExecutor(channel);
@@ -849,6 +852,18 @@ export async function dispatchOperatorAction(ctx, req) {
         };
     }
     const p = paramsOf(req);
+    if (action === "workspaceInitialize") {
+        if (req.source !== "human-ui")
+            return { kind: "error", status: 403, body: operatorFailed({ command: action, outcome: "blocked", code: "HUMAN_UI_REQUIRED", message: "工作区初始化需要从界面显式发起" }) };
+        if (!req.clientRequestId?.trim() || Object.keys(p).some(key => key !== "model") || (p.model !== undefined && (typeof p.model !== "string" || p.model.length > 300)))
+            return invalid(action, "只接受 clientRequestId 和可选模型引用");
+        if (!ctx.workspaceInitialization)
+            return invalid(action, "工作区初始化服务不可用");
+        const created = await ctx.workspaceInitialization.start(req.clientRequestId, p.model);
+        if (created.kind === "conflict")
+            return { kind: "error", status: 409, body: operatorFailed({ command: action, outcome: "conflict", code: "REQUEST_ID_REUSE_CONFLICT", message: created.message }) };
+        return { kind: "accepted", status: 202, body: { operationId: created.operation.operationId, state: created.operation.state, clientRequestId: created.operation.clientRequestId, action } };
+    }
     if (action === "consoleUpdateAndInit") {
         if (req.source !== "human-ui") {
             return {
@@ -874,6 +889,52 @@ export async function dispatchOperatorAction(ctx, req) {
         }
         return acceptConsoleUpdateAndInit(ctx, req.clientRequestId, channel);
     }
+    if (["prepareScheduledTask", "prepareScheduledGoal", "confirmScheduledGoal", "scheduledGoalGet", "scheduledGoalList", "cancelScheduledGoal"].includes(action)) {
+        try {
+            const goals = new ScheduledGoalStore(ctx.repoRoot);
+            const { ChatSessionStore } = await import("./chat/session-store.js");
+            const deps = { goals, client: ctx.client, sessions: new ChatSessionStore(ctx.appData) };
+            let result;
+            if (action === "prepareScheduledTask") {
+                if (!ctx.chatSessionRef || Object.keys(p).some((key) => key !== "request"))
+                    return invalid(action, "requires a host-bound Chat session and request only");
+                result = await prepareScheduledTask(p.request, { repoRoot: ctx.repoRoot, preparationRoot: nodePath.join(ctx.appData.staged, "scheduled-tasks"),
+                    sessionId: ctx.chatSessionRef, client: ctx.client, sessions: deps.sessions });
+            }
+            else if (action === "prepareScheduledGoal") {
+                if (Object.keys(p).some((key) => key !== "booking"))
+                    return invalid(action, "only booking may be provided");
+                result = await prepareScheduledGoalBooking(p.booking, deps);
+            }
+            else if (action === "confirmScheduledGoal") {
+                result = await confirmScheduledGoalBooking(p, deps, { source: req.source, requestId: req.clientRequestId });
+            }
+            else if (action === "cancelScheduledGoal") {
+                if (req.source !== "human-ui" || !req.clientRequestId?.trim())
+                    return invalid(action, "human cancellation required");
+                if (Object.keys(p).some((key) => !["goalId", "stateVersion", "reason"].includes(key)) ||
+                    typeof p.goalId !== "string" || !Number.isSafeInteger(p.stateVersion) || typeof p.reason !== "string")
+                    return invalid(action, "goalId, stateVersion and reason required");
+                await goals.cancel(p.goalId, p.stateVersion, req.clientRequestId, p.reason);
+                result = await getScheduledGoalBooking(p.goalId, goals);
+            }
+            else if (action === "scheduledGoalGet") {
+                if (Object.keys(p).some((key) => key !== "goalId") || typeof p.goalId !== "string")
+                    return invalid(action, "goalId required");
+                result = await getScheduledGoalBooking(p.goalId, goals);
+            }
+            else {
+                if (Object.keys(p).some((key) => key !== "chatSessionRef") || (p.chatSessionRef !== undefined && typeof p.chatSessionRef !== "string"))
+                    return invalid(action, "only optional chatSessionRef may be provided");
+                const records = (await goals.list()).filter((goal) => !p.chatSessionRef || goal.frozen.chatSessionRef === p.chatSessionRef);
+                result = await Promise.all(records.map((goal) => getScheduledGoalBooking(goal.goalId, goals)));
+            }
+            return { kind: "sync", status: 200, body: operatorSucceeded(action, result) };
+        }
+        catch (error) {
+            return invalid(action, error instanceof Error ? error.message : String(error));
+        }
+    }
     switch (action) {
         case "operatorCapabilities": {
             const doc = buildOperatorCapabilitiesDocument();
@@ -1065,6 +1126,7 @@ export async function dispatchOperatorAction(ctx, req) {
             const args = ["dag", "doctor"];
             if (runId)
                 args.push("--run-id", runId);
+            args.push("--json");
             const body = await runReadCli(ctx, args, "dag doctor");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
         }