@tea-agent/loop-agent 0.29.2 → 0.29.3

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

@@ -0,0 +1,178 @@
+/**
+ * Turn grouping for Operator Chat inline process UX (pi-web ProcessDetails mind).
+ */
+/**
+ * Restore chat bubbles + tool cards from durable session messages.
+ * Tool rows often appear before the final assistant `message_end` message;
+ * synthetic turn ids bridge that gap for later grouping.
+ */
+export function hydrateSessionThread(raw) {
+    const messages = [];
+    const toolCalls = [];
+    let turnId;
+    let pendingTools = [];
+    const flushPendingToAssistant = (assistantId) => {
+        for (const tool of pendingTools) {
+            if (!tool.assistantMessageId)
+                tool.assistantMessageId = assistantId;
+            if (!tool.turnId)
+                tool.turnId = turnId;
+        }
+        pendingTools = [];
+    };
+    for (const item of raw) {
+        const createdAt = Date.parse(item.at) || Date.now();
+        if (item.role === "user") {
+            turnId = `restored-${item.id}`;
+            pendingTools = [];
+            messages.push({
+                id: item.id,
+                role: "user",
+                text: item.text,
+                createdAt,
+            });
+            continue;
+        }
+        if (item.role === "assistant") {
+            if (!turnId)
+                turnId = `restored-${item.id}`;
+            messages.push({
+                id: item.id,
+                role: "assistant",
+                text: item.text,
+                createdAt,
+            });
+            flushPendingToAssistant(item.id);
+            continue;
+        }
+        if (item.role === "tool") {
+            if (!turnId)
+                turnId = `restored-tool-${item.id}`;
+            const entry = {
+                id: item.toolCallId || item.id,
+                toolName: item.toolName || "tool",
+                status: item.isError === true ? "error" : "ok",
+                resultText: item.text,
+                result: item.text,
+                createdAt,
+                finishedAt: createdAt,
+                turnId,
+            };
+            toolCalls.push(entry);
+            pendingTools.push(entry);
+        }
+    }
+    return { messages, toolCalls };
+}
+/**
+ * Build user → process → answer groups for the message timeline.
+ */
+export function buildTurnProcessGroups(input) {
+    const visible = input.messages.filter((m) => m.role === "user" || m.role === "assistant");
+    const groups = [];
+    let current = null;
+    const startGroup = (key) => {
+        const group = {
+            key,
+            assistants: [],
+            tools: [],
+            live: false,
+        };
+        groups.push(group);
+        return group;
+    };
+    for (const message of visible) {
+        if (message.role === "user") {
+            current = startGroup(`user-${message.id}`);
+            current.user = message;
+            continue;
+        }
+        if (!current)
+            current = startGroup(`assistant-${message.id}`);
+        current.assistants.push(message);
+    }
+    if (groups.length === 0 && input.toolCalls.length > 0) {
+        groups.push({
+            key: "orphan-tools",
+            assistants: [],
+            tools: [],
+            live: false,
+        });
+    }
+    const assigned = new Set();
+    const assistantToGroup = new Map();
+    for (const group of groups) {
+        for (const assistant of group.assistants) {
+            assistantToGroup.set(assistant.id, group);
+        }
+    }
+    for (const tool of input.toolCalls) {
+        if (tool.assistantMessageId) {
+            const group = assistantToGroup.get(tool.assistantMessageId);
+            if (group) {
+                group.tools.push(tool);
+                assigned.add(tool.id);
+                continue;
+            }
+        }
+    }
+    for (const tool of input.toolCalls) {
+        if (assigned.has(tool.id))
+            continue;
+        if (tool.turnId) {
+            const byTurn = groups.find((group) => 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);
+                assigned.add(tool.id);
+                continue;
+            }
+            // Match restored turn id `restored-<userOrAssistantId>`
+            const restored = groups.find((group) => tool.turnId === `restored-${group.user?.id}` ||
+                group.assistants.some((a) => tool.turnId === `restored-${a.id}`));
+            if (restored) {
+                restored.tools.push(tool);
+                assigned.add(tool.id);
+                continue;
+            }
+        }
+    }
+    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;
+            return tool.createdAt >= start && tool.createdAt < end;
+        });
+        if (windowGroup) {
+            windowGroup.tools.push(tool);
+            assigned.add(tool.id);
+        }
+        else if (groups.length > 0) {
+            groups[groups.length - 1].tools.push(tool);
+            assigned.add(tool.id);
+        }
+    }
+    for (const group of groups) {
+        group.tools.sort((a, b) => a.createdAt - b.createdAt);
+        group.live =
+            input.streaming &&
+                input.activeAssistantId !== null &&
+                group.assistants.some((a) => a.id === input.activeAssistantId);
+    }
+    return groups;
+}
+export function processGroupSummary(tools) {
+    const count = tools.length;
+    const errorCount = tools.filter((t) => t.status === "error").length;
+    const runningCount = tools.filter((t) => t.status === "running").length;
+    const parts = [`执行过程 · ${count} 工具`];
+    if (errorCount > 0)
+        parts.push(`${errorCount} 出错`);
+    else if (runningCount > 0)
+        parts.push("运行中");
+    return { count, errorCount, runningCount, label: parts.join(" · ") };
+}

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

@@ -2,36 +2,164 @@ function record(value) {
     return value && typeof value === "object" ? value : undefined;
 }
 function numberAt(source, keys) {
-    for (const key of keys)
-        if (typeof source[key] === "number" && Number.isFinite(source[key]))
+    for (const key of keys) {
+        if (typeof source[key] === "number" && Number.isFinite(source[key])) {
             return Math.max(0, source[key]);
+        }
+    }
     return undefined;
 }
+function costAt(source) {
+    const direct = numberAt(source, ["cost"]);
+    if (direct !== undefined)
+        return direct;
+    const nested = record(source.cost);
+    if (!nested)
+        return undefined;
+    return numberAt(nested, ["total", "amount"]);
+}
+/**
+ * Extract usage from Pi SDK / OpenAI-shaped events.
+ * Pi assistant usage uses `{ input, output, cacheRead, cacheWrite, totalTokens, cost }`.
+ */
 export function extractUsageSample(value) {
     const event = record(value);
     if (!event)
         return undefined;
     const message = record(event.message);
-    const source = record(event.usage) ?? record(message?.usage) ?? record(event.tokenUsage);
+    const source = record(event.usage) ??
+        record(message?.usage) ??
+        record(event.tokenUsage);
     if (!source)
         return undefined;
-    const inputTokens = numberAt(source, ["input_tokens", "inputTokens", "prompt_tokens", "promptTokens"]);
-    const outputTokens = numberAt(source, ["output_tokens", "outputTokens", "completion_tokens", "completionTokens"]);
-    const totalTokens = numberAt(source, ["total_tokens", "totalTokens"]) ?? (inputTokens !== undefined || outputTokens !== undefined ? (inputTokens ?? 0) + (outputTokens ?? 0) : undefined);
-    if (inputTokens === undefined && outputTokens === undefined && totalTokens === undefined)
+    const inputTokens = numberAt(source, [
+        "input",
+        "input_tokens",
+        "inputTokens",
+        "prompt_tokens",
+        "promptTokens",
+    ]);
+    const outputTokens = numberAt(source, [
+        "output",
+        "output_tokens",
+        "outputTokens",
+        "completion_tokens",
+        "completionTokens",
+    ]);
+    const cacheReadTokens = numberAt(source, [
+        "cacheRead",
+        "cache_read",
+        "cache_read_input_tokens",
+        "cacheReadTokens",
+    ]);
+    const cacheWriteTokens = numberAt(source, [
+        "cacheWrite",
+        "cache_write",
+        "cache_creation_input_tokens",
+        "cacheWriteTokens",
+    ]);
+    const partsSum = (inputTokens ?? 0) +
+        (outputTokens ?? 0) +
+        (cacheReadTokens ?? 0) +
+        (cacheWriteTokens ?? 0);
+    const hasParts = inputTokens !== undefined ||
+        outputTokens !== undefined ||
+        cacheReadTokens !== undefined ||
+        cacheWriteTokens !== undefined;
+    const totalTokens = numberAt(source, ["total_tokens", "totalTokens"]) ??
+        (hasParts ? partsSum : undefined);
+    const cost = costAt(source);
+    if (inputTokens === undefined &&
+        outputTokens === undefined &&
+        cacheReadTokens === undefined &&
+        cacheWriteTokens === undefined &&
+        totalTokens === undefined &&
+        cost === undefined) {
         return undefined;
-    const responseKey = [event.responseId, message?.id, source.responseId].find((item) => typeof item === "string");
-    return { inputTokens, outputTokens, totalTokens, ...(responseKey ? { responseKey } : {}) };
+    }
+    const responseKey = [
+        event.responseId,
+        message?.id,
+        source.responseId,
+    ].find((item) => typeof item === "string");
+    return {
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(cacheReadTokens !== undefined ? { cacheReadTokens } : {}),
+        ...(cacheWriteTokens !== undefined ? { cacheWriteTokens } : {}),
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(cost !== undefined ? { cost } : {}),
+        ...(responseKey ? { responseKey } : {}),
+    };
 }
 export function aggregateUsage(samples) {
     const keyed = new Map();
     const anonymous = [];
-    for (const sample of samples)
-        sample.responseKey ? keyed.set(sample.responseKey, sample) : anonymous.push(sample);
+    for (const sample of samples) {
+        if (sample.responseKey)
+            keyed.set(sample.responseKey, sample);
+        else
+            anonymous.push(sample);
+    }
     const selected = [...keyed.values(), ...anonymous];
-    return selected.reduce((sum, sample) => ({
-        inputTokens: sum.inputTokens + (sample.inputTokens ?? 0), outputTokens: sum.outputTokens + (sample.outputTokens ?? 0), totalTokens: sum.totalTokens + (sample.totalTokens ?? ((sample.inputTokens ?? 0) + (sample.outputTokens ?? 0))),
-        cost: sample.cost === undefined ? sum.cost : (sum.cost ?? 0) + sample.cost,
-        estimated: Boolean(sum.estimated || sample.estimated),
-    }), { inputTokens: 0, outputTokens: 0, totalTokens: 0 });
+    return selected.reduce((sum, sample) => {
+        const input = sample.inputTokens ?? 0;
+        const output = sample.outputTokens ?? 0;
+        const cacheRead = sample.cacheReadTokens ?? 0;
+        const cacheWrite = sample.cacheWriteTokens ?? 0;
+        const total = sample.totalTokens ?? input + output + cacheRead + cacheWrite;
+        return {
+            inputTokens: sum.inputTokens + input,
+            outputTokens: sum.outputTokens + output,
+            cacheReadTokens: sum.cacheReadTokens + cacheRead,
+            cacheWriteTokens: sum.cacheWriteTokens + cacheWrite,
+            totalTokens: sum.totalTokens + total,
+            cost: sample.cost === undefined
+                ? sum.cost
+                : (sum.cost ?? 0) + sample.cost,
+            estimated: Boolean(sum.estimated || sample.estimated),
+        };
+    }, {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        totalTokens: 0,
+    });
+}
+/** Compact token count aligned with pi-web SessionInfoBar / ChatInput. */
+export function formatTokenCount(tokens) {
+    if (tokens >= 1_000_000)
+        return `${(tokens / 1_000_000).toFixed(1)}M`;
+    if (tokens >= 1_000)
+        return `${(tokens / 1_000).toFixed(1)}k`;
+    return tokens.toLocaleString();
+}
+/**
+ * Status-line usage text aligned with pi-web SessionInfoBar chips:
+ * `12.3k in · 1.2k out · 8.0k cache R · $0.01`
+ */
+export function formatUsageStatusLine(usage) {
+    const parts = [];
+    const input = usage.inputTokens ?? 0;
+    const output = usage.outputTokens ?? 0;
+    const cacheRead = usage.cacheReadTokens ?? 0;
+    const cacheWrite = usage.cacheWriteTokens ?? 0;
+    const cost = usage.cost ?? 0;
+    if (input > 0)
+        parts.push(`${formatTokenCount(input)} in`);
+    if (output > 0)
+        parts.push(`${formatTokenCount(output)} out`);
+    if (cacheRead > 0)
+        parts.push(`${formatTokenCount(cacheRead)} cache R`);
+    if (cacheWrite > 0)
+        parts.push(`${formatTokenCount(cacheWrite)} cache W`);
+    if (cost > 0) {
+        parts.push(cost >= 0.01 ? `$${cost.toFixed(2)}` : "<$0.01");
+    }
+    if (parts.length === 0) {
+        const total = usage.totalTokens ?? 0;
+        return total > 0 ? `${formatTokenCount(total)} tokens` : "—";
+    }
+    return parts.join(" · ");
 }

package/dist/worker/console/night-aux-ticker.js

@@ -0,0 +1,141 @@
+import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
+import { DEFAULT_CLOCK_INTERVAL_SEC } from "../scheduler/clock.js";
+export const NIGHT_AUX_TICKER_DISCLAIMER = "仅在本 Console 进程开着时有效；关掉 Console 或睡觉后不会 tick。过夜无人值守请安装 OS clock：agent-worker scheduler clock install --repo .";
+/**
+ * Optional Console-foreground scheduler ticker.
+ * Spawns sibling `agent-worker scheduler tick` so long dispatches do not block
+ * the Console HTTP event loop the way an in-process await would.
+ */
+export class NightAuxTicker {
+    deps;
+    enabled = false;
+    timer = null;
+    inFlight = false;
+    intervalSec;
+    now;
+    lastAttemptAt = null;
+    lastCompletedAt = null;
+    lastOutcome = null;
+    lastError = null;
+    lastSummary = null;
+    constructor(deps) {
+        this.deps = deps;
+        this.intervalSec = Math.max(15, Math.min(3600, deps.intervalSec ?? DEFAULT_CLOCK_INTERVAL_SEC));
+        this.now = deps.now ?? (() => new Date());
+    }
+    status() {
+        return {
+            schemaVersion: 1,
+            enabled: this.enabled,
+            running: this.inFlight,
+            intervalSec: this.intervalSec,
+            scope: "console-foreground",
+            disclaimer: NIGHT_AUX_TICKER_DISCLAIMER,
+            lastAttemptAt: this.lastAttemptAt,
+            lastCompletedAt: this.lastCompletedAt,
+            lastOutcome: this.lastOutcome,
+            lastError: this.lastError,
+            lastSummary: this.lastSummary,
+        };
+    }
+    setEnabled(enabled) {
+        if (enabled === this.enabled)
+            return this.status();
+        this.enabled = enabled;
+        if (enabled) {
+            this.startTimer();
+            void this.fire("enable");
+        }
+        else {
+            this.stopTimer();
+        }
+        return this.status();
+    }
+    dispose() {
+        this.enabled = false;
+        this.stopTimer();
+    }
+    startTimer() {
+        this.stopTimer();
+        this.timer = setInterval(() => {
+            void this.fire("interval");
+        }, this.intervalSec * 1000);
+        // Do not keep the process alive solely for the aux ticker.
+        this.timer.unref?.();
+    }
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    async fire(_reason) {
+        if (!this.enabled)
+            return;
+        if (this.inFlight) {
+            this.lastOutcome = "skipped";
+            this.lastSummary = "previous tick still running";
+            return;
+        }
+        this.inFlight = true;
+        this.lastAttemptAt = this.now().toISOString();
+        this.lastError = null;
+        try {
+            const result = await (this.deps.runTick
+                ? this.deps.runTick()
+                : this.defaultRunTick());
+            this.lastCompletedAt = this.now().toISOString();
+            if (result.ok) {
+                this.lastOutcome = "ok";
+                this.lastSummary = result.summary;
+                this.lastError = null;
+            }
+            else {
+                this.lastOutcome = "error";
+                this.lastSummary = result.summary;
+                this.lastError = result.error ?? result.summary;
+            }
+        }
+        catch (error) {
+            this.lastCompletedAt = this.now().toISOString();
+            this.lastOutcome = "error";
+            this.lastError = error instanceof Error ? error.message : String(error);
+            this.lastSummary = null;
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+    async defaultRunTick() {
+        const bin = resolveSiblingAgentWorkerBin();
+        const result = await this.deps.client.runExternal(bin, [
+            "scheduler",
+            "tick",
+            "--repo",
+            this.deps.repoRoot,
+            "--clock-source",
+            "manual",
+            "--json",
+        ], {
+            cwd: this.deps.repoRoot,
+            artifactName: "console-night-aux-tick",
+            expectJson: true,
+        });
+        if (!result.ok || result.exitCode !== 0) {
+            const message = (result.stderr || result.stdout || "").trim() ||
+                `scheduler tick exit ${result.exitCode}`;
+            return { ok: false, summary: message, error: message };
+        }
+        const json = result.json;
+        const claimed = Array.isArray(json?.claimed) ? json.claimed.length : 0;
+        const dispatched = Array.isArray(json?.dispatched)
+            ? json.dispatched.length
+            : 0;
+        const waiting = Array.isArray(json?.waiting) ? json.waiting.length : 0;
+        const skipped = Array.isArray(json?.skipped) ? json.skipped.length : 0;
+        return {
+            ok: true,
+            summary: `claimed=${claimed} dispatched=${dispatched} waiting=${waiting} skipped=${skipped}`,
+        };
+    }
+}

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

@@ -134,12 +134,10 @@ async function finalizeFromWorkerResult(operationId, result, deps) {
         artifactRefs,
         stdoutPreview: previewStdout,
         stderrPreview: previewStderr,
-        result: envelope ?? {
-            exitCode: result.exitCode,
-            ok: result.ok,
+        result: materializeOperationResult(result, envelope, {
             stdout: previewStdout,
             stderr: previewStderr,
-        },
+        }),
         errorCode: ok ? undefined : (envelope?.error?.code ?? "INTERNAL_ERROR"),
         errorMessage: ok
             ? undefined
@@ -166,6 +164,25 @@ function coerceEnvelope(result) {
     }
     return undefined;
 }
+/**
+ * Prefer OperatorCommandResultV1, then structured CLI JSON (e.g. admission
+ * reviewPacket), else a minimal exit preview. Losing CLI JSON breaks Console
+ * wizards that need scheduleId / gateToken after async operations.
+ */
+export function materializeOperationResult(result, envelope, previews) {
+    if (envelope)
+        return envelope;
+    const json = result.json;
+    if (json && typeof json === "object" && !Array.isArray(json)) {
+        return json;
+    }
+    return {
+        exitCode: result.exitCode,
+        ok: result.ok,
+        stdout: previews.stdout,
+        stderr: previews.stderr,
+    };
+}
 /** Fire-and-forget scheduler for accepted operations. */
 export function scheduleOperation(operationId, deps) {
     void runOperation(operationId, deps).catch((error) => {

package/dist/worker/console/operator-user-error.js

@@ -6,5 +6,17 @@ export function formatOperatorUserError(message) {
     if (/controller identity changed|package fingerprint changed|entry binary sha256 changed/i.test(raw)) {
         return "控制器版本已变更（Console 启动后代码被重新编译）。请重启 Console 后再试，一次会话中途不要升级/重建控制器。";
     }
+    if (/Pi session file missing or not openable|cannot reopen chat session .* no persisted Pi session file/i.test(raw)) {
+        return "该对话的 Pi 会话文件已丢失，无法恢复上下文。请新建对话继续（历史记录无法重开）。";
+    }
+    if (/reopened Pi sessionId mismatch/i.test(raw)) {
+        return "重开对话失败：Pi 会话身份与记录不一致（常见于会话文件丢失后被误建）。请新建对话继续。";
+    }
+    if (/base HEAD .+ != frozen baseCommit|exact-base|not a descendant of frozen baseCommit/i.test(raw)) {
+        return "主分支已相对夜间冻结的 baseCommit 前进，无法安全 fast-forward harvest。请人工核对后使用 Discard（必要时勾选强制），或改走日间合并流程。";
+    }
+    if (/force-required|requires --force/i.test(raw)) {
+        return "该终态需要强制 Discard。请确认后勾选强制再试。";
+    }
     return raw;
 }

package/dist/worker/console/recovery-cta.js

@@ -62,7 +62,7 @@ const CTA = {
         requiresReason: true,
         action: "dagRerun",
         lane: "dag",
-        guide: "子图重跑：需选起点且 plan 合格；含 writer 的早期节点常不可用",
+        guide: "终端失败默认首选：先 dagRerunPlan，plan 合格再 Human Gate 执行；provider 抖动/只读下游优先，勿无理由新开 task",
         commandHint: "loop-agent dag rerun --run-id <run-id> --from-node <node-id> --plan",
     },
     standaloneTaskRerun: {
@@ -71,8 +71,8 @@ const CTA = {
         requiresReason: true,
         action: "standaloneTaskRerun",
         lane: "dag",
-        guide: "整单重跑：失败类默认首选；需确认原因后提交",
-        commandHint: "loop-agent task advance <task-id> --json",
+        guide: "整单重跑：仅当 from-node plan 不合格（writer/decision/fingerprint）或契约/源真变时；需确认原因",
+        commandHint: "loop-agent dag rerun-task --run-id <run-id> --reason <text> --json",
     },
     workerTaskRetry: {
         id: "workerTaskRetry",
@@ -92,8 +92,8 @@ const MATRIX = {
     "verification-failed": [
         "report",
         "doctor",
-        "standaloneTaskRerun",
         "dagRerun",
+        "standaloneTaskRerun",
         "resume",
         "regenerate",
     ],
@@ -149,7 +149,7 @@ export function consoleRecoveryCtas(factClass) {
 }
 /**
  * Suggested primary CTA for the current fact class.
- * Prefer safe whole-task recovery over node rerun when early writers often block.
+ * Prefer node subgraph rerun (cheaper) over whole-task rerun; plan gate still fail-closes unsafe closures.
  */
 export function recommendedRecoveryCtaId(factClass) {
     const allowed = new Set(consoleRecoveryCtas(factClass).map((c) => c.id));
@@ -163,7 +163,7 @@ export function recommendedRecoveryCtaId(factClass) {
     switch (factClass) {
         case "terminal-failed":
         case "verification-failed":
-            return pick("standaloneTaskRerun", "dagRerun", "doctor", "report");
+            return pick("dagRerun", "standaloneTaskRerun", "doctor", "report");
         case "pause-on-human":
             return pick("doctor", "report");
         case "needs-reconcile":

package/dist/worker/console/routes.js

@@ -332,6 +332,59 @@ export async function serveConsoleStatic(req, res, ctx) {
     res.writeHead(200, headers);
     res.end(content);
 }
+async function handleNightAuxTickerGet(_req, res, ctx) {
+    const ticker = ctx.operator?.nightAuxTicker;
+    if (!ticker) {
+        sendJson(res, 503, {
+            ok: false,
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "night aux ticker unavailable",
+            },
+        });
+        return;
+    }
+    sendJson(res, 200, { ok: true, ticker: ticker.status() });
+}
+async function handleNightAuxTickerPost(req, res, ctx) {
+    const ticker = ctx.operator?.nightAuxTicker;
+    if (!ticker) {
+        sendJson(res, 503, {
+            ok: false,
+            error: {
+                code: "INTERNAL_ERROR",
+                message: "night aux ticker unavailable",
+            },
+        });
+        return;
+    }
+    let body;
+    try {
+        body = (await readJsonBody(req));
+    }
+    catch (error) {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return;
+    }
+    if (typeof body.enabled !== "boolean") {
+        sendJson(res, 400, {
+            ok: false,
+            error: {
+                code: "INVALID_INPUT",
+                message: "enabled (boolean) is required",
+            },
+        });
+        return;
+    }
+    const status = ticker.setEnabled(body.enabled);
+    sendJson(res, 200, { ok: true, ticker: status });
+}
 export async function handleConsoleOperatorRequest(req, res, ctx) {
     const method = (req.method ?? "GET").toUpperCase();
     const url = new URL(req.url ?? "/", "http://localhost");
@@ -357,6 +410,10 @@ export async function handleConsoleOperatorRequest(req, res, ctx) {
         await handleCreateOperation(req, res, ctx);
         return true;
     }
+    if (method === "GET" && pathname === "/api/operator/v1/night-aux-ticker") {
+        await handleNightAuxTickerGet(req, res, ctx);
+        return true;
+    }
     const opMatch = pathname.match(/^\/api\/operator\/v1\/operations\/([^/]+)(?:\/(events))?$/);
     if (opMatch) {
         const operationId = decodeURIComponent(opMatch[1]);
@@ -383,6 +440,10 @@ export async function handleConsoleOperatorRequest(req, res, ctx) {
             });
             return true;
         }
+        if (method === "POST" && pathname === "/api/operator/v1/night-aux-ticker") {
+            await handleNightAuxTickerPost(req, res, ctx);
+            return true;
+        }
         // Allow other operator POSTs only under known routes; unknown → 404
         sendJson(res, 404, {
             ok: false,