@tea-agent/loop-agent 0.43.0-next.18 → 0.43.0-next.19

package/dist/worker/console/chat/session-store.js

@@ -477,6 +477,24 @@ export class ChatSessionStore {
             };
         });
     }
+    /** Idempotent persistent delivery, serialized with normal Chat updates. */
+    async appendScheduledGoalResult(sessionId, resultKey, text) {
+        if (!/^[a-zA-Z0-9_-]+$/.test(sessionId) || !/^[a-f0-9]{64}$/.test(resultKey))
+            throw new Error("invalid scheduled goal delivery identity");
+        return this.serialize(sessionId, async () => {
+            const record = await this.get(sessionId);
+            if (!record)
+                return false;
+            const id = `scheduled-goal-${resultKey}`;
+            if (record.messages.some((message) => message.id === id))
+                return true;
+            const at = new Date().toISOString();
+            record.messages.push({ id, role: "assistant", text, at });
+            record.updatedAt = at;
+            await this.persist(record);
+            return true;
+        });
+    }
     async appendMessage(sessionId, message) {
         return this.serialize(sessionId, async () => {
             const record = await this.get(sessionId);
@@ -637,21 +655,36 @@ export async function runChatTurn(options) {
             // never observes agent_settled before its accepted operation ref.
             settledEvent = event;
         }
+        else if (event.type === "message_end") {
+            // Persist the assistant bubble FIRST so the SSE frame and the restore
+            // projection share the same durable message id (2026-09-13). The text-
+            // match + 30s window in projectStoredMessagesWithEventOrder was the only
+            // bridge left between the two, and it mis-aligned on duplicate text.
+            let messageId;
+            try {
+                const stored = await store.appendMessage(sessionId, {
+                    role: "assistant",
+                    text: event.text,
+                    ...(event.content && event.content.length > 0
+                        ? { content: event.content }
+                        : {}),
+                });
+                messageId = stored.id;
+            }
+            catch {
+                // Persistence failure must not swallow the SSE frame — the client
+                // still needs the terminal text even if the durable row is absent.
+            }
+            options.onEvent?.(messageId ? { ...event, messageId } : event);
+        }
         else {
             options.onEvent?.(event);
         }
         switch (event.type) {
             case "message_update":
             case "message_end":
-                if (event.type === "message_end") {
-                    pending.push(store.appendMessage(sessionId, {
-                        role: "assistant",
-                        text: event.text,
-                        ...(event.content && event.content.length > 0
-                            ? { content: event.content }
-                            : {}),
-                    }));
-                }
+                // message_update carries no durable row; message_end was already
+                // persisted + framed above. Nothing further to persist here.
                 break;
             case "tool_call":
                 // Forwarded to the caller (SSE) for UI feedback. The actual tool

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/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/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";
@@ -886,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();
@@ -1077,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 };
         }

package/dist/worker/console/prd-intake-bridge.js

@@ -119,6 +119,33 @@ export function parseEngineeringBoundaryFromParams(p) {
     };
     const allowedPaths = asList(p.allowedPaths ?? p.allowedPath);
     const forbiddenPaths = asList(p.forbiddenPaths ?? p.forbiddenPath);
+    const capabilityBoundaryRaw = p.capabilityBoundary;
+    const capabilityBoundary = capabilityBoundaryRaw && typeof capabilityBoundaryRaw === "object" && !Array.isArray(capabilityBoundaryRaw)
+        ? {
+            allowed: Array.isArray(capabilityBoundaryRaw.allowed)
+                ? capabilityBoundaryRaw.allowed.filter((x) => typeof x === "string" && x.trim().length > 0)
+                : undefined,
+            forbidden: Array.isArray(capabilityBoundaryRaw.forbidden)
+                ? capabilityBoundaryRaw.forbidden.filter((x) => typeof x === "string" && x.trim().length > 0)
+                : undefined,
+        }
+        : undefined;
+    const interactionIds = asList(p.interactionIds ?? p.interactionId);
+    const requirementOwnership = Array.isArray(p.requirementOwnership)
+        ? p.requirementOwnership
+            .map((entry) => ({
+            requirementIds: Array.isArray(entry.requirementIds)
+                ? entry.requirementIds.filter((id) => typeof id === "string" && id.trim().length > 0)
+                : [],
+            implementationFiles: Array.isArray(entry.implementationFiles)
+                ? entry.implementationFiles.filter((f) => typeof f === "string" && f.trim().length > 0)
+                : undefined,
+            verificationFiles: Array.isArray(entry.verificationFiles)
+                ? entry.verificationFiles.filter((f) => typeof f === "string" && f.trim().length > 0)
+                : undefined,
+        }))
+            .filter((entry) => entry.requirementIds.length > 0)
+        : undefined;
     const verifyRaw = p.verifyCommands ?? p.verify;
     const verifyCommands = [];
     if (Array.isArray(verifyRaw)) {
@@ -175,6 +202,11 @@ export function parseEngineeringBoundaryFromParams(p) {
         ...(allowedPaths.length > 0 ? { allowedPaths } : {}),
         ...(forbiddenPaths.length > 0 ? { forbiddenPaths } : {}),
         ...(verifyCommands.length > 0 ? { verifyCommands } : {}),
+        ...(requirementOwnership?.length ? { requirementOwnership } : {}),
+        ...(capabilityBoundary && ((capabilityBoundary.allowed?.length ?? 0) + (capabilityBoundary.forbidden?.length ?? 0)) > 0
+            ? { capabilityBoundary }
+            : {}),
+        ...(interactionIds.length > 0 ? { interactionIds } : {}),
     };
 }
 export function appendEngineeringCliArgs(args, boundary) {
@@ -187,17 +219,38 @@ export function appendEngineeringCliArgs(args, boundary) {
     for (const cmd of boundary.verifyCommands ?? []) {
         args.push("--verify", `${cmd.label}:${cmd.command}`);
     }
+    if (boundary.requirementOwnership?.length) {
+        args.push("--requirement-ownership", JSON.stringify(boundary.requirementOwnership));
+    }
+    if (boundary.capabilityBoundary) {
+        args.push("--capability-boundary", JSON.stringify(boundary.capabilityBoundary));
+    }
+    for (const id of boundary.interactionIds ?? []) {
+        args.push("--interaction-ids", id);
+    }
 }
 export function applyEngineeringBoundaryToDraft(draft, boundary) {
     const allowedPaths = filterPlaceholderPaths(boundary.allowedPaths);
     const forbiddenPaths = filterPlaceholderPaths(boundary.forbiddenPaths);
     if (allowedPaths.length === 0 &&
         forbiddenPaths.length === 0 &&
-        !(boundary.verifyCommands?.length)) {
+        !(boundary.verifyCommands?.length) &&
+        !(boundary.requirementOwnership?.length) &&
+        !boundary.capabilityBoundary &&
+        !(boundary.interactionIds?.length)) {
         return draft;
     }
     return {
         ...draft,
+        ...(boundary.requirementOwnership?.length
+            ? { requirementOwnership: boundary.requirementOwnership }
+            : {}),
+        ...(boundary.capabilityBoundary
+            ? { capabilityBoundary: boundary.capabilityBoundary }
+            : {}),
+        ...(boundary.interactionIds?.length
+            ? { interactionIds: boundary.interactionIds }
+            : {}),
         constraints: {
             invariants: draft.constraints?.invariants ?? [],
             allowedPaths: allowedPaths.length > 0

package/dist/worker/console/scheduled-goal-host.js

@@ -0,0 +1,98 @@
+import { dispatchScheduledGoalOperation } from "./scheduled-goal-operation-adapter.js";
+import { assessScheduledGoal, continueScheduledGoal } from "../scheduler/scheduled-goal-supervisor.js";
+import { evaluateScheduledGoalWake } from "../scheduler/scheduled-goal-time.js";
+/** Background operation ownership, independent of a browser or an interactive Chat turn.
+ * Every wake rebuilds decisions from the ledger; timers carry no authorization.
+ * No stale takeover: reserved work is observed, never re-issued.
+ */
+export class ScheduledGoalHost {
+    deps;
+    timer;
+    active;
+    stopped = true;
+    constructor(deps) {
+        this.deps = deps;
+        if (deps.intervalMs !== undefined && (!Number.isFinite(deps.intervalMs) || deps.intervalMs < 100))
+            throw new Error("invalid scheduled goal wake interval");
+    }
+    start() {
+        if (!this.stopped)
+            return;
+        this.stopped = false;
+        this.wake();
+    }
+    /** Nonblocking. The host retains the operation promise until it settles. */
+    wake() {
+        if (this.stopped || this.active)
+            return;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        this.active = this.tick().catch((error) => this.deps.onError?.(undefined, error)).finally(() => {
+            this.active = undefined;
+            if (!this.stopped) {
+                this.timer = setTimeout(() => { this.timer = undefined; this.wake(); }, this.deps.intervalMs ?? 5000);
+                this.timer.unref?.();
+            }
+        });
+    }
+    /** Stop future admissions. Existing children keep their operation ownership. */
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+    async waitForIdle() { await this.active; }
+    async tick() {
+        for (const snapshot of await this.deps.goals.list()) {
+            if (this.stopped)
+                return;
+            try {
+                await this.advance(snapshot.goalId);
+            }
+            catch (error) {
+                this.deps.onError?.(snapshot.goalId, error);
+            }
+        }
+    }
+    async advance(goalId) {
+        const { goals } = this.deps;
+        let goal = await goals.get(goalId);
+        if (!goal.approval)
+            return;
+        const intent = goal.intents.at(-1);
+        if (intent && ["dispatching", "associated", "unknown"].includes(intent.state)) {
+            await dispatchScheduledGoalOperation(goalId, this.deps);
+            goal = await goals.get(goalId);
+        }
+        if (this.stopped)
+            return;
+        if (["cancelled", "blocked", "budget_exhausted", "unknown"].includes(goal.state)) {
+            await this.deps.deliver?.(goal);
+            return;
+        }
+        goal = await goals.refreshAcceptance(goalId);
+        goal = await goals.settleIdleGoal(goalId, this.deps.now?.());
+        if (["accepted", "cancelled", "blocked", "budget_exhausted", "unknown"].includes(goal.state)) {
+            await this.deps.deliver?.(goal);
+            return;
+        }
+        if (goal.assessmentAttempt || goal.supervisions.some((entry) => ["requested", "preparing", "unknown"].includes(entry.state)))
+            return;
+        const current = goal.intents.at(-1);
+        if (!current || current.state === "prepared") {
+            if (evaluateScheduledGoalWake(goal.frozen.time, this.deps.now?.() ?? new Date()).kind === "due")
+                await dispatchScheduledGoalOperation(goalId, this.deps);
+            return;
+        }
+        if (current.state !== "terminal")
+            return;
+        if (goal.acceptanceState === "failed") {
+            await continueScheduledGoal(goalId, goals, this.deps.client);
+            return;
+        }
+        await assessScheduledGoal(goalId, goals, { now: this.deps.now });
+    }
+}