feat: session goals - server-driven goal loop with independent small-model audit (#2148)

Arm the target button in the composer and the next prompt becomes a goal:
the server keeps the session working toward it (idle tick -> small-model
audit -> continuation) until the objective is verifiably complete, blocked,
or out of budget — even with the UI closed.

Server (packages/web/server/lib/session-goal):
- event-driven loop on the global SSE hub; goal state lives in
  session.metadata.openchamber.goal (merge-safe patches, stale-write guard
  by goal id), so it survives restarts and syncs to every client for free
- the small-model audit (objective + last assistant turn only, language
  pinned to the objective) is the sole termination authority; blocked needs
  3 consecutive verdicts, audit outages tolerate one unaudited continuation
  then stop the goal as resumable-blocked
- hard stops: optional token budget, auto-continuation cap (Resume grants a
  fresh allowance), turn errors; user abort pauses the goal instead of
  blocking it, and resuming over an aborted tail nudges immediately
- token accounting as a snapshot of the latest turn (input + cache.read +
  output), goal-relative via a creation baseline and segmented across
  compactions; a compaction summary skips the audit and continues
- continuations reuse the session's own provider/model/agent/variant

UI:
- three-mode target button (arm / disarm / manage dialog), informational
  goal strip with inline pause/resume and an Evaluating indicator, sidebar
  state glyph, objective length counter (2000-char server clamp),
  read-only completed goals
- goal entry points: composer (sessions and drafts), start-new-session-
  from-answer dialog, plan implement dialog (plan content becomes the
  objective), scheduled tasks (Run as goal + budget)
- Settings -> Chat -> Goal: feature toggle + default token budget with
  three-layer parity (web server, client persistence, VS Code bridge);
  VS Code renders goal state but hides the entry points (the loop runs in
  the web server only)

Notifications: per-turn "ready" notifications are suppressed while a goal
is active; settling sends one final notification (desktop, web-push, APNs
generic titles with the session name as body) honoring the completion
toggle. Error/question/permission notifications are untouched.

Docs: user guide (session-goals) in all 9 locales + sidebar entry,
scheduled-tasks cross-reference, server module DOCUMENTATION.md.

packages/ui/src/components/session/ScheduledTaskEditorDialog.tsx

@@ -6,6 +6,7 @@ import { Input } from '@/components/ui/input';
 import { Textarea } from '@/components/ui/textarea';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
 import { Checkbox } from '@/components/ui/checkbox';
+import { NumberInput } from '@/components/ui/number-input';
 import { Button } from '@/components/ui/button';
 import { MobileOverlayPanel } from '@/components/ui/MobileOverlayPanel';
 import { toast } from '@/components/ui';
@@ -466,6 +467,8 @@ type ScheduledTaskDraft = {
     modelID: string;
     variant: string;
     agent: string;
+    goalEnabled: boolean;
+    goalTokenBudget: number | null;
   };
   state?: ScheduledTask['state'];
 };
@@ -515,6 +518,8 @@ const toDraft = (
         modelID: defaults.modelID,
         variant: defaults.variant,
         agent: defaults.agent,
+        goalEnabled: false,
+        goalTokenBudget: null,
       },
     };
   }
@@ -548,6 +553,10 @@ const toDraft = (
       modelID: task.execution.modelID,
       variant: task.execution.variant || '',
       agent: task.execution.agent || '',
+      goalEnabled: task.execution.goalEnabled === true,
+      goalTokenBudget: typeof task.execution.goalTokenBudget === 'number' && task.execution.goalTokenBudget > 0
+        ? task.execution.goalTokenBudget
+        : null,
     },
     state: task.state,
   };
@@ -1153,6 +1162,10 @@ export function ScheduledTaskEditorDialog(props: {
         modelID: draft.execution.modelID,
         ...(draft.execution.variant.trim() ? { variant: draft.execution.variant.trim() } : {}),
         ...(draft.execution.agent.trim() ? { agent: draft.execution.agent.trim() } : {}),
+        ...(draft.execution.goalEnabled ? { goalEnabled: true } : {}),
+        ...(draft.execution.goalEnabled && draft.execution.goalTokenBudget
+          ? { goalTokenBudget: draft.execution.goalTokenBudget }
+          : {}),
       },
       ...(draft.state ? { state: draft.state } : {}),
     };
@@ -1608,6 +1621,49 @@ export function ScheduledTaskEditorDialog(props: {
               ) : null}
             </div>
           </div>
+
+          <div className="flex flex-wrap items-center gap-x-8 gap-y-2">
+            <label className="inline-flex cursor-pointer items-center gap-2">
+              <Checkbox
+                checked={draft.execution.goalEnabled}
+                onChange={(goalEnabled) => setDraft((prev) => ({
+                  ...prev,
+                  execution: { ...prev.execution, goalEnabled },
+                }))}
+                ariaLabel={t('sessions.scheduledTasks.editor.goal.aria')}
+              />
+              <span className="typography-meta">{t('sessions.scheduledTasks.editor.goal.label')}</span>
+            </label>
+            {draft.execution.goalEnabled ? (
+              <label className="inline-flex cursor-pointer items-center gap-2">
+                <Checkbox
+                  checked={draft.execution.goalTokenBudget !== null}
+                  onChange={(hasBudget) => setDraft((prev) => ({
+                    ...prev,
+                    execution: { ...prev.execution, goalTokenBudget: hasBudget ? 200_000 : null },
+                  }))}
+                  ariaLabel={t('sessions.scheduledTasks.editor.goal.budgetAria')}
+                />
+                <span className="typography-meta">{t('sessions.scheduledTasks.editor.goal.budgetLabel')}</span>
+              </label>
+            ) : null}
+            {draft.execution.goalEnabled && draft.execution.goalTokenBudget !== null ? (
+              <NumberInput
+                value={draft.execution.goalTokenBudget}
+                onValueChange={(value) => {
+                  if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+                    setDraft((prev) => ({
+                      ...prev,
+                      execution: { ...prev.execution, goalTokenBudget: Math.floor(value) },
+                    }));
+                  }
+                }}
+                min={1000}
+                max={100000000}
+                step={50000}
+              />
+            ) : null}
+          </div>
     </div>
   );