@moxxy/mode-goal 0.26.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Moxxy (moxxy.ai)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/completion.d.ts

@@ -0,0 +1,20 @@
+import type { CollectedToolUse, MoxxyEvent } from '@moxxy/sdk';
+export type GoalTerminal = {
+    kind: 'complete';
+    summary: string;
+    evidence: string[];
+} | {
+    kind: 'abandon';
+    reason: string;
+    needsFromUser?: string;
+} | null;
+/**
+ * Inspect a just-executed batch of tool uses for a terminal goal signal. We
+ * confirm against the event log that the goal tool's `tool_result` actually
+ * succeeded (`ok: true`) — a hook could in principle have denied the call — so
+ * a denied goal_complete doesn't silently end the run. Returns the parsed
+ * payload (pulled from the model's tool INPUT, which is what it intended) so
+ * the caller can surface a clean summary.
+ */
+export declare function detectGoalTerminal(log: ReadonlyArray<MoxxyEvent>, batch: ReadonlyArray<CollectedToolUse>): GoalTerminal;
+//# sourceMappingURL=completion.d.ts.map

package/dist/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../src/completion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAI/D,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3D,IAAI,CAAC;AAET;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,aAAa,CAAC,UAAU,CAAC,EAC9B,KAAK,EAAE,aAAa,CAAC,gBAAgB,CAAC,GACrC,YAAY,CAkCd"}

package/dist/completion.js

@@ -0,0 +1,48 @@
+import { GOAL_ABANDON_TOOL, GOAL_COMPLETE_TOOL } from './constants.js';
+/**
+ * Inspect a just-executed batch of tool uses for a terminal goal signal. We
+ * confirm against the event log that the goal tool's `tool_result` actually
+ * succeeded (`ok: true`) — a hook could in principle have denied the call — so
+ * a denied goal_complete doesn't silently end the run. Returns the parsed
+ * payload (pulled from the model's tool INPUT, which is what it intended) so
+ * the caller can surface a clean summary.
+ */
+export function detectGoalTerminal(log, batch) {
+    // Map callId -> the goal tool use, so we only react to OUR tools.
+    const goalCalls = new Map();
+    for (const t of batch) {
+        if (t.name === GOAL_COMPLETE_TOOL || t.name === GOAL_ABANDON_TOOL)
+            goalCalls.set(t.id, t);
+    }
+    if (goalCalls.size === 0)
+        return null;
+    // Walk the log tail for the most recent successful result of one of those.
+    for (let i = log.length - 1; i >= 0; i--) {
+        const e = log[i];
+        if (!e || e.type !== 'tool_result' || !e.ok)
+            continue;
+        const call = goalCalls.get(String(e.callId));
+        if (!call)
+            continue;
+        const input = (call.input ?? {});
+        if (call.name === GOAL_COMPLETE_TOOL) {
+            return {
+                kind: 'complete',
+                summary: typeof input.summary === 'string' ? input.summary : 'Goal completed.',
+                // `input` is the RAW provider-emitted tool input (pre-zod), so the model
+                // can put anything in `evidence`. Keep only the string elements rather
+                // than asserting the type with an unchecked cast.
+                evidence: Array.isArray(input.evidence)
+                    ? input.evidence.filter((x) => typeof x === 'string')
+                    : [],
+            };
+        }
+        return {
+            kind: 'abandon',
+            reason: typeof input.reason === 'string' ? input.reason : 'Goal abandoned.',
+            ...(typeof input.needsFromUser === 'string' ? { needsFromUser: input.needsFromUser } : {}),
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=completion.js.map

package/dist/completion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.js","sourceRoot":"","sources":["../src/completion.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAOvE;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,GAA8B,EAC9B,KAAsC;IAEtC,kEAAkE;IAClE,MAAM,SAAS,GAAG,IAAI,GAAG,EAA4B,CAAC;IACtD,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,CAAC,IAAI,KAAK,kBAAkB,IAAI,CAAC,CAAC,IAAI,KAAK,iBAAiB;YAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;IAC5F,CAAC;IACD,IAAI,SAAS,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEtC,2EAA2E;IAC3E,KAAK,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QACjB,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,aAAa,IAAI,CAAC,CAAC,CAAC,EAAE;YAAE,SAAS;QACtD,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI;YAAE,SAAS;QACpB,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAA4B,CAAC;QAC5D,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;YACrC,OAAO;gBACL,IAAI,EAAE,UAAU;gBAChB,OAAO,EAAE,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,iBAAiB;gBAC9E,yEAAyE;gBACzE,uEAAuE;gBACvE,kDAAkD;gBAClD,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC;oBACrC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC;oBAClE,CAAC,CAAC,EAAE;aACP,CAAC;QACJ,CAAC;QACD,OAAO;YACL,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,iBAAiB;YAC3E,GAAG,CAAC,OAAO,KAAK,CAAC,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC3F,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/constants.d.ts

@@ -0,0 +1,50 @@
+export declare const GOAL_MODE_NAME = "goal";
+export declare const GOAL_PLUGIN_ID: import("@moxxy/sdk").PluginId;
+/** Tool the model MUST call to declare the goal achieved (the terminator). */
+export declare const GOAL_COMPLETE_TOOL = "goal_complete";
+/** Tool the model calls to give up gracefully (blocked, needs the user). */
+export declare const GOAL_ABANDON_TOOL = "goal_abandon";
+/**
+ * Hard cap on autonomous iterations. Goal mode keeps re-prompting the model to
+ * continue until it calls {@link GOAL_COMPLETE_TOOL}; this is the backstop that
+ * guarantees the loop terminates even if the model never declares done. High
+ * enough for a substantial multi-step task, low enough to bound a runaway.
+ */
+export declare const GOAL_MAX_ITERATIONS = 150;
+/**
+ * Consecutive iterations where the model emits NO tool calls and hasn't
+ * completed. After this many we stop (a stall) rather than spin forever
+ * nudging a model that has decided it's done without saying so.
+ */
+export declare const GOAL_MAX_NOOP_ITERATIONS = 3;
+/**
+ * Cumulative token ceiling (full prompt — input + cacheRead + cacheCreation +
+ * output — across the whole goal run). A second backstop alongside the
+ * iteration cap: a few long-context iterations can burn a lot of tokens even
+ * under the iteration limit. Generous; the iteration cap is usually the binding
+ * guard.
+ */
+export declare const GOAL_TOKEN_BUDGET = 4000000;
+/**
+ * Max consecutive retryable provider errors before goal mode bails with a fatal
+ * error. Goal mode runs unattended with auto-approval, so a sustained retryable
+ * condition (429 / overloaded / transient 5xx / ECONNRESET) must NOT busy-loop
+ * the provider — back off exponentially and give up after this many in a row.
+ * The counter resets on any clean provider call, so a long run can still
+ * recover from transient blips.
+ */
+export declare const MAX_CONSECUTIVE_RETRIES = 6;
+/**
+ * Layered on top of any user system prompt for the whole goal run. The framing
+ * is the inverse of normal chat: stopping is NOT the signal to end — the model
+ * keeps going until it explicitly calls goal_complete. It runs unattended with
+ * tool calls auto-approved, so it must be conservative about irreversible
+ * actions and decisive about declaring done.
+ */
+export declare const GOAL_SYSTEM_PROMPT = "You are operating in GOAL MODE. The user has given you a goal and you will work on it AUTONOMOUSLY, across as many steps as it takes, until it is genuinely done. You are running unattended \u2014 the user is not watching each step and your tool calls are auto-approved \u2014 so act like a careful senior engineer who has been handed the keys.\n\nHow goal mode ends \u2014 this is the most important rule:\n- The loop does NOT end when you stop talking. It ends ONLY when you call the `goal_complete` tool. If you produce a message without tool calls, you will simply be prompted to continue.\n- When (and only when) the goal is FULLY achieved AND you have verified it, call `goal_complete` with a short summary and concrete evidence (commands you ran and their results, files you changed, tests that passed).\n- If you become genuinely blocked \u2014 a missing credential, a destructive action you shouldn't take unattended, or a requirement too ambiguous to proceed on \u2014 call `goal_abandon` with the reason and exactly what you need from the user. Do NOT spin on something you cannot resolve.\n\nWhile working:\n- Break the goal into steps and just do them \u2014 don't stop to ask for confirmation on routine work; you have autonomy for this run.\n- Verify your work as you go (run the project's tests / build / linter when relevant) before declaring the goal complete.\n- Be careful with irreversible or destructive operations (deleting data, force-pushing, external side effects). When something is high-stakes and reversible-only-by-the-user, prefer to `goal_abandon` and ask rather than guess.\n- Don't repeat the same failing action. If an approach isn't working, change it; if nothing works, abandon with a clear explanation.\n- Don't declare the goal complete prematurely. \"I think this should work\" is not done \u2014 verify first.";
+/** Trailing nudge appended when the model idles (no tool calls) without
+ *  completing — reminds it the loop only ends via the completion tool. */
+export declare const CONTINUE_NUDGE: string;
+/** Sharper nudge once the model has idled repeatedly. */
+export declare const STALL_NUDGE: string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,SAAS,CAAC;AACrC,eAAO,MAAM,cAAc,+BAAiC,CAAC;AAE7D,8EAA8E;AAC9E,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAClD,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,iBAAiB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,UAAY,CAAC;AAE3C;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,8zDAYuE,CAAC;AAEvG;0EAC0E;AAC1E,eAAO,MAAM,cAAc,QAE8D,CAAC;AAE1F,yDAAyD;AACzD,eAAO,MAAM,WAAW,QAEmG,CAAC"}

package/dist/constants.js

@@ -0,0 +1,65 @@
+import { asPluginId } from '@moxxy/sdk';
+export const GOAL_MODE_NAME = 'goal';
+export const GOAL_PLUGIN_ID = asPluginId('@moxxy/mode-goal');
+/** Tool the model MUST call to declare the goal achieved (the terminator). */
+export const GOAL_COMPLETE_TOOL = 'goal_complete';
+/** Tool the model calls to give up gracefully (blocked, needs the user). */
+export const GOAL_ABANDON_TOOL = 'goal_abandon';
+/**
+ * Hard cap on autonomous iterations. Goal mode keeps re-prompting the model to
+ * continue until it calls {@link GOAL_COMPLETE_TOOL}; this is the backstop that
+ * guarantees the loop terminates even if the model never declares done. High
+ * enough for a substantial multi-step task, low enough to bound a runaway.
+ */
+export const GOAL_MAX_ITERATIONS = 150;
+/**
+ * Consecutive iterations where the model emits NO tool calls and hasn't
+ * completed. After this many we stop (a stall) rather than spin forever
+ * nudging a model that has decided it's done without saying so.
+ */
+export const GOAL_MAX_NOOP_ITERATIONS = 3;
+/**
+ * Cumulative token ceiling (full prompt — input + cacheRead + cacheCreation +
+ * output — across the whole goal run). A second backstop alongside the
+ * iteration cap: a few long-context iterations can burn a lot of tokens even
+ * under the iteration limit. Generous; the iteration cap is usually the binding
+ * guard.
+ */
+export const GOAL_TOKEN_BUDGET = 4_000_000;
+/**
+ * Max consecutive retryable provider errors before goal mode bails with a fatal
+ * error. Goal mode runs unattended with auto-approval, so a sustained retryable
+ * condition (429 / overloaded / transient 5xx / ECONNRESET) must NOT busy-loop
+ * the provider — back off exponentially and give up after this many in a row.
+ * The counter resets on any clean provider call, so a long run can still
+ * recover from transient blips.
+ */
+export const MAX_CONSECUTIVE_RETRIES = 6;
+/**
+ * Layered on top of any user system prompt for the whole goal run. The framing
+ * is the inverse of normal chat: stopping is NOT the signal to end — the model
+ * keeps going until it explicitly calls goal_complete. It runs unattended with
+ * tool calls auto-approved, so it must be conservative about irreversible
+ * actions and decisive about declaring done.
+ */
+export const GOAL_SYSTEM_PROMPT = `You are operating in GOAL MODE. The user has given you a goal and you will work on it AUTONOMOUSLY, across as many steps as it takes, until it is genuinely done. You are running unattended — the user is not watching each step and your tool calls are auto-approved — so act like a careful senior engineer who has been handed the keys.
+
+How goal mode ends — this is the most important rule:
+- The loop does NOT end when you stop talking. It ends ONLY when you call the \`${GOAL_COMPLETE_TOOL}\` tool. If you produce a message without tool calls, you will simply be prompted to continue.
+- When (and only when) the goal is FULLY achieved AND you have verified it, call \`${GOAL_COMPLETE_TOOL}\` with a short summary and concrete evidence (commands you ran and their results, files you changed, tests that passed).
+- If you become genuinely blocked — a missing credential, a destructive action you shouldn't take unattended, or a requirement too ambiguous to proceed on — call \`${GOAL_ABANDON_TOOL}\` with the reason and exactly what you need from the user. Do NOT spin on something you cannot resolve.
+
+While working:
+- Break the goal into steps and just do them — don't stop to ask for confirmation on routine work; you have autonomy for this run.
+- Verify your work as you go (run the project's tests / build / linter when relevant) before declaring the goal complete.
+- Be careful with irreversible or destructive operations (deleting data, force-pushing, external side effects). When something is high-stakes and reversible-only-by-the-user, prefer to \`${GOAL_ABANDON_TOOL}\` and ask rather than guess.
+- Don't repeat the same failing action. If an approach isn't working, change it; if nothing works, abandon with a clear explanation.
+- Don't declare the goal complete prematurely. "I think this should work" is not done — verify first.`;
+/** Trailing nudge appended when the model idles (no tool calls) without
+ *  completing — reminds it the loop only ends via the completion tool. */
+export const CONTINUE_NUDGE = `You stopped without calling \`${GOAL_COMPLETE_TOOL}\`. If the goal is fully achieved AND verified, ` +
+    `call \`${GOAL_COMPLETE_TOOL}\` now. Otherwise, take the next concrete step toward it.`;
+/** Sharper nudge once the model has idled repeatedly. */
+export const STALL_NUDGE = `You have produced no tool calls for several turns. Either take a concrete next action toward the goal, ` +
+    `or call \`${GOAL_COMPLETE_TOOL}\` (if done) / \`${GOAL_ABANDON_TOOL}\` (if blocked). Do not reply with only text again.`;
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC;AACrC,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAAC;AAE7D,8EAA8E;AAC9E,MAAM,CAAC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAClD,4EAA4E;AAC5E,MAAM,CAAC,MAAM,iBAAiB,GAAG,cAAc,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEvC;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,SAAS,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;kFAGgD,kBAAkB;qFACf,kBAAkB;sKAC+D,iBAAiB;;;;;6LAKM,iBAAiB;;sGAExG,CAAC;AAEvG;0EAC0E;AAC1E,MAAM,CAAC,MAAM,cAAc,GACzB,iCAAiC,kBAAkB,kDAAkD;IACrG,UAAU,kBAAkB,2DAA2D,CAAC;AAE1F,yDAAyD;AACzD,MAAM,CAAC,MAAM,WAAW,GACtB,yGAAyG;IACzG,aAAa,kBAAkB,oBAAoB,iBAAiB,qDAAqD,CAAC"}

package/dist/goal-loop.d.ts

@@ -0,0 +1,34 @@
+import { type ModeContext, type MoxxyEvent } from '@moxxy/sdk';
+/**
+ * Override the retry back-off sleep (test seam). Returns a restore fn that
+ * callers MUST invoke (in a `finally`) — `sleepImpl` is a module-scoped
+ * singleton shared process-wide, so a leaked override bleeds the fake sleep
+ * into every other turn/test running in the same worker. Test-only.
+ */
+export declare function __setRetrySleepForTests(fn: (ms: number, signal: AbortSignal) => Promise<void>): () => void;
+/**
+ * Goal mode driver.
+ *
+ * Unlike tool-use (which returns the instant the model stops emitting tools),
+ * goal mode treats "stopped emitting tools" as a cue to re-prompt: it keeps
+ * the model working autonomously across iterations until the model explicitly
+ * calls `goal_complete` (success) or `goal_abandon` (blocked). Every iteration
+ * is guarded so the loop always terminates:
+ *
+ *   - hard iteration cap (`maxIterations`)
+ *   - cumulative token budget
+ *   - stuck-loop detector (same identical-call detection as tool-use)
+ *   - no-progress detection (repeated idle iterations → stall stop)
+ *   - `ctx.signal.aborted` checked every iteration and mid tool batch
+ *
+ * Tool calls are auto-approved for the whole run (the user opted into full
+ * autonomy) by swapping in a resolver that replaces only the PROMPT path:
+ * the session resolver's prompt-free `policyCheck` (user deny/allow rules
+ * from ~/.moxxy/permissions.json plus tool-declared rules) is consulted
+ * first, so a configured deny rule still denies here. Every call also still
+ * flows through `dispatchToolCall`, so tool-call HOOKS (e.g. a security
+ * plugin) still run and can deny. Auto-approve skips the prompt, not the
+ * policy.
+ */
+export declare function runGoalMode(ctx: ModeContext): AsyncIterable<MoxxyEvent>;
+//# sourceMappingURL=goal-loop.d.ts.map

package/dist/goal-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goal-loop.d.ts","sourceRoot":"","sources":["../src/goal-loop.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,KAAK,WAAW,EAChB,KAAK,UAAU,EAEhB,MAAM,YAAY,CAAC;AA2BpB;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GACrD,MAAM,IAAI,CAMZ;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAuB,WAAW,CAAC,GAAG,EAAE,WAAW,GAAG,aAAa,CAAC,UAAU,CAAC,CAkb9E"}