@worca/app 1.3.0 → 1.4.0

package/src/core/ask/events.mjs

@@ -50,6 +50,14 @@ const GIT_NAV_SUBCOMMANDS = new Set(['checkout', 'switch', 'fetch']);
 // becomes the same `memory-changed` broadcast the REST routes emit (ui/server.mjs emitMemoryChanged).
 // The scope key rides the tool RESULT (`scopeKey`), like pokeCommentWrite reads `comment.runId`.
 const MEMORY_WRITE_TOOLS = new Set(['mcp__worca__remember', 'mcp__worca__forget']);
+// …and the script writer (scripts-workbench-design.md §3.3, §9.1): save_script writes a file
+// under ~/.worca-cc/scripts in the CHILD, so the parent turns a successful call into the same
+// `scripts-changed` broadcast the REST routes emit — a script the chat saved shows up in an
+// open Scripts tab. There is no delete tool, and test_script writes nothing outside the bench.
+const SCRIPT_WRITE_TOOLS = new Set(['mcp__worca__save_script']);
+// The direct schedule writes (docs/scheduled-runs.md "Ask Worca"): reversible, never a run start.
+const SCHEDULE_WRITE_TOOLS = new Set(['mcp__worca__pause_schedule', 'mcp__worca__resume_schedule',
+  'mcp__worca__skip_next_run', 'mcp__worca__mark_schedule_activity_read']);
 /** True when a SUCCESSFUL call of `name` with `input` changed this thread's worktree rows. */
 export function worktreeMutatingCall(name, input) {
   if (!WORKTREE_TOOLS.has(name)) return false;
@@ -128,6 +136,8 @@ export function labelForTool(name, input = {}, attachmentNames = {}) {
     case 'get_team_metrics': return 'Reading team metrics';
     case 'list_team_metrics_runs': return 'Listing team runs';
     case 'push_team_metrics': return 'Pushing team metrics';
+    case 'get_team_policy': return 'Reading team policy';
+    case 'propose_policy_change': return 'Proposing a policy change';
     case 'track_run': return 'Tracking a run';
     case 'read_attachment': return `Reading ${(attachmentNames && attachmentNames[id]) || 'attachment'}`;
     case 'list_diff_comments': return id ? `Reading comments on ${id.slice(0, 12)}` : 'Reading diff comments';
@@ -139,6 +149,27 @@ export function labelForTool(name, input = {}, attachmentNames = {}) {
     case 'read_memory': return input?.name ? `Reading memory: ${input.name}` : 'Reading memory';
     case 'remember': return input?.name ? `Saving memory: ${input.name}` : 'Saving memory';
     case 'forget': return input?.name ? `Removing memory: ${input.name}` : 'Removing memory';
+    case 'list_scripts': return 'Looking at scripts';
+    case 'get_script': return input?.key ? `Reading script: ${input.key}` : 'Reading a script';
+    case 'save_script': return input?.key ? `Saving script: ${input.key}` : 'Saving a script';
+    case 'test_script': return input?.key ? `Testing script: ${input.key}` : 'Testing a script';
+    case 'list_schedules': return 'Looking at schedules';
+    case 'get_schedule': return 'Reading a schedule';
+    case 'list_schedule_activity': return 'Reading schedule activity';
+    case 'preview_schedule': return 'Working out the dates';
+    case 'propose_schedule_change': return 'Proposing a schedule change';
+    case 'pause_schedule': return 'Pausing a schedule';
+    case 'resume_schedule': return 'Resuming a schedule';
+    case 'skip_next_run': return 'Skipping the next run';
+    case 'mark_schedule_activity_read': return 'Marking activity read';
+    case 'list_task_sources': return 'Looking at task sources';
+    case 'find_tasks': return input?.search ? `Searching tasks: ${String(input.search).slice(0, 40)}` : 'Searching tasks';
+    case 'get_task': return input?.id ? `Reading task ${String(input.id).slice(0, 40)}` : 'Reading a task';
+    case 'list_models': return 'Looking at models';
+    case 'get_providers': return 'Looking at providers';
+    case 'test_provider': return input?.provider ? `Testing ${String(input.provider).slice(0, 20)}` : 'Testing a provider';
+    case 'list_copilot_models': return 'Listing Copilot models';
+    case 'propose_model_change': return 'Proposing a model change';
     default: return `Using ${n}`;
   }
 }
@@ -149,6 +180,40 @@ const resultText = (content) => {
   return '';
 };
 
+// ── script tools on the thread row (scripts-workbench-design.md §9.3) ─────────
+const SCRIPT_TOOL_NAMES = new Set(['list_scripts', 'get_script', 'save_script', 'test_script']);
+
+/**
+ * The key a script tool was called with, stamped on the block at the CALL: a save_script input
+ * is a whole program, so past blockIoMaxChars the persisted input is the { _truncated, preview }
+ * stub and input.key is gone. '' for a script tool with no key, null for every other tool.
+ */
+export function scriptToolKey(name, input = {}) {
+  if (!SCRIPT_TOOL_NAMES.has(short(name))) return null;
+  return typeof input?.key === 'string' ? input.key.trim().slice(0, 64) : '';
+}
+
+/**
+ * What a script tool's RESULT adds to its thread row: `save script runTests → created`,
+ * `test script runTests → blocking, exit 1`. Pure, tiny and enum-shaped on purpose — it is
+ * merged into the persisted block.script, so nothing free-text (which would need redaction)
+ * rides along. null = the row keeps its ordinary shape.
+ */
+export function scriptResultNote(name, text, isError = false) {
+  const n = short(name);
+  if (isError || (n !== 'save_script' && n !== 'test_script')) return null;
+  let parsed = null;
+  try { parsed = JSON.parse(text); } catch { return null; }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+  if (n === 'save_script') return { saved: parsed.ok === true ? (parsed.created === true ? 'created' : 'updated') : 'not saved' };
+  const r = parsed.ok === true && parsed.result && typeof parsed.result === 'object' ? parsed.result : null;
+  if (!r) return { status: 'not run' };
+  return {
+    status: typeof r.status === 'string' ? r.status.slice(0, 16) : null,
+    exitCode: Number.isInteger(r.exitCode) ? r.exitCode : null,
+  };
+}
+
 /**
  * @param {object} o
  * @param {(frame:object)=>void} o.onFrame
@@ -178,10 +243,15 @@ export function createTurnReducer({
   onWorkflowStart = null,
   onWorkflowResult = null,
   onMetricsProposal = null,      // propose_metrics_change RESULT (team metrics card; the parent re-validates the input)
+  onPolicyProposal = null,       // propose_policy_change RESULT (team policy card; same split)
+  onScheduleProposal = null,     // propose_schedule_change RESULT (schedule card; the parent re-validates the input)
+  onModelProposal = null,        // propose_model_change RESULT (model card; same split)
+  onScheduleMutation = null,     // a direct schedule write succeeded in the MCP child
   onTrackRun = null,
   onCommentMutation = null,
   onWorktreeMutation = null,
   onMemoryMutation = null,
+  onScriptMutation = null,        // save_script RESULT { ok: true, key, created } → { key, action }
   estimateLiveCost = null,
   attachmentNames = {},
   resolveCost = null,
@@ -368,7 +438,9 @@ export function createTurnReducer({
         } else {
           fullInputs.set(c.id, input);
           label(labelForTool(c.name, input, attachmentNames));
-          upsertBlock({ kind: 'tool', id: c.id, name: c.name, input: clipJson(input, limits.blockIoMaxChars), status: 'running', durationMs: null });
+          const scriptKey = scriptToolKey(c.name, input);
+          upsertBlock({ kind: 'tool', id: c.id, name: c.name, input: clipJson(input, limits.blockIoMaxChars), status: 'running', durationMs: null,
+            ...(scriptKey === null ? {} : { script: { key: scriptKey } }) });          // §9.3: the row's key, whatever the clip does
           // P3: the workflow card exists from the tool_use on (state 'building' — the four-step trace), so the
           // START is a hook too. Sync: the block must precede any frame the tool result produces.
           if (c.name === 'mcp__worca__propose_workflow' && typeof onWorkflowStart === 'function') {
@@ -425,6 +497,25 @@ export function createTurnReducer({
     } catch { /* unparseable result — no poke; the next open refetches anyway */ }
   }
 
+  // And for scripts: save_script REFUSES by returning { ok: false, errors } with no is_error
+  // flag (that is what lets the model correct itself), so the result body — not the flag — is
+  // what decides whether anything was written.
+  function pokeScriptWrite(name, text, isError) {
+    if (isError || !SCRIPT_WRITE_TOOLS.has(name) || typeof onScriptMutation !== 'function') return;
+    try {
+      const parsed = JSON.parse(text);
+      if (!parsed || parsed.ok !== true || typeof parsed.key !== 'string' || !parsed.key) return;
+      onScriptMutation({ key: parsed.key, action: parsed.created === true ? 'created' : 'updated' });
+    } catch { /* unparseable result — no poke; the next open refetches anyway */ }
+  }
+
+  // And for schedules: pause / resume / skip / mark-read succeeded in the CHILD, so the parent
+  // broadcasts the same schedules-changed / notifications-changed frames the REST routes emit.
+  function pokeScheduleWrite(name, isError) {
+    if (isError || !SCHEDULE_WRITE_TOOLS.has(name) || typeof onScheduleMutation !== 'function') return;
+    try { onScheduleMutation({ tool: short(name) }); } catch { /* a broken sink never breaks the stream */ }
+  }
+
   function onUser(raw, ptu, isMain) {
     const content = Array.isArray(raw.message?.content) ? raw.message.content : [];
     for (const c of content) {
@@ -439,6 +530,8 @@ export function createTurnReducer({
         pokeCommentWrite(ct.name, text, c.is_error);
         pokeWorktreeMutation(ct.name, ct.input, c.is_error);
         pokeMemoryWrite(ct.name, text, c.is_error);
+        pokeScriptWrite(ct.name, text, c.is_error);
+        pokeScheduleWrite(ct.name, c.is_error);
         continue;
       }
       const b = byId.get(c.tool_use_id);
@@ -465,6 +558,8 @@ export function createTurnReducer({
       b.status = c.is_error ? 'error' : 'done';
       b.durationMs = elapsed(b.id);
       if (c.is_error) b.error = redact(clipStr(text, limits.blockIoMaxChars));
+      const note = scriptResultNote(b.name, text, c.is_error);
+      if (note) b.script = { ...(b.script || {}), ...note };                       // §9.3: the row shows what came back
       upsertBlock(b);
       if (b.name === 'mcp__worca__propose_run' && typeof onProposal === 'function') {
         let childOk = null;
@@ -490,6 +585,27 @@ export function createTurnReducer({
           if (ret && typeof ret.then === 'function') pendingHooks.push(ret.then(() => {}, () => { reducerErrors += 1; }));
         } catch { reducerErrors += 1; }
       }
+      if (b.name === 'mcp__worca__propose_policy_change' && typeof onPolicyProposal === 'function') {
+        // Same split as the metrics card: the parent re-validates from the INPUT (policy-proposal.mjs).
+        try {
+          const ret = onPolicyProposal({ toolUseId: b.id, input: fullInputs.get(b.id) ?? {}, text, isError: !!c.is_error });
+          if (ret && typeof ret.then === 'function') pendingHooks.push(ret.then(() => {}, () => { reducerErrors += 1; }));
+        } catch { reducerErrors += 1; }
+      }
+      if (b.name === 'mcp__worca__propose_schedule_change' && typeof onScheduleProposal === 'function') {
+        // Same split as the metrics card: the parent re-validates the INPUT against the live rows.
+        try {
+          const ret = onScheduleProposal({ toolUseId: b.id, input: fullInputs.get(b.id) ?? {}, text, isError: !!c.is_error });
+          if (ret && typeof ret.then === 'function') pendingHooks.push(ret.then(() => {}, () => { reducerErrors += 1; }));
+        } catch { reducerErrors += 1; }
+      }
+      if (b.name === 'mcp__worca__propose_model_change' && typeof onModelProposal === 'function') {
+        // Same split as the metrics card: the parent re-validates the INPUT over the real catalog (model-proposal.mjs).
+        try {
+          const ret = onModelProposal({ toolUseId: b.id, input: fullInputs.get(b.id) ?? {}, text, isError: !!c.is_error });
+          if (ret && typeof ret.then === 'function') pendingHooks.push(ret.then(() => {}, () => { reducerErrors += 1; }));
+        } catch { reducerErrors += 1; }
+      }
       if (b.name === 'mcp__worca__track_run' && typeof onTrackRun === 'function') {
         // The parent owns the runs Map, the link rows and the followers: it re-resolves the id itself (D4).
         try {
@@ -500,6 +616,8 @@ export function createTurnReducer({
       pokeCommentWrite(b.name, text, c.is_error);
       pokeWorktreeMutation(b.name, fullInputs.get(b.id), c.is_error);
       pokeMemoryWrite(b.name, text, c.is_error);
+      pokeScriptWrite(b.name, text, c.is_error);
+      pokeScheduleWrite(b.name, c.is_error);
     }
   }
 

package/src/core/ask/limits.mjs

@@ -2,7 +2,9 @@
 // Fixed limits of the Ask Worca chat (ask-worca-design.md §6.9) plus the two
 // operator-configurable per-turn guards, read fresh on every turn (D12). Pure
 // apart from the settings readers, which are injectable for tests.
-import { askMaxTurns as readAskMaxTurns, askMaxBudgetUsd as readAskMaxBudgetUsd } from '../settings.mjs';
+import { askMaxTurns as readAskMaxTurns, askMaxBudgetUsd as readAskMaxBudgetUsd, readSettings } from '../settings.mjs';
+import { cachedPolicyForKey } from '../policy/cache.mjs';
+import { fieldsForRun } from '../policy/effective.mjs';
 import { TEXT_EXTENSIONS, BINARY_EXTENSIONS } from './attachment-kind.mjs';
 
 export const ASK_LIMITS = Object.freeze({
@@ -38,6 +40,18 @@ export const ASK_LIMITS = Object.freeze({
   artifactsListMaxLimit: 200,
   artifactReadDefaultBytes: 60_000,
   artifactReadMaxBytes: 200_000,
+  // Scripts in the chat (scripts-workbench-design.md §9.1). The store's own caps (source
+  // 256 KiB, 32 cases) are NOT repeated here: script-store / script-cases own those.
+  scriptListMaxRows: 200,                  // list_scripts rows (= artifactsListMaxLimit)
+  scriptSourceDefaultBytes: 60_000,        // get_script page (= diffDefaultBytes)
+  scriptSourceMaxBytes: 200_000,           // get_script page cap (= diffMaxBytes)
+  scriptLogMaxLines: 200,                  // test_script: the LAST N streamed lines…
+  scriptLogMaxBytes: 16 * 1024,            // …and their byte cap (the tail is kept: a failure ends the log)
+  scriptOutputMaxBytes: 16 * 1024,         // test_script: per output port (the head is kept)
+  scriptTestDefaultTimeoutSec: 120,        // test_script timeoutSec default
+  scriptTestMaxTimeoutSec: 600,            // …and its ceiling (= the engine's 10-minute default)
+  scriptVerdictMaxIssues: 50,              // test_script: verdict issues sent (the rest is counted, not sent)
+  scriptResultFieldMaxChars: 2000,         // test_script: per verdict field / warning / diff / error line (chars)
   briefMaxChars: 8000,
   metricsRunsDefaultLimit: 20,             // list_team_metrics_runs page (= listRunsDefaultLimit)
   metricsRunsMaxLimit: 100,                // list_team_metrics_runs page cap (= listRunsMaxLimit)
@@ -52,7 +66,7 @@ export const ASK_LIMITS = Object.freeze({
   headerAttachments: 5,
   deltaBatchMs: 50,
   deltaBatchChars: 256,
-  defaultModel: 'claude-opus-5',           // D8
+  defaultModel: 'claude-opus-5-5',         // D8
   defaultEffort: 'high',
 });
 
@@ -61,6 +75,20 @@ export const ASK_LIMITS = Object.freeze({
  * applies to the next turn without a restart.
  * @returns {{maxTurns:number, maxBudgetUsd:number|null}}
  */
-export function askLimits({ readMaxTurns = readAskMaxTurns, readMaxBudgetUsd = readAskMaxBudgetUsd } = {}) {
-  return { maxTurns: readMaxTurns(), maxBudgetUsd: readMaxBudgetUsd() };
+export function askLimits({ readMaxTurns = readAskMaxTurns, readMaxBudgetUsd = readAskMaxBudgetUsd, projectKey = null, readStored = readSettings } = {}) {
+  const out = { maxTurns: readMaxTurns(), maxBudgetUsd: readMaxBudgetUsd() };
+  // Team policy defaults (team-policy design §5 `ask.*`): start a thread pinned to a governed
+  // project off the team's numbers, but only where the developer has stored nothing of their own.
+  if (projectKey) {
+    const p = cachedPolicyForKey(projectKey);
+    if (p) {
+      const f = fieldsForRun(p.doc);
+      const stored = readStored() || {};
+      const t = f['ask.maxTurns'];
+      if (t && t.kind === 'default' && stored.askMaxTurns === undefined) out.maxTurns = t.value;
+      const b = f['ask.maxBudgetUsd'];
+      if (b && b.kind === 'default' && stored.askMaxBudgetUsd === undefined) out.maxBudgetUsd = b.value;
+    }
+  }
+  return out;
 }

package/src/core/ask/mcp-stdio.mjs

@@ -25,9 +25,14 @@ import { createAskTools, AskToolError } from './tools.mjs';
 import { defaultToolDeps } from './tool-deps.mjs';
 import { defaultWorktreeDeps } from './worktree-deps.mjs';
 import { defaultMemoryDeps } from './memory-deps.mjs';
+import { defaultScriptDeps } from './script-deps.mjs';
 import { defaultCommentDeps } from './comment-deps.mjs';
 import { defaultWorkflowDeps } from './workflow-deps.mjs';
 import { defaultMetricsDeps } from './metrics-deps.mjs';
+import { defaultPolicyDeps } from './policy-deps.mjs';
+import { defaultScheduleDeps } from './schedule-deps.mjs';
+import { defaultSourceDeps } from './source-deps.mjs';
+import { defaultModelDeps } from './model-deps.mjs';
 
 const SUPPORTED_PROTOCOLS = Object.freeze(['2024-11-05', '2025-03-26', '2025-06-18', '2025-11-25']);
 const DEFAULT_PROTOCOL = '2025-06-18';
@@ -123,9 +128,16 @@ export async function main({ argv = process.argv.slice(2), env = process.env, st
       ...defaultToolDeps({ threadId }),
       ...defaultWorktreeDeps({ threadId }),
       ...defaultMemoryDeps({ threadId }),
+      // The life signal (already built for propose_workflow's nested classifier): stdin closing
+      // means the turn ended or was stopped, and a bench run still going is stopped with it.
+      ...defaultScriptDeps({ threadId, signal: life.signal }),
       ...defaultCommentDeps(),
       ...defaultWorkflowDeps({ threadId, signal: life.signal }),
       ...defaultMetricsDeps({ threadId }),
+      ...defaultPolicyDeps({ threadId }),
+      ...defaultScheduleDeps({ threadId }),
+      ...defaultSourceDeps(),
+      ...defaultModelDeps({ threadId }),
     }),
     write: (s) => stdout.write(s),
   });

package/src/core/ask/model-deps.mjs

@@ -0,0 +1,126 @@
+// src/core/ask/model-deps.mjs
+// The models + providers dependency bundle of the Ask Worca tools (docs/models.md "Ask Worca"):
+// the ONE module that touches the catalog and the bridge on the tools' behalf (tools.mjs may not
+// import anything). Two callers:
+//   • the MCP child (mcp-stdio.mjs): deps.models.* behind list_models, get_providers,
+//     test_provider, list_copilot_models and propose_model_change (validate only);
+//   • the parent: turn.mjs re-validates a proposal with validateModelChange, and the cards route
+//     applies a confirmed card with applyModelChange.
+// Never a credential out: env values and keys are masked unless they are ${VAR} references.
+import { listModels, PREDEFINED_MODELS, EFFORTS, globalModelRefs, removeGlobalModelAndRefs } from '../config.mjs';
+import { listGlobalModels, addGlobalModel, updateGlobalModel, updateProvider, providerConfig } from '../settings.mjs';
+import { listPluginModels } from '../plugin-models.mjs';
+import { policyCatalogModels } from '../policy/cache.mjs';
+import { providerReadiness } from '../bridge/registry.mjs';
+import {
+  providersState, patchProvider, copilotModelsForImport, importCopilotModels, testProviderConnection,
+  endpointModelsForImport, importEndpointModels,
+} from '../bridge/provider-ops.mjs';
+import { UPSTREAM_PROVIDERS } from '../model-env.mjs';
+import { createModelChangeValidator, mergeEditPatch, maskEntry } from './model-proposal.mjs';
+
+const envHas = (name) => typeof process.env[name] === 'string' && process.env[name].trim() !== '';
+
+/** The authoritative validator, over the real readers (the turn's default; the child's too). */
+export const validateModelChange = createModelChangeValidator({
+  listGlobalModels, listPluginModels, policyModels: policyCatalogModels, predefined: PREDEFINED_MODELS,
+  addModel: addGlobalModel, updateModel: updateGlobalModel, updateProvider,
+  providerConfig, providerReadiness, modelRefs: globalModelRefs, envHas,
+  copilotModels: () => copilotModelsForImport(),
+  endpointModels: (baseUrl) => endpointModelsForImport({ baseUrl }),
+});
+
+/**
+ * Every catalog model as list_models shows it: the picker row (source, efforts, bridge facts,
+ * readiness) joined with the entry's own masked config when it is a user (global) entry.
+ */
+export async function listModelsForAsk() {
+  const rows = await listModels('');
+  const globals = new Map(listGlobalModels().map((m) => [m.id.toLowerCase(), m]));
+  const plugins = new Map(listPluginModels().map((m) => [m.id.toLowerCase(), m]));
+  const source = { false: 'built-in', global: 'user', plugin: 'plugin', policy: 'team policy', project: 'project (legacy)' };
+  const models = rows.map((row) => {
+    const g = globals.get(row.id.toLowerCase());
+    const p = !g ? plugins.get(row.id.toLowerCase()) : null;
+    const entry = g ? maskEntry(g) : null;
+    const up = (g && g.upstream) || (p && p.upstream) || null;
+    return {
+      id: row.id, label: row.label, source: source[String(row.custom)] || String(row.custom),
+      ...(row.plugin ? { plugin: row.plugin } : {}), ...(row.policy ? { policyHome: row.policy } : {}),
+      editable: !!g, efforts: row.efforts,
+      connection: up ? 'provider' : row.routed ? 'env' : 'default',
+      ...(row.bridged ? { provider: row.bridged, upstreamApi: row.upstreamApi, upstreamModel: row.upstreamModel } : {}),
+      ...(row.bridged ? { ready: !row.needsSignIn, ...(row.needsSignIn && up ? { notReady: providerReadiness(up).message } : {}) } : {}),
+      ...(row.capabilities ? { capabilities: row.capabilities } : {}),
+      ...(row.hidden ? { hidden: true } : {}), ...(row.costUnreliable ? { costUnreliable: true } : {}),
+      ...(entry ? { entry: { env: entry.env || {}, ...(entry.upstream ? { upstream: entry.upstream } : {}), ...(entry.cost ? { cost: entry.cost } : {}) } } : {}),
+    };
+  });
+  return { models, efforts: [...EFFORTS], providers: [...UPSTREAM_PROVIDERS] };
+}
+
+/**
+ * Apply a CONFIRMED model card (ui/server.mjs cards route, after the user's click). Every setter
+ * re-validates; an edit re-merges its patch onto the entry as it is NOW. Returns a result the card
+ * renders and the event turn quotes; throws on failure.
+ */
+export async function applyModelChange(card, io = {}) {
+  const c = card.change || {};
+  switch (card.kind) {
+    case 'add_model': {
+      const m = await (io.addModel ?? addGlobalModel)(c.model);
+      return { ok: true, detail: `${m.id} is in the catalog` };
+    }
+    case 'edit_model': {
+      const current = (io.listGlobalModels ?? listGlobalModels)().find((m) => m.id.toLowerCase() === String(c.id).toLowerCase());
+      if (!current) throw new Error(`model "${c.id}" is no longer in the catalog`);
+      await (io.updateModel ?? updateGlobalModel)(current.id, mergeEditPatch(current, c.patch || {}));
+      return { ok: true, detail: `${current.id} updated` };
+    }
+    case 'remove_model': {
+      const r = await (io.removeModel ?? removeGlobalModelAndRefs)(c.id);
+      const n = (r?.clearedSteps || 0) + (r?.clearedNodes || 0);
+      // The event turn quotes this detail: it names the Settings › Memory ref it cleared too.
+      return { ok: true, detail: `${c.id} removed${n ? ` · ${n} workflow selection${n === 1 ? '' : 's'} cleared` : ''}${r?.clearedMemoryDefrag ? ' · Settings › Memory defragment model cleared' : ''}` };
+    }
+    case 'provider': {
+      await (io.patchProvider ?? patchProvider)(c.provider, c.set || {});
+      return { ok: true, detail: `${c.provider} provider saved` };
+    }
+    case 'import_endpoint': {
+      const r = await (io.importEndpoint ?? importEndpointModels)(c.ids || [], { baseUrl: c.baseUrl || '' });
+      const bits = [];
+      if (r.created?.length) bits.push(`added ${r.created.join(', ')}`);
+      if (r.updated?.length) bits.push(`refreshed ${r.updated.join(', ')}`);
+      // The endpoint's skips carry a reason (an embedding model, no tool calls); Copilot's are ids.
+      if (r.skipped?.length) bits.push(`skipped ${r.skipped.map((s) => (typeof s === 'string' ? s : `${s.id} (${s.why})`)).join(', ')}`);
+      return { ok: true, detail: `${bits.join(' · ') || 'nothing to import'} — from ${r.serverLabel || r.baseUrl || 'the endpoint'}` };
+    }
+    case 'import_copilot': {
+      const r = await (io.importCopilot ?? importCopilotModels)(c.ids || []);
+      const bits = [];
+      if (r.created?.length) bits.push(`added ${r.created.join(', ')}`);
+      if (r.updated?.length) bits.push(`refreshed ${r.updated.join(', ')}`);
+      if (r.skipped?.length) bits.push(`skipped ${r.skipped.join(', ')}`);
+      return { ok: true, detail: bits.join(' · ') || 'nothing to import' };
+    }
+    default:
+      throw new Error(`unknown model change kind "${card.kind}"`);
+  }
+}
+
+/**
+ * @param {{threadId?:string|null}} [o]  threadId unused today; keeps the *-deps.mjs signature uniform
+ */
+export function defaultModelDeps({ threadId = null } = {}) {   // eslint-disable-line no-unused-vars
+  return {
+    models: {
+      list: listModelsForAsk,
+      providers: () => providersState(),
+      test: (name) => testProviderConnection(name),
+      copilotModels: () => copilotModelsForImport(),
+      endpointModels: (baseUrl) => endpointModelsForImport({ baseUrl }),
+      validateChange: validateModelChange,
+    },
+  };
+}