fix: update goal budget and live cost tracking

ThomasK33 · ThomasK33 · commit ab5d66e0ec38 · 2026-05-12T12:00:33.000Z
diff --git a/src/browser/features/RightSidebar/GoalTab.tsx b/src/browser/features/RightSidebar/GoalTab.tsx
@@ -92,7 +92,7 @@ export function GoalTab(props: GoalTabProps) {
       if (editingField === "budget") {
         const budgetCents = parseBudgetInput(submittedValue);
         if (budgetCents === undefined) {
-          setError("Enter a budget like $5, 500c, or leave blank for no budget.");
+          setError("Enter a budget like $5 or 500c. Use 0 or blank for no budget.");
           return;
         }
         await props.onUpdateBudget?.(budgetCents);
@@ -330,7 +330,7 @@ export function GoalTab(props: GoalTabProps) {
           />
           <p className="text-muted mt-1 text-xs">
             {editingField === "budget"
-              ? "Use $5, 500c, or blank for no budget."
+              ? "Use $5, 500c, 0, or blank for no budget."
               : "Use a positive whole number, or blank for no cap."}
           </p>
           <div className="mt-2 flex gap-2">
diff --git a/src/browser/features/RightSidebar/RightSidebar.tsx b/src/browser/features/RightSidebar/RightSidebar.tsx
@@ -19,6 +19,7 @@ import { useProvidersConfig } from "@/browser/hooks/useProvidersConfig";
 import { useAPI } from "@/browser/contexts/API";
 import { useSendMessageOptions } from "@/browser/hooks/useSendMessageOptions";
 import {
+  hasGoalBudgetLimit,
   modelHasPricingData,
   UNPRICED_CURRENT_MODEL_GOAL_MESSAGE,
 } from "@/common/utils/goals/budgetPricing";
@@ -687,7 +688,10 @@ const RightSidebarComponent: React.FC<RightSidebarProps> = ({
   };
 
   const handleGoalUpdateBudget = async (budgetCents: number | null) => {
-    if (budgetCents != null && !modelHasPricingData(sendMessageOptions.model, providersConfig)) {
+    if (
+      hasGoalBudgetLimit(budgetCents) &&
+      !modelHasPricingData(sendMessageOptions.model, providersConfig)
+    ) {
       throw new Error(UNPRICED_CURRENT_MODEL_GOAL_MESSAGE);
     }
     await setGoalWithSingleConflictRetry({ budgetCents });
diff --git a/src/browser/features/Settings/Sections/GoalsSection.tsx b/src/browser/features/Settings/Sections/GoalsSection.tsx
@@ -89,7 +89,7 @@ export function GoalsSection() {
             <label htmlFor="goal-default-budget" className="min-w-0 flex-1">
               <div className="text-foreground text-sm font-medium">Default goal budget</div>
               <div className="text-muted mt-0.5 text-xs">
-                Applied to new goals when no budget flag is provided.
+                Applied to new goals when no budget flag is provided. Use $0.00 for no dollar limit.
               </div>
             </label>
             <div className="flex items-center gap-1">
diff --git a/src/browser/utils/chatCommands.test.ts b/src/browser/utils/chatCommands.test.ts
@@ -755,6 +755,35 @@ describe("processSlashCommand - goal budgets", () => {
     });
   });
 
+  test("passes zero-dollar budget updates through on unpriced current model", async () => {
+    enableGoalsExperiment();
+    const currentGoal = {
+      goalId: "11111111-1111-4111-8111-111111111111",
+      objective: "existing objective",
+    };
+    const setGoal = mock().mockResolvedValueOnce({
+      success: true,
+      data: { ...currentGoal, budgetCents: null },
+    });
+    const context = createGoalCommandContext({
+      config: { getConfig: mock(() => Promise.resolve({})) },
+      workspace: {
+        getGoal: mock(() => Promise.resolve({ goal: currentGoal })),
+        setGoal,
+        clearGoal: mock(),
+      },
+    } as unknown as SlashCommandContext["api"]);
+    context.sendMessageOptions.model = "custom-provider:no-price-model";
+
+    await processSlashCommand({ type: "goal-budget", budgetCents: 0 }, context);
+
+    expect(setGoal).toHaveBeenCalledWith({
+      workspaceId: "goal-ws",
+      budgetCents: 0,
+      expectedGoalId: currentGoal.goalId,
+    });
+  });
+
   test("refuses budgeted goals on an unpriced current model", async () => {
     enableGoalsExperiment();
     const setGoal = mock();
diff --git a/src/browser/utils/chatCommands.ts b/src/browser/utils/chatCommands.ts
@@ -39,6 +39,7 @@ import type { ParsedCommand } from "@/browser/utils/slashCommands/types";
 import { type GoalDefaults } from "@/constants/goals";
 import {
   hasBudgetedResumableGoal,
+  hasGoalBudgetLimit,
   modelHasPricingData,
   UNPRICED_CURRENT_MODEL_GOAL_MESSAGE,
   UNPRICED_TARGET_MODEL_GOAL_MESSAGE,
@@ -824,7 +825,7 @@ async function handleGoalCommand(
     }
 
     if (parsed.type === "goal-budget") {
-      if (parsed.budgetCents != null && !(await currentModelHasPricingData(context))) {
+      if (hasGoalBudgetLimit(parsed.budgetCents) && !(await currentModelHasPricingData(context))) {
         showUnpricedModelGoalToast(setToast);
         return { clearInput: false, toastShown: true };
       }
@@ -844,7 +845,10 @@ async function handleGoalCommand(
 
     const goalDefaults = await getGoalDefaults(context);
     const goalSetIntent = resolveSlashGoalSetIntent(parsed, goalDefaults);
-    if (goalSetIntent.budgetCents != null && !(await currentModelHasPricingData(context))) {
+    if (
+      hasGoalBudgetLimit(goalSetIntent.budgetCents) &&
+      !(await currentModelHasPricingData(context))
+    ) {
       showUnpricedModelGoalToast(setToast);
       return { clearInput: false, toastShown: true };
     }
diff --git a/src/browser/utils/commands/sources.test.ts b/src/browser/utils/commands/sources.test.ts
@@ -519,6 +519,34 @@ test("goal set objective prompt treats blank budget as explicit no-budget", asyn
   });
 });
 
+test("goal set objective prompt allows zero budget on unpriced model", async () => {
+  const setGoal = mock(() => Promise.resolve({ success: true, data: makeGoalRecord("active") }));
+  const actions = getVisibleGoalActions({
+    api: {
+      config: { getConfig: mock(() => Promise.resolve({})) },
+      providers: { getConfig: mock(() => Promise.resolve({})) },
+      workspace: { getGoal: mock(() => Promise.resolve({ goal: null })), setGoal },
+    } as unknown as APIClient,
+    selectedWorkspaceState: {
+      ...makeWorkspaceState(null),
+      currentModel: "custom:unpriced-model",
+    },
+  });
+
+  const setObjectiveAction = actions.find((action) => action.id === "goal:set-objective");
+  await setObjectiveAction!.prompt!.onSubmit({
+    objective: "Track without dollar limit",
+    budget: "0",
+  });
+
+  expect(setGoal).toHaveBeenCalledWith(
+    expect.objectContaining({
+      objective: "Track without dollar limit",
+      budgetCents: null,
+    })
+  );
+});
+
 test("goal set objective prompt submits objective and parsed budget", async () => {
   const getGoal = mock(() => Promise.resolve({ goal: null }));
   const setGoal = mock(() => Promise.resolve({ success: true, data: makeGoalRecord("active") }));
diff --git a/src/browser/utils/commands/sources.ts b/src/browser/utils/commands/sources.ts
@@ -49,6 +49,7 @@ import { parseGoalBudgetCents } from "@/browser/utils/slashCommands/registry";
 import { setGoalWithConflictRetry } from "@/browser/utils/goals/setGoalWithConflictRetry";
 import { loadGoalDefaults, resolveGoalSetIntent } from "@/browser/utils/goals/resolveGoalSetIntent";
 import {
+  hasGoalBudgetLimit,
   modelHasPricingData,
   UNPRICED_CURRENT_MODEL_GOAL_MESSAGE,
 } from "@/common/utils/goals/budgetPricing";
@@ -301,7 +302,7 @@ function canSetBudgetedGoalWithCurrentPaletteModel(
   budgetCents: number | null,
   providersConfig: unknown
 ): boolean {
-  if (budgetCents == null) {
+  if (!hasGoalBudgetLimit(budgetCents)) {
     return true;
   }
   const selectedModel =
diff --git a/src/browser/utils/goals/resolveGoalSetIntent.test.ts b/src/browser/utils/goals/resolveGoalSetIntent.test.ts
@@ -15,6 +15,11 @@ describe("resolveGoalSetIntent", () => {
     expect(intent.budgetCents).toBe(200);
   });
 
+  test("treats explicit zero budget as no budget", () => {
+    const intent = resolveGoalSetIntent({ objective: "ship", budgetCents: 0 }, baseDefaults);
+    expect(intent.budgetCents).toBeNull();
+  });
+
   test("preserves explicit null budget (user-cleared)", () => {
     const intent = resolveGoalSetIntent({ objective: "ship", budgetCents: null }, baseDefaults);
     expect(intent.budgetCents).toBeNull();
@@ -36,6 +41,14 @@ describe("resolveGoalSetIntent", () => {
     expect(intent.budgetCents).toBe(1500);
   });
 
+  test("treats a zero default budget as no budget", () => {
+    const intent = resolveGoalSetIntent(
+      { objective: "ship" },
+      { ...baseDefaults, defaultBudgetCents: 0, alwaysRequireExplicitBudget: true }
+    );
+    expect(intent.budgetCents).toBeNull();
+  });
+
   test("turnCap falls back to defaultTurnCap when omitted", () => {
     const intent = resolveGoalSetIntent({ objective: "ship" }, baseDefaults);
     expect(intent.turnCap).toBe(7);
diff --git a/src/browser/utils/goals/resolveGoalSetIntent.ts b/src/browser/utils/goals/resolveGoalSetIntent.ts
@@ -1,3 +1,4 @@
+import { normalizeGoalBudgetCents } from "@/common/utils/goals/budgetPricing";
 import type { APIClient } from "@/browser/contexts/API";
 import { DEFAULT_GOAL_DEFAULTS, normalizeGoalDefaults, type GoalDefaults } from "@/constants/goals";
 
@@ -7,8 +8,8 @@ import { DEFAULT_GOAL_DEFAULTS, normalizeGoalDefaults, type GoalDefaults } from
  *
  * - `budgetCents` is a discriminated tri-state:
  *   - `undefined` → "user did not specify; apply default"
- *   - `null` → "user explicitly cleared the budget"
- *   - `number` → explicit cents value
+ *   - `null` or `0` → "no budget" (explicit clear)
+ *   - positive `number` → explicit cents value
  */
 export interface GoalSetIntentInput {
   objective: string;
@@ -29,7 +30,7 @@ export interface GoalSetIntent {
  *   - If the caller omitted `budgetCents`:
  *     - `alwaysRequireExplicitBudget` → fall back to `defaultBudgetCents`.
  *     - Otherwise → `null` (no budget).
- *   - `null` is preserved (explicit "no budget" clear).
+ *   - `null` and `0` both become no budget (explicit "no budget" clear).
  *   - If the caller omitted `turnCap`, fall back to `defaultTurnCap`.
  *
  * Coder-agents-review P3 DEREM-27: the slash command path (`/goal`) used to
@@ -44,9 +45,9 @@ export function resolveGoalSetIntent(
 ): GoalSetIntent {
   let budgetCents: number | null;
   if (input.budgetCents !== undefined) {
-    budgetCents = input.budgetCents;
+    budgetCents = normalizeGoalBudgetCents(input.budgetCents);
   } else if (defaults.alwaysRequireExplicitBudget) {
-    budgetCents = defaults.defaultBudgetCents;
+    budgetCents = normalizeGoalBudgetCents(defaults.defaultBudgetCents);
   } else {
     budgetCents = null;
   }
diff --git a/src/common/utils/goals/budgetParser.test.ts b/src/common/utils/goals/budgetParser.test.ts
@@ -29,6 +29,13 @@ describe("parseGoalBudgetInputCents", () => {
     expect(parseGoalBudgetInputCents("100C")).toBe(100);
   });
 
+  test("parses zero dollar inputs", () => {
+    expect(parseGoalBudgetInputCents("0")).toBe(0);
+    expect(parseGoalBudgetInputCents("$0")).toBe(0);
+    expect(parseGoalBudgetInputCents("$0.00")).toBe(0);
+    expect(parseGoalBudgetInputCents("0c")).toBe(0);
+  });
+
   test("returns undefined for invalid input", () => {
     expect(parseGoalBudgetInputCents("abc")).toBeUndefined();
     expect(parseGoalBudgetInputCents("$")).toBeUndefined();
diff --git a/src/common/utils/goals/budgetPricing.test.ts b/src/common/utils/goals/budgetPricing.test.ts
@@ -1,5 +1,11 @@
 import { describe, expect, test } from "bun:test";
-import { formatGoalCents, hasBudgetedResumableGoal, modelHasPricingData } from "./budgetPricing";
+import {
+  formatGoalCents,
+  hasBudgetedResumableGoal,
+  hasGoalBudgetLimit,
+  modelHasPricingData,
+  normalizeGoalBudgetCents,
+} from "./budgetPricing";
 
 describe("formatGoalCents", () => {
   test("formats integer cents as a dollar-prefixed two-decimal string", () => {
@@ -31,6 +37,18 @@ describe("modelHasPricingData", () => {
   });
 });
 
+describe("goal budget limit helpers", () => {
+  test("treat zero cents as no dollar budget limit", () => {
+    expect(hasGoalBudgetLimit(0)).toBe(false);
+    expect(normalizeGoalBudgetCents(0)).toBeNull();
+  });
+
+  test("preserve positive budget limits", () => {
+    expect(hasGoalBudgetLimit(1)).toBe(true);
+    expect(normalizeGoalBudgetCents(1)).toBe(1);
+  });
+});
+
 describe("hasBudgetedResumableGoal", () => {
   // Regression: the active-only check let the user pause a budgeted goal,
   // switch to an unpriced model, and resume — the next stream then records
@@ -45,6 +63,12 @@ describe("hasBudgetedResumableGoal", () => {
     expect(hasBudgetedResumableGoal({ status: "complete", budgetCents: 100 })).toBe(false);
   });
 
+  test("returns false for zero-dollar budgets", () => {
+    expect(hasBudgetedResumableGoal({ status: "active", budgetCents: 0 })).toBe(false);
+    expect(hasBudgetedResumableGoal({ status: "paused", budgetCents: 0 })).toBe(false);
+    expect(hasBudgetedResumableGoal({ status: "budget_limited", budgetCents: 0 })).toBe(false);
+  });
+
   test("returns false for any goal without a budget", () => {
     expect(hasBudgetedResumableGoal({ status: "active", budgetCents: null })).toBe(false);
     expect(hasBudgetedResumableGoal({ status: "paused", budgetCents: null })).toBe(false);
diff --git a/src/common/utils/goals/budgetPricing.ts b/src/common/utils/goals/budgetPricing.ts
@@ -11,15 +11,33 @@ export function formatGoalCents(cents: number): string {
 
 type GoalBudgetState = Pick<GoalRecordV1 | GoalSnapshot, "status" | "budgetCents">;
 
+/** True when the budget imposes a positive dollar limit; zero cents means no budget. */
+export function hasGoalBudgetLimit(budgetCents: number | null | undefined): boolean {
+  if (budgetCents == null) {
+    return false;
+  }
+  assert(
+    Number.isInteger(budgetCents) && budgetCents >= 0,
+    `goal budget limit requires non-negative integer cents, got ${budgetCents}`
+  );
+  return budgetCents > 0;
+}
+
+/** Collapse zero-cent and nullish budgets to null (no dollar limit). */
+export function normalizeGoalBudgetCents(budgetCents: number | null | undefined): number | null {
+  return budgetCents != null && hasGoalBudgetLimit(budgetCents) ? budgetCents : null;
+}
+
 /**
  * Returns true for any goal whose budget will be debited again if the user
  * continues working — i.e. `active`, `paused`, or `budget_limited` (the
- * non-terminal states with a numeric `budgetCents`). Used to gate model
+ * non-terminal states with a positive `budgetCents`). Used to gate model
  * switches: an unpriced model on such a goal silently records 0 cost on the
- * next stream, breaking budget enforcement after resume.
+ * next stream, breaking budget enforcement after resume. A zero-dollar budget
+ * is treated as "no budget" so users can disable dollar limits from settings.
  */
 export function hasBudgetedResumableGoal(goal: GoalBudgetState | null | undefined): boolean {
-  if (goal?.budgetCents == null) {
+  if (!goal || !hasGoalBudgetLimit(goal.budgetCents)) {
     return false;
   }
   return goal.status === "active" || goal.status === "paused" || goal.status === "budget_limited";
diff --git a/src/node/services/agentSession.goalAutoPause.test.ts b/src/node/services/agentSession.goalAutoPause.test.ts
diff --git a/src/node/services/agentSession.ts b/src/node/services/agentSession.ts
diff --git a/src/node/services/workspaceGoalService.test.ts b/src/node/services/workspaceGoalService.test.ts
diff --git a/src/node/services/workspaceGoalService.ts b/src/node/services/workspaceGoalService.ts
