@worca/app 1.2.0-rc.2 → 1.2.0

package/README.md

@@ -90,6 +90,15 @@ and durations, the clarify Q&A, agent transcripts, and logs:
   runs out). Flow cards — **Task** (the run's request), **End** (the result),
   **AND**, **OR**, **Combine** — express joins, choices and merges without any
   code. Saved pipelines appear in the New Pipeline picker.
+- **Share a pipeline** — *Export…* on a saved pipeline offers three formats.
+  A *JSON file* passes it to another Worca user, who picks it up with
+  *Import…* (a taken name gets a ` (2)` suffix; nothing is ever overwritten).
+  A *Claude Code skill* turns it into a runnable `/command` under `.claude/`
+  so it runs without Worca. A *Worca plugin* folder bundles the pipeline with
+  your own agents it uses and the skills they need, so the recipient runs
+  `worca plugin link <folder>` and updates later with `worca plugin reimport`.
+  Built-in agents are never copied — a plugin pipeline may reference them
+  directly. The saved list is tabbed by domain; click a card to open it.
 
 ![Workflow Composer — drag agents into steps, groups, and feedback loops](docs/screenshots/composer.png)
 
@@ -143,6 +152,12 @@ and durations, the clarify Q&A, agent transcripts, and logs:
   per-model routing environment (e.g. `ANTHROPIC_BASE_URL`) that is merged
   into that model's agent spawns. Share a model catalog as a plugin, with
   secrets required at install time.
+- **No first-party account needed** — run and chat titles are written by the
+  model the run or chat itself uses (Settings › General › Title generation picks
+  a fixed one instead), endpoint-routed models carry Claude Code's internal
+  haiku/sonnet/opus/fable tier keys so nothing falls back to the Anthropic API,
+  and *Hide built-in models* (Settings › Models) drops the built-ins from every
+  picker.
 
 ### Storage
 
@@ -214,10 +229,15 @@ worca resume <pipelineId>
 
 # offline demo — full pipeline, no tokens
 worca --project /path/to/your/project --prompt "demo task" --mock --yes
+
+# share a saved pipeline: as JSON, or as a plugin folder bundling your agents + skills
+worca workflow export wf_my-flow --format json --out my-flow.json
+worca workflow import my-flow.json
+worca workflow export wf_my-flow --format plugin --target ./my-flow-plugin
 ```
 
 Run `worca --help` for all subcommands (projects, plugins, marketplaces,
-config, doctor) and flags.
+workflows, config, doctor) and flags.
 
 Exit codes, for scripts and CI wrappers: `0` the run finished (or an
 interactive run paused and you can resume it); `1` a hard error, a stop, or an

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/app",
-  "version": "1.2.0-rc.2",
+  "version": "1.2.0",
   "description": "Worca — deterministic multi-agent pipeline that drives Claude Code (headless) through Plan -> Refine -> Implement -> Review, with a CLI, an installable /worca skill, and a web UI.",
   "license": "MIT",
   "author": "Sinisha Djukic",

package/src/cli/worca-cc.mjs

@@ -225,6 +225,7 @@ Subcommands:
   config [get|set|unset]      Budget & cost-limit settings
   ui [start|stop|restart|status]
                               Run the web UI (default http://localhost:4317). See: worca ui help
+  workflow <cmd> [...]        Export a workflow (Claude Code skill, JSON, or plugin) / import JSON: list|export|import. See: worca workflow help
   help                        Print this help (same as --help).
   version                     Print the version (same as --version).
 
@@ -1203,6 +1204,43 @@ working, including updates (install provenance lives in plugins.lock.json).
 Exit codes: 0 ok, 1 failure, 2 usage/validation errors.
 `;
 
+const WORKFLOW_HELP = `worca workflow — export a saved Composer workflow (as a Claude Code skill, as
+shareable JSON, or as a Worca plugin) and import one shared as JSON
+
+Usage:
+  worca workflow list                                List workflows (id, name, domain)
+  worca workflow export <id> [options]               Export a workflow (see --format)
+  worca workflow import <file> [--name <name>]       Import a JSON export into your library ('-' = stdin)
+
+Export formats (--format):
+  claude (default)         A runnable Claude Code skill tree under <dest>/.claude/
+  json                     The shareable v2 graph, to stdout (or --out <file>)
+  plugin                   A Worca plugin folder (--target <dir>) bundling the workflow,
+                           your own agents it uses and the skills they require; the
+                           recipient runs: worca plugin link <dir>
+
+Options (claude):
+  --global                 Export to the home dir (~/.claude), not a project
+  --target <dir>           Export into <dir>/.claude (default: cwd)
+  --slug <name>            Skill slug (default: slugified workflow name)
+  --dry-run                Show the classification (create/update/no-op/conflict); write nothing
+  --on-conflict <mode>     skip (default) | overwrite | namespace conflicting files
+Options (json):
+  --out <file>             Write to <file> instead of stdout
+Options (plugin):
+  --target <dir>           The plugin folder (created, or updated in place)
+  --name <plugin>          Plugin name (default: an existing manifest's name, else the folder name)
+  --keep-version           Do not patch-bump the manifest version on an update
+  --dry-run                Show the classification; write nothing
+
+Import: the id is minted from the name; a name already in use gets a " (2)" suffix —
+nothing is ever overwritten. A workflow that needs agents you do not have is refused;
+ask its author for the plugin export instead.
+
+Export always prints the plan first, then applies (unless --dry-run). A re-export
+of an unchanged workflow is an all-no-op. Exit codes: 0 ok, 1 failure, 2 usage/validation errors.
+`;
+
 /** Tiny per-verb arg parser: positionals plus declared --value / --bool flags. */
 function pluginArgs(argv, valueFlags = [], boolFlags = []) {
   const out = { _: [] };
@@ -1220,7 +1258,7 @@ function pluginArgs(argv, valueFlags = [], boolFlags = []) {
       out[a.slice(2)] = v;
     } else if (boolFlags.includes(a)) {
       out[a.slice(2)] = true;
-    } else if (a.startsWith('-')) {
+    } else if (a.startsWith('-') && a !== '-') {                 // a lone '-' is the stdin positional
       fail(`Unknown flag: ${a}`);
     } else {
       out._.push(a);
@@ -1305,9 +1343,8 @@ async function pluginInit(rest) {
   for (const part of withParts) {
     if (!INIT_PARTS.includes(part)) fail(`unknown --with part "${part}" (known: ${INIT_PARTS.join(', ')})`);
   }
-  if (withParts.includes('workflows') && !withParts.includes('agents')) {
-    fail('--with workflows requires agents (templates may only reference the plugin\'s own agent keys)');
-  }
+  // `--with workflows` no longer requires `agents`: a plugin template may reference
+  // built-in agents (#421), so a workflow-only plugin scaffolds a built-in chain.
   const target = resolve(process.cwd(), a.dir || name);
   const { mkdir, writeFile, chmod, readdir } = await import('node:fs/promises');
   try {
@@ -1416,19 +1453,24 @@ async function pluginInit(rest) {
   }
   if (withParts.includes('workflows')) {
     // A v2 graph: the Task and End cards are mandatory (V20/V21) and every input
-    // takes exactly one wire (V7). Ports come from the sidecar above.
+    // takes exactly one wire (V7). With agents, ports come from the sidecar above;
+    // without, the chain runs the built-in planner (a plugin template may
+    // reference built-ins — they are on every host).
+    const withAgent = withParts.includes('agents');
+    const key = withAgent ? agentKey : 'planner';
+    const outPort = withAgent ? 'notes' : 'plan';
     files.set('workflows/example-flow.json', JSON.stringify({
       name: `${name} example flow`,
       version: 2,
       domain: 'general',
       nodes: [
         { id: 'n_task', kind: 'task', x: 40, y: 200, config: {} },
-        { id: 'n_helper', kind: 'agent', key: agentKey, x: 320, y: 200, config: {} },
+        { id: 'n_helper', kind: 'agent', key, x: 320, y: 200, config: {} },
         { id: 'n_end', kind: 'end', x: 600, y: 200, config: {} },
       ],
       wires: [
         { id: 'w1', from: { node: 'n_task', port: 'task' }, to: { node: 'n_helper', port: 'task' } },
-        { id: 'w2', from: { node: 'n_helper', port: 'notes' }, to: { node: 'n_end', port: 'result' } },
+        { id: 'w2', from: { node: 'n_helper', port: outPort }, to: { node: 'n_end', port: 'result' } },
       ],
     }, null, 2) + '\n');
   }
@@ -1838,9 +1880,141 @@ async function cmdMarketplace(argv) {
   }
 }
 
+async function cmdWorkflow(argv) {
+  const verb = argv[0];
+  const rest = argv.slice(1);
+  if (!verb || verb === 'help') { process.stdout.write(WORKFLOW_HELP); return 0; }
+  const wf = await import('../core/workflows.mjs');
+  const xp = await import('../core/workflow-export.mjs');
+  const share = await import('../core/workflow-share.mjs');
+  const { formatIssue } = await import('../shared/graph/validate.mjs');
+  try {
+    switch (verb) {
+      case 'list': {
+        // GRAPH_DEFAULT_WORKFLOW (the built-in default) is not in the user store, so
+        // prepend it — mirrors the server/UI, which always show it first.
+        const items = [wf.GRAPH_DEFAULT_WORKFLOW, ...(await wf.listWorkflows())];
+        for (const w of items) out(`${w.id}\t${w.name}\t${(w.domain || 'general')}`);
+        return 0;
+      }
+      case 'import': {
+        const a = pluginArgs(rest, ['--name'], []);
+        const file = a._[0];
+        if (!file) fail('Usage: worca workflow import <file> [--name <name>]');
+        const { readFile } = await import('node:fs/promises');
+        let text;
+        try {
+          text = file === '-'
+            ? await new Promise((res, rej) => { let s = ''; process.stdin.setEncoding('utf8'); process.stdin.on('data', (c) => (s += c)); process.stdin.on('end', () => res(s)); process.stdin.on('error', rej); })
+            : await readFile(resolve(process.cwd(), file), 'utf8');
+        } catch (e) { process.stderr.write(`worca workflow import: cannot read ${file}: ${e.message}\n`); return 1; }
+        let obj;
+        try { obj = JSON.parse(text); } catch (e) { process.stderr.write(`worca workflow import: ${file} is not valid JSON (${e.message})\n`); return 2; }
+        try {
+          const r = await share.importGraphWorkflow(obj, { name: a.name });
+          out(`imported\t${r.workflow.id}\t${r.workflow.name}`);
+          if (r.renamed) out(c('yellow', `renamed: "${r.requestedName}" was already taken — saved as "${r.workflow.name}"`));
+          for (const w of r.warnings || []) out(`${c('yellow', 'warn')}\t${formatIssue(w)}`);
+          return 0;
+        } catch (e) {
+          if (e && e.code === 'INVALID_GRAPH') {
+            process.stderr.write(`worca workflow import: ${e.summary || 'invalid graph'}\n`);
+            for (const issue of e.errors || []) process.stderr.write(`  - ${formatIssue(issue)}\n`);
+            return 2;
+          }
+          if (e && (e.code === 'BAD_REQUEST' || e.code === 'RESERVED_NAME')) { process.stderr.write(`worca workflow import: ${e.message}\n`); return 2; }
+          throw e;
+        }
+      }
+      case 'export': {
+        const a = pluginArgs(rest, ['--target', '--slug', '--on-conflict', '--format', '--out', '--name'], ['--global', '--dry-run', '--keep-version']);
+        const id = a._[0];
+        if (!id) fail('Usage: worca workflow export <id> [--format claude|json|plugin] [--global | --target <dir>] [--slug <name>] [--out <file>] [--name <plugin>] [--keep-version] [--dry-run] [--on-conflict=skip|overwrite|namespace]');
+        const format = a.format || 'claude';
+        if (!['claude', 'json', 'plugin'].includes(format)) fail(`--format must be claude|json|plugin (got ${format})`);
+
+        if (format === 'json') {
+          const payload = await share.exportGraphJson(id);
+          const text = JSON.stringify(payload, null, 2) + '\n';
+          if (a.out) {
+            const { writeFile } = await import('node:fs/promises');
+            const dest = resolve(process.cwd(), a.out);
+            await writeFile(dest, text, 'utf8');
+            out(`${c('green', 'wrote')}\t${dest}`);
+          } else {
+            process.stdout.write(text);
+          }
+          return 0;
+        }
+
+        if (format === 'plugin') {
+          if (!a.target) fail('--format plugin requires --target <dir> (the plugin folder)');
+          if (a.global) fail('--global does not apply to --format plugin');
+          const r = await xp.exportWorkflowPlugin({
+            workflowId: id, targetDir: resolve(process.cwd(), a.target), pluginName: a.name,
+            keepVersion: !!a['keep-version'], dryRun: !!a['dry-run'],
+          });
+          for (const p of r.created) out(`${c('green', 'create')}\t${p}`);
+          for (const p of r.updated) out(`${c('cyan', 'update')}\t${p}`);
+          for (const p of r.noop) out(`${c('gray', 'no-op')}\t${p}`);
+          for (const s of r.skipped) out(`${c('gray', 'skip')}\t${s.path}\t(${s.reason})`);
+          for (const w of r.warnings || []) out(`${c('yellow', 'warn')}\t${w}`);
+          for (const p of r.written) out(`${c('green', 'wrote')}\t${p}`);
+          if (r.validation && !r.validation.ok) {
+            out(c('yellow', `\nthe plugin folder does not validate — fix the errors above before sharing it`));
+            return 1;
+          }
+          if (!a['dry-run']) {
+            out(`\nplugin "${r.name}" v${r.version} at ${r.dir}`);
+            out(`share the folder; the recipient runs: worca plugin link ${r.dir}`);
+          }
+          return 0;
+        }
+
+        if (a.global && a.target) fail('--global and --target are mutually exclusive');
+        const onConflict = a['on-conflict'] || 'skip';
+        if (!xp.ON_CONFLICT_MODES.includes(onConflict)) fail(`--on-conflict must be ${xp.ON_CONFLICT_MODES.join('|')} (got ${onConflict})`);
+        const destination = a.global ? 'global' : 'project';
+        const projectDir = a.global ? undefined : (a.target || process.cwd());
+        const common = { workflowId: id, destination, projectDir, slug: a.slug };
+
+        // Always show the classification first. A dry-run stops at planExport (writes nothing);
+        // an apply reuses the buckets applyExport already computes, so the full resolve+classify
+        // pipeline runs ONCE, not twice.
+        const printPlan = (p) => {
+          for (const path of p.created) out(`${c('green', 'create')}\t${path}`);
+          for (const path of p.updated) out(`${c('cyan', 'update')}\t${path}`);
+          for (const path of p.noop) out(`${c('gray', 'no-op')}\t${path}`);
+          for (const cf of p.conflicts) out(`${c('yellow', 'conflict')}\t${cf.path}\t(${cf.reason})`);
+          for (const w of p.warnings || []) out(`${c('yellow', 'warn')}\t${w}`);
+          for (const o of p.orphans || []) out(`${c('gray', 'orphan')}\t${o}`);
+        };
+
+        if (a['dry-run']) { printPlan(await xp.planExport(common)); return 0; }
+
+        const applied = await xp.applyExport({ ...common, onConflict });
+        printPlan(applied);
+        for (const p of applied.written) out(`${c('green', 'wrote')}\t${p}`);
+        for (const p of applied.skipped) out(`${c('gray', 'skip')}\t${p}`);
+        if (applied.conflicts.length) {
+          // A partial export (conflicts skipped) can leave a non-runnable skill on disk. Warn AND
+          // exit non-zero so a CI/script that only checks the exit code does not treat it as success.
+          out(c('yellow', `\n${applied.conflicts.length} conflict(s) left unresolved (--on-conflict=${onConflict}). Re-run with --on-conflict=overwrite|namespace.`));
+          return 1;
+        }
+        return 0;
+      }
+      default: fail(`unknown workflow verb "${verb}" — see: worca workflow help`);
+    }
+  } catch (err) {
+    process.stderr.write(`worca workflow ${verb}: ${err && err.message ? err.message : err}\n`);
+    return 1;
+  }
+}
+
 // ── main ──────────────────────────────────────────────────────────────────────────
 
-const SUBCOMMANDS = new Set(['add', 'list', 'remove', 'resume', 'doctor', 'plugin', 'marketplace', 'config', 'ui']);
+const SUBCOMMANDS = new Set(['add', 'list', 'remove', 'resume', 'doctor', 'plugin', 'marketplace', 'config', 'ui', 'workflow']);
 
 /** Levenshtein distance, two-row. Only ever called on short argv tokens. */
 function editDistance(a, b) {
@@ -1899,6 +2073,7 @@ async function main() {
     if (sub === 'marketplace') return cmdMarketplace(rest);
     if (sub === 'config') return cmdConfig(rest);
     if (sub === 'ui') return cmdUi(rest);
+    if (sub === 'workflow') return cmdWorkflow(rest);
   }
   // `worca --ui [...]` is the historical spelling of `worca ui start [...]`; hand the
   // remaining tokens to the ui parser so --port/--open/--mock work with either.

package/src/core/ask/models.mjs

@@ -47,7 +47,12 @@ export function createAskModels({
   /** The D8 initial pick, validated against the live catalog (D5). */
   function pickDefault(models) {
     const want = String(defaults.defaultModel || '').toLowerCase();
-    const hit = models.find((m) => m.id.toLowerCase() === want) || models[0] || null;
+    // Hidden built-ins (#422) are never the initial pick: on an install that
+    // hides them the default is the first model the user actually owns. They
+    // stay in `models` so a stored thread on one keeps validating.
+    const visible = models.filter((m) => !m.hidden);
+    const pool = visible.length ? visible : models;
+    const hit = pool.find((m) => m.id.toLowerCase() === want) || pool[0] || null;
     if (!hit) return null;
     const efforts = hit.efforts.length ? hit.efforts : [...EFFORTS];
     const effort = efforts.includes(defaults.defaultEffort)
@@ -83,6 +88,7 @@ export function createAskModels({
         hasEnv: m.hasEnv === true,
       };
       if (custom === 'plugin' && typeof m.plugin === 'string' && m.plugin) entry.plugin = m.plugin;
+      if (m.hidden === true) entry.hidden = true;   // the picker skips it; validation does not (#422)
       // Only globals and plugin entries can arrive flagged: composeCatalog emits an
       // UNSHADOWED built-in as {...m, custom:false, hasEnv:false} with no
       // ...unreliable(lc) (src/core/config.mjs:200), so a built-in in model_cost_flags

package/src/core/ask/turn.mjs

@@ -439,6 +439,11 @@ class AskTurn extends EventEmitter {
         tools: [], strictMcpConfig: true, settingSources: ['project'],
         disableSlashCommands: true, envScrub: true, envAllowlist: [],
         permissionMode: 'dontAsk',
+        // The chat's own model is the title default (#422) — a chat on a
+        // custom endpoint titles itself there, not on a first-party Haiku.
+        runModel: this.model,
+        onError: ({ model, error }) => console.warn(
+          `[worca-ask] thread ${this.threadId}: title generation failed (model ${model}): ${error?.message || error} — keeping the fallback title`),
       }))
       .then((generated) => {
         // The route stamps NOTHING before the 202 (the header reads "Ask Worca"

package/src/core/config.mjs

@@ -15,8 +15,8 @@
 import { getDb, prepare, tx } from './db.mjs';
 import { projectKey } from './store.mjs';
 import { loadAgentRegistry, registryToSteps } from './agent-registry.mjs';
-import { EFFORTS, prepareModelEnv, isSubagentModelValue, subagentModelIssue } from './model-env.mjs';
-import { listGlobalModels, addGlobalModel, removeGlobalModel } from './settings.mjs';
+import { EFFORTS, prepareModelEnv, withTierModelEnv, isSubagentModelValue, subagentModelIssue } from './model-env.mjs';
+import { listGlobalModels, addGlobalModel, removeGlobalModel, hideBuiltinModels } from './settings.mjs';
 import { listPluginModels, allPluginModels, flattenPluginModelEnv } from './plugin-models.mjs';
 
 /**
@@ -184,6 +184,11 @@ function composeCatalog(projectCustom = []) {
   const seen = new Set();
   const unreliable = (lc) => (flagged.has(lc) ? { costUnreliable: true } : {});
   const routedOf = (env) => !!(env && 'ANTHROPIC_BASE_URL' in env);
+  // "Hide built-in models" (#422): a cosmetic flag on the UNSHADOWED built-ins,
+  // read by every picker. The entry stays in the catalog — hiding an id must
+  // never stop it resolving, or a stored run / plugin reference that names it
+  // would break — so pickers skip `hidden`, validators ignore it.
+  const hidden = hideBuiltinModels() ? { hidden: true } : {};
   const pluginShape = (id, m, lc) => ({
     id, label: m.label, efforts: [...m.efforts], custom: 'plugin', plugin: m.plugin,
     hasEnv: !!m.env, routed: routedOf(m.env), ...unreliable(lc),
@@ -196,7 +201,7 @@ function composeCatalog(projectCustom = []) {
       ? { id: m.id, label: shadow.label, efforts: [...shadow.efforts], custom: 'global', hasEnv: !!shadow.env, routed: routedOf(shadow.env), ...unreliable(lc) }
       : pshadow
         ? pluginShape(m.id, pshadow, lc)
-        : { ...m, custom: false, hasEnv: false, routed: false });
+        : { ...m, custom: false, hasEnv: false, routed: false, ...hidden });
     seen.add(lc);
   }
   for (const m of globals) {
@@ -486,10 +491,12 @@ export function resolveModelEnv(modelId) {
   const lc = id.toLowerCase();
   let rawEnv;
   let who;
+  let canonicalId = id;
   const entry = listGlobalModels().find((m) => m.id.toLowerCase() === lc);
   if (entry && entry.env) {
     rawEnv = entry.env;
     who = JSON.stringify(entry.id);
+    canonicalId = entry.id;
   } else if (!entry) {
     const pm = listPluginModels().find((m) => m.id.toLowerCase() === lc);
     if (pm && pm.env) {
@@ -499,6 +506,7 @@ export function resolveModelEnv(modelId) {
       }
       rawEnv = env;
       who = `${JSON.stringify(pm.id)} (plugin "${pm.plugin}")`;
+      canonicalId = pm.id;
     }
   }
   if (!rawEnv) return undefined;
@@ -506,7 +514,27 @@ export function resolveModelEnv(modelId) {
   for (const k of dropped) {
     console.warn(`[worca] model ${who}: dropping env key ${JSON.stringify(k)} (reserved or unresolvable \${VAR} ref)`);
   }
-  return Object.keys(env).length ? env : undefined;
+  if (!Object.keys(env).length) return undefined;
+  // Endpoint-routed entries also carry the CLI's internal tier keys, pointed at
+  // this entry's own wire id (#422, model-env.mjs#withTierModelEnv) — so the
+  // CLI's session-title / alias / probe calls never fall back to a first-party
+  // id the endpoint has never heard of. Keys the entry sets itself win.
+  return withTierModelEnv(env, canonicalId);
+}
+
+/**
+ * Whether `modelId` names a catalog member — built-in, global, or plugin —
+ * regardless of the hide-built-ins flag (hidden entries still resolve).
+ * Case-insensitive like every other id lookup here. Synchronous; never throws.
+ * @param {string} modelId
+ */
+export function catalogHasModel(modelId) {
+  const id = typeof modelId === 'string' ? modelId.trim() : '';
+  if (!id) return false;
+  const lc = id.toLowerCase();
+  return PREDEFINED_MODELS.some((m) => m.id.toLowerCase() === lc)
+    || listGlobalModels().some((m) => m.id.toLowerCase() === lc)
+    || listPluginModels().some((m) => m.id.toLowerCase() === lc);
 }
 
 /**
@@ -990,6 +1018,7 @@ export async function setActiveWorkflow(projectDir, workflowId) {
  * @returns {Promise<{nodes:Record<string,object>,feedbacks:Record<string,{maxCycles:number}>}>}
  */
 export async function resolveRunConfig(projectDir, workflowId) {
+  if (!projectDir) return { nodes: {}, wires: {}, feedbacks: {} };   // defaults-only (global export); avoids projectKey(null). v2 shape incl. wires.
   const wf = readWorkflowsMap(projectKey(projectDir))[workflowId] || {};
   return {
     nodes: wf.nodes && typeof wf.nodes === 'object' ? wf.nodes : {},

package/src/core/folder-dialog.mjs

@@ -20,7 +20,14 @@
 
 import { spawn } from 'node:child_process';
 
-const PROMPT = 'Select a project folder';
+// The dialog title, by PURPOSE. A closed set, never caller text: the string is
+// interpolated into an osascript / PowerShell command line.
+const PROMPTS = Object.freeze({
+  project: 'Select a project folder',
+  export: 'Select the project folder to export into',
+  plugin: 'Select the plugin folder',
+});
+const promptFor = (purpose) => PROMPTS[purpose] || PROMPTS.project;
 // A dialog waits on a human; give it a long leash, then kill the process so a
 // forgotten dialog cannot pin server resources forever.
 const DIALOG_TIMEOUT_MS = 5 * 60 * 1000;
@@ -75,20 +82,22 @@ export const _testing = {
 /**
  * Open the platform's native folder picker and wait for the user.
  * Serialized: while one dialog is open, further calls resolve { status:'busy' }.
+ * @param {{purpose?: 'project'|'export'|'plugin'}} [opts] picks the dialog title
  * @returns {Promise<{status:'picked', path:string} | {status:'canceled'}
  *   | {status:'unsupported'} | {status:'busy'}>}
  */
-export async function pickFolderNative() {
+export async function pickFolderNative({ purpose } = {}) {
   if (_inFlight) return { status: 'busy' };
   _inFlight = true;
   try {
     const platform = _ov.platform || process.platform;
     const env = _ov.env || process.env;
     const run = _ov.runner || defaultRun;
+    const prompt = promptFor(purpose);
     if ((env.WORCA_NO_NATIVE_DIALOG || '') === '1') return { status: 'unsupported' };
-    if (platform === 'darwin') return await pickMac(run);
-    if (platform === 'win32') return await pickWindows(run);
-    if (platform === 'linux') return await pickLinux(run, env);
+    if (platform === 'darwin') return await pickMac(run, prompt);
+    if (platform === 'win32') return await pickWindows(run, prompt);
+    if (platform === 'linux') return await pickLinux(run, env, prompt);
     return { status: 'unsupported' };
   } finally {
     _inFlight = false;
@@ -101,10 +110,10 @@ function pickedOrCanceled(stdoutRaw) {
   return path ? { status: 'picked', path } : { status: 'canceled' };
 }
 
-async function pickMac(run) {
+async function pickMac(run, prompt) {
   const r = await run('osascript', [
     '-e', 'tell application "System Events" to activate',
-    '-e', `POSIX path of (choose folder with prompt "${PROMPT}")`,
+    '-e', `POSIX path of (choose folder with prompt "${prompt}")`,
   ]);
   if (r.ok) return pickedOrCanceled(r.stdout);
   // `choose folder` cancel: exit 1 + "execution error: User canceled. (-128)"
@@ -112,11 +121,11 @@ async function pickMac(run) {
   return { status: 'unsupported' }; // no GUI session, automation denied, ...
 }
 
-async function pickWindows(run) {
+async function pickWindows(run, prompt) {
   const script =
     'Add-Type -AssemblyName System.Windows.Forms | Out-Null; ' +
     '$d = New-Object System.Windows.Forms.FolderBrowserDialog; ' +
-    `$d.Description = '${PROMPT}'; $d.ShowNewFolderButton = $true; ` +
+    `$d.Description = '${prompt}'; $d.ShowNewFolderButton = $true; ` +
     "if ($d.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { [Console]::Out.WriteLine($d.SelectedPath) }";
   const r = await run('powershell.exe', ['-NoProfile', '-STA', '-Command', script]);
   if (!r.ok) return { status: 'unsupported' };
@@ -125,13 +134,13 @@ async function pickWindows(run) {
   return path ? { status: 'picked', path } : { status: 'canceled' };
 }
 
-async function pickLinux(run, env) {
+async function pickLinux(run, env, prompt) {
   if (!env.DISPLAY && !env.WAYLAND_DISPLAY) return { status: 'unsupported' };
-  const zen = await run('zenity', ['--file-selection', '--directory', `--title=${PROMPT}`]);
+  const zen = await run('zenity', ['--file-selection', '--directory', `--title=${prompt}`]);
   if (zen.ok) return pickedOrCanceled(zen.stdout);
   if (zen.code === 1 && !zen.timedOut) return { status: 'canceled' }; // user closed it
   // zenity missing (spawn error -> code -1) or broken: try kdialog.
-  const kd = await run('kdialog', ['--title', PROMPT, '--getexistingdirectory', env.HOME || '/']);
+  const kd = await run('kdialog', ['--title', prompt, '--getexistingdirectory', env.HOME || '/']);
   if (kd.ok) return pickedOrCanceled(kd.stdout);
   if (kd.code === 1 && !kd.timedOut) return { status: 'canceled' };
   return { status: 'unsupported' };

package/src/core/marketplaces.mjs

@@ -122,6 +122,19 @@ async function syncEntry(entry, { exec } = {}) {
 export async function addMarketplace(url, { exec } = {}) {
   const norm = normalizeMarketplaceUrl(url);
   if (!norm) throw Object.assign(new Error('marketplace url is required'), { code: 'BAD_REQUEST' });
+  // A plain PLUGIN folder — a worca-cc-plugin.json, no marketplace manifest, and
+  // NOT a git repository (a git repo whose root is a plugin IS a marketplace:
+  // the fallback scan discovers it at depth 0) — is not a marketplace. It is the
+  // natural thing to paste after `worca workflow export --format plugin`. Say
+  // so, name the fix, and carry the dir so the server route can link it on the
+  // user's behalf (code PLUGIN_FOLDER).
+  if (!/^[a-z+]+:\/\//i.test(norm) && !/^[A-Za-z0-9._-]+@[A-Za-z0-9._-]+:/.test(norm)
+    && existsSync(join(norm, 'worca-cc-plugin.json')) && !existsSync(join(norm, 'worca-cc-marketplace.json'))
+    && !existsSync(join(norm, '.git'))) {
+    throw Object.assign(
+      new Error(`${norm} is a single plugin folder, not a marketplace — link it instead: worca plugin link ${norm}`),
+      { code: 'PLUGIN_FOLDER', dir: norm });
+  }
   const id = marketplaceId(norm);
   if (readMarketplaces().marketplaces[id]) { // cheap pre-check: fail before any git work
     throw Object.assign(new Error(`marketplace already added: ${norm}`), { code: 'EXISTS' });

package/src/core/model-env.mjs

@@ -17,6 +17,47 @@
  *  without importing the core graph. */
 export const EFFORTS = ['medium', 'high', 'xhigh', 'max'];
 
+// The effort worca's own auxiliary calls run at (title generation, the Models
+// view Test button). Deliberately BELOW the pipeline list: the CLI accepts
+// `--effort low` (claude --help, 2.1.259) and a one-line summary needs nothing
+// more, so the cheapest tier is the right one. EFFORTS omits it on purpose —
+// pipeline nodes are not offered `low` — which is why it lives here as its own
+// constant instead of being clamped into that list (#422).
+export const AUX_EFFORT = 'low';
+
+// Claude Code resolves its OWN internal calls — session titles, the alias tiers
+// a Task `model: haiku|sonnet|opus|fable` expands to, quota probes — through
+// these keys. A catalog entry that routes to a custom endpoint (ANTHROPIC_BASE_URL)
+// routinely sets ANTHROPIC_MODEL and nothing else, so the CLI falls back to
+// first-party ids against an endpoint that does not serve them (the
+// `unrecognized_model` noise in run logs). withTierModelEnv fills every one the
+// entry left unset with the entry's own wire id (#422). ANTHROPIC_SMALL_FAST_MODEL
+// is the pre-DEFAULT_HAIKU spelling older CLIs still read.
+export const TIER_MODEL_ENV_KEYS = Object.freeze([
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL', 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL', 'ANTHROPIC_DEFAULT_FABLE_MODEL',
+  'ANTHROPIC_SMALL_FAST_MODEL',
+]);
+
+/**
+ * The tier keys an endpoint-routed model env should carry, synthesized from
+ * the env's wire id. Pure: a non-routed env (no ANTHROPIC_BASE_URL) comes back
+ * untouched, an explicit key in the env is never overwritten, and with no wire
+ * id to point at (no ANTHROPIC_MODEL and no model id) nothing is added.
+ * @param {Record<string,string>|undefined} env  a PREPARED model env
+ * @param {string} [modelId]  the catalog id — the wire id when ANTHROPIC_MODEL is unset (#374)
+ * @returns {Record<string,string>|undefined}
+ */
+export function withTierModelEnv(env, modelId) {
+  if (!env || typeof env !== 'object' || !('ANTHROPIC_BASE_URL' in env)) return env;
+  const wire = (typeof env.ANTHROPIC_MODEL === 'string' && env.ANTHROPIC_MODEL.trim())
+    || (typeof modelId === 'string' ? modelId.trim() : '');
+  if (!wire) return env;
+  const out = { ...env };
+  for (const k of TIER_MODEL_ENV_KEYS) if (!(k in out)) out[k] = wire;
+  return out;
+}
+
 // Env keys a model entry may NOT set (§4.4): process fundamentals and worca's
 // own runtime knobs, any of which injection could otherwise subvert (mock
 // mode, the claude binary path, the effort flag name). Everything else —

package/src/core/model-test.mjs

@@ -7,6 +7,7 @@
 
 import { runClaude } from './claude-runner.mjs';
 import { resolveModelEnv } from './config.mjs';
+import { AUX_EFFORT } from './model-env.mjs';
 import { classifyError } from './recoverable-error.mjs';
 
 const TEST_TIMEOUT_MS = 60_000;
@@ -52,7 +53,7 @@ export async function testModel(id, { signal, bin, run = runClaude } = {}) {
       prompt: 'Reply with exactly OK.',
       model: id,
       modelEnv: resolveModelEnv(id),
-      effort: 'low',
+      effort: AUX_EFFORT,
       permissionMode: 'acceptEdits',
       allowedTools: [],          // empty → no --allowedTools flag; pure text gen
       signal: ctrl.signal,