@tea-agent/loop-agent 0.44.0-next.13 → 0.44.0-next.14

package/dist/worker/console/chat/browser-automation.js

@@ -57,8 +57,18 @@ export class BrowserAutomationService {
     disposed = false;
     dialogQueue = [];
     downloadQueue = [];
+    mirrorPage;
+    mirrorSession;
+    mirrorSeq = 0;
+    mirrorFrame;
     constructor(options) {
         this.options = options;
+        // The visible window stays the default so human picking works out of the
+        // box. LOOP_BROWSER_HEADLESS=1 (or "true"/"on") switches the browser to a
+        // background (headless) instance that never opens a window.
+        if (this.options.headless === undefined) {
+            this.options.headless = browserHeadlessEnabled();
+        }
     }
     /** Runtime entrypoint: tools and HTTP must enter once, binding the target before queuing. */
     run(input, operation) {
@@ -156,13 +166,14 @@ export class BrowserAutomationService {
      */
     async state() {
         if (!this.browserPromise && !this.disposed)
-            return emptyBrowserState();
+            return { ...emptyBrowserState(), headless: this.options.headless === true };
         // Polling never starts a context, changes selection, or waits on a quarantined page.
         const page = this.operations.current?.target.page ?? this.activePage;
         if (!page || page.isClosed())
-            return { ...emptyBrowserState(), running: !!this.browserPromise, tabs: await this.tabSummaries() };
+            return { ...emptyBrowserState(), running: !!this.browserPromise, headless: this.options.headless === true, tabs: await this.tabSummaries() };
         const state = {
             running: true,
+            headless: this.options.headless === true,
             tabId: this.trackPage(page),
             url: page.url(),
             title: this.recovering.has(page) ? "Page busy — script may still be running" : await page.title().catch(() => ""),
@@ -172,6 +183,36 @@ export class BrowserAutomationService {
         };
         return state;
     }
+    /**
+     * Passive screencast frame of the active page for the panel mirror view.
+     * Like state(), polling never launches the browser and never touches the
+     * operation queue, so a stuck page cannot block the panel.
+     */
+    async panelFrame(since = 0) {
+        if (!this.browserPromise || this.disposed) {
+            await this.stopMirror().catch(() => undefined);
+            return { running: false, changed: false, seq: this.mirrorSeq };
+        }
+        const page = this.operations.current?.target.page ?? this.activePage;
+        if (!page || page.isClosed()) {
+            return { running: true, changed: false, seq: this.mirrorSeq };
+        }
+        if (page !== this.mirrorPage || !this.mirrorSession) {
+            await this.startMirror(page);
+        }
+        const frame = this.mirrorFrame;
+        if (!frame || this.mirrorSeq <= since) {
+            return { running: true, changed: false, seq: this.mirrorSeq };
+        }
+        return {
+            running: true,
+            changed: true,
+            seq: this.mirrorSeq,
+            url: page.url(),
+            title: await page.title().catch(() => ""),
+            image: `data:image/jpeg;base64,${frame.data}`,
+        };
+    }
     async search(rawQuery, rawUrl) {
         const query = rawQuery.trim();
         if (!query)
@@ -346,7 +387,14 @@ export class BrowserAutomationService {
     async screenshot(options) {
         return this.snapshot({ ...options, screenshot: true });
     }
+    /** True when this service runs a visible browser instead of the background default. */
+    get visibleBrowser() {
+        return this.options.headless === false;
+    }
     async focus() {
+        if (!this.visibleBrowser) {
+            throw new BrowserAutomationError("HEADLESS_NO_WINDOW", "浏览器正在后台运行（LOOP_BROWSER_HEADLESS=1），没有可聚焦的窗口；取消该设置并重启 Console 可恢复可见窗口，或在右侧面板预览当前页面");
+        }
         const page = await this.page();
         await page.bringToFront();
         return { ok: true };
@@ -358,7 +406,7 @@ export class BrowserAutomationService {
     }
     async pick(input) {
         if (this.options.headless === true)
-            throw new BrowserAutomationError("PICK_UNAVAILABLE", "human picking requires the visible external browser");
+            throw new BrowserAutomationError("PICK_UNAVAILABLE", "human picking requires the visible external browser; unset LOOP_BROWSER_HEADLESS (or set it to 0) and restart the console to launch one");
         const page = await this.page();
         await page.bringToFront();
         const element = await pickBrowserElement(page, input.message, clamp(input.timeoutMs ?? 30_000, 1, 60_000), this.operations.current?.signal).catch((error) => {
@@ -480,6 +528,7 @@ export class BrowserAutomationService {
         if (this.disposed)
             return;
         this.disposed = true;
+        await this.stopMirror().catch(() => undefined);
         const pending = this.browserPromise;
         this.browserPromise = undefined;
         this.diagnostics.reset();
@@ -581,6 +630,9 @@ export class BrowserAutomationService {
                         this.dialogQueue.length = 0;
                         this.downloadQueue.length = 0;
                         this.tabs.clear();
+                        this.mirrorPage = undefined;
+                        this.mirrorSession = undefined;
+                        this.mirrorFrame = undefined;
                     }
                 });
             }
@@ -628,9 +680,53 @@ export class BrowserAutomationService {
             this.tabs.delete(id);
             if (this.activePage === page)
                 this.activePage = undefined;
+            if (this.mirrorPage === page) {
+                this.mirrorPage = undefined;
+                this.mirrorSession = undefined;
+                this.mirrorFrame = undefined;
+            }
         });
         return id;
     }
+    /** Attaches a CDP screencast to the page, replacing any previous session. */
+    async startMirror(page) {
+        await this.stopMirror();
+        this.mirrorFrame = undefined;
+        try {
+            const session = await page.context().newCDPSession(page);
+            session.on("Page.screencastFrame", (frame) => {
+                this.mirrorSeq += 1;
+                this.mirrorFrame = { data: frame.data };
+                void session.send("Page.screencastFrameAck", { sessionId: frame.sessionId }).catch(() => undefined);
+            });
+            await session.send("Page.startScreencast", {
+                format: "jpeg",
+                quality: 85,
+                maxWidth: BROWSER_VIEWPORT_WIDTH,
+                maxHeight: BROWSER_VIEWPORT_HEIGHT,
+                everyNthFrame: 1,
+            });
+            this.mirrorSession = session;
+            this.mirrorPage = page;
+        }
+        catch {
+            await this.stopMirror().catch(() => undefined);
+        }
+    }
+    async stopMirror() {
+        const session = this.mirrorSession;
+        this.mirrorSession = undefined;
+        this.mirrorPage = undefined;
+        if (!session)
+            return;
+        try {
+            await session.send("Page.stopScreencast");
+        }
+        catch {
+            // The session may already be gone with its page or context.
+        }
+        await session.detach().catch(() => undefined);
+    }
     dialogFor(page) {
         const index = this.dialogQueue.findIndex((entry) => entry.page === page);
         const dialog = index >= 0 ? this.dialogQueue[index]?.dialog : undefined;
@@ -729,17 +825,30 @@ function emptyBrowserState() {
         ariaSnapshot: "",
     };
 }
-function chromiumLaunchOptions(headless) {
+/** Linux GitHub runners (and similar CI) have no usable Chromium sandbox. */
+export function chromiumSandboxEnabled(env = process.env) {
+    return env.GITHUB_ACTIONS !== "true" && env.CI !== "true";
+}
+export function chromiumLaunchOptions(headless, env = process.env) {
     return {
         headless: headless ?? false,
         viewport: undefined,
         acceptDownloads: true,
         locale: "zh-CN",
         timezoneId: "Asia/Shanghai",
-        args: ["--start-maximized", "--disable-blink-features=AutomationControlled"],
+        // Desktop: drop Playwright's implicit --no-sandbox so Chrome does not show
+        // the "unsupported command-line flag" infobar. CI Linux has no usable
+        // user-namespace sandbox, so keep Playwright's --no-sandbox there.
+        chromiumSandbox: chromiumSandboxEnabled(env),
+        args: ["--disable-blink-features=AutomationControlled"],
         ignoreDefaultArgs: ["--enable-automation"],
     };
 }
+/** LOOP_BROWSER_HEADLESS=1/true/on runs the browser in the background (headless). */
+export function browserHeadlessEnabled(env = process.env) {
+    const raw = env.LOOP_BROWSER_HEADLESS?.trim().toLowerCase();
+    return raw === "1" || raw === "true" || raw === "on";
+}
 /**
  * Bounded settle after a committed navigation. `domcontentloaded` fires before
  * late client-side redirects (for example an engine that reroutes to a regional

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

@@ -1,6 +1,8 @@
 /**
  * HTTP API for the workspace-controlled external browser. The sidebar iframe
  * is an independent preview; these endpoints operate the Playwright page.
+ * `GET panel/frame` additionally serves passive screencast frames so the
+ * panel can mirror the shared window (same context, login state included).
  */
 import { embeddabilityOf, extractFrameAncestors, normalizeBrowserUrl, } from "./browser-policy.js";
 function workspaceIdOf(req) {
@@ -170,6 +172,25 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
                 clearTimeout(timer);
             }
         }
+        if (method === "GET" && sub === "panel" && parts[1] === "frame") {
+            const scope = requireScope(req, deps);
+            if (!scope.ok) {
+                sendJson(res, scope.status, {
+                    ok: false,
+                    error: { code: scope.code, message: scope.message },
+                });
+                return true;
+            }
+            if (!deps.automation) {
+                sendJson(res, 200, { ok: true, data: { running: false, changed: false, seq: 0 } });
+                return true;
+            }
+            const sinceRaw = new URL(req.url ?? "/", "http://localhost").searchParams.get("since");
+            const parsed = sinceRaw === null ? 0 : Number(sinceRaw);
+            const frame = await deps.automation.panelFrame(Number.isFinite(parsed) ? parsed : 0);
+            sendJson(res, 200, { ok: true, data: frame });
+            return true;
+        }
         if (method === "POST" && parts.length >= 1) {
             const scope = requireScope(req, deps);
             if (!scope.ok) {

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

@@ -502,8 +502,8 @@ const DEFAULT_PERSIST_DEBOUNCE_MS = 250;
  *  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;
+/** Conservative per-event scale for the byte pre-check gate (UTF-8 multibyte ≤ 4 bytes/char). Persist is compact JSON, so this is no longer multiplied by pretty-print expansion. */
+const BYTE_GATE_SCALE = 4;
 /** Fixed envelope slack (schema keys, turnCount, nextSeq, minSeq, turns) for the byte pre-check gate. */
 const BYTE_GATE_SLACK = 8192;
 /** Legacy epoch for event files written before M5.1 (no epoch field). */
@@ -704,7 +704,8 @@ 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 persistWriter = options?.persistWriter ??
+        ((file, payload) => writeSecureJsonSync(file, payload, { pretty: false }));
     const persistDebounceMs = options?.persistDebounceMs ?? DEFAULT_PERSIST_DEBOUNCE_MS;
     const persistMaxPendingUpdates = options?.persistMaxPendingUpdates ?? DEFAULT_PERSIST_MAX_PENDING_UPDATES;
     const persistenceDir = options?.appData?.chatEvents
@@ -807,10 +808,10 @@ export function createChatEventStore(options) {
             epoch: ring.epoch,
         };
     }
-    /** Serialized exactly as `writeSecureJsonSync` writes it, so byte accounting
-     *  (D4) and the on-disk bytes use the same formatting. */
+    /** Serialized exactly as compact `writeSecureJsonSync` writes it, so byte
+     *  accounting (D4) and the on-disk bytes use the same formatting. */
     function serializeRingForPersist(sessionId, ring) {
-        return `${JSON.stringify(ringPayload(sessionId, ring), null, 2)}\n`;
+        return `${JSON.stringify(ringPayload(sessionId, ring))}\n`;
     }
     function bytesOfRing(sessionId, ring) {
         return Buffer.byteLength(serializeRingForPersist(sessionId, ring), "utf8");

package/dist/worker/console/chat/context-insights.js

@@ -261,6 +261,52 @@ export function deriveContextInsights(events, options = {}) {
     const browserMessages = [];
     const browserInjected = [];
     const browserToolResults = [];
+    const liveNodes = [];
+    /** Nodes removed by a prune/compaction, newest last, for the prune card. */
+    const archivedNodes = [];
+    /** Remove the ledger nodes whose seq the removal claims; deduct slices and browser rows. */
+    function claimNodes(claimed, removedAtSeq) {
+        if (claimed.size === 0)
+            return [];
+        const removedIds = [];
+        const kept = [];
+        for (const node of liveNodes) {
+            if (claimed.has(node.seq)) {
+                const slice = sliceOf(composition, node.category);
+                slice.tokens = Math.max(0, slice.tokens - node.tokens);
+                slice.items = Math.max(0, slice.items - 1);
+                archivedNodes.push({ ...node, removedAt: removedAtSeq });
+                removedIds.push(node.element.id);
+            }
+            else {
+                kept.push(node);
+            }
+        }
+        if (removedIds.length > 0) {
+            liveNodes.length = 0;
+            liveNodes.push(...kept);
+            const drop = (list) => {
+                for (let i = list.length - 1; i >= 0; i -= 1) {
+                    const row = list[i];
+                    if (row && claimed.has(row.seq))
+                        list.splice(i, 1);
+                }
+            };
+            drop(browserMessages);
+            drop(browserToolResults);
+            drop(browserInjected);
+        }
+        return removedIds;
+    }
+    /** Parse "<sessionId>:<seq>" entry ids into a keep-from seq anchor. */
+    function entrySeqOf(entryId) {
+        if (typeof entryId !== "string" || !entryId)
+            return undefined;
+        const idx = entryId.lastIndexOf(":");
+        const tail = idx >= 0 ? entryId.slice(idx + 1) : entryId;
+        const seq = Number.parseInt(tail, 10);
+        return Number.isInteger(seq) && seq >= 0 ? seq : undefined;
+    }
     if (options.systemPromptPreview) {
         addSlice(composition, "system", estimateTokensFromText(options.systemPromptPreview));
     }
@@ -306,14 +352,16 @@ export function deriveContextInsights(events, options = {}) {
                 if (text) {
                     const tokens = estimateTokensFromText(text);
                     addSlice(composition, "user", tokens);
-                    browserMessages.push({
+                    const element = {
                         id: `user:${event.seq}`,
                         label: "用户",
                         tokens,
                         preview: text,
                         seq: event.seq,
                         at: event.at,
-                    });
+                    };
+                    browserMessages.push(element);
+                    liveNodes.push({ seq: event.seq, tokens, category: "user", element });
                     if (!turnUserBrief.has(event.turnId)) {
                         turnUserBrief.set(event.turnId, text.slice(0, 200));
                     }
@@ -338,14 +386,16 @@ export function deriveContextInsights(events, options = {}) {
                     if (text) {
                         const tokens = estimateTokensFromText(text);
                         addSlice(composition, "assistant", tokens);
-                        browserMessages.push({
+                        const element = {
                             id: `assistant:${event.seq}`,
                             label: thinking ? "助手（含思考）" : "助手",
                             tokens,
                             preview: text,
                             seq: event.seq,
                             at: event.at,
-                        });
+                        };
+                        browserMessages.push(element);
+                        liveNodes.push({ seq: event.seq, tokens, category: "assistant", element });
                     }
                     const toolsCalled = stepToolsCalled.get(event.turnId) ?? [];
                     const recorded = asRecord(data.timing);
@@ -474,7 +524,7 @@ export function deriveContextInsights(events, options = {}) {
                 if (resultPreview) {
                     const tokens = estimateTokensFromText(resultPreview);
                     addSlice(composition, "toolResults", tokens);
-                    browserToolResults.push({
+                    const element = {
                         id: `result:${event.seq}`,
                         label: typeof data.toolName === "string" && data.toolName
                             ? data.toolName
@@ -484,7 +534,9 @@ export function deriveContextInsights(events, options = {}) {
                         status: data.isError === true ? "error" : "ok",
                         seq: event.seq,
                         at: event.at,
-                    });
+                    };
+                    browserToolResults.push(element);
+                    liveNodes.push({ seq: event.seq, tokens, category: "toolResults", element });
                 }
                 break;
             }
@@ -531,6 +583,30 @@ export function deriveContextInsights(events, options = {}) {
                 const after = num(data.estimatedTokensAfter);
                 const reclaimed = before !== undefined && after !== undefined ? before - after : null;
                 const pruned = data.pruned === true || data.kind === "prune";
+                // --- Exact removal (dsh-context parity) ---
+                // A prune/compaction claims live nodes either by explicit seq list
+                // (shadowedSeqs) or by a keep-from anchor (firstKeptEntryId = the
+                // first ring entry that survives). Claim exactly those nodes from
+                // the ledger: deduct slices, drop browser rows, archive the nodes.
+                const explicitSeqs = Array.isArray(data.shadowedSeqs)
+                    ? data.shadowedSeqs.filter((value) => typeof value === "number" && Number.isInteger(value) && value >= 0)
+                    : undefined;
+                const keepFromSeq = entrySeqOf(data.firstKeptEntryId);
+                let removedIds = [];
+                let removalBasis;
+                if (explicitSeqs && explicitSeqs.length > 0) {
+                    removedIds = claimNodes(new Set(explicitSeqs), event.seq);
+                    removalBasis = "seqs";
+                }
+                else if (keepFromSeq !== undefined && liveNodes.length > 0) {
+                    const rangeSeqs = new Set();
+                    for (const node of liveNodes) {
+                        if (node.seq < keepFromSeq)
+                            rangeSeqs.add(node.seq);
+                    }
+                    removedIds = claimNodes(rangeSeqs, event.seq);
+                    removalBasis = "range";
+                }
                 contextEvents.push({
                     seq: event.seq,
                     at: event.at,
@@ -548,25 +624,14 @@ export function deriveContextInsights(events, options = {}) {
                     ...(Array.isArray(data.shadowedSeqs) ? { shadowedItems: data.shadowedSeqs.length } : {}),
                     ...(typeof data.reason === "string" ? { reason: data.reason } : {}),
                     ...(pruned ? { pruned: true } : {}),
+                    ...(removedIds.length > 0 ? { removedIds } : {}),
+                    ...(removalBasis !== undefined ? { removalBasis } : {}),
                     detail: boundedText(asRecord(data.details)?.text, 300),
                 });
                 const lastStep = trend.at(-1);
                 if (lastStep && event.kind !== "compaction_start") {
                     lastStep.eventMark = pruned ? "prune" : "compact";
                 }
-                if (reclaimed !== null && reclaimed > 0) {
-                    const userSlice = sliceOf(composition, "user");
-                    const assistantSlice = sliceOf(composition, "assistant");
-                    const toolSlice = sliceOf(composition, "toolResults");
-                    let remaining = reclaimed;
-                    for (const slice of [userSlice, assistantSlice, toolSlice]) {
-                        const take = Math.min(slice.tokens, remaining);
-                        slice.tokens -= take;
-                        remaining -= take;
-                        if (remaining <= 0)
-                            break;
-                    }
-                }
                 break;
             }
             default:

package/dist/worker/console/chat/pet/pet-affinity.js

@@ -0,0 +1,169 @@
+/**
+ * Pet affinity + treat economy — ported from @linxin666/dsh-pet
+ * affinity.ts + treats.ts. Pure, clock-injected; persistence lives in the
+ * service. Ranks use plain ASCII glyphs (repo bans emoji characters).
+ * @module loop-agent/console/chat/pet/pet-affinity
+ */
+import { BUILTIN_PET_REMARKS, builtinPetRemark, } from "./pet-remarks.js";
+export const PET_AFFINITY_MAX = 999_999_999;
+export const PET_AFFINITY_RANKS = [
+    { min: 0, name: "一粒火星", glyph: "*" },
+    { min: 25, name: "小火苗", glyph: "**" },
+    { min: 50, name: "炉边伙伴", glyph: "***" },
+    { min: 80, name: "炽热搭档", glyph: "****" },
+    { min: 200, name: "烈焰挚友", glyph: "*****" },
+    { min: 500, name: "篝火达人", glyph: "******" },
+    { min: 2_000, name: "火焰大师", glyph: "*******" },
+    { min: 10_000, name: "燎原之势", glyph: "********" },
+    { min: 100_000, name: "恒星之火", glyph: "*********" },
+];
+export const defaultPetAffinityConfig = {
+    turnReward: 1,
+    petReward: 1,
+    petCooldownMs: 10_000,
+    feedReward: 5,
+    feedCooldownMs: 30_000,
+};
+export function emptyPetAffinity() {
+    return {
+        points: 0,
+        lastPetAt: 0,
+        lastFeedAt: 0,
+        pets: 0,
+        feeds: 0,
+        petRejects: 0,
+        feedRejects: 0,
+        turns: 0,
+    };
+}
+export function petRankOf(points) {
+    let rank = PET_AFFINITY_RANKS[0];
+    for (const candidate of PET_AFFINITY_RANKS) {
+        if (points >= candidate.min)
+            rank = candidate;
+    }
+    return rank;
+}
+export function petAffinityViewOf(state, nowMs, config = defaultPetAffinityConfig) {
+    const rank = petRankOf(state.points);
+    return {
+        points: state.points,
+        rank: rank.name,
+        rankGlyph: rank.glyph,
+        pets: state.pets,
+        feeds: state.feeds,
+        turns: state.turns,
+        petCooldown: nowMs - state.lastPetAt < config.petCooldownMs,
+        feedCooldown: nowMs - state.lastFeedAt < config.feedCooldownMs,
+    };
+}
+function clampPoints(points) {
+    return Math.min(PET_AFFINITY_MAX, Math.max(0, points));
+}
+/** Deterministic round-robin reaction from a persisted counter. */
+function countedRemark(kind, count) {
+    const pool = BUILTIN_PET_REMARKS[kind];
+    return pool[Math.max(0, Math.floor(count)) % pool.length] ?? builtinPetRemark(kind);
+}
+/**
+ * Apply one interaction to a copy of the state. Cooldowns only apply once
+ * the pet has been interacted with at least once (last*At === 0 = never).
+ */
+export function applyPetInteraction(state, kind, nowMs, config = defaultPetAffinityConfig) {
+    const next = { ...state };
+    if (kind === "pet") {
+        if (state.lastPetAt !== 0 &&
+            nowMs - state.lastPetAt < config.petCooldownMs) {
+            next.petRejects += 1;
+            return {
+                affinity: next,
+                delta: 0,
+                reaction: countedRemark("petCooldown", state.petRejects),
+                accepted: false,
+            };
+        }
+        next.lastPetAt = nowMs;
+        next.pets += 1;
+        next.points = clampPoints(state.points + config.petReward);
+        return {
+            affinity: next,
+            delta: config.petReward,
+            reaction: countedRemark("pet", state.pets),
+            accepted: true,
+        };
+    }
+    if (kind === "feed") {
+        if (state.lastFeedAt !== 0 &&
+            nowMs - state.lastFeedAt < config.feedCooldownMs) {
+            next.feedRejects += 1;
+            return {
+                affinity: next,
+                delta: 0,
+                reaction: countedRemark("feedCooldown", state.feedRejects),
+                accepted: false,
+            };
+        }
+        next.lastFeedAt = nowMs;
+        next.feeds += 1;
+        next.points = clampPoints(state.points + config.feedReward);
+        return {
+            affinity: next,
+            delta: config.feedReward,
+            reaction: countedRemark("feed", state.feeds),
+            accepted: true,
+        };
+    }
+    return { affinity: state, delta: 0, reaction: "", accepted: false };
+}
+/** Reward one completed turn (host calls this on phase done). */
+export function applyPetTurnReward(state, config = defaultPetAffinityConfig) {
+    const next = { ...state };
+    next.turns += 1;
+    next.points = clampPoints(state.points + config.turnReward);
+    return next;
+}
+export const defaultPetTreatConfig = {
+    turnsPerTreat: 30,
+    timeTreatMs: 300 * 60_000,
+    maxTreats: 20,
+};
+export function emptyPetTreatLedger() {
+    return { treats: 0, lastTreatGrantAt: 0, turnsAtLastTreatGrant: 0 };
+}
+function capTreats(treats, max) {
+    return Math.min(max, Math.max(0, treats));
+}
+/**
+ * Settle treat grants from both sources (work output + wall-clock time).
+ * Lazy settlement from persisted anchors — no timer, no drift. A zero-gain
+ * first settlement still writes the time anchor so the clock can start.
+ */
+export function settlePetTreatGrants(ledger, turns, nowMs, config = defaultPetTreatConfig) {
+    const turnDelta = Math.max(0, turns - ledger.turnsAtLastTreatGrant);
+    const workGrants = Math.floor(turnDelta / config.turnsPerTreat);
+    const timeAnchor = ledger.lastTreatGrantAt === 0 ? nowMs : ledger.lastTreatGrantAt;
+    const timeGrants = Math.floor(Math.max(0, nowMs - timeAnchor) / config.timeTreatMs);
+    const gained = workGrants + timeGrants;
+    if (gained <= 0) {
+        if (ledger.lastTreatGrantAt === 0) {
+            return { ledger: { ...ledger, lastTreatGrantAt: nowMs }, gained: 0 };
+        }
+        return { ledger, gained: 0 };
+    }
+    return {
+        ledger: {
+            treats: capTreats(ledger.treats + gained, config.maxTreats),
+            lastTreatGrantAt: timeGrants > 0 ? timeAnchor + timeGrants * config.timeTreatMs : timeAnchor,
+            turnsAtLastTreatGrant: workGrants > 0
+                ? turns - (turnDelta % config.turnsPerTreat)
+                : ledger.turnsAtLastTreatGrant,
+        },
+        gained,
+    };
+}
+/** Consume one treat for a feed; refuses when the stock is empty. */
+export function consumePetTreat(ledger) {
+    if (ledger.treats <= 0)
+        return { ok: false };
+    return { ok: true, ledger: { ...ledger, treats: ledger.treats - 1 } };
+}