@tea-agent/loop-agent 0.40.0-next.9 → 0.40.0

package/dist/worker/console/chat/assistant-content.js

@@ -98,6 +98,13 @@ function isFinalAnswerBlock(block) {
 }
 export function splitFinalAssistantBlocks(blocks, options = {}) {
     const displayable = getDisplayableAssistantBlocks(blocks, options);
+    // A streaming Pi message is cumulative: a later update may append a toolCall
+    // after text that is already visible. Keep the whole live message in the
+    // chronological process subtree so that update appends the tool in place
+    // instead of reparenting the earlier text from answer -> process.
+    if (options.isStreaming) {
+        return { answerBlocks: [], processBlocks: displayable };
+    }
     let lastProcessIndex = -1;
     for (let i = displayable.length - 1; i >= 0; i--) {
         if (!isFinalAnswerBlock(displayable[i])) {

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

@@ -136,7 +136,7 @@ export function projectOperationForChat(operation) {
         state: operation.state,
         createdAt: operation.createdAt,
         updatedAt: operation.finishedAt ?? operation.startedAt ?? operation.createdAt,
-        inspectHref: `/inspect/?operationId=${encodeURIComponent(operation.operationId)}#/`,
+        inspectHref: `/#/inspect?operationId=${encodeURIComponent(operation.operationId)}`,
         ...(taskId ? { taskId } : {}),
         ...(dagRunId ? { dagRunId } : {}),
         ...(featureId ? { featureId } : {}),
@@ -381,12 +381,26 @@ function dropOneByPriority(ring) {
     const events = ring.events;
     if (events.length === 0)
         return undefined;
-    const textIndex = events.findIndex((event) => event.kind === "message_update");
+    // Keep the newest Goal snapshot/tombstone as the session's durable Goal
+    // source of truth. Otherwise a long thread could forget an active Goal or
+    // resurrect a cleared one after ring eviction.
+    let protectedGoalIndex = -1;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        if (events[index].kind === "goal_changed" ||
+            events[index].kind === "goal_cleared") {
+            protectedGoalIndex = index;
+            break;
+        }
+    }
+    const textIndex = events.findIndex((event, index) => index !== protectedGoalIndex && event.kind === "message_update");
     if (textIndex !== -1)
         return events.splice(textIndex, 1)[0];
-    const structuralIndex = events.findIndex((event) => event.kind !== "message_end");
+    const structuralIndex = events.findIndex((event, index) => index !== protectedGoalIndex && event.kind !== "message_end");
     if (structuralIndex !== -1)
         return events.splice(structuralIndex, 1)[0];
+    const anyUnprotected = events.findIndex((_event, index) => index !== protectedGoalIndex);
+    if (anyUnprotected !== -1)
+        return events.splice(anyUnprotected, 1)[0];
     return events.shift();
 }
 /**
@@ -430,6 +444,13 @@ const DEFAULT_MAX_EVENTS = 2000;
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
 /** Same-turn `message_update` events inside this window coalesce into one persisted event. */
 const DEFAULT_COALESCE_WINDOW_MS = 100;
+/** B5-1: `message_update` appends persist at most once per this window (driven
+ *  by the event `at` clock, same as coalescing — no timers involved). */
+const DEFAULT_PERSIST_DEBOUNCE_MS = 250;
+/** B5-1: hard cap on pending debounced `message_update` appends before an
+ *  interim flush is forced, so a fast stream never widens the loss window
+ *  unboundedly even if the `at` clock stalls. */
+const DEFAULT_PERSIST_MAX_PENDING_UPDATES = 250;
 /** Conservative per-event scale for the byte pre-check gate (UTF-8 multibyte ≤ 4 bytes/char × pretty-print expansion). */
 const BYTE_GATE_SCALE = 12;
 /** Fixed envelope slack (schema keys, turnCount, nextSeq, minSeq, turns) for the byte pre-check gate. */
@@ -632,6 +653,9 @@ export function createChatEventStore(options) {
     const maxBytes = options?.maxBytesPerSession ?? DEFAULT_MAX_BYTES;
     const coalesceWindowMs = options?.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS;
     const eventEpoch = options?.epoch?.trim() || LEGACY_EPOCH;
+    const persistWriter = options?.persistWriter ?? writeSecureJsonSync;
+    const persistDebounceMs = options?.persistDebounceMs ?? DEFAULT_PERSIST_DEBOUNCE_MS;
+    const persistMaxPendingUpdates = options?.persistMaxPendingUpdates ?? DEFAULT_PERSIST_MAX_PENDING_UPDATES;
     const persistenceDir = options?.appData?.chatEvents
         ? path.resolve(options.appData.chatEvents)
         : undefined;
@@ -642,6 +666,9 @@ export function createChatEventStore(options) {
     const turnCounts = new Map();
     /** Live subscribers per session. */
     const subscribers = new Map();
+    /** B5-1: sessions whose latest `message_update` appends are still waiting
+     *  for the next persist (debounced; structural events / turn changes flush). */
+    const pendingPersists = new Map();
     function persistedPath(sessionId) {
         return persistenceDir
             ? path.join(persistenceDir, `${safeSessionId(sessionId)}.json`)
@@ -709,7 +736,7 @@ export function createChatEventStore(options) {
             // current limits if it was written by an older config or hand-edited.
             enforceBounds(sessionId, ring);
             if (orphaned)
-                persist(sessionId, ring);
+                persistNow(sessionId, ring);
             return ring;
         }
         catch (error) {
@@ -763,11 +790,36 @@ export function createChatEventStore(options) {
             ring.minSeq = ring.events[0].seq;
         }
     }
-    function persist(sessionId, ring) {
+    /** Persist the full ring synchronously (atomic tmp+rename) and clear any
+     *  B5-1 pending-debounce marker for this session. */
+    function persistNow(sessionId, ring) {
         const file = persistedPath(sessionId);
+        pendingPersists.delete(sessionId);
         if (!file)
             return;
-        writeSecureJsonSync(file, ringPayload(sessionId, ring));
+        persistWriter(file, ringPayload(sessionId, ring));
+    }
+    /** B5-1: defer the persist of a `message_update` append. The window is driven
+     *  by the append `at` clock (mirroring `shouldCoalesce`) — a structural event,
+     *  turn change, elapsed window or the pending-count cap each force a real
+     *  flush, so a streaming turn no longer serializes the whole ring per token. */
+    function persistDebounced(sessionId, ring, atMs) {
+        const file = persistedPath(sessionId);
+        if (!file)
+            return;
+        const pending = pendingPersists.get(sessionId);
+        if (!pending) {
+            pendingPersists.set(sessionId, {
+                firstPendingAtMs: atMs,
+                pendingUpdates: 1,
+            });
+            return;
+        }
+        pending.pendingUpdates += 1;
+        if (atMs - pending.firstPendingAtMs >= persistDebounceMs ||
+            pending.pendingUpdates >= persistMaxPendingUpdates) {
+            persistNow(sessionId, ring);
+        }
     }
     function ringFor(sessionId) {
         let ring = rings.get(sessionId);
@@ -870,7 +922,7 @@ export function createChatEventStore(options) {
             };
             ring.turns.push(turn);
             ring.approxBytes += byteHint(turn);
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ok: true, turn: { ...turn }, created: true, idempotent: false };
         },
         setTurnState(sessionId, turnId, state, error) {
@@ -889,7 +941,7 @@ export function createChatEventStore(options) {
                 turn.error = error;
             ring.approxBytes +=
                 (JSON.stringify(turn).length - before) * BYTE_GATE_SCALE;
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ...turn };
         },
         markAbortRequested(sessionId, turnId, at) {
@@ -902,7 +954,7 @@ export function createChatEventStore(options) {
                 turn.abortRequestedAt = at ?? new Date().toISOString();
             ring.approxBytes +=
                 (JSON.stringify(turn).length - before) * BYTE_GATE_SCALE;
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ...turn };
         },
         findTurnByClientRequestId(sessionId, clientRequestId) {
@@ -962,7 +1014,23 @@ export function createChatEventStore(options) {
                 ring.approxBytes += byteHint(live);
             }
             enforceBounds(sessionId, ring);
-            persist(sessionId, ring);
+            // B5-1: only high-frequency `message_update` appends defer the persist;
+            // every other kind (message_end / tool_call / error / turn signals …)
+            // still persists synchronously. Because persistNow writes the FULL
+            // in-memory ring, one flush also lands any earlier pending updates in
+            // order — no two-phase flush is needed.
+            if (partial.kind === "message_update") {
+                const atMs = partial.at ? Date.parse(partial.at) : Date.now();
+                if (!Number.isNaN(atMs)) {
+                    persistDebounced(sessionId, ring, atMs);
+                }
+                else {
+                    persistNow(sessionId, ring);
+                }
+            }
+            else {
+                persistNow(sessionId, ring);
+            }
             const subs = subscribers.get(sessionId);
             if (subs) {
                 for (const fn of subs) {
@@ -1017,7 +1085,7 @@ export function createChatEventStore(options) {
             const ring = ringFor(sessionId);
             const next = (turnCounts.get(sessionId) ?? 0) + 1;
             turnCounts.set(sessionId, next);
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return next;
         },
         latestTurnId(sessionId) {
@@ -1043,6 +1111,9 @@ export function createChatEventStore(options) {
             rings.delete(sessionId);
             turnCounts.delete(sessionId);
             subscribers.delete(sessionId);
+            // B5-1: drop any debounced (not yet written) updates with the ring itself —
+            // the file is being deleted, so flushing first would only resurrect it.
+            pendingPersists.delete(sessionId);
             const file = persistedPath(sessionId);
             if (file)
                 rmSync(file, { force: true });

package/dist/worker/console/chat/goal-round-driver.js

@@ -0,0 +1,72 @@
+export function classifyGoalRoundAdmission(input) {
+    if (input.phase !== "active")
+        return { action: "idle", reason: "not-active" };
+    if (!input.armed)
+        return { action: "idle", reason: "disarmed" };
+    if (input.round >= input.maxRounds)
+        return { action: "idle", reason: "round-limit" };
+    if (input.hasQueuedUserTurn)
+        return { action: "wait", reason: "user-queue" };
+    if (input.hasActiveTurn || input.runtimeBusy)
+        return { action: "wait", reason: "turn-busy" };
+    if (input.operationBusy)
+        return { action: "wait", reason: "operation-busy" };
+    return { action: "ready" };
+}
+/**
+ * Small process-local wake coordinator. Durable Goal phase lives in the event
+ * stream; timers deliberately do not. A Console restart therefore cannot
+ * resume work until a human explicitly arms the Goal again.
+ */
+export class GoalRoundDriver {
+    drive;
+    waitMs;
+    timers = new Map();
+    running = new Set();
+    disposed = false;
+    constructor(drive, waitMs = 1_500) {
+        this.drive = drive;
+        this.waitMs = waitMs;
+    }
+    wake(sessionId, delayMs = 0) {
+        if (this.disposed || this.timers.has(sessionId) || this.running.has(sessionId))
+            return;
+        const timer = setTimeout(() => {
+            this.timers.delete(sessionId);
+            void this.run(sessionId);
+        }, Math.max(0, delayMs));
+        timer.unref?.();
+        this.timers.set(sessionId, timer);
+    }
+    cancel(sessionId) {
+        const timer = this.timers.get(sessionId);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(sessionId);
+    }
+    dispose() {
+        this.disposed = true;
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+    }
+    async run(sessionId) {
+        if (this.disposed || this.running.has(sessionId))
+            return;
+        this.running.add(sessionId);
+        let retry = false;
+        try {
+            const result = await this.drive(sessionId);
+            retry = result === "wait";
+        }
+        catch {
+            // The route-level driver disarms on unsafe failures. A thrown observer or
+            // transient read must not create a hot retry loop.
+        }
+        finally {
+            this.running.delete(sessionId);
+            if (retry)
+                this.wake(sessionId, this.waitMs);
+        }
+    }
+}

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

@@ -0,0 +1,300 @@
+import { randomUUID } from "node:crypto";
+export const DEFAULT_GOAL_MAX_ROUNDS = 32;
+function cloneGoal(goal) {
+    return structuredClone(goal);
+}
+export function normalizeGoalObjective(value) {
+    if (typeof value !== "string")
+        throw new Error("objective must be a string");
+    const objective = value.replace(/\r\n/g, "\n").trim();
+    if (!objective)
+        throw new Error("objective must not be empty");
+    if (objective.length > 8_000)
+        throw new Error("objective exceeds 8000 characters");
+    return objective;
+}
+export function isExplicitGoalCreationRequest(text) {
+    const normalized = text.trim().toLowerCase();
+    return (/^\/goal(?:\s|$)/i.test(normalized) ||
+        /(创建|新建|启动|开启|设定|设置).{0,10}(持续目标|goal)/i.test(normalized) ||
+        /(create|start|set up|enable).{0,16}\bgoal\b/i.test(normalized));
+}
+export function parseGoalSnapshot(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const item = value;
+    if (item.schemaVersion !== 1 ||
+        typeof item.goalId !== "string" ||
+        !item.goalId ||
+        !Number.isSafeInteger(item.revision) ||
+        (item.revision ?? 0) < 1 ||
+        typeof item.objective !== "string" ||
+        !item.objective.trim() ||
+        !["active", "paused", "blocked", "complete"].includes(item.phase) ||
+        !Number.isSafeInteger(item.round) ||
+        (item.round ?? -1) < 0 ||
+        !Number.isSafeInteger(item.maxRounds) ||
+        (item.maxRounds ?? 0) < 1 ||
+        typeof item.createdAt !== "string" ||
+        typeof item.updatedAt !== "string") {
+        return undefined;
+    }
+    return {
+        schemaVersion: 1,
+        goalId: item.goalId,
+        revision: item.revision,
+        objective: item.objective.trim(),
+        phase: item.phase,
+        round: item.round,
+        maxRounds: item.maxRounds,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+        ...(typeof item.lastTurnId === "string" && item.lastTurnId
+            ? { lastTurnId: item.lastTurnId }
+            : {}),
+        ...(typeof item.blocker === "string" && item.blocker.trim()
+            ? { blocker: item.blocker.trim() }
+            : {}),
+    };
+}
+export function projectCurrentGoal(events) {
+    let current = null;
+    for (const event of events) {
+        if (event.kind === "goal_cleared")
+            current = null;
+        if (event.kind === "goal_changed") {
+            const parsed = parseGoalSnapshot(event.data.goal);
+            if (parsed)
+                current = parsed;
+        }
+    }
+    return current ? cloneGoal(current) : null;
+}
+export function buildGoalCompactionInstructions(rawInstructions, goal) {
+    const reminder = goal
+        ? [
+            "Preserve this durable Goal snapshot in the compaction summary. Do not mark it complete or change its phase unless the Goal tool already did so:",
+            JSON.stringify(goal),
+        ].join("\n")
+        : undefined;
+    return [rawInstructions?.trim(), reminder]
+        .filter((item) => Boolean(item))
+        .join("\n\n") || undefined;
+}
+export function buildGoalContinuationContext(goal) {
+    if (!goal)
+        return undefined;
+    return [
+        "<current_goal>",
+        "This is the durable cross-turn Goal for this session. Continue working toward its objective without broadening user authorization.",
+        JSON.stringify(goal),
+        "Use get_goal to refresh it. Use update_goal with status=complete only when the objective is genuinely achieved and no required work remains; use blocked only when safe progress cannot continue.",
+        "</current_goal>",
+    ].join("\n");
+}
+export class GoalRegistry {
+    events;
+    armed = new Set();
+    modelCreateGrants = new Set();
+    constructor(events) {
+        this.events = events;
+    }
+    get(sessionId) {
+        const goal = projectCurrentGoal(this.events.snapshot(sessionId));
+        return goal ? { ...goal, armed: this.armed.has(sessionId) } : null;
+    }
+    startTurn(sessionId, userText) {
+        if (isExplicitGoalCreationRequest(userText))
+            this.modelCreateGrants.add(sessionId);
+        else
+            this.modelCreateGrants.delete(sessionId);
+    }
+    consumeModelCreateGrant(sessionId) {
+        const granted = this.modelCreateGrants.has(sessionId);
+        this.modelCreateGrants.delete(sessionId);
+        return granted;
+    }
+    create(input) {
+        let objective;
+        try {
+            objective = normalizeGoalObjective(input.objective);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: "GOAL_INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+        const existing = this.get(input.sessionId);
+        if (existing && existing.phase !== "complete") {
+            return {
+                ok: false,
+                code: "GOAL_ALREADY_EXISTS",
+                message: "an unfinished Goal already exists for this session",
+                goal: existing,
+            };
+        }
+        const maxRounds = Number.isSafeInteger(input.maxRounds)
+            ? Math.max(1, Math.min(128, input.maxRounds))
+            : DEFAULT_GOAL_MAX_ROUNDS;
+        const now = new Date().toISOString();
+        const goal = {
+            schemaVersion: 1,
+            goalId: randomUUID(),
+            revision: 1,
+            objective,
+            phase: "active",
+            round: 0,
+            maxRounds,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.events.append(input.sessionId, input.turnId ?? `${input.sessionId}:goal`, { kind: "goal_changed", data: { goal } });
+        if (input.arm !== false)
+            this.armed.add(input.sessionId);
+        return { ok: true, goal: { ...goal, armed: this.armed.has(input.sessionId) } };
+    }
+    update(input) {
+        const current = this.get(input.sessionId);
+        if (!current)
+            return { ok: false, code: "GOAL_NOT_FOUND", message: "Goal not found" };
+        if (current.goalId !== input.goalId)
+            return {
+                ok: false,
+                code: "GOAL_ID_CONFLICT",
+                message: "Goal id does not match the current session Goal",
+                goal: current,
+            };
+        if (current.revision !== input.expectedRevision)
+            return {
+                ok: false,
+                code: "GOAL_REVISION_CONFLICT",
+                message: `Goal revision changed: expected ${input.expectedRevision}, current ${current.revision}`,
+                goal: current,
+            };
+        let objective = current.objective;
+        if (input.objective !== undefined) {
+            try {
+                objective = normalizeGoalObjective(input.objective);
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    code: "GOAL_INVALID_INPUT",
+                    message: error instanceof Error ? error.message : String(error),
+                    goal: current,
+                };
+            }
+        }
+        const phase = input.phase ?? current.phase;
+        const blocker = typeof input.blocker === "string" ? input.blocker.trim().slice(0, 2_000) : "";
+        if (phase === "blocked" && !blocker && !current.blocker) {
+            return {
+                ok: false,
+                code: "GOAL_INVALID_INPUT",
+                message: "blocked Goal requires a concrete blocker",
+                goal: current,
+            };
+        }
+        const next = {
+            ...current,
+            revision: current.revision + 1,
+            objective,
+            phase,
+            updatedAt: new Date().toISOString(),
+            ...(phase === "blocked" && blocker
+                ? { blocker }
+                : current.blocker && phase === "blocked"
+                    ? { blocker: current.blocker }
+                    : {}),
+        };
+        delete next.armed;
+        if (phase !== "blocked")
+            delete next.blocker;
+        this.events.append(input.sessionId, input.turnId ?? current.lastTurnId ?? `${input.sessionId}:goal`, { kind: "goal_changed", data: { goal: next } });
+        if (phase !== "active" || input.arm === false)
+            this.armed.delete(input.sessionId);
+        else if (input.arm === true)
+            this.armed.add(input.sessionId);
+        return { ok: true, goal: { ...next, armed: this.armed.has(input.sessionId) } };
+    }
+    beginRound(input) {
+        const current = this.get(input.sessionId);
+        if (!current)
+            return { ok: false, code: "GOAL_NOT_FOUND", message: "Goal not found" };
+        if (current.round >= current.maxRounds) {
+            this.armed.delete(input.sessionId);
+            return {
+                ok: false,
+                code: "GOAL_ROUND_LIMIT",
+                message: `Goal reached its ${current.maxRounds}-round safety limit`,
+                goal: { ...current, armed: false },
+            };
+        }
+        if (current.goalId !== input.goalId)
+            return {
+                ok: false,
+                code: "GOAL_ID_CONFLICT",
+                message: "Goal id changed before the next round started",
+                goal: current,
+            };
+        if (current.revision !== input.expectedRevision)
+            return {
+                ok: false,
+                code: "GOAL_REVISION_CONFLICT",
+                message: `Goal revision changed: expected ${input.expectedRevision}, current ${current.revision}`,
+                goal: current,
+            };
+        const next = {
+            ...current,
+            revision: current.revision + 1,
+            round: current.round + 1,
+            lastTurnId: input.turnId,
+            updatedAt: new Date().toISOString(),
+        };
+        delete next.armed;
+        this.events.append(input.sessionId, input.turnId, {
+            kind: "goal_changed",
+            data: { goal: next },
+        });
+        return { ok: true, goal: { ...next, armed: this.armed.has(input.sessionId) } };
+    }
+    clear(input) {
+        const current = this.get(input.sessionId);
+        if (!current)
+            return { ok: false, code: "GOAL_NOT_FOUND", message: "Goal not found" };
+        if (current.goalId !== input.goalId || current.revision !== input.expectedRevision) {
+            return {
+                ok: false,
+                code: current.goalId !== input.goalId
+                    ? "GOAL_ID_CONFLICT"
+                    : "GOAL_REVISION_CONFLICT",
+                message: "Goal changed before it could be cleared",
+                goal: current,
+            };
+        }
+        this.armed.delete(input.sessionId);
+        this.events.append(input.sessionId, input.turnId ?? current.lastTurnId ?? `${input.sessionId}:goal`, { kind: "goal_cleared", data: {} });
+        return { ok: true, goal: { ...current, armed: false } };
+    }
+    arm(sessionId) {
+        const goal = this.get(sessionId);
+        if (!goal || goal.phase !== "active" || goal.round >= goal.maxRounds)
+            return goal;
+        this.armed.add(sessionId);
+        return { ...goal, armed: true };
+    }
+    disarm(sessionId) {
+        this.armed.delete(sessionId);
+        const goal = this.get(sessionId);
+        return goal ? { ...goal, armed: false } : null;
+    }
+    isArmed(sessionId) {
+        return this.armed.has(sessionId);
+    }
+    clearRuntime(sessionId) {
+        this.armed.delete(sessionId);
+        this.modelCreateGrants.delete(sessionId);
+    }
+}