@worca/app 1.3.0-rc.2 → 1.4.0-rc.1

package/ui/server.mjs

@@ -15,7 +15,7 @@ import fsp from 'node:fs/promises';
 import process from 'node:process';
 import { createRequire } from 'node:module';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { randomUUID, timingSafeEqual } from 'node:crypto';
+import { randomUUID, randomBytes, timingSafeEqual } from 'node:crypto';
 
 import { preflightNode } from '../src/core/preflight-node.mjs';
 import { createOrchestratorFor } from '../src/core/engine-select.mjs';
@@ -24,9 +24,11 @@ import {
   enrichPipelinesPr, reconcileStaleRunning, readPipelineForResume, persistPrState, readPrState,
   readRunLogText, readRunArtifactText, countPipelines, runRootSweepLookups, legacySweepLookups, slugify,
   listArtifacts, listRunArtifacts, lookupPipelineRow, findPipelineRowById, readPipelineStateById, resolveIndexedArtifact, resolveIndexedArtifactForRow,
-  readPromptFile,
+  readPromptFile, runDirForRow,
 } from '../src/core/artifacts.mjs';
 import { DIFF_PATCH_FILE } from '../src/core/results.mjs';
+import { readAskFileEntry, ASK_FILE_MIMES } from '../src/core/ask-files.mjs';
+import { ASK_FILES_DIR } from '../src/core/ask-forms.mjs';
 import { protectedSectionKeys } from '../src/core/diff-anchor.mjs';
 import {
   addDiffComment, addDiffCommentReply, listDiffComments, getDiffComment, setDiffCommentResolved,
@@ -40,15 +42,21 @@ import {
   rawProjectsRoot, defaultProjectsRoot, runRootMode,
   pipelineCostLimitUsd, totalCostLimitUsd, costLimitResetPeriod,
   setPipelineCostLimitUsd, setTotalCostLimitUsd, setCostLimitResetPeriod, assertCostLimitInputs,
+  humanRateUsdPerHour, setHumanRateUsdPerHour, assertHumanRateInput,
   askMaxTurns, askMaxBudgetUsd, setAskMaxTurns, setAskMaxBudgetUsd, assertAskLimitInputs,
   chatPrefs, setChatPrefs,
   debugSpawnEnabled as storedDebugSpawnEnabled, effectiveDebugSpawn, setDebugSpawnEnabled, assertDebugSpawnInput, SETTINGS_POST_KEYS,
   titleModel as storedTitleModel, setTitleModel, assertTitleModelInput,
   hideBuiltinModels, setHideBuiltinModels, assertHideBuiltinModelsInput,
   theme as storedTheme, setTheme, assertThemeInput,
+  uiLevel as storedUiLevel, setUiLevel, assertUiLevelInput, defaultUiLevel,
   autoWorkflowModel as storedAutoWorkflowModel, setAutoWorkflowModel, assertAutoWorkflowModelInput,
+  memoryDefragModel, setMemoryDefragModel, assertMemoryDefragModelInput,
+  scheduleDefaults, setScheduleDefaults,
 } from '../src/core/settings.mjs';
+import { resolveDefragModel, defragDefaultModel, defragWorkflowView, checkStartPair } from '../src/core/memory-defrag-model.mjs';
 import { describeTitleModel } from '../src/core/title.mjs';
+import { effectiveHumanRateUsd } from '../src/core/human-rate.mjs';
 import {
   ASK_ID_RE, createThread as askCreateThread, getThread as askGetThread,
   listThreads as askListThreads, updateThread as askUpdateThread,
@@ -73,6 +81,7 @@ import {
   buildTurnPrompt as askBuildTurnPrompt, buildRestoredPrompt as askBuildRestoredPrompt,
   selectInlineAttachments as askSelectInlineAttachments, validateClientContext,
 } from '../src/core/ask/prompt.mjs';
+import { askScriptPromptInput } from '../src/core/ask/script-deps.mjs';
 import {
   classifyExtension as askClassifyExtension, sniffMime as askSniffMime,
 } from '../src/core/ask/attachment-kind.mjs';
@@ -86,13 +95,25 @@ import { createAskTurn } from '../src/core/ask/turn.mjs';
 import { attachRunFollower } from '../src/core/ask/follow.mjs';
 import { mockEnabled, MOCK_WRITER_ROLES } from '../src/core/claude-runner.mjs';
 import { budgetStatus, readCostCapOverride, setCostCapOverride } from '../src/core/cost-budget.mjs';
-import { getStats } from '../src/core/stats.mjs';
+import { getStats, budgetWindowSavings } from '../src/core/stats.mjs';
 import {
   enableTeamMetrics, setRecordMyRuns, flushSlug, flushAll, flushProject, scheduleFlush, discoverProject,
   discoverAll, scanMembers, routeWorkspaceMembers, projectMetricsStatus, startTeamMetricsBackground,
   metricsEvents, slugDirName, autoMetricsHome,
 } from '../src/core/metrics/sync.mjs';
 import { readScope, listScopes, parseScopeParam, aggregate, resolveRange, GROUP_BYS, PROJECT_KEY_RE as TM_PROJECT_KEY_RE } from '../src/core/metrics/read.mjs';
+// Team policy (team-policy design §9, §11): the worca-policy branch, its gates and its pages.
+import {
+  policyEvents, discoverPolicy, discoverAllPolicies, resolveProjectPolicy, resolveWorkspacePolicy, enableTeamPolicy, publishPolicy,
+  projectPolicyStatus, listPolicyScopes, routeWorkspaceMembersPolicy, autoPolicyHome, startTeamPolicyBackground,
+} from '../src/core/policy/sync.mjs';
+import { deviationsFor, fieldsForRun, capSummary } from '../src/core/policy/effective.mjs';
+import { installedPluginsMap, pluginRequirements, blockedPluginFindings, seedPolicyMarketplaces, WORCA_VERSION as POLICY_WORCA_VERSION } from '../src/core/policy/local.mjs';
+import { normalizePolicyDoc } from '../src/core/policy/registry.mjs';
+import { checkTeamTotalGate, checkTeamPipelineGate, teamCapsForTarget } from '../src/core/policy/gate.mjs';
+import { readPolicyState } from '../src/core/policy/state.mjs';
+import { policyForScope, policyPayload } from '../src/core/policy/scope.mjs';
+import { policyCatalogModels } from '../src/core/policy/cache.mjs';
 import { pickFolderNative } from '../src/core/folder-dialog.mjs';
 import { listFolders } from '../src/core/fs-browse.mjs';
 import {
@@ -103,7 +124,14 @@ import {
   readPrRemotePrefs, setPrRemotePrefs,
 } from '../src/core/config.mjs';
 import { listGlobalModels, addGlobalModel, updateGlobalModel } from '../src/core/settings.mjs';
-import { modelEnvRef, maskModelEnvValue, SUBAGENT_MODEL_VALUES, subagentModelIssue } from '../src/core/model-env.mjs';
+import { modelEnvRef, maskModelEnvValue, SUBAGENT_MODEL_VALUES, subagentModelIssue, UPSTREAM_PROVIDERS } from '../src/core/model-env.mjs';
+import { providerReadiness } from '../src/core/bridge/registry.mjs';
+import { startBridge } from '../src/core/bridge/server.mjs';
+import {
+  providersState, patchProvider, acknowledgeTerms, beginCopilotLogin, pollCopilotLogin, copilotLogout,
+  copilotModelsForImport, importCopilotModels, testProviderConnection,
+  endpointModelsForImport, importEndpointModels,
+} from '../src/core/bridge/provider-ops.mjs';
 import { listPluginModels, modelSecretsSchema, pluginModelSecretStatus } from '../src/core/plugin-models.mjs';
 import { testModel } from '../src/core/model-test.mjs';
 import {
@@ -111,7 +139,7 @@ import {
 } from '../src/core/ui-instance.mjs';
 import { validateGuardrails } from '../src/core/guardrails.mjs';
 import {
-  listBuiltinGuardrailSets, listGuardrailSets, readGuardrailSet,
+  listBuiltinGuardrailSets, listGuardrailSets, readGuardrailSet, listPolicyGuardrailSets, isPolicyGuardrailSetId,
   writeGuardrailSet, deleteGuardrailSet, isBuiltinGuardrailSetId,
 } from '../src/core/guardrail-store.mjs';
 import {
@@ -124,17 +152,25 @@ import {
 } from '../src/core/ask/workflow-deps.mjs';
 import { applyMetricsChange } from '../src/core/ask/metrics-deps.mjs';
 import { metricsEventPrompt, metricsNoticeText } from '../src/core/ask/metrics-proposal.mjs';
+import { applyPolicyChange } from '../src/core/ask/policy-deps.mjs';
+import { policyEventPrompt, policyNoticeText } from '../src/core/ask/policy-proposal.mjs';
+import { scheduleEventPrompt, scheduleNoticeText } from '../src/core/ask/schedule-spec.mjs';
+import { applyModelChange } from '../src/core/ask/model-deps.mjs';
+import { modelEventPrompt, modelNoticeText } from '../src/core/ask/model-proposal.mjs';
 import { registryPortsFn } from '../src/core/graph/registry-ports.mjs';
-import { sweepV1Runs, V1_RUN_RETIRED } from '../src/core/db.mjs';
+import { sweepV1Runs, V1_RUN_RETIRED, getDb } from '../src/core/db.mjs';
 import { exportWorkflow, exportWorkflowPlugin, ON_CONFLICT_MODES, RESOLUTION_CHOICES } from '../src/core/workflow-export.mjs';
 import {
   saveGraphWorkflow, importGraphWorkflow, exportGraphJson, workflowFileSlug, nodeDefaultsError,
 } from '../src/core/workflow-share.mjs';
 import { loadAgentRegistry } from '../src/core/agent-registry.mjs';
+import { loadScriptRegistry } from '../src/core/script-registry.mjs';
+import { probePython, pythonRuntimeState } from '../src/core/graph/python-probe.mjs';
 import {
   listLocalBranches, currentBranch, isValidSourceRef, sweepRunRoots, sweepLegacyWorktreesAll,
 } from '../src/core/worktree.mjs';
-import { hasGh, pushBranch, createPr, createIssue, prMergeable, listRemotes, sameRepo } from '../src/core/git-info.mjs';
+import { hasGh, pushBranch, createPr, createIssue, prMergeable, listRemotes, listRemoteBranches, sameRepo } from '../src/core/git-info.mjs';
+import { isSyntacticRef } from '../src/core/ask/proposal.mjs';
 import { archivePipeline, discardRetainedWorktrees } from '../src/core/pipeline-delete.mjs';
 import {
   listWorkspaces, readWorkspace, createWorkspace,
@@ -155,7 +191,14 @@ import { createWorkspaceScan } from '../src/core/workspace-scan.mjs';
 import { createAgentGen } from '../src/core/agent-gen.mjs';
 import { listAgents, readAgent, createAgent, updateAgent, deleteAgent, AGENT_KEY_RE } from '../src/core/agent-store.mjs';
 import {
-  listInstalledPlugins, installPlugin, updatePlugin, uninstallPlugin,
+  listScripts, readScript, createScript, updateScript, deleteScript, duplicateScript, writeCases,
+  SCRIPT_KEY_RE,
+} from '../src/core/script-store.mjs';
+
+import { createBench, sweepBenchDirs, benchRoot } from '../src/core/script-bench.mjs';
+import { PORT_ID_RE } from '../src/shared/graph/constants.mjs';
+import {
+  listInstalledPlugins, installPlugin, updatePlugin, uninstallPlugin, pythonNoticeFor,
   setPluginEnabled, doctorPlugin, linkPlugin,
   listOrphanPluginData, purgePluginData,
 } from '../src/core/plugin-store.mjs';
@@ -180,7 +223,22 @@ import { TokenBucket } from '../src/core/chat/rate-limiter.mjs';
 import { renderTest } from '../src/core/chat/renderers.mjs';
 import { readPluginsLock, pluginCurrentDir } from '../src/core/plugins-lock.mjs';
 import { normalizeManifest, validatePluginDir, PLUGIN_NAME_RE as MANIFEST_PLUGIN_NAME_RE } from '../src/core/plugin-manifest.mjs';
-import { listTaskSources, retryWriteback } from '../src/core/sources.mjs';
+import { listTaskSources, retryWriteback, resolveTaskInput } from '../src/core/sources.mjs';
+import {
+  createTicket, getTicket, listTickets, updateTicket, cancelTicket, requestRunNow, setTicketPipeline,
+  createSchedule, getSchedule, listSchedules, updateSchedule, pauseSchedule, resumeSchedule, skipNext,
+  runScheduleNow, deleteSchedule, cancelForTarget, dependentsOfWorkflow, runDueTickets, recordOutcome,
+  recoverScheduler, purgeScheduler, scheduleCounts, scheduleStageDir, scheduleSignature,
+  resolveAfterRef, predecessorState, previousBranchesOf, dependentsOfRun, AFTER_POLICIES, afterRefOf,
+  chainBaseBranchesOf,
+} from '../src/core/scheduler.mjs';
+import {
+  onNotification, listNotifications, unreadCount, latestNotificationId, markRead, markAllRead, purgeNotifications,
+} from '../src/core/notifications.mjs';
+import {
+  normalizeRule, nextOccurrence, previewOccurrences, describeRule, parseScheduledFor, localDate,
+  isValidTimeZone, formatInstant, OVERLAP_POLICIES, MISSED_POLICIES,
+} from '../src/shared/schedule/recurrence.mjs';
 import { callSource, PluginOpError } from '../src/core/plugin-shim.mjs';
 import { resolveAutoModel, AUTO_MODEL_ENV } from '../src/core/auto/model.mjs';
 import {
@@ -327,6 +385,12 @@ const SCAN_EVENT_NAMES = ['scan-progress', 'scan-done', 'scan-error'];
 // a NEW family in the SAME runs Map. createAgentGen emits many agentgen-progress
 // then exactly one terminal agentgen-done OR agentgen-error.
 const AGENTGEN_EVENT_NAMES = ['agentgen-progress', 'agentgen-done', 'agentgen-error'];
+// The scriptbench-* family (Scripts workbench §4.1): one more family in the same
+// runs Map. createBench emits many scriptbench-line then exactly one terminal
+// scriptbench-done OR scriptbench-error. A bench is NOT a run: no DB row, no
+// History entry, no ledger and no cost (W15) — only this buffer.
+const SCRIPTBENCH_EVENT_NAMES = ['scriptbench-line', 'scriptbench-done', 'scriptbench-error'];
+const MAX_BENCH_ENTRIES = 8;   // finished bench entries kept in the runs Map (startScriptBench evicts the rest)
 const MAX_BUFFER = 5000;
 
 // ---------------------------------------------------------------------------
@@ -373,20 +437,23 @@ wss.on('connection', (ws, req) => {
   let requestedRunId = null;
   let requestedScanId = null;
   let requestedGenId = null;
+  let requestedBenchId = null;
   let requestedThreadId = null;
   try {
     const u = new URL(req.url, 'http://localhost');
     requestedRunId = u.searchParams.get('runId');
     requestedScanId = u.searchParams.get('scanId');
     requestedGenId = u.searchParams.get('genId');
+    requestedBenchId = u.searchParams.get('benchId');
     requestedThreadId = u.searchParams.get('threadId');
   } catch {
     requestedRunId = null;
     requestedScanId = null;
     requestedGenId = null;
+    requestedBenchId = null;
     requestedThreadId = null;
   }
-  const id = requestedRunId || requestedScanId || requestedGenId;
+  const id = requestedRunId || requestedScanId || requestedGenId || requestedBenchId;
 
   send(ws, { type: 'hello', runs: summarizeRuns(), ask: askHello() });
 
@@ -410,7 +477,7 @@ wss.on('connection', (ws, req) => {
     } catch {
       return;
     }
-    const subId = msg && msg.type === 'subscribe' ? (msg.runId || msg.scanId || msg.genId) : null;
+    const subId = msg && msg.type === 'subscribe' ? (msg.runId || msg.scanId || msg.genId || msg.benchId) : null;
     if (subId && runs.has(subId)) {
       replayEntry(ws, runs.get(subId));
     }
@@ -490,6 +557,7 @@ function emitChanged(type, action) {
 }
 
 metricsEvents.on('changed', (e) => emitChanged('team-metrics-changed', e && e.action ? e.action : null));
+policyEvents.on('changed', (e) => emitChanged('team-policy-changed', e && e.action ? e.action : null));
 
 // Every comment mutation in THIS process (the REST routes below) pokes the open
 // Diff tabs. A poke carries ids only — no payload, so it is idempotent and has no
@@ -582,7 +650,11 @@ function liveDefragRun(scopeKeyStr) {
 }
 
 function summarizeRuns() {
-  return [...runs.values()].map((r) => ({
+  // W15: a bench is NOT a run. Its entry shares the runs Map for the WS replay
+  // plumbing only — leaving it here puts "bench: <key>" in every hello and the
+  // client's liveRuns() (which does NOT filter by kind) raises the rail's
+  // Running badge over an empty Running list.
+  return [...runs.values()].filter((r) => r.kind !== 'scriptbench').map((r) => ({
     runId: r.id,
     stepper: r.orch?.state?.stepper ?? null,
     pipelineId: r.pipelineId || null,
@@ -712,7 +784,36 @@ function wireRun(entry) {
         // Capture the on-disk pipeline short id the orchestrator stamps onto
         // state.id after createPipeline. Guard so null in pre-createPipeline
         // snapshots cannot overwrite a previously-captured value.
-        if (typeof payload.id === 'string' && payload.id) entry.pipelineId = payload.id;
+        if (typeof payload.id === 'string' && payload.id) {
+          const first = !entry.pipelineId;
+          entry.pipelineId = payload.id;
+          // Scheduled runs: the ticket learns the pipeline it became (provenance columns).
+          if (first && entry.ticketId) {
+            try { setTicketPipeline(entry.ticketId, payload.id); } catch (err) { console.error(`[worca-ui] ticket link failed: ${err && err.message ? err.message : err}`); }
+          }
+        }
+      }
+      if (entry.ticketId && (name === 'done' || name === 'error') && !entry._outcomeRecorded) {
+        // Scheduled runs: report how the fired run ended (feed item, failure streak).
+        // 'error' is the launch-error channel — a failure before the pipeline row exists.
+        entry._outcomeRecorded = true;
+        try {
+          recordOutcome(entry.ticketId, {
+            status: name === 'error' ? 'error' : ((payload && payload.status) || 'done'),
+            pipelineId: entry.pipelineId || null,
+            reason: (payload && payload.reason) || null,
+            detail: (payload && (payload.detail || payload.message)) || null,
+          });
+          emitChanged('schedules-changed', 'outcome');
+        } catch (err) { console.error(`[worca-ui] schedule outcome failed: ${err && err.message ? err.message : err}`); }
+      }
+      if ((name === 'done' || name === 'error') && !entry._chainNudged) {
+        // Run chains: a dependent waits on this run — open its gate now rather than at the next 30 s tick.
+        entry._chainNudged = true;
+        try {
+          const waiting = [...(entry.ticketId ? dependentsOfRun({ ticketId: entry.ticketId }) : []), ...(entry.pipelineId ? dependentsOfRun({ pipelineId: entry.pipelineId }) : [])];
+          if (waiting.length) setTimeout(() => { void schedulerTick(); }, 0);
+        } catch (err) { console.error(`[worca-ui] chain nudge failed: ${err && err.message ? err.message : err}`); }
       }
       if (name === 'title' && payload && typeof payload.title === 'string') {
         // Keep the in-memory run fresh so a late-joining client's hello
@@ -788,6 +889,47 @@ function wireAgentGen(entry) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Wire a Bench's events onto the WebSocket, tagged with benchId. The
+// scriptbench-* family: same runs Map, same ring-buffer/replay plumbing as
+// wireAgentGen. createBench emits many scriptbench-line then exactly one
+// terminal scriptbench-done OR scriptbench-error (run() never throws). The
+// terminal result is kept on the entry: the output route reads its PATHS from
+// there, never from the URL, and a reconnecting tab replays the buffer.
+// ---------------------------------------------------------------------------
+function wireScriptBench(entry) {
+  const { benchId, orch } = entry;
+
+  // Every frame carries a per-bench sequence number. The page learns its benchId
+  // from the POST answer and THEN subscribes, so for one round trip it receives a
+  // frame both live (the broadcast) and replayed (the buffer): `seq` is what lets
+  // it keep exactly one. It lives on the entry, not on events.length — the ring
+  // buffer is spliced at MAX_BUFFER.
+  const record = (event) => {
+    entry.seq = (entry.seq || 0) + 1;
+    const tagged = { ...event, benchId, seq: entry.seq };
+    entry.events.push(tagged);
+    if (entry.events.length > MAX_BUFFER) entry.events.splice(0, entry.events.length - MAX_BUFFER);
+    broadcast(tagged);
+    return tagged;
+  };
+
+  for (const name of SCRIPTBENCH_EVENT_NAMES) {
+    subscribe(orch, name, (payload) => {
+      const event = { type: name, ...(payload && typeof payload === 'object' ? payload : { value: payload }) };
+      if (name === 'scriptbench-line') { if (entry.status === 'running' || entry.status === 'created') entry.status = 'running'; }
+      else if (name === 'scriptbench-done') {
+        // A stop still ends in `done` with a stopped RESULT; the stop route has
+        // already marked the entry, so it is not overwritten here.
+        if (entry.status !== 'stopped') entry.status = 'done';
+        entry.result = (payload && payload.result) || null;
+      } else if (name === 'scriptbench-error') entry.status = 'error';
+      record(event);
+    });
+  }
+}
+
+
 // ---------------------------------------------------------------------------
 // Teams ingress (chat-connectivity-design.md §4.7) — the ONE deliberate,
 // auditable exemption from the loopback guard below: Bot Framework can only
@@ -876,6 +1018,9 @@ app.use((req, res, next) => {
 // over-budget upload still reaches the route's OWN clear 400/413, not a raw
 // parser error.
 app.post('/api/ask/threads/:id/messages', express.json({ limit: '64mb' }));
+// A script's saved cases are inline text: 32 cases x 256 KiB PER PORT is legal (workbench
+// spec §3.2) and does not fit the global 8 MB, so the one route that saves them all gets room.
+app.put('/api/scripts/:key/cases', express.json({ limit: '64mb' }));
 app.use(express.json({ limit: '8mb' }));
 
 if (HLJS_ASSETS) {
@@ -951,13 +1096,30 @@ app.use('/src/shared', (_req, res) => {
 // design §5.2). Read per request (100 KB, local) so an index.html edit is live
 // without a restart, exactly like static serving was. no-store: a theme change
 // must never be served from the browser cache.
+// Interface mode (docs/ui-levels.md): the stored choice, else the install's default. "Fresh" =
+// the welcome dialog was never dismissed and the store holds no project and no run; anything
+// else is an install that predates the mode (or has outgrown it) and keeps the full UI.
+function effectiveUiLevel() {
+  const stored = storedUiLevel();
+  if (stored) return stored;
+  let fresh = false;
+  try { fresh = !onboardingPrefs().welcomeSeen && countProjects() === 0 && countPipelines() === 0; }
+  catch { fresh = false; }
+  return defaultUiLevel({ fresh });
+}
+// "Fresh" is derived from state the user changes (welcomeSeen, the first project), so a new user's
+// mode would jump from simple to expert the moment they act. Each of those writes pins the derived
+// value first; a stored choice is never overwritten.
+async function pinUiLevel() {
+  if (!storedUiLevel()) await setUiLevel(effectiveUiLevel());
+}
 const INDEX_FILE = path.join(PUBLIC_DIR, 'index.html');
 if (!fs.readFileSync(INDEX_FILE, 'utf8').includes(INDEX_THEME_ANCHOR)) {
   throw new Error(`ui/public/index.html lost its theme anchor ${INDEX_THEME_ANCHOR}`);
 }
 function sendIndex(res) {
   let html;
-  try { html = renderIndexHtml(fs.readFileSync(INDEX_FILE, 'utf8'), storedTheme()); }
+  try { html = renderIndexHtml(fs.readFileSync(INDEX_FILE, 'utf8'), storedTheme(), effectiveUiLevel()); }
   catch (err) { return res.status(500).json({ error: err && err.message ? err.message : 'shell unavailable' }); }
   res.set('Content-Type', 'text/html; charset=utf-8');
   res.set('Cache-Control', 'no-store');
@@ -1264,6 +1426,11 @@ function askTrackRun(threadId, input, pin) {
 const startRunHandler = async (req, res) => {
   try {
     const body = req.body || {};
+    // Scheduled runs: `internal` is set ONLY by fireTicket() (never from HTTP) — the
+    // due ticket being started through this same gate. It carries the ticket, whose id
+    // IS the runId, plus the CLI-only options a stored request may hold.
+    const internal = req._internal && typeof req._internal === 'object' ? req._internal : null;
+    const stored = internal && body.internal && typeof body.internal === 'object' ? body.internal : {};
 
     // Mutual exclusion: exactly one of workspaceId / projectDir (§2.6).
     const hasWorkspace = typeof body.workspaceId === 'string' && body.workspaceId.trim();
@@ -1291,12 +1458,24 @@ const startRunHandler = async (req, res) => {
       if (!askGetThread(body.askThreadId)) return badRequest(res, 'unknown askThreadId');
       const found = askFindCard(body.askThreadId, body.askCardId);
       if (!found) return badRequest(res, 'unknown askCardId');
-      if (found.block.state !== 'proposed') {
+      const ownScheduledCard = internal && found.block.state === 'scheduled' && found.block.runId === internal.ticket.id;
+      if (found.block.state !== 'proposed' && !ownScheduledCard) {
         return res.status(409).json({ error: `card is ${found.block.state}` });
       }
       askLink = { threadId: body.askThreadId, cardId: body.askCardId };
     }
 
+    // Scheduled runs: `scheduledFor` (one-shot) and/or `repeat` (recurring) turn this
+    // request into a TICKET instead of a run. Parsed here so a bad time is a clean 400
+    // before anything else; everything below still validates the request, so a schedule
+    // fails fast now and is validated AGAIN when it starts.
+    let sched = null;
+    if (!internal && (body.scheduledFor != null || body.repeat != null || body.after != null || (body.sourceFromPrevious != null && body.sourceFromPrevious !== false))) {
+      const parsed = parseScheduleRequest(body);
+      if (!parsed.ok) return badRequest(res, parsed.error);
+      sched = parsed;
+    }
+
     // ── Shared resolution (factored BEFORE the target branch, §2.6) ──────────
     // NEW (plugins §7.3): body.source is the task-source descriptor; shape-check
     // only and pass through — the orchestrator resolves it exactly once. Absent
@@ -1373,6 +1552,16 @@ const startRunHandler = async (req, res) => {
     const memoryScope = typeof body.memoryScope === 'string' && body.memoryScope.trim() ? body.memoryScope.trim() : null;
     const scopeReason = validateMemoryScope({ workflowId, memoryScope, isWorkspace: !!hasWorkspace });
     if (scopeReason) return badRequest(res, scopeReason);
+    // Settings › Memory: a defragment run may name its model/effort PAIR at start — tier 1, above
+    // the setting (memory-defrag-model.mjs). Defragment runs only: every other workflow picks its
+    // models per node, and a body model there stays ignored exactly as before. The shape here; the
+    // catalog check needs the target project (below).
+    let startPair = null;
+    if (memoryScope) {
+      const shape = checkStartPair(body, null);
+      if (shape.error) return badRequest(res, shape.error);
+      startPair = shape.pair;
+    }
     // Human in the loop (spec D15): the body wins, else the project's stored
     // switch, else on. Resolved per target below (it needs the project dir).
     const bodyHumanInLoop = typeof body.humanInLoop === 'boolean' ? body.humanInLoop : null;
@@ -1395,16 +1584,20 @@ const startRunHandler = async (req, res) => {
 
     // Budget gate: no new pipelines while the total window is spent (F6).
     const budget = budgetStatus();
-    if (budget.blocked) {
+    if (budget.blocked && !sched) {
       return res.status(403).json({ error: 'total cost limit reached', budget });
     }
 
-    const runId = randomUUID();
+    const runId = internal ? internal.ticket.id : randomUUID();
     const title = (typeof body.title === 'string' && body.title.trim()) || fallbackRunTitle(effectivePrompt, source);
 
     // Materialize any uploaded extra files to a temp dir; the orchestrator's
     // createPipeline copies them into <pipeline>/extras/.
-    const extras = await writeExtras(runId, body.extras);
+    // A ticket's extras were staged durably when it was scheduled (the OS temp dir
+    // does not survive a reboot); a schedule stages them below, once it is validated.
+    const extras = internal
+      ? (Array.isArray(stored.extrasPaths) ? stored.extrasPaths.filter((x) => typeof x === 'string' && fs.existsSync(x)) : [])
+      : (sched ? [] : await writeExtras(runId, body.extras));
 
     const branch = {
       source: typeof body.sourceBranch === 'string' && body.sourceBranch.trim()
@@ -1425,6 +1618,12 @@ const startRunHandler = async (req, res) => {
       const ws = await readWorkspace(workspaceId);
       if (!ws) return res.status(404).json({ error: 'workspace not found' });
 
+      // Team total cap (design §7): soft — `pastTeamCap` acknowledges it once per window per home.
+      {
+        const gate = await checkTeamTotalGate({ workspaceId: ws.id }, { pastTeamCap: body.pastTeamCap === true, reason: typeof body.policyReason === 'string' ? body.policyReason : null });
+        if (gate.blocked) return res.status(gate.code === 'reason_required' ? 400 : 403).json({ error: gate.error, code: gate.code, policy: gate.policy, needsPolicyAck: gate.code === 'team_total' });
+      }
+
       // Resolve member detail. Each member must be an existing git repo (D3:
       // per-project worktrees + checkpoints). A vanished member is a hard 400 —
       // skip-missing is NOT allowed; a workspace run is defined over its full set.
@@ -1466,6 +1665,13 @@ const startRunHandler = async (req, res) => {
       const wsFileProblem = await promptFileProblem(effectiveSource, projects[0].projectDir);
       if (wsFileProblem) return badRequest(res, wsFileProblem);
 
+      if (sched && sched.after) {
+        const r = resolveAfterRef(sched.after, { workspaceId: ws.id, policy: sched.afterPolicy, isLive: liveProbe });
+        if (!r.ok) return badRequest(res, r.error);
+        sched.afterRef = r.after;
+      }
+      if (sched) return res.status(202).json(await scheduleRequest({ body, sched, title, askLink, budget, workspaceId: ws.id, projectDir: projects[0].projectDir }));
+
       orch = await createOrchestratorFor({
         workspace: {
           id: ws.id,
@@ -1483,7 +1689,9 @@ const startRunHandler = async (req, res) => {
         template: workflowRow,
         guardrailsId,
         branch,
-        claude: { permissionMode: 'acceptEdits', mock },
+        claude: { permissionMode: stored.permissionMode || 'acceptEdits', ...(stored.model ? { model: stored.model } : {}), mock },
+        // A CLI-made ticket may carry `--yes`: the explicit non-interactive choice survives the wait.
+        ...(stored.auto ? { auto: true } : {}),
       });
 
       entry = {
@@ -1522,14 +1730,35 @@ const startRunHandler = async (req, res) => {
 
       const fileProblem = await promptFileProblem(effectiveSource, projectDir);
       if (fileProblem) return badRequest(res, fileProblem);
+      // The pair against THIS project's catalog (a schedule is checked here too, before it is
+      // stored). A ticket firing takes its already-checked pair verbatim, like a CLI --model.
+      if (startPair && !internal) {
+        const checked = checkStartPair(body, await listModels(projectDir));
+        if (checked.error) return badRequest(res, checked.error);
+        startPair = checked.pair;
+      }
       // One live defragment run per scope (§7.3, amendment B20: this server process only).
       if (memoryScope) {
         const live = liveDefragRun(memoryScopeKey(memoryScope, projectDir));
         if (live) return res.status(409).json({ error: 'a defragment run for this memory scope is already live', runId: live.id });
       }
 
+      // Team total cap (design §7): soft — `pastTeamCap` acknowledges it once per window per home.
+      {
+        const gate = await checkTeamTotalGate({ projectDir }, { pastTeamCap: body.pastTeamCap === true, reason: typeof body.policyReason === 'string' ? body.policyReason : null });
+        if (gate.blocked) return res.status(gate.code === 'reason_required' ? 400 : 403).json({ error: gate.error, code: gate.code, policy: gate.policy, needsPolicyAck: gate.code === 'team_total' });
+      }
       const humanInLoop = bodyHumanInLoop ?? ((await readRunConfig(projectDir)).humanInLoop !== false);
 
+      if (sched && sched.after) {
+        const r = resolveAfterRef(sched.after, { projectDir, policy: sched.afterPolicy, isLive: liveProbe });
+        if (!r.ok) return badRequest(res, r.error);
+        sched.afterRef = r.after;
+      }
+      // A schedule stores the pair as checked (the catalog's casing, trimmed): its ticket takes it verbatim.
+      const storedBody = startPair ? { ...body, model: startPair.model, effort: startPair.effort || undefined } : body;
+      if (sched) return res.status(202).json(await scheduleRequest({ body: storedBody, sched, title, askLink, budget, projectDir }));
+
       orch = await createOrchestratorFor({
         projectDir,
         prompt: effectivePrompt,
@@ -1543,7 +1772,13 @@ const startRunHandler = async (req, res) => {
         branch,
         humanInLoop,
         ...(memoryScope ? { memoryScope } : {}),
-        claude: { permissionMode: 'acceptEdits', mock },
+        claude: {
+          permissionMode: stored.permissionMode || 'acceptEdits',
+          ...(startPair ? { model: startPair.model, ...(startPair.effort ? { effort: startPair.effort } : {}) } : (stored.model ? { model: stored.model } : {})),
+          mock,
+        },
+        // A CLI-made ticket may carry `--yes`: the explicit non-interactive choice survives the wait.
+        ...(stored.auto ? { auto: true } : {}),
       });
 
       entry = {
@@ -1559,6 +1794,11 @@ const startRunHandler = async (req, res) => {
       };
     }
 
+    if (internal) {
+      entry.ticketId = internal.ticket.id;
+      entry.scheduleId = internal.ticket.scheduleId || null;
+      entry.scheduledFor = internal.ticket.runAt;
+    }
     runs.set(runId, entry);
     wireRun(entry);
     if (askLink) {
@@ -1568,7 +1808,8 @@ const startRunHandler = async (req, res) => {
       // must not launch a second pipeline for the same card (review of PR #376).
       // Withdraw the run entry (nothing has run or been announced yet) and 409.
       const still = askFindCard(askLink.threadId, askLink.cardId);
-      if (!still || still.block.state !== 'proposed') {
+      const stillOwn = internal && still && still.block.state === 'scheduled' && still.block.runId === runId;
+      if (!still || (still.block.state !== 'proposed' && !stillOwn)) {
         runs.delete(runId);
         return res.status(409).json({ error: `card is no longer proposed (${still ? still.block.state : 'gone'})` });
       }
@@ -1622,6 +1863,582 @@ const startRunHandler = async (req, res) => {
 };
 app.post('/api/run', startRunHandler);
 
+// ---------------------------------------------------------------------------
+// Scheduled runs (schema v31, src/core/scheduler.mjs). A schedule is a TICKET, not a
+// pipeline: POST /api/run with `scheduledFor` and/or `repeat` validates the request
+// exactly like a run, stores it, and answers 202. The tick below claims due tickets
+// and pushes each one back through startRunHandler — so a scheduled run is validated
+// twice and born through the one start path every run uses.
+// ---------------------------------------------------------------------------
+const TRANSIENT_SOURCE_KINDS = new Set(['network', 'rate-limit', 'timeout']);
+const SCHEDULER_TICK_MS = 30_000;
+const SCHEDULER_STAGGER_MS = 3_000;
+
+/** Validate `scheduledFor` / `repeat` / `ifMissed` / `graceMin` on a run body. */
+function parseScheduleRequest(body, { now = Date.now() } = {}) {
+  const defaults = scheduleDefaults();
+  const out = { ok: true, runAtMs: null, repeat: null, after: null, afterPolicy: 'done', sourceFromPrevious: false, ifMissed: defaults.ifMissed, graceMin: defaults.graceMin };
+  const given = ['scheduledFor', 'repeat', 'after'].filter((k) => body[k] != null);
+  if (given.length > 1) return { ok: false, error: 'provide scheduledFor, repeat OR after, not both' };
+  if (body.sourceFromPrevious != null && typeof body.sourceFromPrevious !== 'boolean') return { ok: false, error: 'sourceFromPrevious must be true or false' };
+  if (body.sourceFromPrevious === true && body.after == null) return { ok: false, error: 'sourceFromPrevious needs after' };
+  if (body.after != null) {
+    const a = body.after;
+    if (!a || typeof a !== 'object' || Array.isArray(a) || !['ticket', 'pipeline'].includes(a.kind) || typeof a.id !== 'string' || !a.id.trim()) {
+      return { ok: false, error: 'after must be { kind: ticket | pipeline, id }' };
+    }
+    if (body.ifMissed != null || body.graceMin != null) return { ok: false, error: 'ifMissed and graceMin do not apply to a run after another run' };
+    if (body.afterPolicy != null && !AFTER_POLICIES.includes(body.afterPolicy)) return { ok: false, error: `afterPolicy must be one of ${AFTER_POLICIES.join(' | ')}` };
+    if (body.sourceFromPrevious === true && (body.sourceBranch != null || body.sourceBranchByKey != null)) return { ok: false, error: 'sourceFromPrevious and sourceBranch / sourceBranchByKey cannot both be given' };
+    out.after = { kind: a.kind, id: a.id.trim() };
+    out.afterPolicy = body.afterPolicy || 'done';
+    out.sourceFromPrevious = body.sourceFromPrevious === true;
+    return out;
+  }
+  if (body.ifMissed != null) {
+    if (!MISSED_POLICIES.includes(body.ifMissed)) return { ok: false, error: `ifMissed must be one of ${MISSED_POLICIES.join(' | ')}` };
+    out.ifMissed = body.ifMissed;
+  }
+  if (body.graceMin != null) {
+    if (!Number.isSafeInteger(body.graceMin) || body.graceMin < 0 || body.graceMin > 10080) return { ok: false, error: 'graceMin must be a whole number of minutes from 0 to 10080' };
+    out.graceMin = body.graceMin;
+  }
+  if (body.repeat != null) {
+    if (body.scheduledFor != null) return { ok: false, error: 'provide scheduledFor (run once) OR repeat (recurring), not both' };
+    const rep = body.repeat;
+    if (!rep || typeof rep !== 'object' || Array.isArray(rep)) return { ok: false, error: 'repeat must be an object: { rule, overlap?, maxFailures? }' };
+    const tz = rep.rule && typeof rep.rule === 'object' ? rep.rule.tz : null;
+    const norm = normalizeRule(rep.rule, { todayLocal: isValidTimeZone(tz) ? localDate(now, tz) : null });
+    if (!norm.ok) return { ok: false, error: norm.error };
+    if (rep.overlap != null && !OVERLAP_POLICIES.includes(rep.overlap)) return { ok: false, error: `repeat.overlap must be one of ${OVERLAP_POLICIES.join(' | ')}` };
+    if (rep.maxFailures != null && (!Number.isSafeInteger(rep.maxFailures) || rep.maxFailures < 0 || rep.maxFailures > 100)) {
+      return { ok: false, error: 'repeat.maxFailures must be a whole number from 0 to 100 (0 = never pause)' };
+    }
+    if (nextOccurrence(norm.rule, now) == null) return { ok: false, error: 'repeat.rule has no future occurrence' };
+    out.repeat = { rule: norm.rule, overlap: rep.overlap || 'skip', maxFailures: rep.maxFailures ?? defaults.maxFailures };
+    return out;
+  }
+  const at = parseScheduledFor(body.scheduledFor);
+  if (!at.ok) return { ok: false, error: at.error };
+  if (at.ms < now - 5_000) return { ok: false, error: 'scheduledFor is in the past' };
+  out.runAtMs = at.ms;
+  return out;
+}
+
+/** The request a ticket stores: the validated body minus schedule fields and uploads. */
+async function storedRequestOf(body, stageId, projectDir) {
+  const request = { ...body };
+  for (const k of ['scheduledFor', 'repeat', 'after', 'afterPolicy', 'sourceFromPrevious', 'ifMissed', 'graceMin', 'extras', 'internal']) delete request[k];
+  // Text the user authored is part of the request: a prompt FILE is frozen now, so a
+  // file deleted or half-edited overnight cannot fail an unattended run.
+  if (request.source && request.source.type === 'markdown' && request.source.promptFile && !request.source.promptText) {
+    const promptText = await readPromptFile(projectDir, request.source.promptFile);
+    request.source = { type: 'markdown', promptText };
+  }
+  const extrasPaths = await writeExtras(stageId, body.extras, path.join(scheduleStageDir(stageId), 'extras'));
+  request.internal = { extrasPaths };
+  return request;
+}
+
+/** Turn a validated run request into a ticket (or a recurring schedule). 202 body. */
+async function scheduleRequest({ body, sched, title, askLink, budget, projectDir, workspaceId = null }) {
+  const target = workspaceId ? { workspaceId } : { projectDir };
+  let ticket, schedule = null;
+  if (sched.repeat) {
+    const id = `sch_${randomBytes(4).toString('hex')}`;
+    const request = await storedRequestOf(body, id, projectDir);
+    ({ schedule, ticket } = createSchedule({
+      id, title, ...target, request, rule: sched.repeat.rule, overlap: sched.repeat.overlap,
+      maxFailures: sched.repeat.maxFailures, ifMissed: sched.ifMissed, graceMin: sched.graceMin,
+      askThreadId: askLink ? askLink.threadId : null, askCardId: askLink ? askLink.cardId : null,
+    }));
+    // An Ask card that became a repeating schedule follows the SERIES, not one run of it.
+    if (askLink) {
+      try { flipCard(askLink.threadId, askLink.cardId, { state: 'scheduled', runId: null, scheduleId: schedule.id, sentence: schedule.sentence, scheduledFor: ticket ? ticket.runAt : null }); }
+      catch (err) { console.error(`[worca-ui] ask card schedule flip failed: ${err && err.message ? err.message : err}`); }
+    }
+  } else {
+    const id = randomUUID();
+    const request = await storedRequestOf(body, id, projectDir);
+    // Both arms carry ifMissed / graceMin: parseScheduleRequest filled them with the Settings defaults
+    // (an after body may not name them), and a chained ticket later moved to a time shows them.
+    const chain = sched.after ? {
+      after: { kind: sched.afterRef.kind, id: sched.afterRef.id }, afterPolicy: sched.afterPolicy, sourceFromPrevious: sched.sourceFromPrevious, ifMissed: sched.ifMissed, graceMin: sched.graceMin,
+    } : { runAtMs: sched.runAtMs, ifMissed: sched.ifMissed, graceMin: sched.graceMin };
+    ticket = createTicket({ id, title, ...target, request, ...chain, askThreadId: askLink ? askLink.threadId : null, askCardId: askLink ? askLink.cardId : null });
+    if (askLink) {
+      try { flipCard(askLink.threadId, askLink.cardId, { state: 'scheduled', runId: id, scheduledFor: sched.after ? null : ticket.runAt, after: sched.after ? { kind: sched.afterRef.kind, id: sched.afterRef.id, title: sched.afterRef.title } : null }); }
+      catch (err) { console.error(`[worca-ui] ask card schedule flip failed: ${err && err.message ? err.message : err}`); }
+    }
+  }
+  emitChanged('schedules-changed', 'created');
+  return {
+    runId: ticket ? ticket.id : null,
+    status: 'scheduled',
+    scheduledFor: ticket && !ticket.after ? ticket.runAt : null,
+    ...(ticket && ticket.after ? { after: { kind: sched.afterRef.kind, id: sched.afterRef.id, title: sched.afterRef.title }, sourceFromPrevious: ticket.sourceFromPrevious } : {}),
+    ...(schedule ? { scheduleId: schedule.id, sentence: schedule.sentence } : {}),
+    ...(budget && budget.blocked ? { budgetWarning: 'The total cost limit is reached right now. The run will only start if the budget allows it at that time.' } : {}),
+  };
+}
+
+/** An Ask card that was scheduled goes back to `proposed` when its ticket dies or its series is deleted. */
+function releaseAskCard(item) {
+  if (!item || !item.askThreadId || !item.askCardId) return;
+  try {
+    const found = askFindCard(item.askThreadId, item.askCardId);
+    const b = found && found.block;
+    if (b && b.state === 'scheduled' && (item.kind === 'recurring' ? b.scheduleId === item.id : b.runId === item.id)) {
+      flipCard(item.askThreadId, item.askCardId, { state: 'proposed', runId: null, scheduledFor: null, scheduleId: null, sentence: null });
+    }
+  } catch (err) { console.error(`[worca-ui] ask card release failed: ${err && err.message ? err.message : err}`); }
+}
+
+/** Call startRunHandler without HTTP. Resolves { status, body }. */
+async function invokeStartRun(body, internal) {
+  let out = { status: 200, body: null };
+  const res = {
+    statusCode: 200,
+    status(code) { this.statusCode = code; return this; },
+    json(payload) { out = { status: this.statusCode, body: payload }; return this; },
+  };
+  await startRunHandler({ body, _internal: internal }, res);
+  return out;
+}
+
+/** runDueTickets' `start`: probe an external task first (transient errors retry), then start. */
+async function fireTicket(ticket) {
+  const body = { ...(ticket.request || {}) };
+  if (body.source && body.source.type === 'plugin') {
+    try {
+      await resolveTaskInput(body.source, { projectDir: ticket.projectDir || undefined });
+    } catch (err) {
+      return { ok: false, error: err && err.message ? err.message : String(err), transient: TRANSIENT_SOURCE_KINDS.has(err && err.kind) };
+    }
+  }
+  if (ticket.after) {
+    const p = predecessorState(ticket.after, { policy: ticket.after.policy, isLive: liveProbe });
+    if (p.state === 'waiting' && !ticket.forced) return { ok: false, error: 'the run before it is still going', transient: true };
+    if (ticket.sourceFromPrevious) {
+      const prev = p.pipelineId ? previousBranchesOf(p.pipelineId) : null;
+      if (!prev) return { ok: false, error: 'the run before it left no branch to start from', transient: false };
+      if (prev.sourceBranch) {
+        if (!(await isValidSourceRef(ticket.projectDir, prev.sourceBranch))) return { ok: false, error: `branch ${prev.sourceBranch} no longer exists`, transient: false };
+      } else {
+        const ws = ticket.workspaceId ? await readWorkspace(ticket.workspaceId) : null;
+        if (!ws) return { ok: false, error: 'workspace not found', transient: false };
+        for (const dir of ws.projectPaths) {
+          const key = projectKey(dir);
+          const br = prev.sourceBranchByKey[key];
+          if (!br) return { ok: false, error: `the run before it has no branch for ${path.basename(dir)}`, transient: false };
+          if (!(await isValidSourceRef(dir, br))) return { ok: false, error: `branch ${br} no longer exists in ${path.basename(dir)}`, transient: false };
+        }
+      }
+      delete body.sourceBranch; delete body.sourceBranchByKey;
+      Object.assign(body, prev);
+    }
+  }
+  // Every occurrence of a series needs its own feature branch.
+  if (ticket.scheduleId && typeof body.featureBranch === 'string' && body.featureBranch.trim()) {
+    const s = getSchedule(ticket.scheduleId);
+    const day = (s && s.tz ? localDate(Date.parse(ticket.runAt), s.tz) : ticket.runAt.slice(0, 10)).replace(/-/g, '');
+    body.featureBranch = `${body.featureBranch.trim()}-${day}`;
+  }
+  const out = await invokeStartRun(body, { ticket });
+  if (out.status === 200 && out.body && out.body.runId) return { ok: true };
+  const error = (out.body && out.body.error) || `the run could not be started (HTTP ${out.status})`;
+  return { ok: false, error, transient: out.status >= 500 };
+}
+
+/** The host's in-memory view of a run: by run id, or by the pipeline id it became. liveRunEntry is the
+ *  house lookup: it skips scans / agentgens / benches and, on a resumed lineage (D23), prefers the entry
+ *  still driving the pipeline over a settled same-pipeline entry that sits earlier in Map order. */
+function liveProbe({ id, pipelineId }) {
+  const e = liveRunEntry(id) || (pipelineId ? liveRunEntry(pipelineId) : null);
+  return !!e && !SETTLED_RUN.has(String(e.status || ''));
+}
+
+let _schedulerBusy = false;
+let _lastNotificationId = -1;
+let _lastScheduleSig = null;
+
+/** One scheduler pass. Exported for tests; the server calls it on a 30 s timer. */
+export async function schedulerTick({ now = Date.now() } = {}) {
+  if (_schedulerBusy) return null;
+  _schedulerBusy = true;
+  try {
+    const out = await runDueTickets({
+      now,
+      start: fireTicket,
+      isLive: liveProbe,
+      staggerMs: SCHEDULER_STAGGER_MS,
+    });
+    for (const id of [...out.failed, ...out.missed]) releaseAskCard(getTicket(id));
+    if (out.fired.length || out.missed.length || out.skipped.length || out.failed.length || out.retried.length) {
+      emitChanged('schedules-changed', 'tick');
+    }
+    // A `--wait` CLI writes notifications from ITS process: notice them here.
+    const latest = latestNotificationId();
+    if (_lastNotificationId !== -1 && latest !== _lastNotificationId) emitChanged('notifications-changed');
+    _lastNotificationId = latest;
+    // ...and the CLI writes tickets straight into the shared DB: notice those too.
+    const sig = scheduleSignature();
+    if (_lastScheduleSig !== null && sig !== _lastScheduleSig && !out.fired.length) emitChanged('schedules-changed', 'external');
+    _lastScheduleSig = sig;
+    return out;
+  } catch (err) {
+    console.error(`[worca-ui] scheduler tick failed: ${err && err.message ? err.message : err}`);
+    return null;
+  } finally {
+    _schedulerBusy = false;
+  }
+}
+
+let _schedulerTimer = null;
+/** Start the scheduler: recover, run one pass now (boot catch-up), then tick. */
+export function startScheduler() {
+  if (_schedulerTimer) return () => {};
+  try {
+    const recovered = recoverScheduler();
+    if (recovered) console.log(`[worca-ui] scheduler: returned ${recovered} interrupted ticket(s) to the queue`);
+    const purged = purgeScheduler();
+    purgeNotifications();
+    if (purged.tickets || purged.schedules) console.log(`[worca-ui] scheduler: purged ${purged.tickets} old ticket(s), ${purged.schedules} ended schedule(s)`);
+  } catch (err) { console.error(`[worca-ui] scheduler recovery failed: ${err && err.message ? err.message : err}`); }
+  schedulerTick();
+  _schedulerTimer = setInterval(() => { schedulerTick(); }, SCHEDULER_TICK_MS);
+  _schedulerTimer.unref();
+  return () => { clearInterval(_schedulerTimer); _schedulerTimer = null; };
+}
+
+// Notifications written in THIS process reach open tabs at once, and chat.
+onNotification((n) => {
+  broadcast({ type: 'notification', notification: n });
+  try { chatNotifier.notifySchedule(n); } catch { /* never break the writer */ }
+});
+
+/** A schedule item (ticket or series) by id, for the unified /api/schedules routes. */
+function findScheduleItem(id) {
+  if (typeof id !== 'string' || !id) return null;
+  if (id.startsWith('sch_')) { const s = getSchedule(id); return s ? { kind: 'recurring', item: s } : null; }
+  const t = getTicket(id);
+  return t ? { kind: 'once', item: t } : null;
+}
+
+/** A ticket for the wire: its predecessor resolved for display (title, live status, pipeline). */
+function withAfter(t) {
+  if (!t || !t.after) return t;
+  const p = predecessorState(t.after, { policy: t.after.policy, isLive: liveProbe });
+  return { ...t, after: { ...t.after, title: p.title || null, status: p.status || null, pipelineId: p.pipelineId || null } };
+}
+
+// GET /api/schedules[?projectDir=|workspaceId=][&all=1] -> { schedules, tickets, counts, defaults }
+app.get('/api/schedules', (req, res) => {
+  try {
+    const projectDir = resolveProjectDir(req.query.projectDir) || null;
+    const workspaceId = typeof req.query.workspaceId === 'string' && req.query.workspaceId.trim() ? req.query.workspaceId.trim() : null;
+    const all = req.query.all === '1' || req.query.all === 'true';
+    res.json({
+      schedules: listSchedules({ projectDir, workspaceId }),
+      tickets: listTickets({ projectDir, workspaceId, all }).map(withAfter),
+      counts: { ...scheduleCounts(), unread: unreadCount('schedule') },
+      defaults: scheduleDefaults(),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+// POST /api/schedules/preview { rule, count? } -> { sentence, next: [iso…] }
+app.post('/api/schedules/preview', (req, res) => {
+  const body = req.body || {};
+  const tz = body.rule && typeof body.rule === 'object' ? body.rule.tz : null;
+  const norm = normalizeRule(body.rule, { todayLocal: isValidTimeZone(tz) ? localDate(Date.now(), tz) : null });
+  if (!norm.ok) return badRequest(res, norm.error);
+  const n = Number.isSafeInteger(body.count) ? Math.max(1, Math.min(10, body.count)) : 3;
+  res.json({ rule: norm.rule, sentence: describeRule(norm.rule), next: previewOccurrences(norm.rule, Date.now(), n).map((t) => new Date(t).toISOString()) });
+});
+
+// GET /api/schedules/dependents?workflowId=|projectDir=|workspaceId= -> what a removal
+// would strand, so the confirmation can NAME it.
+app.get('/api/schedules/dependents', (req, res) => {
+  const q = req.query;
+  const label = (x) => ({ id: x.id, kind: x.kind, title: x.title });
+  if (typeof q.workflowId === 'string' && q.workflowId) return res.json({ dependents: dependentsOfWorkflow(q.workflowId) });
+  if (typeof q.pipelineId === 'string' && q.pipelineId) return res.json({ dependents: dependentsOfRun({ pipelineId: q.pipelineId }) });
+  if (typeof q.ticketId === 'string' && q.ticketId) return res.json({ dependents: dependentsOfRun({ ticketId: q.ticketId }) });
+  const projectDir = resolveProjectDir(q.projectDir) || null;
+  const workspaceId = typeof q.workspaceId === 'string' && q.workspaceId.trim() ? q.workspaceId.trim() : null;
+  if (!projectDir && !workspaceId) return badRequest(res, 'workflowId, projectDir or workspaceId is required');
+  res.json({
+    dependents: [
+      ...listSchedules({ projectDir, workspaceId, includeEnded: false }).map(label),
+      ...listTickets({ projectDir, workspaceId, oneShotOnly: true }).map(label),
+    ],
+  });
+});
+
+// GET /api/schedules/after-candidates?projectDir=|workspaceId= -> what a new run may wait for:
+// live runs of that target and its one-off tickets that have not ended.
+app.get('/api/schedules/after-candidates', (req, res) => {
+  try {
+    const projectDir = resolveProjectDir(req.query.projectDir) || null;
+    const workspaceId = typeof req.query.workspaceId === 'string' && req.query.workspaceId.trim() ? req.query.workspaceId.trim() : null;
+    if (!projectDir && !workspaceId) return badRequest(res, 'projectDir or workspaceId is required');
+    // The ROWS are the source of truth (spec §5): SETTLED_RUN contains 'paused', and another
+    // process's run is not in this host's runs Map at all. The Map only adds live runIds.
+    const where = workspaceId ? 'workspace_key = ?' : "project_key = ? AND target = 'project'";
+    const rows = getDb().prepare(`SELECT id, title, status FROM pipelines WHERE ${where}
+      AND status IN ('created', 'starting', 'running', 'pausing', 'paused') AND archived_at IS NULL ORDER BY started_at DESC LIMIT 50`)
+      .all(workspaceId || projectKey(projectDir));
+    const byPipeline = new Map(rows.map((r) => [r.id, { pipelineId: r.id, runId: null, title: r.title || null, status: r.status }]));
+    for (const r of runs.values()) {
+      if (!r.pipelineId || (r.kind && r.kind !== 'run' && r.kind !== 'workspace-run')) continue;
+      if (workspaceId ? r.workspaceId !== workspaceId : (r.projectDir !== projectDir || r.workspaceId)) continue;
+      const stillGoing = !SETTLED_RUN.has(String(r.status || '')) || r.status === 'paused';
+      if (!stillGoing) continue;
+      const cur = byPipeline.get(r.pipelineId) || { pipelineId: r.pipelineId, title: r.title || null, status: r.status };
+      byPipeline.set(r.pipelineId, { ...cur, runId: r.id, status: r.status });
+    }
+    // listTickets({ oneShotOnly: true }) returns scheduled | firing | missed. A MISSED ticket is left
+    // out: resolveAfterRef refuses it under either policy ("‘X’ was missed — nothing to wait for"),
+    // so offering it would be a dead pick (spec §5 lists it; this is the one deliberate narrowing).
+    const tickets = listTickets({ projectDir, workspaceId, oneShotOnly: true })
+      .filter((t) => t.status !== 'missed')
+      .map((t) => ({ id: t.id, title: t.title, status: t.status, after: t.after ? { kind: t.after.kind, id: t.after.id } : null }));
+    res.json({ runs: [...byPipeline.values()], tickets });
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+// GET /api/schedules/after/:id -> one predecessor and its target (the #new/after/<id> deep link).
+// async (listProjects is async) — and therefore wrapped: Express 4 does not catch a rejected
+// handler, and the deep link's fetch would hang instead of showing an error line.
+app.get('/api/schedules/after/:id', async (req, res) => {
+  try {
+    const id = req.params.id;
+    if (id.startsWith('sch_')) return badRequest(res, 'after a repeating schedule is not supported — give the id of one of its runs');
+    const ref = afterRefOf(id);
+    if (!ref || ref.scheduleId) return res.status(404).json({ error: 'run not found' });
+    let projectDir = null;
+    if (ref.kind === 'ticket') projectDir = (getTicket(ref.id) || {}).projectDir || null;   // a purge between the two reads is a null, not a throw
+    else if (!ref.workspaceId) {
+      const projects = await listProjects();
+      projectDir = (projects.find((p) => projectKey(p.path) === ref.projectKey) || {}).path || null;
+    }
+    res.json({ kind: ref.kind, id: ref.id, title: ref.title, status: ref.status, projectDir, workspaceId: ref.workspaceId || null });
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+app.get('/api/schedules/:id', (req, res) => {
+  const found = findScheduleItem(req.params.id);
+  if (!found) return res.status(404).json({ error: 'schedule not found' });
+  const history = found.kind === 'recurring' ? listTickets({ scheduleId: found.item.id, all: true, limit: 50 }).reverse() : [];
+  res.json({ ...found, item: found.kind === 'once' ? withAfter(found.item) : found.item, history, notifications: listNotifications({ scheduleId: found.kind === 'recurring' ? found.item.id : null, limit: 50 }).filter((n) => found.kind === 'recurring' || n.ticketId === found.item.id) });
+});
+
+// One schedule change, for the REST routes AND an applied Ask Worca schedule card — so the
+// card does exactly what the button on the Schedules page does. Resolves { status, body }.
+//   verb 'patch'     a ticket: { scheduledFor?, ifMissed?, graceMin? }
+//                    a series: { title?, rule?, overlap?, maxFailures?, ifMissed?, graceMin? }
+//   verb 'delete'    cancel a one-off ticket, or delete a series
+//   verb 'run-now'   start a ticket now, or one extra occurrence of a series
+//   verb 'pause' | 'resume' | 'skip-next'   a series only
+async function scheduleVerb(verb, id, body = {}) {
+  const found = findScheduleItem(id);
+  const out = (status, payload) => ({ status, body: payload });
+  if (!found) return out(404, { error: 'schedule not found' });
+  if (verb === 'patch') {
+    try {
+      if (found.kind === 'once') {
+        const patch = {};
+        if (body.scheduledFor != null) {
+          const at = parseScheduledFor(body.scheduledFor);
+          if (!at.ok) return out(400, { error: at.error });
+          if (at.ms < Date.now() - 5_000) return out(400, { error: 'scheduledFor is in the past' });
+          patch.runAtMs = at.ms;
+        }
+        if (body.ifMissed != null) {
+          if (!MISSED_POLICIES.includes(body.ifMissed)) return out(400, { error: `ifMissed must be one of ${MISSED_POLICIES.join(' | ')}` });
+          patch.ifMissed = body.ifMissed;
+        }
+        if (body.graceMin != null) patch.graceMin = body.graceMin;
+        if (body.after != null) {
+          if (body.scheduledFor != null) return out(400, { error: 'provide scheduledFor OR after, not both' });
+          if (body.ifMissed != null || body.graceMin != null) return out(400, { error: 'ifMissed and graceMin do not apply to a run after another run' });
+          const policy = body.afterPolicy != null ? body.afterPolicy : (found.item.after ? found.item.after.policy : 'done');
+          if (!AFTER_POLICIES.includes(policy)) return out(400, { error: `afterPolicy must be one of ${AFTER_POLICIES.join(' | ')}` });
+          const r = resolveAfterRef(body.after, { projectDir: found.item.projectDir, workspaceId: found.item.workspaceId, policy, selfId: found.item.id, isLive: liveProbe });
+          if (!r.ok) return out(400, { error: r.error });
+          patch.after = { kind: r.after.kind, id: r.after.id };
+          patch.afterPolicy = policy;
+        } else if (body.afterPolicy != null) {
+          if (!AFTER_POLICIES.includes(body.afterPolicy)) return out(400, { error: `afterPolicy must be one of ${AFTER_POLICIES.join(' | ')}` });
+          // A timed ticket has no policy (updateTicket drops one sent with runAtMs); say so rather than accept and
+          // ignore — for a policy sent WITH a time, and for one sent ALONE to a ticket that has no predecessor
+          // (that wrote after_policy onto a row with after_id NULL: harmless, but a lie in the row).
+          if (patch.runAtMs != null || !found.item.after) return out(400, { error: 'afterPolicy does not apply to a run at a time' });
+          patch.afterPolicy = body.afterPolicy;
+        }
+        if (body.sourceFromPrevious != null) {
+          if (typeof body.sourceFromPrevious !== 'boolean') return out(400, { error: 'sourceFromPrevious must be true or false' });
+          // Needs a predecessor AFTER this patch: none on the row and none coming, or a move back to a time
+          // (which clears after_* — `source_from_previous = 1` with `after_id = NULL` must never be written).
+          if (body.sourceFromPrevious && (patch.runAtMs != null || (!patch.after && !found.item.after))) return out(400, { error: 'sourceFromPrevious needs after' });
+          patch.sourceFromPrevious = body.sourceFromPrevious;
+        }
+        if (found.item.scheduleId && (patch.runAtMs != null || patch.after)) return out(400, { error: 'an occurrence of a repeating schedule cannot be moved — edit the schedule, or skip this occurrence' });
+        const t = updateTicket(found.item.id, patch);
+        if (!t) return out(409, { error: `this run is ${found.item.status} and can no longer be changed` });
+        const item = withAfter(t);
+        if (t.askThreadId && t.askCardId && (patch.runAtMs != null || patch.after)) {
+          try { flipCard(t.askThreadId, t.askCardId, { scheduledFor: t.after ? null : t.runAt, after: t.after ? { kind: t.after.kind, id: t.after.id, title: item.after.title } : null }); } catch { /* display only */ }
+        }
+        emitChanged('schedules-changed', 'updated');
+        emitChanged('notifications-changed');
+        return out(200, { kind: 'once', item });
+      }
+      const patch = {};
+      for (const k of ['title', 'rule', 'overlap', 'maxFailures', 'ifMissed', 'graceMin']) if (body[k] !== undefined) patch[k] = body[k];
+      if (patch.rule && typeof patch.rule === 'object' && !isValidTimeZone(patch.rule.tz)) return out(400, { error: `rule.tz is not a known timezone: ${patch.rule.tz ?? '(missing)'}` });
+      if (patch.maxFailures !== undefined && (!Number.isSafeInteger(patch.maxFailures) || patch.maxFailures < 0 || patch.maxFailures > 100)) {
+        return out(400, { error: 'maxFailures must be a whole number from 0 to 100 (0 = never pause)' });
+      }
+      if (patch.graceMin !== undefined && (!Number.isSafeInteger(patch.graceMin) || patch.graceMin < 0 || patch.graceMin > 10080)) {
+        return out(400, { error: 'graceMin must be a whole number of minutes from 0 to 10080' });
+      }
+      const s = updateSchedule(found.item.id, patch);
+      if (s && s.askThreadId && s.askCardId && patch.rule) {
+        try { flipCard(s.askThreadId, s.askCardId, { sentence: s.sentence, scheduledFor: s.nextRunAt }); } catch { /* display only */ }
+      }
+      emitChanged('schedules-changed', 'updated');
+      return out(200, { kind: 'recurring', item: s });
+    } catch (err) {
+      return out(400, { error: err && err.message ? err.message : String(err) });
+    }
+  }
+  if (verb === 'delete') {
+    if (found.kind === 'recurring') {
+      deleteSchedule(found.item.id);
+      releaseAskCard(found.item);
+    } else {
+      if (found.item.scheduleId) return out(400, { error: 'this is an occurrence of a repeating schedule — skip it instead' });
+      const t = cancelTicket(found.item.id);
+      if (!t) return out(409, { error: `this run is ${found.item.status} and can no longer be canceled` });
+      releaseAskCard(t);
+    }
+    emitChanged('schedules-changed', 'deleted');
+    emitChanged('notifications-changed');
+    return out(200, { ok: true });
+  }
+  if (verb === 'run-now') {
+    if (found.kind === 'once' && found.item.after && found.item.sourceFromPrevious) {
+      const p = predecessorState(found.item.after, { policy: found.item.after.policy, isLive: liveProbe });
+      if (!p.pipelineId || !previousBranchesOf(p.pipelineId)) return out(409, { error: `Start ‘${p.title || 'the run before it'}’ first, or change its source branch` });
+    }
+    const ticket = found.kind === 'recurring' ? runScheduleNow(found.item.id) : requestRunNow(found.item.id);
+    if (!ticket) return out(409, { error: `this ${found.kind === 'recurring' ? 'schedule' : 'run'} is ${found.item.status} and cannot be started` });
+    emitChanged('schedules-changed', 'run-now');
+    emitChanged('notifications-changed');
+    await schedulerTick();
+    const after = getTicket(ticket.id);
+    // A ticket held by a waiting `--wait` terminal is started by that terminal within seconds.
+    return out(200, { runId: ticket.id, status: after ? after.status : 'scheduled', failReason: after ? after.failReason : null, pipelineId: after ? after.pipelineId : null });
+  }
+  if (['pause', 'resume', 'skip-next'].includes(verb)) {
+    if (found.kind !== 'recurring') return out(404, { error: 'repeating schedule not found' });
+    const s = verb === 'pause' ? pauseSchedule(found.item.id) : verb === 'resume' ? resumeSchedule(found.item.id) : skipNext(found.item.id);
+    if (!s) return out(409, { error: `this schedule is ${found.item.status}` });
+    emitChanged('schedules-changed', verb);
+    emitChanged('notifications-changed');
+    return out(200, { kind: 'recurring', item: s });
+  }
+  return out(400, { error: `unknown schedule action ${verb}` });
+}
+
+/** Apply a CONFIRMED Ask Worca schedule card (schedule-spec.mjs shape) through scheduleVerb. */
+async function applyScheduleCard(card) {
+  const map = { run_now: ['run-now', {}], move: ['patch', card.patch || {}], edit: ['patch', card.patch || {}], cancel: ['delete', {}], delete: ['delete', {}] };
+  const m = map[card.action];
+  if (!m) return { ok: false, error: `unknown schedule action "${card.action}"` };
+  const r = await scheduleVerb(m[0], card.id, m[1]);
+  if (r.status !== 200) return { ok: false, error: (r.body && r.body.error) || `failed (${r.status})` };
+  const b = r.body || {};
+  let detail = '';
+  if (card.action === 'run_now') {
+    detail = b.status === 'failed' ? `could not start: ${b.failReason || 'unknown error'}`
+      : b.status === 'fired' ? `started${b.pipelineId ? ` as run ${b.pipelineId}` : ''}` : 'starting within seconds';
+    if (b.status === 'failed') return { ok: false, error: `could not start: ${b.failReason || 'unknown error'}`, runId: b.runId };
+  } else if (card.action === 'move') detail = card.after && card.after.when ? `now at ${card.after.when}` : card.after && card.after.afterRun ? `now after ‘${card.after.afterRun.title || card.after.afterRun.id}’` : 'moved';
+  else if (card.action === 'edit') {
+    const it = b.item;
+    detail = !it ? 'changed'
+      : it.nextRunAt ? `next run ${formatInstant(Date.parse(it.nextRunAt), it.tz || 'UTC')}`
+        : it.status === 'paused' ? 'still paused — resume it to run again' : `the schedule is ${it.status}`;
+  }
+  else detail = card.action === 'cancel' ? 'canceled' : 'deleted';
+  return { ok: true, detail, ...(b.runId ? { runId: b.runId } : {}), ...(b.pipelineId ? { pipelineId: b.pipelineId } : {}) };
+}
+
+// PATCH /api/schedules/:id — a ticket: { scheduledFor?, ifMissed?, graceMin? };
+// a series: { title?, rule?, overlap?, maxFailures?, ifMissed?, graceMin? }.
+app.patch('/api/schedules/:id', async (req, res) => {
+  const r = await scheduleVerb('patch', req.params.id, req.body || {});
+  res.status(r.status).json(r.body);
+});
+
+// DELETE /api/schedules/:id — cancel a one-shot ticket, or delete a series.
+app.delete('/api/schedules/:id', async (req, res) => {
+  const r = await scheduleVerb('delete', req.params.id);
+  res.status(r.status).json(r.body);
+});
+
+// POST /api/schedules/:id/run-now — start a ticket now, or one extra occurrence of a series.
+app.post('/api/schedules/:id/run-now', async (req, res) => {
+  const r = await scheduleVerb('run-now', req.params.id);
+  res.status(r.status).json(r.body);
+});
+
+for (const verb of ['pause', 'resume', 'skip-next']) {
+  app.post(`/api/schedules/:id/${verb}`, async (req, res) => {
+    const r = await scheduleVerb(verb, req.params.id);
+    res.status(r.status).json(r.body);
+  });
+}
+
+// GET /api/notifications?scope=schedule[&unread=1][&problems=1] -> { notifications, unread }
+app.get('/api/notifications', (req, res) => {
+  try {
+    const scope = typeof req.query.scope === 'string' && req.query.scope ? req.query.scope : 'schedule';
+    const flag = (v) => v === '1' || v === 'true';
+    res.json({
+      notifications: listNotifications({ scope, unread: flag(req.query.unread), problems: flag(req.query.problems) }),
+      unread: unreadCount(scope),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+app.post('/api/notifications/read-all', (req, res) => {
+  const scope = req.body && typeof req.body.scope === 'string' && req.body.scope ? req.body.scope : 'schedule';
+  markAllRead(scope);
+  emitChanged('notifications-changed');
+  res.json({ unread: unreadCount(scope) });
+});
+
+app.post('/api/notifications/:id/read', (req, res) => {
+  const id = Number(req.params.id);
+  if (!Number.isSafeInteger(id)) return badRequest(res, 'invalid notification id');
+  const read = !(req.body && req.body.read === false);
+  if (!markRead(id, { read })) return res.status(404).json({ error: 'notification not found' });
+  emitChanged('notifications-changed');
+  res.json({ unread: unreadCount('schedule') });
+});
+
 // ---------------------------------------------------------------------------
 // Chat connectivity (chat-connectivity-design.md): persistent channel workers
 // + inbound command router. Workers are dumb transports; every command
@@ -1640,6 +2457,11 @@ const chatContext = {
 
 const chatActions = {
   listRuns: () => summarizeRuns(),
+  // Waiting + missed tickets, soonest first, with the time in this server's zone.
+  listScheduled: () => listTickets().map((t) => ({
+    id: t.id, title: t.title, runAt: t.runAt, status: t.status, projectDir: t.projectDir,
+    when: formatInstant(Date.parse(t.runAt), Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'),
+  })),
   runState: (runId) => { try { return runs.get(runId)?.orch?.getState() ?? null; } catch { return null; } },
   pendingQuestion: (runId) => runs.get(runId)?.pendingQuestion ?? null,
   answer: (runId, id, payload) => answerRun(runId, id, payload),
@@ -1742,6 +2564,18 @@ function reloadChatWorkers(name) {
 // from Discord clears the question card in every browser tab exactly like the
 // UI button does (resolvePending is part of the action, not the route).
 // ---------------------------------------------------------------------------
+/**
+ * Resolve a pending question. ONE implementation behind the HTTP route and the
+ * chat command router (`chatActions.answer`), so answering from Discord clears the
+ * card in every browser tab exactly like the UI button does.
+ *
+ * Ask forms, gate 3 (ruling X2): `orch.answer` THROWS `Error('invalid answer')`
+ * with `code: 'INVALID_ANSWER'` and `errors: [{ path, code, message }]` when the
+ * values are refused. That throw is RETHROWN unchanged and must never be caught
+ * here — `resolvePending` below must not run, or the question would be cleared in
+ * every tab while the run is still waiting on it. Callers (`POST /api/answer` →
+ * 422, and P4's CLI + chat) branch on `err.code === 'INVALID_ANSWER'`.
+ */
 function answerRun(runId, id, payload) {
   const entry = runs.get(runId);
   if (!entry) throw new Error('unknown runId');
@@ -1776,6 +2610,12 @@ app.post('/api/answer', (req, res) => {
     answerRun(runId, id, payload);
     res.json({ ok: true });
   } catch (err) {
+    // Gate 3 (ask forms, spec §5): the answer was validated and refused, so the
+    // question stays OPEN and the client gets the field errors to mark up. Every
+    // other failure keeps its 500.
+    if (err && err.code === 'INVALID_ANSWER') {
+      return res.status(422).json({ error: 'invalid answer', errors: Array.isArray(err.errors) ? err.errors : [] });
+    }
     res.status(500).json({ error: err && err.message ? err.message : String(err) });
   }
 });
@@ -1828,7 +2668,7 @@ class ResumeError extends Error {
   }
 }
 
-async function resumeRun(pipelineId, { ignoreCostCap = false, mock = false } = {}) {
+async function resumeRun(pipelineId, { ignoreCostCap = false, mock = false, pastTeamCap = false, policyReason = null } = {}) {
   if (!pipelineId || typeof pipelineId !== 'string') throw new ResumeError(400, { error: 'pipelineId is required' });
   const saved = readPipelineForResume(pipelineId);
   if (!saved) throw new ResumeError(404, { error: 'pipeline not found' });
@@ -1897,6 +2737,19 @@ async function resumeRun(pipelineId, { ignoreCostCap = false, mock = false } = {
     if (!projectDir) throw new ResumeError(400, { error: 'project for this pipeline is not onboarded on this machine' });
   }
 
+  // Team policy gates (design §7): the total cap once per window per home, the pipeline cap once
+  // per run. Both soft — `pastTeamCap` (with an optional / required reason) records the choice
+  // and lets the resume through; the local gates above stay never-bypassable.
+  const teamTarget = workspace ? { workspaceId: workspace.id } : { projectDir };
+  const totalGate = await checkTeamTotalGate(teamTarget, { pastTeamCap, reason: policyReason });
+  if (totalGate.blocked) {
+    throw new ResumeError(totalGate.code === 'reason_required' ? 400 : 403, { error: totalGate.error, code: totalGate.code, policy: totalGate.policy, needsPolicyAck: totalGate.code === 'team_total' });
+  }
+  const pipeGate = checkTeamPipelineGate(totalGate.caps, { pipelineId, spentSoFar, pastTeamCap, reason: policyReason });
+  if (pipeGate.blocked) {
+    throw new ResumeError(pipeGate.code === 'reason_required' ? 400 : 403, { error: pipeGate.error, code: pipeGate.code, policy: pipeGate.policy, needsPolicyOverride: pipeGate.code === 'team_pipeline' });
+  }
+
   // A paused defragment run is not live; another one on the same scope may have started since.
   // Resuming the first would sync its stale mount over the second's work (spec §5 concurrency).
   const rpScope = saved.resumePoint?.memoryScope || null;
@@ -1986,6 +2839,8 @@ app.post('/api/resume', async (req, res) => {
     const out = await resumeRun(req.body?.pipelineId, {
       ignoreCostCap: req.body?.ignoreCostCap === true,
       mock: !!(req.body && req.body.mock),
+      pastTeamCap: req.body?.pastTeamCap === true,
+      policyReason: typeof req.body?.policyReason === 'string' ? req.body.policyReason : null,
     });
     res.json(out);
   } catch (err) {
@@ -2013,7 +2868,7 @@ app.get('/api/runs', async (req, res) => {
       const live = [...runs.values()]
         .filter((r) => r.workspaceId === ws.id)
         .map((r) => ({ id: r.pipelineId || r.id, runId: r.id, title: r.title, status: r.status, live: true }));
-      return res.json({ pipelines, live, ghAvailable: await hasGh() });
+      return res.json({ pipelines, live, scheduled: listTickets({ workspaceId: ws.id }), ghAvailable: await hasGh() });
     } catch (err) {
       return res.status(500).json({ error: err && err.message ? err.message : String(err) });
     }
@@ -2037,7 +2892,8 @@ app.get('/api/runs', async (req, res) => {
         status: r.status,
         live: true,
       }));
-    res.json({ pipelines, live, ghAvailable: await hasGh() });
+    // Additive: runs that WAIT for their start time are tickets, not pipelines.
+    res.json({ pipelines, live, scheduled: listTickets({ projectDir }), ghAvailable: await hasGh() });
   } catch (err) {
     res.status(500).json({ error: err && err.message ? err.message : String(err) });
   }
@@ -2088,6 +2944,72 @@ app.get('/api/runs/:id/artifacts', async (req, res) => {
   }
 });
 
+// ---------------------------------------------------------------------------
+// Ask-form preview files (spec §7, D8). Served by (run, askId, index) — there is
+// NO path input on this surface: `:askId` is a token askIdToken() minted,
+// `:index` is a small integer, and the only string joined onto a directory is the
+// basename the snapshot's own manifest.json recorded. Posture copied from the Ask
+// attachment route: streamed sendFile, dotfiles denied, the SNIFFED type, nosniff,
+// inline, immutable private cache. Behind the loopback guard like every route.
+// ---------------------------------------------------------------------------
+const ASK_FILES_TOKEN_RE = /^[A-Za-z0-9_-]{1,96}$/;
+
+async function serveAskFile(res, runDir, askId, index) {
+  if (!runDir) return res.status(404).json({ error: 'pipeline not found' });
+  if (typeof askId !== 'string' || !ASK_FILES_TOKEN_RE.test(askId)) {
+    return res.status(400).json({ error: 'invalid ask id' });
+  }
+  if (typeof index !== 'string' || !/^\d{1,2}$/.test(index)) {
+    return res.status(400).json({ error: 'invalid file index' });
+  }
+  const dir = path.join(runDir, ASK_FILES_DIR, askId);
+  const entry = await readAskFileEntry(dir, Number(index));
+  if (!entry) return res.status(404).json({ error: 'ask file not found' });
+  // The text classes are PROVEN UTF-8 by the sniffer (a fatal decoder), so say so:
+  // under nosniff a bare `text/plain` is decoded with the browser's legacy default
+  // charset on a direct open, and non-ASCII prose garbles. Binary types stay bare.
+  const type = ASK_FILE_MIMES[entry.mime].trust === 'text' ? `${entry.mime}; charset=utf-8` : entry.mime;
+  const headers = {
+    'Content-Type': type,
+    'X-Content-Type-Options': 'nosniff',
+    'Content-Disposition': 'inline',
+    'Cache-Control': 'private, max-age=31536000, immutable',
+  };
+  // §7's "inline, inert only" row: an SVG is drawn through <img> in the panel,
+  // and a direct hit on this URL is inert too — no script, no fetch, no anything.
+  if (entry.mime === 'image/svg+xml') headers['Content-Security-Policy'] = "sandbox; default-src 'none'";
+  res.sendFile(entry.stored, { root: dir, dotfiles: 'deny', cacheControl: false, headers }, (err) => {
+    if (!err || res.headersSent) return;
+    if (err.code === 'ENOENT' || err.status === 404) return res.status(404).json({ error: 'ask file not found' });
+    res.status(500).json({ error: err.message || String(err) });
+  });
+}
+
+/** The run dir behind a LIVE id: the pipeline id (what /api/runs/:id/artifact
+ *  takes) or the WebSocket run UUID (what the browser holds). */
+async function askFilesRunDir(id) {
+  const live = liveRunEntry(id);
+  const row = findPipelineRowById(live?.pipelineId || id);
+  if (!row) return null;
+  try { return await runDirForRow(row); } catch { return null; }
+}
+
+app.get('/api/runs/:id/ask-files/:askId/:index', async (req, res) => {
+  try {
+    await serveAskFile(res, await askFilesRunDir(req.params.id), req.params.askId, req.params.index);
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+/** The run dir behind a STORE KEY + run id — the shape both the History and the
+ *  workspace twin resolve through. Null (→ 404) when the row or its dir is gone. */
+async function askFilesStoreDir(key, runId) {
+  const row = lookupPipelineRow(key, runId);
+  if (!row) return null;
+  try { return await runDirForRow(row); } catch { return null; }
+}
+
 // Shared query-scope resolver for the retained-work routes (recovery-patch GET +
 // discard POST). Returns null after writing the error response itself. The older
 // DELETE /api/runs/:id route keeps its inline copy DELIBERATELY (it shadows the
@@ -2199,7 +3121,10 @@ app.get('/api/onboarding', async (_req, res) => {
   catch (err) { res.status(500).json({ error: err && err.message ? err.message : String(err) }); }
 });
 app.post('/api/onboarding', async (req, res) => {
-  try { await setOnboardingPrefs(req.body || {}); }
+  try {
+    await pinUiLevel();                        // before welcomeSeen flips and ends "fresh install"
+    await setOnboardingPrefs(req.body || {});
+  }
   catch (err) { return badRequest(res, err && err.message ? err.message : String(err)); }
   emitChanged('onboarding-changed');
   try { res.json(await onboardingStatus()); }
@@ -2212,6 +3137,7 @@ app.get('/api/counts', (_req, res) => {
       pipelines: countPipelines(),
       projects: countProjects(),
       workspaces: countWorkspaces(),
+      schedules: { ...scheduleCounts(), unread: unreadCount('schedule') },
     });
   } catch (err) {
     res.status(500).json({ error: err && err.message ? err.message : String(err) });
@@ -2279,16 +3205,18 @@ app.get('/api/team-metrics', async (req, res) => {
     // `changed` event tells the page to reload. Other clients (Ask tools, CLI, tests) keep the
     // inline fetch and get fresh data in one round trip.
     const read = await readScope(scope, { refresh: req.query.refresh === '1', defer: req.query.defer === '1' });
+    const humanRateUsd = effectiveHumanRateUsd(read.rateProjectDir);
     // Flush trigger: page open (§4.5). reason:'page-open' backs off for 60 s after a failed flush,
     // so a failing push cannot loop through flush-failed → WS → page reload → GET → flush.
     for (const s of read.sync) if (s.pending > 0) scheduleFlush(s.slug, { reason: 'page-open' });
     res.json({
       scope: read.scope,
       records: read.records,
+      humanRateUsd,                                     // the client re-aggregates with it (money-saved §9.2)
       // The page re-aggregates client-side (§4.9 "one fetch serves the session") and asks with
       // aggregate=0: at 12k records the unused aggregate added ~3.9 MB to a ~9.9 MB response.
       // Other clients (and the API tests) still get it by default.
-      aggregate: req.query.aggregate === '0' ? null : aggregate(read.records, { range, from, to, groupBy }),
+      aggregate: req.query.aggregate === '0' ? null : aggregate(read.records, { range, from, to, groupBy, humanRateUsd }),
       stats: read.stats,
       sync: read.sync,
       refresh: read.refresh,
@@ -2380,6 +3308,112 @@ app.post('/api/workspaces/:id/metrics-route', async (req, res) => {
   catch (err) { sendMetricsError(res, err); }
 });
 
+// ---------------------------------------------------------------------------
+// Team policy (team-policy design §11): scopes/statuses, the effective document for one
+// scope, publish, notes for the New pipeline form, enable / follow, workspace routing.
+// ---------------------------------------------------------------------------
+const POLICY_ERROR_STATUS = {
+  BAD_REQUEST: 400, NOT_FOUND: 404, NO_ORIGIN: 400, DELEGATE_INVALID: 400, NOT_HOME: 409, NOT_ENABLED: 409,
+  REMOTE_UNREACHABLE: 502, FETCH_FAILED: 502, WORKTREE_FAILED: 500, COMMIT_FAILED: 500,
+  PUSH_REJECTED: 409, PUSH_RETRIES_EXHAUSTED: 409,
+};
+function sendPolicyError(res, err) {
+  const code = (err && err.code) || 'INTERNAL';
+  res.status(POLICY_ERROR_STATUS[code] || 500).json({
+    error: err && err.message ? err.message : String(err), code,
+    ...(err && err.stderr ? { stderr: err.stderr } : {}),
+    ...(err && err.hint ? { hint: err.hint } : {}),
+    ...(err && Array.isArray(err.warnings) ? { warnings: err.warnings } : {}),
+  });
+}
+
+app.get('/api/policy/scopes', async (req, res) => {
+  try {
+    const scopes = await listPolicyScopes({ discover: req.query.discover === '1' });
+    // The Plugins page strip and the setup checklist: every home's requirements, folded.
+    const docs = [];
+    for (const s of scopes.projects) if (s.home && !docs.some((d) => d.slug === s.home)) {
+      const r = await resolveProjectPolicy(s.path, { discover: false }).catch(() => null);
+      if (r?.ok) docs.push({ slug: r.home, doc: r.doc });
+    }
+    res.json({ ...scopes, requirements: pluginRequirements(docs), blockedPlugins: blockedPluginFindings(docs) });
+  } catch (err) { sendPolicyError(res, err); }
+});
+
+app.get('/api/policy', async (req, res) => {
+  const scope = parseScopeParam(req.query.scope);
+  if (!scope) return badRequest(res, 'scope must be project:<projectKey> or workspace:<workspaceId>');
+  try {
+    const { meta, r, workspaceRun, projectDir } = await policyForScope(scope);
+    if (!r.ok) return res.status(404).json({ error: r.detail || `no team policy for this ${scope.kind}`, code: (r.code || r.reason || 'NOT_ENABLED').toString().toUpperCase().replace(/-/g, '_'), scope: meta });
+    res.json(policyPayload(meta, r, { workspaceRun, projectDir }));
+  } catch (err) { sendPolicyError(res, err); }
+});
+
+// New pipeline form (board 8): the notes for a selection — caps, off-policy picks, plugin gaps.
+app.get('/api/policy/notes', async (req, res) => {
+  const scope = parseScopeParam(req.query.scope);
+  if (!scope) return badRequest(res, 'scope must be project:<projectKey> or workspace:<workspaceId>');
+  try {
+    const { meta, r, workspaceRun } = await policyForScope(scope);
+    if (!r.ok) return res.json({ scope: meta, policy: null, notes: [] });
+    const fields = fieldsForRun(r.doc, { workspaceRun });
+    const guardrailsId = typeof req.query.guardrailsId === 'string' && req.query.guardrailsId ? req.query.guardrailsId : 'permissive';
+    const set = await readGuardrailSet(guardrailsId);
+    const models = typeof req.query.models === 'string' && req.query.models ? req.query.models.split(',').filter(Boolean).map((m) => ({ role: null, model: m })) : [];
+    const dev = deviationsFor(fields, { guardrailsId, guardrailSet: set, stepModels: models, installed: installedPluginsMap(), worcaVersion: POLICY_WORCA_VERSION, metricsRecord: null });
+    res.json({ scope: meta, policy: { home: r.home, sha: r.sha, delegated: r.delegated, from: r.from, caps: capSummary(r.doc, { workspaceRun }) }, notes: dev, guardrailsDefault: fields['guardrails.default']?.value ?? null });
+  } catch (err) { sendPolicyError(res, err); }
+});
+
+// Publish (board 5): one commit to the home's worca-policy branch; a rejection comes back verbatim.
+app.put('/api/policy', async (req, res) => {
+  const scope = parseScopeParam(req.body?.scope);
+  if (!scope) return badRequest(res, 'scope must be project:<projectKey> or workspace:<workspaceId>');
+  if (!req.body || typeof req.body.doc !== 'object' || req.body.doc === null) return badRequest(res, 'doc must be the policy document');
+  try {
+    const { r } = await policyForScope(scope);
+    if (!r.ok) return res.status(404).json({ error: r.detail || 'no team policy for this scope', code: 'NOT_ENABLED' });
+    if (!r.homeDir || !fs.existsSync(r.homeDir)) return res.status(409).json({ error: `the policy home ${r.home} is not checked out on this machine`, code: 'NOT_HOME' });
+    const out = await publishPolicy(r.homeDir, req.body.doc, { message: typeof req.body.message === 'string' ? req.body.message : null });
+    res.json({ ok: true, slug: out.slug, sha: out.sha, unchanged: !!out.unchanged, doc: out.doc });
+  } catch (err) { sendPolicyError(res, err); }
+});
+
+// Validate without publishing (the editor's live check): the normaliser's warnings, if any.
+app.post('/api/policy/validate', (req, res) => {
+  const { doc, warnings, unknownSchema } = normalizePolicyDoc(req.body?.doc);
+  res.json({ ok: !!doc && !unknownSchema && warnings.length === 0, warnings, doc });
+});
+
+app.post('/api/policy/discover', async (_req, res) => {
+  try { await discoverAllPolicies({ force: true }); res.json(await listPolicyScopes()); }
+  catch (err) { sendPolicyError(res, err); }
+});
+
+app.get('/api/projects/:key/policy', async (req, res) => {
+  const p = await tmProject(req, res); if (!p) return;
+  try { res.json({ status: await projectPolicyStatus(p, { discover: req.query.discover === '1' }) }); }
+  catch (err) { sendPolicyError(res, err); }
+});
+
+app.post('/api/projects/:key/policy/enable', async (req, res) => {
+  const p = await tmProject(req, res); if (!p) return;
+  const body = req.body || {};
+  const mode = body.mode === 'follow' ? 'follow' : body.mode === 'here' || body.mode == null ? 'here' : null;
+  if (!mode) return badRequest(res, 'mode must be "here" or "follow"');
+  try {
+    const result = await enableTeamPolicy(p.path, { mode, delegateTo: body.delegateTo || null, change: body.change === true, title: typeof body.title === 'string' ? body.title : '' });
+    res.json({ ...result, status: await projectPolicyStatus(p) });
+  } catch (err) { sendPolicyError(res, err); }
+});
+
+app.post('/api/workspaces/:id/policy-route', async (req, res) => {
+  if (!WORKSPACE_KEY_RE.test(req.params.id)) return res.status(404).json({ error: 'workspace not found', code: 'NOT_FOUND' });
+  try { res.json(await routeWorkspaceMembersPolicy(req.params.id)); }
+  catch (err) { sendPolicyError(res, err); }
+});
+
 // ---------------------------------------------------------------------------
 // POST /api/history/pr  -> enrich the skeleton with live PR state, pushed back
 // over the WS as batched `history-pr` events (reuses broadcast(), the same
@@ -2666,6 +3700,20 @@ app.get('/api/history/:key/:id/artifact', async (req, res) => {
   }
 });
 
+// GET /api/history/:key/:id/ask-files/:askId/:index -> the same bytes, resolved
+// through the store key. Same key regex as /diff and /artifact.
+app.get('/api/history/:key/:id/ask-files/:askId/:index', async (req, res) => {
+  if (!/^[a-z0-9][a-z0-9-]*-[0-9a-f]{8}$/.test(req.params.key)) {
+    return res.status(404).json({ error: 'pipeline not found' });
+  }
+  try {
+    await serveAskFile(res, await askFilesStoreDir(req.params.key, req.params.id),
+      req.params.askId, req.params.index);
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
 // ---------------------------------------------------------------------------
 // DELETE /api/runs/:id?projectKey=...  (or ?projectDir=...)
 // ARCHIVE a FINISHED pipeline: reclaims everything on disk — its store folder,
@@ -2797,26 +3845,43 @@ async function resolvePrPipeline(src, res) {
 // the ship-it dialog plus the defaults POST /api/pr applies when the body names
 // none. Same pipeline resolution as POST /api/pr (the repo dir comes from the
 // pipeline's store_meta, never from the query). gh is not required here.
+// The base-branch choices ride along: `chain` is the run chain's base branches,
+// root first (a run outside a chain: just its source), `defaultBase` its root, and
+// `branches` each remote's branches from the LOCAL remote-tracking refs (no fetch),
+// without HEAD and the run's own feature branch. A git remote failure still carries
+// the chain so the dialog can offer it.
 // -> { ok, remotes:[{name,fetchUrl,pushUrl,host,owner,repo,slug}],
-//      defaults:{pushRemote,baseRemote}, remembered:{pushRemote,baseRemote}|null }
+//      defaults:{pushRemote,baseRemote}, remembered:{pushRemote,baseRemote}|null,
+//      chain:[branch], defaultBase:branch|null, branches:{[remote]:[branch]} }
 // ---------------------------------------------------------------------------
 app.get('/api/pr/remotes', async (req, res) => {
   const resolved = await resolvePrPipeline(req.query || {}, res);
   if (!resolved) return;
   const repoDir = resolved.state.projectDir;          // null when store_meta is missing
   if (!repoDir) return badRequest(res, 'pipeline has no project directory');
+  const feature = resolved.state.branch && resolved.state.branch.feature;
+  const source = resolved.state.branch && resolved.state.branch.source;
+  const walked = chainBaseBranchesOf(resolved.state.id || resolved.id);
+  const chain = (walked.length ? walked : (source ? [source] : [])).filter((b) => b !== feature);
+  const defaultBase = chain[0] || null;
   const rl = await listRemotes(repoDir);
-  if (!rl.ok) return res.status(500).json({ error: `git remote failed: ${rl.error}` });
+  if (!rl.ok) return res.status(500).json({ error: `git remote failed: ${rl.error}`, chain, defaultBase });
   const remembered = readPrRemotePrefs(repoDir);
-  res.json({ ok: true, remotes: rl.remotes, defaults: defaultPrRemotes(rl.remotes, remembered), remembered });
+  const rb = await listRemoteBranches(repoDir, rl.remotes.map((r) => r.name));
+  const branches = {};
+  for (const [name, list] of Object.entries(rb.byRemote)) branches[name] = list.filter((b) => b !== feature);
+  res.json({ ok: true, remotes: rl.remotes, defaults: defaultPrRemotes(rl.remotes, remembered), remembered,
+    chain, defaultBase, branches });
 });
 
 // ---------------------------------------------------------------------------
 // POST /api/pr  -> push the pipeline's feature branch (if needed) and open a PR
-// against its source branch via the GitHub CLI. Mergeability is read back only
-// here (never during list rendering).
-// body: { id, projectDir?, projectKey?, pushRemote?, baseRemote? } — remote names
-// are validated against the repo's real remote list (never trusted from the body).
+// against its source branch (or the dialog's `baseBranch`) via the GitHub CLI.
+// Mergeability is read back only here (never during list rendering).
+// body: { id, projectDir?, projectKey?, pushRemote?, baseRemote?, baseBranch? } —
+// remote names are validated against the repo's real remote list (never trusted
+// from the body); baseBranch must be a well-formed ref other than the feature
+// branch (whether the base repo has it is gh's call, its error surfaces as usual).
 // ---------------------------------------------------------------------------
 app.post('/api/pr', async (req, res) => {
   const body = req.body || {};
@@ -2834,6 +3899,15 @@ app.post('/api/pr', async (req, res) => {
   if (!repoDir || !feature || !source) {
     return badRequest(res, 'pipeline has no branch info to open a PR');
   }
+  // The base branch: the dialog's pick (a run chain defaults to its root there),
+  // else the run's own source. Per run — never remembered with the remotes.
+  let base = source;
+  if (body.baseBranch !== undefined && body.baseBranch !== null) {
+    const b = typeof body.baseBranch === 'string' ? body.baseBranch.trim() : '';
+    if (!isSyntacticRef(b)) return badRequest(res, `invalid base branch: ${String(body.baseBranch).slice(0, 80)}`);
+    if (b === feature) return badRequest(res, 'the base branch cannot be the feature branch');
+    base = b;
+  }
 
   // Remote selection. A named remote must exist; unnamed ones take the dialog's
   // defaults. With no usable remote list (no remotes, unparseable URLs) the legacy
@@ -2876,7 +3950,7 @@ app.post('/api/pr', async (req, res) => {
   if (!pushed.ok) return res.status(500).json({ error: `git push failed: ${pushed.stderr}` });
 
   const pr = await createPr({
-    projectDir: repoDir, base: source, head: feature, title: state.title || feature, repo, headOwner,
+    projectDir: repoDir, base, head: feature, title: state.title || feature, repo, headOwner,
   });
   if (!pr.ok) return res.status(500).json({ error: `gh pr create failed: ${pr.error}` });
 
@@ -2968,7 +4042,23 @@ app.get('/api/branches', async (req, res) => {
       listLocalBranches(projectDir),
       currentBranch(projectDir),
     ]);
-    res.json({ branches, current });
+    // Run branches: this project's pipelines whose feature branch still exists (spec D7).
+    // Throw-safe on purpose: test/branches-api.test.mjs calls this route for a temp directory
+    // that is not a registered project (and has no temp home) — the DB read must never turn the
+    // plain branch list into a 500.
+    const have = new Set(branches);
+    const runsOut = [];
+    try {
+      const rows = getDb().prepare(`SELECT id, title, status, updated_at, branch FROM pipelines
+        WHERE project_key = ? AND target = 'project' AND archived_at IS NULL ORDER BY started_at DESC LIMIT 50`).all(projectKey(projectDir));
+      for (const r of rows) {
+        let b = null; try { b = JSON.parse(r.branch || 'null'); } catch { b = null; }
+        if (b && typeof b.feature === 'string' && have.has(b.feature)) runsOut.push({ branch: b.feature, pipelineId: r.id, title: r.title || null, status: r.status, endedAt: r.updated_at || null });
+      }
+    } catch (err) {
+      console.error(`[worca-ui] run branches lookup failed: ${err && err.message ? err.message : err}`);
+    }
+    res.json({ branches, current, runs: runsOut });
   } catch (err) {
     res.status(500).json({ error: err && err.message ? err.message : String(err) });
   }
@@ -2985,6 +4075,7 @@ app.get('/api/projects', async (_req, res) => {
 app.post('/api/projects', async (req, res) => {
   const body = req.body || {};
   try {
+    await pinUiLevel();                        // before the first project ends "fresh install"
     const projects = await addProject({ name: body.name, path: body.path });
     emitChanged('projects-changed', 'created');
     discoverProject(normalizeProjectPath(body.path), { force: true })
@@ -3003,7 +4094,13 @@ app.delete('/api/projects', async (req, res) => {
   const name = typeof req.query.name === 'string' ? req.query.name : '';
   if (!name.trim()) return badRequest(res, 'name is required');
   try {
+    // Scheduled runs of a removed project can never start: cancel them with it.
+    const before = (await listProjects()).find((p) => p && p.name === name.trim());
     const projects = await removeProject(name);
+    if (before && before.path) {
+      try { if (cancelForTarget({ projectDir: before.path })) emitChanged('schedules-changed', 'target-removed'); }
+      catch (err) { console.error(`[worca-ui] schedule cleanup failed: ${err && err.message ? err.message : err}`); }
+    }
     emitChanged('projects-changed', 'deleted');
     res.json({ projects });
   } catch (err) {
@@ -3072,6 +4169,20 @@ async function defragRequest(req, res, { memoryScope, projectKey: key }) {
   return startRunHandler(req, res);
 }
 
+/** Settings › Memory as the health card names it: `{ model, effort, label, stale }`, or null when
+ *  unset. Checked the way a run checks it (memory-defrag-model.mjs), against this scope's catalog —
+ *  the project's own for a project scope, the project-less one for global. `stale`: the model left
+ *  the catalog, so a run degrades to the workflow default. */
+async function defragModelState(catalogDir) {
+  const stored = memoryDefragModel();
+  if (!stored.model) return null;
+  const models = await listModels(catalogDir);
+  const r = resolveDefragModel({ stored, models });
+  if (!r.model) return { model: stored.model, effort: stored.effort, label: stored.model, stale: true };
+  const hit = models.find((m) => m.id === r.model);
+  return { model: r.model, effort: r.effort, label: (hit && hit.label) || r.model, stale: false };
+}
+
 function registerMemoryRoutes(prefix, { family }) {
   const scoped = (handler) => async (req, res) => {
     try {
@@ -3097,7 +4208,10 @@ function registerMemoryRoutes(prefix, { family }) {
 
   app.get(prefix, scoped(async (_req, res, { scope, key, project }) => {
     const report = await memoryScopeReport(memoryRoot(), scope, memoryCaps(), { onError });
-    res.json({ scope: key, project, files: report.entries, state: report.state, health: report.health, defragRunId: liveDefragRun(key)?.id || null });
+    res.json({
+      scope: key, project, files: report.entries, state: report.state, health: report.health, defragRunId: liveDefragRun(key)?.id || null,
+      defragModel: await defragModelState(project ? project.path : ''),
+    });
   }));
   app.get(`${prefix}/files/:name`, scoped(async (req, res, { scope }) => {
     const name = named(req, res); if (name === null) return;
@@ -3226,7 +4340,14 @@ app.post('/api/workspaces', async (req, res) => {
     // records, if there is exactly one; every other case is "Choose…" on the workspace card.
     const explicit = typeof body.metricsProject === 'string' && body.metricsProject ? body.metricsProject : null;
     const metricsProject = explicit ?? await autoMetricsHome(projectPaths);
-    const workspace = await createWorkspace({ name: body.name, projectPaths, description: body.description, metricsProject });
+    // Team policy home (design §9): defaults to the metrics home when that member's policy
+    // resolves, else the one member (or shared home) whose policy does; else unset.
+    let policyProject = typeof body.policyProject === 'string' && body.policyProject ? body.policyProject : null;
+    if (!policyProject) {
+      const viaMetrics = metricsProject ? await resolveProjectPolicy(metricsProject, { discover: false }).catch(() => null) : null;
+      policyProject = viaMetrics?.ok ? metricsProject : await autoPolicyHome({ projectPaths }).catch(() => null);
+    }
+    const workspace = await createWorkspace({ name: body.name, projectPaths, description: body.description, metricsProject, policyProject });
     emitChanged('workspaces-changed', 'created');
     res.status(201).json({ workspace, metricsHomeAuto: !explicit && !!metricsProject });
   } catch (err) {
@@ -3253,9 +4374,16 @@ app.patch('/api/workspaces/:id', async (req, res) => {
     }
     patch.metricsProject = body.metricsProject;
   }
+  if ('policyProject' in body) {
+    if (body.policyProject !== null && typeof body.policyProject !== 'string') {
+      return badRequest(res, 'policyProject must be a member project path or null');
+    }
+    patch.policyProject = body.policyProject;
+  }
   try {
     const workspace = await updateWorkspace(id, patch);
     if ('metricsProject' in patch) emitChanged('workspaces-changed', 'metrics-home');
+    if ('policyProject' in patch) { emitChanged('workspaces-changed', 'policy-home'); emitChanged('team-policy-changed', 'policy-home'); }
     res.json({ workspace });
   } catch (err) {
     const status = workspaceErrorStatus(err && err.code);
@@ -3274,6 +4402,8 @@ app.delete('/api/workspaces/:id', async (req, res) => {
   if (live) return res.status(409).json({ error: 'cannot delete a workspace with a live run or scan' });
   try {
     const report = await deleteWorkspace(id);
+    try { if (cancelForTarget({ workspaceId: id })) emitChanged('schedules-changed', 'target-removed'); }
+    catch (err) { console.error(`[worca-ui] schedule cleanup failed: ${err && err.message ? err.message : err}`); }
     emitChanged('workspaces-changed', 'deleted');
     res.json({ ok: true, warnings: (report && report.warnings) || [] });
   } catch (err) {
@@ -3454,6 +4584,19 @@ app.get('/api/workspaces/:id/runs/:runId/artifact', async (req, res) => {
   }
 });
 
+// The ask-form preview twin for a workspace run (see the project route above).
+// WORKSPACE_KEY_RE is the only validation the id needs; the key is composed here
+// and never taken from the client, so there is no path-traversal surface.
+app.get('/api/workspaces/:wid/runs/:id/ask-files/:askId/:index', async (req, res) => {
+  if (!WORKSPACE_KEY_RE.test(req.params.wid)) return res.status(404).json({ error: 'pipeline not found' });
+  try {
+    await serveAskFile(res, await askFilesStoreDir(`workspaces/${req.params.wid}`, req.params.id),
+      req.params.askId, req.params.index);
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
 // ---------------------------------------------------------------------------
 // GET /api/settings  -> { root, projectsRoot, projectsRootDefault, default }
 //   root                : the configured Worca CC data-root base, '' when unset
@@ -3489,6 +4632,7 @@ const settingsState = () => ({
   pipelineCostLimitUsd: pipelineCostLimitUsd(),
   totalCostLimitUsd: totalCostLimitUsd(),
   costLimitResetPeriod: costLimitResetPeriod(),
+  humanRateUsdPerHour: humanRateUsdPerHour(),
   askMaxTurns: askMaxTurns(),
   askMaxBudgetUsd: askMaxBudgetUsd(),
   debugSpawnEnabled: storedDebugSpawnEnabled(),          // what is STORED (the checkbox)
@@ -3497,6 +4641,10 @@ const settingsState = () => ({
   titleModelEffective: describeTitleModel(),              // env override / stale id, for the hint line (#422)
   hideBuiltinModels: hideBuiltinModels(),
   theme: storedTheme(),                                   // system | light | dark (dark-mode design §6)
+  schedule: scheduleDefaults(),                           // defaults a NEW schedule inherits
+  uiLevel: effectiveUiLevel(),                            // simple | advanced | expert (docs/ui-levels.md)
+  memoryDefrag: memoryDefragModel(),                      // Settings › Memory: the STORED { model, effort } (null = the workflow default)
+  memoryDefragDefault: defragDefaultModel(),              // what "(default)" means there: the built-in's own model
 });
 
 /** Settings ▸ Auto workflow model: the stored id + what the classifier will actually use
@@ -3559,20 +4707,32 @@ app.get('/api/settings', async (_req, res) => {
 });
 
 app.get('/api/budget', (_req, res) => {
-  res.json(budgetStatus());
+  const budget = budgetStatus();
+  // The sidebar's "Saved this month" figure rides on this snapshot (money-saved design §10).
+  // Additive and best-effort: a failed savings read must never cost the gate figures the
+  // New-view Start button and every cost banner key on, so it degrades to nulls instead.
+  let savings = { windowHumanHours: null, windowSavedUsd: null };
+  try { savings = budgetWindowSavings(budget); } catch { /* keep the nulls */ }
+  res.json({ ...budget, ...savings });
 });
 
 app.post('/api/settings', async (req, res) => {
   const body = req.body || {};
   const has = (k) => Object.prototype.hasOwnProperty.call(body, k);
   const hasBudgetKey = has('pipelineCostLimitUsd') || has('totalCostLimitUsd') || has('costLimitResetPeriod');
+  const hasHumanRateKey = has('humanRateUsdPerHour');
   const hasAskKey = has('askMaxTurns') || has('askMaxBudgetUsd');
   const hasDebugSpawnKey = has('debugSpawnEnabled');
   const hasTitleModelKey = has('titleModel');
   const hasHideBuiltinKey = has('hideBuiltinModels');
   const hasThemeKey = has('theme');
+  const hasUiLevelKey = has('uiLevel');
   const hasAutoKey = has('autoWorkflowModel');
   const autoModels = hasAutoKey ? await listModels('') : null;
+  // Settings › Memory: the defragment { model, effort } pair, checked against the same
+  // project-less catalog the Settings pickers offer (a run re-checks it against its own).
+  const hasMemoryDefragKey = has('memoryDefrag');
+  const defragModels = hasMemoryDefragKey ? (autoModels || await listModels('')) : null;
   // #422: the title model is a SELECT over the catalog, so an id that is not a
   // catalog member is a client bug (or a stale option) — refuse it here rather
   // than store an id resolveModelEnv could never route.
@@ -3596,6 +4756,7 @@ app.post('/api/settings', async (req, res) => {
   if (has('askMaxBudgetUsd')) ask.askMaxBudgetUsd = body.askMaxBudgetUsd === undefined ? '' : body.askMaxBudgetUsd;
   try {
     assertCostLimitInputs(budget);
+    if (hasHumanRateKey) assertHumanRateInput(body.humanRateUsdPerHour ?? '');
     assertAskLimitInputs(ask);
     if (hasDebugSpawnKey) assertDebugSpawnInput(body.debugSpawnEnabled);
     if (hasTitleModelKey) {
@@ -3606,7 +4767,9 @@ app.post('/api/settings', async (req, res) => {
     }
     if (hasHideBuiltinKey) assertHideBuiltinModelsInput(body.hideBuiltinModels);
     if (hasThemeKey) assertThemeInput(body.theme);
+    if (hasUiLevelKey) assertUiLevelInput(body.uiLevel);
     if (hasAutoKey) assertAutoWorkflowModelInput(body.autoWorkflowModel ?? '', autoModels);
+    if (hasMemoryDefragKey) assertMemoryDefragModelInput(body.memoryDefrag, defragModels);
     // Root first: it is the one key whose setter can still fail AFTER the asserts
     // above (an unusable path), so every other key's write must come after it or
     // a mixed POST would answer 400 with those keys already applied on disk.
@@ -3622,17 +4785,21 @@ app.post('/api/settings', async (req, res) => {
     if (has('pipelineCostLimitUsd')) await setPipelineCostLimitUsd(budget.pipelineCostLimitUsd);
     if (has('totalCostLimitUsd')) await setTotalCostLimitUsd(budget.totalCostLimitUsd);
     if (has('costLimitResetPeriod')) await setCostLimitResetPeriod(budget.costLimitResetPeriod);
+    if (hasHumanRateKey) await setHumanRateUsdPerHour(body.humanRateUsdPerHour ?? '');
     if (has('askMaxTurns')) await setAskMaxTurns(ask.askMaxTurns);
     if (has('askMaxBudgetUsd')) await setAskMaxBudgetUsd(ask.askMaxBudgetUsd);
     if (hasDebugSpawnKey) await setDebugSpawnEnabled(body.debugSpawnEnabled);
     if (hasTitleModelKey) await setTitleModel(titleModelInput);
     if (hasHideBuiltinKey) await setHideBuiltinModels(body.hideBuiltinModels);
     if (hasThemeKey) await setTheme(body.theme);
+    if (hasUiLevelKey) await setUiLevel(body.uiLevel);
     if (hasAutoKey) await setAutoWorkflowModel(body.autoWorkflowModel ?? '', { models: autoModels });
+    if (hasMemoryDefragKey) await setMemoryDefragModel(body.memoryDefrag, { models: defragModels });
+    if (has('schedule')) await setScheduleDefaults(body.schedule && typeof body.schedule === 'object' ? body.schedule : {});
     if (hasBudgetKey) emitChanged('budget-changed');
     // Other open tabs repaint their Settings cards (a stale tab could otherwise
     // "save" its old checkbox state over this one with no feedback to either).
-    if (hasAskKey || hasDebugSpawnKey || hasTitleModelKey || hasHideBuiltinKey || hasThemeKey || hasAutoKey) emitChanged('settings-changed');
+    if (hasAskKey || hasDebugSpawnKey || hasTitleModelKey || hasHideBuiltinKey || hasThemeKey || hasUiLevelKey || hasAutoKey || hasHumanRateKey || hasMemoryDefragKey || has('schedule')) emitChanged('settings-changed');
     res.json({ ...settingsState(), ...(await autoModelState()), chat: chatPrefs() });
   } catch (err) {
     // The setters throw only on an unusable path -> client error (400).
@@ -3820,17 +4987,42 @@ app.delete('/api/config/models', async (req, res) => {
 // ---------------------------------------------------------------------------
 
 const maskEnvValue = (v) => (modelEnvRef(v) ? v : maskModelEnvValue(v));
-const maskedGlobalModel = (m) => (m.env
-  ? { ...m, env: Object.fromEntries(Object.entries(m.env).map(([k, v]) => [k, maskEnvValue(v)])) }
-  : m);
+// A bridged entry's `upstream.apiKey` is masked like an env secret; the rest of
+// the block is routing config and passes through. `bridged`/`needsSignIn` are
+// the picker/card facts (model-bridge-design.md §8.5), one readiness check
+// per provider per response.
+const bridgeFacts = (m, readiness) => {
+  if (!m.upstream) return {};
+  const p = m.upstream.provider;
+  if (!readiness.has(p)) readiness.set(p, providerReadiness(m.upstream));
+  const r = readiness.get(p);
+  return { bridged: p, needsSignIn: !r.ok, ...(r.ok ? {} : { signInReason: r.reason, signInMessage: r.message }) };
+};
+const maskedGlobalModel = (m, readiness = new Map()) => ({
+  ...m,
+  ...(m.env ? { env: Object.fromEntries(Object.entries(m.env).map(([k, v]) => [k, maskEnvValue(v)])) } : {}),
+  ...(m.upstream ? { upstream: { ...m.upstream, ...(m.upstream.apiKey ? { apiKey: maskEnvValue(m.upstream.apiKey) } : {}) } } : {}),
+  ...bridgeFacts(m, readiness),
+});
 const isMaskedEcho = (v) => typeof v === 'string' && v.startsWith('••');
 const maskedGlobalModels = () => {
   const flagged = costUnreliableModelIds(); // §4.6 observed flag, merged for the editor's badge
+  const readiness = new Map();
   return listGlobalModels().map((m) => ({
-    ...maskedGlobalModel(m),
+    ...maskedGlobalModel(m, readiness),
     ...(flagged.has(m.id.toLowerCase()) ? { costUnreliable: true } : {}),
   }));
 };
+/** A POST/PATCH `upstream` body with a masked apiKey echo dropped ("keep"). */
+const upstreamInput = (u, current) => {
+  if (!u || typeof u !== 'object' || Array.isArray(u)) return u;
+  if (isMaskedEcho(u.apiKey)) {
+    const keep = current && current.upstream ? current.upstream.apiKey : undefined;
+    const { apiKey, ...rest } = u;
+    return keep ? { ...rest, apiKey: keep } : rest;
+  }
+  return u;
+};
 
 /** Read-only plugin model entries (design §9.7): literals masked with the
  *  standard masker, ${VAR} refs readable, {secret} placeholders surfaced as
@@ -3838,6 +5030,7 @@ const maskedGlobalModels = () => {
 const pluginModelsPayload = () => {
   const flagged = costUnreliableModelIds();
   const statusByPlugin = new Map();
+  const readiness = new Map();
   return listPluginModels().map((m) => {
     if (!statusByPlugin.has(m.plugin)) statusByPlugin.set(m.plugin, pluginModelSecretStatus(m.plugin));
     const status = statusByPlugin.get(m.plugin);
@@ -3848,30 +5041,153 @@ const pluginModelsPayload = () => {
       ])),
       secrets: status.filter((s) => m.secrets.includes(s.key)),
       ...(m.cost ? { cost: m.cost } : {}),   // manifest-pinned pricing — config, never a credential
+      ...(m.upstream ? { upstream: { ...m.upstream } } : {}),   // a plugin apiKey is a ${VAR} ref by validation — readable
+      ...bridgeFacts(m, readiness),
       ...(flagged.has(m.id.toLowerCase()) ? { costUnreliable: true } : {}),
     };
   });
 };
 
 app.get('/api/models', (req, res) => {
+  const readiness = new Map();
   res.json({
     models: maskedGlobalModels(), plugin: pluginModelsPayload(), predefined: PREDEFINED_MODELS, efforts: EFFORTS,
     hideBuiltinModels: hideBuiltinModels(),   // the Models-view checkbox (#422)
+    // Team policy catalog entries (team-policy design §8): read-only, env masked like a global's.
+    policy: policyCatalogModels().map((m) => maskedGlobalModel(m, readiness)),
+    providers: UPSTREAM_PROVIDERS,
   });
 });
 
 app.post('/api/models', async (req, res) => {
   const b = req.body || {};
   try {
-    const model = await addGlobalModel({ id: b.id, label: b.label, efforts: b.efforts, env: b.env, cost: b.cost });
+    const model = await addGlobalModel({ id: b.id, label: b.label, efforts: b.efforts, env: b.env, cost: b.cost, upstream: upstreamInput(b.upstream) });
     res.json({ model: maskedGlobalModel(model), models: maskedGlobalModels() });
   } catch (err) {
     // addGlobalModel throws only on validation (empty/dup id, unknown effort,
-    // reserved env key, non-string env value) -> client error.
+    // reserved env key, non-string env value, malformed upstream) -> client error.
     return badRequest(res, err && err.message ? err.message : String(err));
   }
 });
 
+// ---------------------------------------------------------------------------
+// Providers + the Copilot import (model-bridge-design.md §9). Never a token in
+// a response; the sign-in is a device-flow session the client polls.
+// ---------------------------------------------------------------------------
+const providerError = (res, err) => {
+  const msg = err && err.message ? err.message : String(err);
+  if (err && (err.code === 'TERMS' || err.code === 'NOT_SIGNED_IN')) return res.status(409).json({ error: msg, code: err.code });
+  return badRequest(res, msg);
+};
+
+app.get('/api/providers', async (req, res) => {
+  try {
+    res.json(await providersState({ quota: req.query.quota === '1' }));
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+app.patch('/api/providers/:name', async (req, res) => {
+  try {
+    await patchProvider(req.params.name, req.body || {});
+    emitChanged('settings-changed');
+    res.json(await providersState());
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
+app.post('/api/providers/copilot/acknowledge', async (req, res) => {
+  try {
+    await acknowledgeTerms();
+    res.json(await providersState());
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
+app.post('/api/providers/copilot/login', async (req, res) => {
+  try {
+    res.json(await beginCopilotLogin());
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
+app.get('/api/providers/copilot/login/:deviceCode', async (req, res) => {
+  try {
+    const r = await pollCopilotLogin(String(req.params.deviceCode));
+    if (r.ok) emitChanged('settings-changed');
+    res.json(r);
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
+app.post('/api/providers/copilot/logout', async (req, res) => {
+  try {
+    await copilotLogout();
+    emitChanged('settings-changed');
+    res.json(await providersState());
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
+app.get('/api/providers/copilot/models', async (req, res) => {
+  try {
+    res.json({ models: await copilotModelsForImport() });
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
+// What an OpenAI-compatible endpoint serves (§8.4): llama.cpp, Ollama, LM Studio, vLLM or a
+// gateway, asked on its own surface so the rows carry real context windows and tool support.
+// ?baseUrl= overrides the provider's own, so a second local server can be browsed without
+// saving it first. Same reach as Test connection: the UI is loopback-only.
+app.get('/api/providers/openai/models', async (req, res) => {
+  try {
+    res.json(await endpointModelsForImport({ baseUrl: typeof req.query.baseUrl === 'string' ? req.query.baseUrl : '' }));
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
+app.post('/api/providers/openai/import-models', async (req, res) => {
+  const b = req.body || {};
+  try {
+    const result = await importEndpointModels(b.ids, { baseUrl: typeof b.baseUrl === 'string' ? b.baseUrl : '' });
+    emitChanged('settings-changed');
+    res.json({ ...result, models: maskedGlobalModels() });
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
+app.post('/api/providers/:name/test', async (req, res) => {
+  // The card tests what is ON SCREEN (§8.1): an unsaved base URL or key is sent with the request,
+  // so "Test connection" answers for the endpoint the user is looking at, not the stored one.
+  const b = req.body || {};
+  res.json(await testProviderConnection(req.params.name, {
+    baseUrl: typeof b.baseUrl === 'string' ? b.baseUrl : '',
+    ...(typeof b.apiKey === 'string' ? { apiKey: b.apiKey } : {}),
+  }));
+});
+
+app.post('/api/providers/copilot/import-models', async (req, res) => {
+  const b = req.body || {};
+  if (b.provider && b.provider !== 'copilot') return badRequest(res, 'only the copilot provider supports import');
+  try {
+    const result = await importCopilotModels(b.ids);
+    res.json({ ...result, models: maskedGlobalModels() });
+  } catch (err) {
+    return providerError(res, err);
+  }
+});
+
 // Promote a legacy per-project custom model to the global catalog (§4.9).
 // Refs survive by construction — see promoteCustomModel. Registered before the
 // :id routes only for readability; POST /api/models/promote shares no method
@@ -4020,7 +5336,8 @@ app.patch('/api/models/:id', async (req, res) => {
     env = Object.fromEntries(Object.entries(env).filter(([, v]) => !isMaskedEcho(v)));
   }
   try {
-    const model = await updateGlobalModel(req.params.id, { label: b.label, efforts: b.efforts, env, cost: b.cost });
+    const current = b.upstream ? listGlobalModels().find((m) => m.id.toLowerCase() === String(req.params.id).toLowerCase()) : null;
+    const model = await updateGlobalModel(req.params.id, { label: b.label, efforts: b.efforts, env, cost: b.cost, upstream: upstreamInput(b.upstream, current) });
     res.json({ model: maskedGlobalModel(model), models: maskedGlobalModels() });
   } catch (err) {
     // updateGlobalModel throws only on validation (unknown id, unknown effort,
@@ -4052,6 +5369,9 @@ app.get('/api/models/:id/env-value', (req, res) => {
 app.delete('/api/models/:id', async (req, res) => {
   try {
     const result = await removeGlobalModelAndRefs(req.params.id);
+    // Settings › Memory's defragment model went with the entry: open tabs repaint that card (as
+    // the Ask remove_model path's settings-changed does).
+    if (result.clearedMemoryDefrag) emitChanged('settings-changed');
     res.json({ ...result, models: maskedGlobalModels() });
   } catch (err) {
     // Throws only on an unknown id -> client error.
@@ -4124,6 +5444,9 @@ function sendWorkflowShareError(res, err) {
   // line, verbatim.
   if (code === 'RESERVED_NAME') return res.status(422).json({ error: message });
   if (code === 'ID_TAKEN') return res.status(409).json({ error: message, id: err.id });
+  // P10: a script import the user has not confirmed is well-formed but conflicts
+  // with a confirmation not yet given; `scriptNodes` are the commands to show first.
+  if (code === 'SCRIPTS_UNCONFIRMED') return res.status(409).json({ error: message, code, scriptNodes: err.scriptNodes || [] });
   if (code === 'NOT_FOUND') return res.status(404).json({ error: message });
   return res.status(500).json({ error: message });
 }
@@ -4149,7 +5472,15 @@ app.get('/api/workflows/:id', async (req, res) => {
     // this is a READ (the Composer's Open): a template stranded by an agent-port
     // edit must still load, or the user could never repair it. The RUN path keeps
     // the graph check.
-    res.json(await assertRunnableWorkflow(req.params.id, { checkGraph: false }));
+    const wf = await assertRunnableWorkflow(req.params.id, { checkGraph: false });
+    // Settings › Memory: the built-in reads with the pair every defragment run will use, so New
+    // pipeline's agent rows and an Ask card's lane show — and lock — it (memory-defrag-model.mjs).
+    if (wf && wf.id === MEMORY_DEFRAG_WORKFLOW_ID) {
+      const stored = memoryDefragModel();
+      const pair = stored.model ? resolveDefragModel({ stored, models: await listModels('') }) : null;
+      return res.json(defragWorkflowView(wf, pair));
+    }
+    res.json(wf);
   } catch (err) {
     if (err && (err.code === 'NOT_FOUND' || err.code === 'ARCHIVED')) {
       return res.status(404).json({ error: err.message });
@@ -4193,9 +5524,13 @@ app.post('/api/workflows/import-json', async (req, res) => {
   const src = body.workflow && typeof body.workflow === 'object' && !Array.isArray(body.workflow) ? body.workflow : null;
   if (!src) return badRequest(res, 'workflow (the exported JSON object) is required');
   try {
+    // D18: a dry run validates and lists the script commands the Import dialog must show first.
+    const dryRun = body.dryRun === true;
     const r = await importGraphWorkflow(src, {
-      name: typeof body.name === 'string' ? body.name : undefined, agentsDir: AGENTS_DIR,
+      name: typeof body.name === 'string' ? body.name : undefined, agentsDir: AGENTS_DIR, dryRun,
+      acceptScripts: body.acceptScripts === true,
     });
+    if (dryRun) return res.json({ scriptNodes: r.scriptNodes, warnings: r.warnings, requestedName: r.requestedName });
     return res.status(201).json(r);
   } catch (err) {
     return sendWorkflowShareError(res, err);
@@ -4344,7 +5679,8 @@ function sendGuardrailError(res, err) {
 app.get('/api/guardrails', async (_req, res) => {
   try {
     const sets = await listGuardrailSets(); // CONV-1: await
-    res.json({ guardrails: [...listBuiltinGuardrailSets(), ...sets] });
+    // Team policy sets (gp:<id>, origin policy:<home>) sit between the built-ins and the user's own.
+    res.json({ guardrails: [...listBuiltinGuardrailSets(), ...listPolicyGuardrailSets(), ...sets] });
   } catch (err) {
     res.status(500).json({ error: err && err.message ? err.message : String(err) });
   }
@@ -4410,6 +5746,7 @@ app.delete('/api/guardrails/:id', async (req, res) => {
   const id = req.params.id;
   // Built-ins are not in the user store and must never be deleted.
   if (isBuiltinGuardrailSetId(id)) return badRequest(res, 'built-in guardrail sets cannot be deleted');
+  if (isPolicyGuardrailSetId(id)) return badRequest(res, 'team policy guardrail sets are edited on the Team policy page, not deleted here');
   try {
     const removed = await deleteGuardrailSet(id); // CONV-1: await; throws ReferencedError while pinned
     if (!removed) return res.status(404).json({ error: 'guardrail set not found' });
@@ -4884,10 +6221,25 @@ function askValidateScope(raw) {
   return { ok: true, scope: { pinned: true, [keys[0]]: cv.context[keys[0]] } };
 }
 
-/** The system prompt of ONE Ask turn: the rules and the catalog, byte-stable. Memory is mounted,
- *  not rendered (native-rules revision) — see createAskTurn's memoryProject. */
+/** The system prompt of ONE Ask turn: the rules, the catalog, and — only when the chat's
+ *  "Create and run scripts" pref is on (W20) — the scripts section with the runtimes this host
+ *  actually has (the python probe, cached 60 s). Memory is mounted, not rendered. */
 async function askSystemPromptFor(catalog) {
-  return askBuildSystemPrompt(catalog);
+  return askBuildSystemPrompt(catalog, { scripts: await askScriptPromptInput() });
+}
+
+/** "scheduled Sat Sep 19, 02:00 (run 1a2b…)" / "repeats: Every weekday at 02:00 (sch_…)" / "proposes: …" — or ''. */
+function askCardScheduleLine(b, tz = null) {
+  if (b.state === 'scheduled' && b.scheduleId) return `repeats: ${b.sentence || ''} (${b.scheduleId})`;
+  if (b.state === 'scheduled' && b.after) return `after ‘${b.after.title || b.after.id}’ (run ${b.runId})`;
+  if (b.state === 'scheduled' && b.runId) {
+    const ms = Date.parse(b.scheduledFor || '');
+    const when = Number.isFinite(ms) ? formatInstant(ms, isValidTimeZone(tz) ? tz : Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC') : '?';
+    return `scheduled for ${when} (run ${b.runId})`;
+  }
+  const s = b.card && b.card.schedule;
+  if (b.state === 'proposed' && s) return s.kind === 'repeat' ? `proposes: ${s.sentence}` : s.kind === 'after' ? `proposes: ${s.text}` : `proposes: once at ${s.when}`;
+  return '';
 }
 
 /** Resolve the VALIDATED client context into the server-side shape
@@ -4897,6 +6249,7 @@ async function askSystemPromptFor(catalog) {
 async function resolveAskContext(threadId, ctx = {}, listedAttachments = [], currentMessageId = null) {
   const out = { now: new Date().toISOString() };
   if (ctx.pinned === true) out.pinned = true;   // #397: rendered as the [pinned by the user] marker
+  if (ctx.timeZone) out.timeZone = ctx.timeZone;   // validated IANA name; the header adds the user's clock
   if (ctx.view) out.view = ctx.view;
   if (ctx.diffPath) out.diffPath = ctx.diffPath;   // client-supplied, already length-checked by validateClientContext
   try {
@@ -4934,6 +6287,25 @@ async function resolveAskContext(threadId, ctx = {}, listedAttachments = [], cur
       }
     }
   } catch { /* absent line */ }
+  // The Team policy page's scope (validated slug): its name and, from the local cache only (no git), its home.
+  try {
+    if (ctx.tpScope) {
+      const [kind, tpId] = ctx.tpScope.split(':');
+      if (kind === 'project') {
+        const p = (await listProjects()).find((x) => x.key === tpId);
+        if (p) {
+          const r = await resolveProjectPolicy(p.path, { discover: false }).catch(() => null);
+          out.teamPolicy = { kind, id: tpId, name: p.name, home: r && r.ok ? r.home : null };
+        }
+      } else if (kind === 'workspace') {
+        const ws = await readWorkspace(tpId);
+        if (ws) {
+          const r = await resolveWorkspacePolicy(ws, { discover: false }).catch(() => null);
+          out.teamPolicy = { kind, id: tpId, name: ws.name, home: r && r.ok ? r.home : null };
+        }
+      }
+    }
+  } catch { /* absent line */ }
   try {
     if (ctx.pipelineId) {
       const key = ctx.workspaceId ? `workspaces/${ctx.workspaceId}` : out.project?.key;
@@ -4968,8 +6340,12 @@ async function resolveAskContext(threadId, ctx = {}, listedAttachments = [], cur
         // workflowId once the user saved it; a run card keeps its pre-P3 line byte for byte.
         const wf = !!(b.card && b.card.type === 'workflow');
         if (wf && b.state === 'building') continue;   // transient (no name yet) — never worth a header line
-        if (b.card && b.card.type === 'metrics') {
-          cards.push({ id: b.id, type: 'metrics', state: b.state, summary: b.card.summary || '' });
+        if (b.card && (b.card.type === 'metrics' || b.card.type === 'policy')) {
+          cards.push({ id: b.id, type: b.card.type, state: b.state, summary: b.card.summary || '' });
+          continue;
+        }
+        if (b.card && b.card.type === 'schedule') {
+          cards.push({ id: b.id, type: 'schedule', state: b.state, summary: b.card.summary || '' });
           continue;
         }
         cards.push(wf
@@ -4980,6 +6356,9 @@ async function resolveAskContext(threadId, ctx = {}, listedAttachments = [], cur
           : {
             id: b.id, state: b.state, workflowId: b.card && b.card.workflowId,
             targetName: (b.card && (b.card.projectName || b.card.workspaceName)) || '',
+            // A scheduled (or schedule-proposing) run card says when, so the model never re-proposes it.
+            ...(askCardScheduleLine(b, ctx.timeZone) ? { schedule: askCardScheduleLine(b, ctx.timeZone) } : {}),
+            ...(b.card && b.card.source ? { task: `${b.card.source.plugin}/${b.card.source.sourceId} ${b.card.source.taskId}` } : {}),
           });
       }
     }
@@ -5110,6 +6489,7 @@ async function startAskTurn({ threadId: id, thread, ctx, model, effort, text, fi
       firstText: text,
       deterministicTitle,
       pinnedScope: askPinnedScope(ctx),             // #397: proposal defaulting + mismatch flag
+      timeZone: ctx.timeZone || (thread.context && thread.context.timeZone) || null,   // scheduled runs: the user's clock
       memoryProject: headerCtx.project ? { key: headerCtx.project.key, name: headerCtx.project.name || '' } : null,   // native-rules revision: the turn mounts global + this project through --add-dir
       mock: mockEnabled({}) ? { card: mockAskCard(ctx, text) } : null, // R-F
       attachmentNames,
@@ -5124,7 +6504,12 @@ async function startAskTurn({ threadId: id, thread, ctx, model, effort, text, fi
         onMemoryMutation: ({ scope }) => {
           if (scope === 'global' || (typeof scope === 'string' && scope.startsWith('projects/') && PROJECT_KEY_RE.test(scope.slice('projects/'.length)))) emitMemoryChanged(scope);
         },
+        // A save_script in the MCP child is the same change a REST write makes (spec §3.3):
+        // the open Scripts tabs drop their list and the composer marks its script list dirty.
+        onScriptMutation: () => { emitChanged('scripts-changed', 'updated'); },
         trackRun: (input, { pin } = {}) => askTrackRun(id, input, pin ?? null),
+        // pause / resume / skip / mark-read in the MCP child: the Schedules page and the badges repaint.
+        onScheduleMutation: () => { emitChanged('schedules-changed', 'ask'); emitChanged('notifications-changed'); },
       },
     });
     job.turn = turn;
@@ -5378,15 +6763,20 @@ async function startWorkflowEventTurn(threadId, block, { declined = false, thenR
   return failedEventTurn(threadId, { error: r.error, status: r.status, ...(r.budget ? { budget: r.budget } : {}) });
 }
 
-/** The metrics card's event turn: the synthetic notice row + the "[worca event] metrics card …" prompt (same queueing as workflow cards). */
+/** The metrics / policy / schedule card's event turn: the synthetic notice row + the
+ *  "[worca event] <type> card …" prompt (same queueing as workflow cards). */
 async function startMetricsEventTurn(threadId, block) {
   const thread = askGetThread(threadId);
   if (!thread) return null;
   const card = block.card || {};
   const state = block.state === 'declined' ? 'declined' : block.state === 'failed' ? 'failed' : 'applied';
   const result = card.result || null;
-  const text = metricsEventPrompt({ cardId: block.id, state, card, result });
-  const notice = metricsNoticeText({ state, card, result });
+  // One event turn for every non-workflow card; the type picks the wording. Metrics is the fallback.
+  const kind = card.type === 'policy' || card.type === 'schedule' || card.type === 'model' ? card.type : 'metrics';
+  const eventPrompt = { policy: policyEventPrompt, schedule: scheduleEventPrompt, model: modelEventPrompt, metrics: metricsEventPrompt }[kind];
+  const noticeText = { policy: policyNoticeText, schedule: scheduleNoticeText, model: modelNoticeText, metrics: metricsNoticeText }[kind];
+  const text = eventPrompt({ cardId: block.id, state, card, result });
+  const notice = noticeText({ state, card, result });
   let mv = await validateModelEffort(thread.model, thread.effort);
   if (!mv.ok) {
     const d = (await askCatalog({ withSecrets: false })).default;
@@ -5420,10 +6810,34 @@ app.post('/api/ask/threads/:id/cards/:cardId', async (req, res) => {
     const body = req.body || {};
     const found = askFindCard(id, cardId);
     if (!found) return res.status(404).json({ error: 'card not found' });
-    if (found.block.card && found.block.card.type === 'metrics') {
-      // Metrics card (docs/team-metrics.md "Ask Worca"): proposed → applied | failed | declined. The change is
-      // the outward-facing part — a branch on origin, a marker on another repo, this machine's switch, the
-      // workspace's home — so it happens HERE, behind the click, never in the model's tool.
+    if (found.block.card && found.block.card.type === 'schedule') {
+      // Schedule card (docs/scheduled-runs.md "Ask Worca"): proposed → applied | failed | declined. The change —
+      // start now, move, edit, cancel, delete — happens HERE, behind the click, through the same scheduleVerb
+      // the Schedules page uses; never in the model's tool.
+      if (body.state !== 'applied' && body.state !== 'declined') return badRequest(res, 'state must be "applied" or "declined"');
+      if (found.block.state !== 'proposed') return res.status(409).json({ error: `card is ${found.block.state}` });
+      if (askCardBusy.has(cardId)) return res.status(409).json({ error: 'card is being applied' });
+      if (body.state === 'declined') {
+        const block = flipCard(id, cardId, { state: 'declined' });
+        if (!block) return res.status(409).json({ error: 'card vanished' });
+        const turn = await startMetricsEventTurn(id, block);
+        return res.json({ block, turn });
+      }
+      askCardBusy.add(cardId);
+      let block;
+      try {
+        let result;
+        try { result = await applyScheduleCard(found.block.card); }
+        catch (err) { result = { ok: false, error: err && err.message ? err.message : String(err) }; }
+        block = flipCard(id, cardId, result.ok ? { state: 'applied', card: { result } } : { state: 'failed', error: result.error, card: { result } });
+      } finally { askCardBusy.delete(cardId); }
+      if (!block) return res.status(409).json({ error: 'card vanished' });
+      const turn = await startMetricsEventTurn(id, block);
+      return res.json({ block, turn });
+    }
+    if (found.block.card && found.block.card.type === 'model') {
+      // Model card (docs/models.md "Ask Worca"): proposed → applied | failed | declined. The catalog / provider
+      // write happens HERE, behind the click, through the same setters the Models view uses — each re-validates.
       if (body.state !== 'applied' && body.state !== 'declined') return badRequest(res, 'state must be "applied" or "declined"');
       if (found.block.state !== 'proposed') return res.status(409).json({ error: `card is ${found.block.state}` });
       if (askCardBusy.has(cardId)) return res.status(409).json({ error: 'card is being applied' });
@@ -5437,7 +6851,34 @@ app.post('/api/ask/threads/:id/cards/:cardId', async (req, res) => {
       let block;
       try {
         let result;
-        try { result = await applyMetricsChange(found.block.card); }
+        try { result = await applyModelChange(found.block.card); emitChanged('settings-changed'); }
+        catch (err) { result = { ok: false, error: err && err.message ? err.message : String(err) }; }
+        block = flipCard(id, cardId, result.ok ? { state: 'applied', card: { result } } : { state: 'failed', error: result.error, card: { result } });
+      } finally { askCardBusy.delete(cardId); }
+      if (!block) return res.status(409).json({ error: 'card vanished' });
+      const turn = await startMetricsEventTurn(id, block);
+      return res.json({ block, turn });
+    }
+    if (found.block.card && (found.block.card.type === 'metrics' || found.block.card.type === 'policy')) {
+      // Metrics / policy card (docs/team-metrics.md, docs/team-policy.md "Ask Worca"): proposed → applied | failed |
+      // declined. The change is the outward-facing part — a branch on origin, a commit to the team's policy, a
+      // marker on another repo, this machine's switch, the workspace's home — so it happens HERE, behind the
+      // click, never in the model's tool.
+      const apply = found.block.card.type === 'policy' ? applyPolicyChange : applyMetricsChange;
+      if (body.state !== 'applied' && body.state !== 'declined') return badRequest(res, 'state must be "applied" or "declined"');
+      if (found.block.state !== 'proposed') return res.status(409).json({ error: `card is ${found.block.state}` });
+      if (askCardBusy.has(cardId)) return res.status(409).json({ error: 'card is being applied' });
+      if (body.state === 'declined') {
+        const block = flipCard(id, cardId, { state: 'declined' });
+        if (!block) return res.status(409).json({ error: 'card vanished' });
+        const turn = await startMetricsEventTurn(id, block);
+        return res.json({ block, turn });
+      }
+      askCardBusy.add(cardId);
+      let block;
+      try {
+        let result;
+        try { result = await apply(found.block.card); }
         catch (err) {
           result = { ok: false, error: err && err.message ? err.message : String(err), code: (err && err.code) || 'ERROR', ...(err && err.hint ? { hint: err.hint } : {}), ...(err && err.stderr ? { stderr: String(err.stderr).slice(0, 2000) } : {}) };
         }
@@ -5514,10 +6955,22 @@ function agentErrorStatus(code) {
   if (code === 'NOT_FOUND') return 404;
   if (code === 'BAD_REQUEST') return 400;
   if (code === 'PLUGIN') return 400;
+  // A declared ask form that fails gate 1 is a well-formed request the server
+  // understood and refused on content — the same 422 POST /api/answer uses for a
+  // gate-3 failure (ask-forms spec §5, §11).
+  if (code === 'ASK_FORM') return 422;
   if (code === 'BUILTIN' || code === 'DUPLICATE' || code === 'REFERENCED') return 409;
   return 500;
 }
 
+/** The error body: `{ error }` for every failure, plus the structured `errors`
+ *  list when the store produced one (gate 1). Never adds an empty `errors`. */
+function agentErrorBody(err) {
+  const body = { error: err && err.message ? err.message : String(err) };
+  if (Array.isArray(err?.errors) && err.errors.length) body.errors = err.errors;
+  return body;
+}
+
 /**
  * Fire-and-forget agent generation (mirrors startScan). Mints genId, registers
  * a kind:'agentgen' entry in the SAME runs Map, wires its agentgen-* events,
@@ -5619,7 +7072,7 @@ app.post('/api/agents', async (req, res) => {
     const created = await createAgent({ meta: body.meta, markdown: body.markdown });
     res.status(201).json(created);
   } catch (err) {
-    res.status(agentErrorStatus(err && err.code)).json({ error: err && err.message ? err.message : String(err) });
+    res.status(agentErrorStatus(err && err.code)).json(agentErrorBody(err));
   }
 });
 
@@ -5630,7 +7083,7 @@ app.put('/api/agents/:key', async (req, res) => {
   try {
     res.json(await updateAgent(key, { meta: body.meta, markdown: body.markdown }));
   } catch (err) {
-    res.status(agentErrorStatus(err && err.code)).json({ error: err && err.message ? err.message : String(err) });
+    res.status(agentErrorStatus(err && err.code)).json(agentErrorBody(err));
   }
 });
 
@@ -5640,10 +7093,269 @@ app.delete('/api/agents/:key', async (req, res) => {
   try {
     res.json(await deleteAgent(key));
   } catch (err) {
-    res.status(agentErrorStatus(err && err.code)).json({ error: err && err.message ? err.message : String(err) });
+    res.status(agentErrorStatus(err && err.code)).json(agentErrorBody(err));
+  }
+});
+
+// ---------------------------------------------------------------------------
+// /api/scripts* -> the script registry (spec §8.4): built-in scripts/ + the user
+// layer + enabled plugins, D16-filtered against the agent registry. The write half
+// (CRUD, duplicate, cases) is below, delegated to src/core/script-store.mjs.
+// ---------------------------------------------------------------------------
+function scriptRegistryNow() {
+  return loadScriptRegistry({ agentKeys: Object.keys(loadAgentRegistry(AGENTS_DIR)) });
+}
+
+/**
+ * Workbench spec §7 / W17: a python card this host cannot run is flagged ON THE
+ * WIRE, so the composer's V4 names it the moment the card is placed and the
+ * Scripts list can chip it. The probe is 60 s-cached, so this costs at most one
+ * spawn a minute. The REGISTRY is deliberately never stamped: it is loaded
+ * synchronously and the probe is not, and a run must be gated by its own
+ * preflight — with a fresh probe, at run time — not by a flag baked into a
+ * snapshot taken when some browser last asked for a list.
+ */
+async function stampRuntimeMissing(list) {
+  if (!list.some((m) => m.runtime === 'python')) return list;
+  const probe = await probePython();
+  if (probe.ok) return list;
+  return list.map((m) => (m.runtime === 'python' ? { ...m, runtimeMissing: true } : m));
+}
+
+app.get('/api/scripts', async (req, res) => {
+  try {
+    // listScripts() IS the registry, in the same order, with caseCount stamped
+    // (the list card's case chip). scriptRegistryNow() stays for the graph
+    // routes, which need the raw index for registryPortsFn.
+    res.json({ scripts: await stampRuntimeMissing(await listScripts()) });
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+// Literal segments are registered BEFORE /api/scripts/:key, so the param route
+// can never swallow them (the POST /api/agents/generate rule).
+app.get('/api/scripts/runtimes', async (req, res) => {
+  // C8: the picker is wired once, against the real shape. The python arm is the
+  // real probe (workbench spec §7; never rejects, 60 s-cached); node and shell are
+  // guaranteed by the host itself.
+  res.json({
+    node: { ok: true, version: process.version },
+    shell: { ok: true, path: process.platform === 'win32' ? (process.env.ComSpec || 'cmd.exe') : '/bin/sh' },
+    python: pythonRuntimeState(await probePython()),
+  });
+});
+
+/**
+ * Fire-and-forget bench run (mirrors startAgentGen). Mints nothing itself: the
+ * engine owns the id and tags every event with it, so the runs-Map key, the
+ * buffered events and the `?benchId=` replay all agree on one id.
+ * @returns {string} benchId
+ */
+function startScriptBench(request) {
+  const orch = createBench(request);
+  const benchId = orch.id;
+  const entry = {
+    id: benchId, benchId, orch, kind: 'scriptbench', projectDir: null,
+    title: `bench: ${request.key}`, status: 'running',
+    startedAt: new Date().toISOString(), events: [], pendingQuestion: null, result: null, seq: 0,
+  };
+  runs.set(benchId, entry);
+  // Nothing else ever deletes a bench entry (runs.delete fires for pipeline
+  // lineages only), and Run is the page's main verb: keep the newest few so the
+  // output route and a reconnect can still read them, drop the rest with their
+  // <= 5000 buffered lines and 256 KiB-per-output results.
+  const benches = [...runs.values()].filter((e) => e.kind === 'scriptbench');
+  for (const old of benches.slice(0, Math.max(0, benches.length - MAX_BENCH_ENTRIES))) {
+    if (old.status !== 'running') runs.delete(old.id);
+  }
+  wireScriptBench(entry);
+
+  Promise.resolve()
+    .then(() => orch.run())
+    .catch((err) => {
+      // run() never throws (it emits scriptbench-error); this is startScan's
+      // defensive backstop, surfacing an unexpected throw as a tagged error.
+      // It carries the entry's next `seq` like every other frame (C17), or a
+      // subscribe replay would deliver this one twice.
+      entry.seq = (entry.seq || 0) + 1;
+      const event = { benchId, seq: entry.seq, type: 'scriptbench-error', message: err && err.message ? err.message : String(err), code: null };
+      entry.status = 'error';
+      entry.events.push(event);
+      broadcast(event);
+    });
+
+  return benchId;
+}
+
+// The §4.2 request rides through untouched: the engine validates it and reports
+// every refusal (unknown key, bad param, cap hit) as ONE scriptbench-error on
+// the socket. Only the key shape is checked here, so a malformed :key-shaped
+// value can never reach the store.
+app.post('/api/scripts/bench', (req, res) => {
+  const body = req.body || {};
+  const key = typeof body.key === 'string' ? body.key.trim() : '';
+  if (!SCRIPT_KEY_RE.test(key)) return res.status(404).json({ error: 'script not found' });
+  try {
+    res.json({ benchId: startScriptBench({ ...body, key }) });
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+// Idempotent stop (the /api/agents/generate/stop shape): an unknown or finished
+// bench still answers ok.
+app.post('/api/scripts/bench/stop', (req, res) => {
+  const benchId = req.body && typeof req.body.benchId === 'string' ? req.body.benchId : '';
+  const entry = benchId ? runs.get(benchId) : null;
+  if (entry && entry.kind === 'scriptbench' && entry.orch && typeof entry.orch.stop === 'function') {
+    try { entry.orch.stop(); } catch { /* best-effort */ }
+    entry.status = 'stopped';
+  }
+  res.json({ ok: true });
+});
+
+// The full text of one output (the WS result carries at most 256 KiB). The file
+// PATH comes from the entry's stored result — never from the URL — so this route
+// cannot be walked; `:port` is only a lookup key into that result.
+app.get('/api/scripts/bench/:benchId/output/:port', async (req, res) => {
+  const entry = runs.get(req.params.benchId);
+  if (!entry || entry.kind !== 'scriptbench' || !entry.result) return res.status(404).json({ error: 'bench not found' });
+  if (!PORT_ID_RE.test(req.params.port)) return res.status(404).json({ error: 'output not found' });
+  const caseId = typeof req.query.caseId === 'string' ? req.query.caseId : '';
+  // A Run-all result is a list of per-case results (§4.3), so it needs ?caseId=.
+  const result = Array.isArray(entry.result.cases)
+    ? (entry.result.cases.find((c) => c.caseId === caseId) || {}).result
+    : entry.result;
+  // hasOwn: PORT_ID_RE admits `constructor` / `toString`, which a plain lookup would find on Object.prototype.
+  const out = result && result.outputs && Object.hasOwn(result.outputs, req.params.port) ? result.outputs[req.params.port] : null;
+  if (!out || !out.path) return res.status(404).json({ error: 'output not found' });
+  // STREAMED, not read into a string: a bench output is whatever the script
+  // wrote. readFile() buffered the whole file (a 600 MB log spiked the server by
+  // half a gigabyte) and past ~512 MiB threw "Invalid string length", which this
+  // catch then reported as a missing output.
+  let st;
+  try { st = await fsp.stat(out.path); } catch { return res.status(404).json({ error: 'output not found' }); }
+  if (!st.isFile()) return res.status(404).json({ error: 'output not found' });
+  res.type('text/plain; charset=utf-8').set('Content-Length', String(st.size));
+  const stream = fs.createReadStream(out.path);
+  stream.on('error', () => { res.destroy(); });
+  res.on('close', () => stream.destroy());
+  stream.pipe(res);
+});
+
+
+app.get('/api/scripts/:key', async (req, res) => {
+  const key = req.params.key;
+  if (!SCRIPT_KEY_RE.test(key)) return res.status(404).json({ error: 'script not found' });
+  try {
+    const data = await readScript(key);
+    if (!data) return res.status(404).json({ error: 'script not found' });
+    // The meta is spread FLAT (the Scripts page and the composer read `key`,
+    // `runtime`, `ports` off the top level); the store's reads ride beside it.
+    res.json({
+      ...data.meta,
+      source: data.source,
+      sourceWin32: data.sourceWin32,
+      sourcePath: data.sourcePath,
+      sourceTruncated: data.sourceTruncated,
+      cases: data.cases,
+      userCases: data.userCases,
+      casesWritable: data.casesWritable,
+    });
+  } catch (err) {
+    res.status(500).json({ error: err && err.message ? err.message : String(err) });
+  }
+});
+
+
+// ---------------------------------------------------------------------------
+// The write half (spec §3.3–§3.4): user-layer CRUD, duplicate and cases,
+// delegated to src/core/script-store.mjs. The store's err.code vocabulary IS
+// the agent store's, so agentErrorStatus maps it unchanged. `by: 'ui'` stamps
+// every save from this process (W19); the CLI and Ask Worca call core directly
+// with their own stamp. Each mutation pokes every open tab with the bare
+// `scripts-changed` broadcast, so a script saved elsewhere appears without a
+// reload — the client drops its cached list and marks the palette dirty.
+// ---------------------------------------------------------------------------
+const STORE_ERROR_CODES = new Set(['NOT_FOUND', 'BAD_REQUEST', 'PLUGIN', 'BUILTIN', 'DUPLICATE', 'REFERENCED']);
+// Only the store's OWN vocabulary is quoted back to the page. An fs failure
+// (EACCES on the scripts dir, a full disk) carries the absolute home path in its
+// message, which no banner may surface (agent-store.mjs#propagateToVariants).
+const scriptError = (res, err) => {
+  const code = err && err.code;
+  return res
+    .status(agentErrorStatus(code))
+    .json({ error: STORE_ERROR_CODES.has(code) && err.message ? err.message : `the script store failed (${code || 'unknown error'})` });
+};
+
+app.post('/api/scripts', async (req, res) => {
+  const body = req.body || {};
+  try {
+    const created = await createScript({ meta: body.meta, source: body.source, sourceWin32: body.sourceWin32, by: 'ui' });
+    emitChanged('scripts-changed', 'created');
+    res.status(201).json(created);
+  } catch (err) {
+    scriptError(res, err);
+  }
+});
+
+app.put('/api/scripts/:key', async (req, res) => {
+  const key = req.params.key;
+  if (!SCRIPT_KEY_RE.test(key)) return res.status(404).json({ error: 'script not found' });
+  const body = req.body || {};
+  try {
+    const updated = await updateScript(key, { meta: body.meta, source: body.source, sourceWin32: body.sourceWin32, by: 'ui' });
+    emitChanged('scripts-changed', 'updated');
+    res.json(updated);
+  } catch (err) {
+    scriptError(res, err);
+  }
+});
+
+app.delete('/api/scripts/:key', async (req, res) => {
+  const key = req.params.key;
+  if (!SCRIPT_KEY_RE.test(key)) return res.status(404).json({ error: 'script not found' });
+  try {
+    const r = await deleteScript(key);
+    emitChanged('scripts-changed', 'deleted');
+    res.json(r);
+  } catch (err) {
+    scriptError(res, err);
   }
 });
 
+app.post('/api/scripts/:key/duplicate', async (req, res) => {
+  const key = req.params.key;
+  if (!SCRIPT_KEY_RE.test(key)) return res.status(404).json({ error: 'script not found' });
+  const newKey = req.body && typeof req.body.newKey === 'string' ? req.body.newKey.trim() : '';
+  if (!newKey) return badRequest(res, 'newKey is required');
+  try {
+    const copy = await duplicateScript(key, newKey, 'ui');
+    emitChanged('scripts-changed', 'created');
+    res.status(201).json(copy);
+  } catch (err) {
+    scriptError(res, err);
+  }
+});
+
+app.put('/api/scripts/:key/cases', async (req, res) => {
+  const key = req.params.key;
+  if (!SCRIPT_KEY_RE.test(key)) return res.status(404).json({ error: 'script not found' });
+  const cases = req.body && Array.isArray(req.body.cases) ? req.body.cases : null;
+  if (!cases) return badRequest(res, 'cases must be an array');
+  try {
+    // W18: for a built-in or plugin key this lands in the user layer as an
+    // overlay — a tests file with no meta beside it.
+    const r = await writeCases(key, cases);
+    emitChanged('scripts-changed', 'cases');
+    res.json(r);
+  } catch (err) {
+    scriptError(res, err);
+  }
+});
+
+
 // ---------------------------------------------------------------------------
 // /api/plugins* -> plugin lifecycle, delegated to src/core/plugin-store.mjs /
 // plugin-repo.mjs / plugin-config.mjs (spec §6). Thin wrappers: all policy
@@ -5710,13 +7422,19 @@ function readInstalledManifest(name) {
   }
 }
 
-app.get('/api/plugins', (req, res) => {
+app.get('/api/plugins', async (req, res) => {
   try {
     const mkts = readMarketplaces().marketplaces;
+    const rows = listInstalledPlugins();
+    // The python notice (spec §8.1) is a fact about THIS host: resolved once per
+    // request, and only when some plugin ships a python script (the probe caches 60 s).
+    const anyPython = rows.some((p) => Number((p.scriptRuntimes || {}).python) > 0);
+    const notice = anyPython ? await pythonNoticeFor([{ runtime: 'python' }]) : null;
     res.json({
-      plugins: listInstalledPlugins().map((p) => ({
+      plugins: rows.map((p) => ({
         ...p,
         marketplaceName: p.marketplace && mkts[p.marketplace] ? mkts[p.marketplace].name : null,
+        pythonMissing: !!(notice && Number((p.scriptRuntimes || {}).python) > 0),
       })),
       orphans: listOrphanPluginData(),
     });
@@ -6357,7 +8075,7 @@ app.post('/api/pipelines/:id/report-issue', async (req, res) => {
 });
 
 // ---------------------------------------------------------------------------
-// Install logic (mirrors scripts/install.mjs): copy agents/*.md and
+// Install logic (mirrors tools/install.mjs): copy agents/*.md and
 // skills/worca/** into <projectDir>/.claude/...
 // ---------------------------------------------------------------------------
 async function installAgents(projectDir) {
@@ -6438,9 +8156,9 @@ async function copyDir(srcDir, destDir, baseForRel, copiedOut) {
  * @param {Array<{name?:string, dataBase64?:string}>} list
  * @returns {Promise<string[]>}
  */
-async function writeExtras(runId, list) {
+async function writeExtras(runId, list, dirOverride = null) {
   if (!Array.isArray(list) || list.length === 0) return [];
-  const dir = path.join(os.tmpdir(), `orchestrator-extras-${runId}`);
+  const dir = dirOverride || path.join(os.tmpdir(), `orchestrator-extras-${runId}`);
   await fsp.mkdir(dir, { recursive: true });
   const out = [];
   let i = 0;
@@ -6553,7 +8271,7 @@ app.use((err, _req, res, next) => {
  *        sweep keeps its own console default.
  */
 export async function bootMaintenance({ log } = {}) {
-  const summary = { reconciled: 0, sweptV1: 0, runRoots: null, legacy: null, ask: null, askWorktrees: null };
+  const summary = { reconciled: 0, sweptV1: 0, runRoots: null, legacy: null, ask: null, askWorktrees: null, bench: null };
   const sink = (scope) => (typeof log === 'function' ? (level, msg) => log(scope, level, msg) : undefined);
 
   // Runs left 'running' by a previous process that died before writing a terminal
@@ -6645,6 +8363,19 @@ export async function bootMaintenance({ log } = {}) {
   } catch (err) {
     console.error(`[worca-ui] ask-worktree sweep failed: ${err && err.message ? err.message : err}`);
   }
+
+  // Script bench folders (workbench W11): the newest folder per script key
+  // outlives its run so the output tabs can still read it; 24 h later it is
+  // junk. os.tmpdir() would have been cleaned under us on macOS, hence
+  // <worcaHome>/bench and this sweep.
+  try {
+    const removed = await sweepBenchDirs(benchRoot());
+    summary.bench = { removed: removed.length };
+    if (removed.length) console.log(`[worca-ui] bench sweep: removed ${removed.length} folder(s)`);
+  } catch (err) {
+    summary.bench = { removed: 0 };
+    console.error(`[worca-ui] bench sweep failed: ${err && err.message ? err.message : err}`);
+  }
   return summary;
 }
 
@@ -6710,15 +8441,38 @@ if (isMain) {
     }
     try { startTeamMetricsBackground({ log: (m) => console.warn(m) }); }
     catch (err) { console.warn(`[worca-ui] team metrics background: ${err?.message || err}`); }
+    // Model bridge (model-bridge-design.md §4.1): up before the first bridged
+    // spawn so resolveModelEnv's synchronous start is the exception, not the rule.
+    startBridge({ log: (m) => console.warn(m) }).catch((err) => console.warn(`[worca-ui] model bridge: ${err?.message || err}`));
+    // Team policy discovery (design §9), then the marketplace seeding a policy asks for — metadata
+    // only (a git archive), never an install; installs go through the setup checklist.
+    try {
+      startTeamPolicyBackground({
+        log: (m) => console.warn(m),
+        onTick: async () => {
+          const scopes = await listPolicyScopes();
+          const docs = [];
+          for (const s of scopes.projects) if (s.home && !docs.some((d) => d.slug === s.home)) {
+            const r = await resolveProjectPolicy(s.path, { discover: false }).catch(() => null);
+            if (r?.ok) docs.push({ slug: r.home, doc: r.doc });
+          }
+          const seeded = await seedPolicyMarketplaces(docs);
+          for (const s of seeded) if (s.added) { console.warn(`[worca-ui] team policy: added marketplace ${s.url} (asked for by ${s.homes.join(', ')})`); emitChanged('plugins-changed', 'marketplace-seeded'); }
+        },
+      });
+    } catch (err) { console.warn(`[worca-ui] team policy background: ${err?.message || err}`); }
+    // Scheduled runs: boot catch-up + the 30 s tick (the server IS the scheduler).
+    try { startScheduler(); } catch (err) { console.warn(`[worca-ui] scheduler: ${err?.message || err}`); }
   });
 }
 
 export { app, server, runs };
 export const _testing = {
-  wireRun, wireScan, summarizeRuns, startScan, wireAgentGen, startAgentGen,
-  chatActions, chatRouter, channelHost, handleChatInbound, enqueueChatWork,
+  wireRun, wireScan, summarizeRuns, startScan, wireAgentGen, startAgentGen, wireScriptBench, startScriptBench,
+  chatActions, chatRouter, channelHost, handleChatInbound, enqueueChatWork, answerRun,
   chatNotifier, resumeRun, resolveHljsAssets, resolveEsmAsset, askJobs, askFollowers, askDeleting, resolveAskContext, flipCard,
   emitDiffCommentsChanged, emitAskWorktrees, askWorktreesEnvelope, deleteAskThreadFully,
   askTrackRun, liveRunEntry, liveDefragRun, memoryScopeKey, startRunHandler, emitMemoryChanged, askSystemPromptFor,
   uiControl, bearerMatches,
+  broadcast, askFilesRunDir,
 };