drafted 1.13.0 → 1.14.1

package/cli/drafted.mjs

@@ -1911,89 +1911,89 @@ skillCmd
     else console.log(`ok\t${id}\t${data.hash}\tpushed ${data.count}${data.stripped ? `, stripped ${data.stripped}` : ''}${gitignored ? ', gitignored .skillinstall/' : ''}`);
   });
 
-// ── Collectors: management seam (parity with the MCP `collector` tool) ──
-// Collectors are checklist-driven intake surfaces. Management is behind the
-// agent allowlist (same gate as Minion) and scoped to the session's active org.
-function emitCollectorResult(format, obj) {
+// ── Minions: management seam (parity with the MCP `minion` tool) ──
+// Minions are checklist-driven intake surfaces. Management is behind the
+// agent allowlist and scoped to the session's active org.
+function emitMinionResult(format, obj) {
   if (format === 'json') { console.log(JSON.stringify(obj)); return; }
   console.log([obj.status, obj.id || '', obj.slug || '', obj.name || '', obj.error || ''].join('\t'));
 }
 
-async function collectorSetEnabled(id, enabled, format) {
+async function minionSetEnabled(id, enabled, format) {
   requireLogin();
   const server = getServerUrl().replace(/\/$/, '');
-  const res = await authFetch(`${server}/api/collectors/${encodeURIComponent(id)}`, {
+  const res = await authFetch(`${server}/api/minions/${encodeURIComponent(id)}`, {
     method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ enabled }),
   });
   const data = await res.json().catch(() => ({}));
-  if (!res.ok) { emitCollectorResult(format, { status: res.status === 404 ? 'not-found' : 'error', error: data.error || `HTTP ${res.status}` }); process.exit(1); }
-  const c = data.collector || {};
-  emitCollectorResult(format, { status: 'ok', id: c.id, slug: c.slug, name: c.name });
+  if (!res.ok) { emitMinionResult(format, { status: res.status === 404 ? 'not-found' : 'error', error: data.error || `HTTP ${res.status}` }); process.exit(1); }
+  const c = data.minion || {};
+  emitMinionResult(format, { status: 'ok', id: c.id, slug: c.slug, name: c.name });
 }
 
-const collectorCmd = program.command('collector').description('Collector management (checklist-driven intake surfaces). Requires the agent allowlist.');
+const minionCmd = program.command('minion').description('Minion management (checklist-driven intake surfaces). Requires the agent allowlist.');
 
-collectorCmd
+minionCmd
   .command('list')
-  .description('List collectors (scoped to --project or your active project; all org collectors if neither)')
+  .description('List Minions (scoped to --project or your active project; all org Minions if neither)')
   .option('--project <id>', 'project to scope to (defaults to your active project)')
   .option('--format <fmt>', 'output format: json or text', 'text')
   .action(async (opts) => {
     const pid = opts.project || getActiveProject()?.id;
-    const data = await readApiGet('collector:list', withQuery('/api/collectors', { projectId: pid }));
-    const rows = data.collectors || [];
+    const data = await readApiGet('minion:list', withQuery('/api/minions', { projectId: pid }));
+    const rows = data.minions || [];
     if (opts.format === 'json') { console.log(JSON.stringify(rows)); return; }
     for (const c of rows) console.log(`${c.id}\t${c.slug}\t${c.enabled ? 'enabled' : 'disabled'}\t${c.name}`);
   });
 
-collectorCmd
+minionCmd
   .command('get <id>')
-  .description('Get a collector by id')
+  .description('Get a Minion by id')
   .option('--format <fmt>', 'output format: json or text', 'text')
   .action(async (id, opts) => {
-    const data = await readApiGet('collector:get', `/api/collectors/${encodeURIComponent(id)}`);
-    if (opts.format === 'json') { console.log(JSON.stringify(data.collector || data)); return; }
-    const c = data.collector || {};
+    const data = await readApiGet('minion:get', `/api/minions/${encodeURIComponent(id)}`);
+    if (opts.format === 'json') { console.log(JSON.stringify(data.minion || data)); return; }
+    const c = data.minion || {};
     console.log(`${c.id}\t${c.slug}\t${c.enabled ? 'enabled' : 'disabled'}\t${c.name}`);
   });
 
-collectorCmd
+minionCmd
   .command('meta')
-  .description('Project layers/lanes/frames for building a collector target/output')
+  .description('Project layers/lanes/frames for building a Minion target/output')
   .option('--project <id>', 'project (defaults to your active project)')
   .option('--format <fmt>', 'output format: json or text', 'text')
   .action(async (opts) => {
     const pid = opts.project || getActiveProject()?.id;
     if (!pid) { console.error('No active project. Pass --project <id> or run `drafted use <project>`.'); process.exit(1); }
-    const data = await readApiGet('collector:meta', withQuery('/api/collectors/meta', { projectId: pid }));
+    const data = await readApiGet('minion:meta', withQuery('/api/minions/meta', { projectId: pid }));
     console.log(JSON.stringify(data));
   });
 
-collectorCmd
+minionCmd
   .command('create')
-  .description('Create a collector from stdin JSON {name,description?,target,checklist,output,enabled?}')
+  .description('Create a Minion from stdin JSON {name,description?,target,checklist,output,enabled?}')
   .option('--project <id>', 'project to bind to (defaults to your active project)')
   .option('--format <fmt>', 'output format: json or text', 'text')
   .action(async (opts) => {
     requireLogin();
     const pid = opts.project || getActiveProject()?.id;
-    if (!pid) { emitCollectorResult(opts.format, { status: 'error', error: 'no project — pass --project <id> or run `drafted use <project>`' }); process.exit(1); }
+    if (!pid) { emitMinionResult(opts.format, { status: 'error', error: 'no project — pass --project <id> or run `drafted use <project>`' }); process.exit(1); }
     let p;
     try { p = readStdinJSON(); } catch { console.error('invalid JSON on stdin'); process.exit(1); }
     const server = getServerUrl().replace(/\/$/, '');
-    const res = await authFetch(`${server}/api/collectors`, {
+    const res = await authFetch(`${server}/api/minions`, {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ projectId: pid, name: p.name, description: p.description, target: p.target, checklist: p.checklist, output: p.output, enabled: p.enabled }),
     });
     const data = await res.json().catch(() => ({}));
-    if (!res.ok) { emitCollectorResult(opts.format, { status: res.status === 403 ? 'forbidden' : 'error', error: data.error || `HTTP ${res.status}` }); process.exit(1); }
-    const c = data.collector || {};
-    emitCollectorResult(opts.format, { status: 'ok', id: c.id, slug: c.slug, name: c.name });
+    if (!res.ok) { emitMinionResult(opts.format, { status: res.status === 403 ? 'forbidden' : 'error', error: data.error || `HTTP ${res.status}` }); process.exit(1); }
+    const c = data.minion || {};
+    emitMinionResult(opts.format, { status: 'ok', id: c.id, slug: c.slug, name: c.name });
   });
 
-collectorCmd
+minionCmd
   .command('update <id>')
-  .description('Update a collector from stdin JSON {name?,description?,target?,checklist?,output?,enabled?}')
+  .description('Update a Minion from stdin JSON {name?,description?,target?,checklist?,output?,enabled?}')
   .option('--format <fmt>', 'output format: json or text', 'text')
   .action(async (id, opts) => {
     requireLogin();
@@ -2003,33 +2003,33 @@ collectorCmd
     for (const k of ['name', 'description', 'target', 'checklist', 'output', 'enabled']) {
       if (p[k] !== undefined) body[k] = p[k];
     }
-    if (Object.keys(body).length === 0) { emitCollectorResult(opts.format, { status: 'error', error: 'no fields to update' }); process.exit(1); }
+    if (Object.keys(body).length === 0) { emitMinionResult(opts.format, { status: 'error', error: 'no fields to update' }); process.exit(1); }
     const server = getServerUrl().replace(/\/$/, '');
-    const res = await authFetch(`${server}/api/collectors/${encodeURIComponent(id)}`, {
+    const res = await authFetch(`${server}/api/minions/${encodeURIComponent(id)}`, {
       method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
     });
     const data = await res.json().catch(() => ({}));
-    if (!res.ok) { emitCollectorResult(opts.format, { status: res.status === 404 ? 'not-found' : 'error', error: data.error || `HTTP ${res.status}` }); process.exit(1); }
-    const c = data.collector || {};
-    emitCollectorResult(opts.format, { status: 'ok', id: c.id, slug: c.slug, name: c.name });
+    if (!res.ok) { emitMinionResult(opts.format, { status: res.status === 404 ? 'not-found' : 'error', error: data.error || `HTTP ${res.status}` }); process.exit(1); }
+    const c = data.minion || {};
+    emitMinionResult(opts.format, { status: 'ok', id: c.id, slug: c.slug, name: c.name });
   });
 
-collectorCmd
+minionCmd
   .command('enable <id>')
-  .description('Make a collector live')
+  .description('Make a Minion live')
   .option('--format <fmt>', 'output format: json or text', 'text')
-  .action((id, opts) => collectorSetEnabled(id, true, opts.format));
+  .action((id, opts) => minionSetEnabled(id, true, opts.format));
 
-collectorCmd
+minionCmd
   .command('disable <id>')
-  .description('Take a collector offline')
+  .description('Take a Minion offline')
   .option('--format <fmt>', 'output format: json or text', 'text')
-  .action((id, opts) => collectorSetEnabled(id, false, opts.format));
+  .action((id, opts) => minionSetEnabled(id, false, opts.format));
 
-async function collectorTestPost(id, path, body, format) {
+async function minionTestPost(id, path, body, format) {
   requireLogin();
   const server = getServerUrl().replace(/\/$/, '');
-  const res = await authFetch(`${server}/api/collectors/${encodeURIComponent(id)}/${path}`, {
+  const res = await authFetch(`${server}/api/minions/${encodeURIComponent(id)}/${path}`, {
     method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body || {}),
   });
   const data = await res.json().catch(() => ({}));
@@ -2041,39 +2041,39 @@ async function collectorTestPost(id, path, body, format) {
   console.log(JSON.stringify(data));
 }
 
-collectorCmd
+minionCmd
   .command('test-start <id>')
-  .description('QA: start (or resume) a test run of a collector you own — works even when disabled. --fresh for a new run.')
+  .description('QA: start (or resume) a test run of a Minion you own — works even when disabled. --fresh for a new run.')
   .option('--fresh', 'start a brand-new run instead of resuming', false)
   .option('--format <fmt>', 'output format: json (default)', 'json')
-  .action((id, opts) => collectorTestPost(id, 'test-start', { fresh: !!opts.fresh }, opts.format));
+  .action((id, opts) => minionTestPost(id, 'test-start', { fresh: !!opts.fresh }, opts.format));
 
-collectorCmd
+minionCmd
   .command('test-say <id>')
   .description('QA: send a text answer to your test run; returns the agent reply, checklist state, pending actions.')
   .requiredOption('--text <text>', 'the consumer message to send')
   .option('--format <fmt>', 'output format: json (default)', 'json')
-  .action((id, opts) => collectorTestPost(id, 'test-message', { content: opts.text }, opts.format));
+  .action((id, opts) => minionTestPost(id, 'test-message', { content: opts.text }, opts.format));
 
-collectorCmd
+minionCmd
   .command('test-resolve <id>')
   .description('QA: approve or reject a pending destructive action in your test run.')
   .requiredOption('--action <actionId>', 'the pending action id')
   .option('--reject', 'reject instead of approve', false)
   .option('--format <fmt>', 'output format: json (default)', 'json')
-  .action((id, opts) => collectorTestPost(id, 'test-resolve', { actionId: opts.action, approve: !opts.reject }, opts.format));
+  .action((id, opts) => minionTestPost(id, 'test-resolve', { actionId: opts.action, approve: !opts.reject }, opts.format));
 
-collectorCmd
+minionCmd
   .command('delete <id>')
-  .description('Delete a collector (past submissions are kept as history)')
+  .description('Delete a Minion (past submissions are kept as history)')
   .option('--format <fmt>', 'output format: json or text', 'text')
   .action(async (id, opts) => {
     requireLogin();
     const server = getServerUrl().replace(/\/$/, '');
-    const res = await authFetch(`${server}/api/collectors/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    const res = await authFetch(`${server}/api/minions/${encodeURIComponent(id)}`, { method: 'DELETE' });
     const data = await res.json().catch(() => ({}));
-    if (!res.ok) { emitCollectorResult(opts.format, { status: res.status === 404 ? 'not-found' : 'error', error: data.error || `HTTP ${res.status}` }); process.exit(1); }
-    emitCollectorResult(opts.format, { status: 'ok', id: data.id || id });
+    if (!res.ok) { emitMinionResult(opts.format, { status: res.status === 404 ? 'not-found' : 'error', error: data.error || `HTTP ${res.status}` }); process.exit(1); }
+    emitMinionResult(opts.format, { status: 'ok', id: data.id || id });
   });
 
 program.parse();

package/install-mcp.sh

@@ -227,7 +227,17 @@ if [ -n "$STALE_DRAFTED_BIN" ]; then
   fi
 fi
 
-npm config set prefix "$NPM_GLOBAL_PREFIX" >/dev/null
+# Do NOT `npm config set prefix` — that repoints the user's GLOBAL npm prefix, so every
+# `npm install -g <pkg>` they ever run lands in our dir AND our uninstall (`rm -rf ~/.drafted`)
+# would wipe all their other globals. Install drafted with an explicit per-command --prefix
+# instead (below), and HEAL any global prefix pin an older version of this installer wrote so
+# the user's default is restored. Preserve every other ~/.npmrc line (auth tokens, etc.).
+NPMRC="${npm_config_userconfig:-$HOME/.npmrc}"
+if [ -f "$NPMRC" ] && grep -Eq '^[[:space:]]*prefix[[:space:]]*=.*/\.drafted/npm-global/?[[:space:]]*$' "$NPMRC"; then
+  tmp_npmrc="$(mktemp)"
+  grep -Ev '^[[:space:]]*prefix[[:space:]]*=.*/\.drafted/npm-global/?[[:space:]]*$' "$NPMRC" > "$tmp_npmrc" && cat "$tmp_npmrc" > "$NPMRC"
+  rm -f "$tmp_npmrc"
+fi
 export PATH="$NPM_GLOBAL_PREFIX/bin:$PATH"
 
 # Persist the prefix's bin dir at the FRONT of PATH for future shells — without
@@ -262,7 +272,7 @@ step "Installing Drafted"
 install_drafted_pkg() {
   attempts=5; delay=4; n=1
   while :; do
-    if npm install -g drafted@latest --force; then return 0; fi
+    if npm install -g drafted@latest --force --prefix "$NPM_GLOBAL_PREFIX"; then return 0; fi
     if [ "$n" -ge "$attempts" ]; then return 1; fi
     echo -e "    ${YELLOW}npm install failed (attempt $n/$attempts) — retrying in ${delay}s (a new release may still be propagating to the npm CDN)...${RESET}"
     sleep "$delay"
@@ -274,7 +284,7 @@ if ! install_drafted_pkg; then
   exit 1
 fi
 hash -r 2>/dev/null || true
-NPM_ROOT="$(npm root -g 2>/dev/null || true)"
+NPM_ROOT="$(npm root -g --prefix "$NPM_GLOBAL_PREFIX" 2>/dev/null || true)"
 MCP_SERVER_MODULE="$NPM_ROOT/drafted/mcp/server.mjs"
 if [ -n "$NPM_ROOT" ] && [ -f "$MCP_SERVER_MODULE" ]; then
   node -e "import('node:url').then(({ pathToFileURL }) => import(pathToFileURL(process.argv[1]).href)).then(() => process.exit(0), (err) => { console.error(err); process.exit(1); })" "$MCP_SERVER_MODULE"
@@ -1288,7 +1298,7 @@ echo ""
 echo -e "  ${DIM}MCP name:${RESET}  ${BOLD}$INSTALL_NAME${RESET}"
 echo -e "  ${DIM}Server:${RESET}    ${BOLD}$INSTALL_SERVER${RESET}"
 echo -e "  ${DIM}To update production:${RESET}  rerun curl -fsSL https://drafted.live/install.sh | bash"
-echo -e "  ${DIM}To uninstall:${RESET}  npm uninstall -g drafted && rm -rf ~/.drafted"
+echo -e "  ${DIM}To uninstall:${RESET}  npm uninstall -g drafted --prefix ~/.drafted/npm-global && rm -rf ~/.drafted"
 echo ""
 echo -e "${YELLOW}${BOLD}"
 echo "  ┌─────────────────────────────────────────────────────────┐"

package/mcp/server.mjs

@@ -144,7 +144,7 @@ const REMOTE_JSON_STRING_PARAMS = {
   wiki: ['frontmatter', 'pages'],
   project: ['layers'],
   template: ['layers'],
-  collector: ['target', 'checklist', 'output'],
+  minion: ['target', 'checklist', 'output'],
 };
 
 // Remove sentences that reference local-file params from a tool description,
@@ -258,8 +258,8 @@ const TOOL_ANNOTATIONS = {
   skill:               { title: 'Skills',              readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage the Drafted skill library: search, load, add, update, remove, attach/detach from projects, favorite, and edit skill files.' },
   wiki:                { title: 'Wiki',                readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Per-org wiki. Markdown pages with paths as hierarchy. Dispatch by `action`.' },
 
-  // Collectors — checklist-driven, Minion-run intake surfaces bound to a project
-  collector:           { title: 'Collectors',          readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage Collectors: checklist-driven intake surfaces that guide a consumer through a checklist (via a shareable /c/<slug> link) and then write a producible into the project. Dispatch by `action`: meta (discover layers/lanes/frames), list, get, create, update, enable, disable, delete. QA your own collectors with test_start/test_say/test_resolve — drive the checklist conversation yourself (works even when disabled) and verify it produces the right Doc/Sheet output. Requires the agent allowlist (same gate as Minion).' },
+  // Minions — checklist-driven intake surfaces bound to a project
+  minion:              { title: 'Minions',             readOnlyHint: false, destructiveHint: true,  openWorldHint: false, description: 'Manage Minions: checklist-driven intake surfaces that guide a consumer through a checklist (via a shareable /c/<slug> link) and then write a producible into the project. Dispatch by `action`: meta (discover layers/lanes/frames), list, get, create, update, enable, disable, delete. QA your own Minions with test_start/test_say/test_resolve — drive the checklist conversation yourself (works even when disabled) and verify it produces the right Doc/Sheet output. Requires the agent allowlist.' },
 };
 
 function isMutatingToolCall(name, args = {}) {
@@ -285,7 +285,7 @@ function isMutatingToolCall(name, args = {}) {
       return ['add', 'update', 'remove', 'attach', 'detach', 'favorite', 'unfavorite', 'update_file'].includes(action);
     case 'wiki':
       return ['log', 'write', 'edit', 'mv', 'rm', 'source-register', 'bulk-write'].includes(action);
-    case 'collector':
+    case 'minion':
       return ['create', 'update', 'enable', 'disable', 'delete', 'test_start', 'test_say', 'test_resolve'].includes(action);
     case 'rm':
     case 'shape':
@@ -1462,10 +1462,85 @@ async function consumePendingDeviceCode() {
 // meaningless and disruptive — it returns spurious sign-in URLs and, on login,
 // spawns a server-side browser-open and blocks polling until timeout. Register
 // it only on stdio.
-if (!isRemote) tool('auth', 'Sign in to Drafted. `action=get_link` returns a verification URL immediately (use for SSH/headless/tmux where a browser may not open) and starts background polling; after the user opens the link, later Drafted tool calls also auto-consume the approved login. `action=login` opens a browser when needed and explicitly waits/polls for approval. If get_link was called first, login reuses that pending code instead of opening a new browser.', {
+// --- Local-install auth surface: the desktop app, never a device link ---
+// The stdio installer ALWAYS installs the Drafted desktop app alongside the MCP, so on a
+// local install the app IS the sign-in surface. Spawning it hands off to the always-running
+// instance (single-instance plugin), which opens the sign-in window and starts the native
+// cookie->auth.json capture that this MCP reads via getBootstrapSessionId(). Only the web MCP
+// is app-less, and that path authenticates via OAuth2 in the browser — never this tool. The
+// device-code flow below is kept ONLY as a fallback for platforms without the desktop app.
+function desktopAppBinary() {
+  try {
+    if (process.platform === 'darwin') {
+      const p = '/Applications/Drafted.app/Contents/MacOS/drafted-desktop';
+      return existsSync(p) ? p : null;
+    }
+    if (process.platform === 'win32') {
+      const p = join(process.env.LOCALAPPDATA || '', 'Programs', 'Drafted', 'Drafted.exe');
+      return existsSync(p) ? p : null;
+    }
+  } catch { /* fall through to no-app */ }
+  return null; // e.g. Linux — no desktop app → device-code fallback
+}
+
+async function launchDesktopSignin() {
+  const bin = desktopAppBinary();
+  if (!bin) return false;
+  try {
+    const { spawn } = await import('child_process');
+    // If the app is already running (macOS KeepAlive normally guarantees it), the single-instance
+    // handler opens the sign-in window and DRAFTED_OPEN_LOGIN is ignored. If it isn't running,
+    // the fresh primary instance honors DRAFTED_OPEN_LOGIN=1 and opens sign-in on boot.
+    const child = spawn(bin, [], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, DRAFTED_OPEN_LOGIN: '1' },
+    });
+    child.unref();
+    return true;
+  } catch { return false; }
+}
+
+// Poll auth.json (written by the desktop app's cookie->auth.json bridge on in-app sign-in)
+// until a valid session id lands or the deadline passes.
+async function waitForBootstrapAuth(deadline) {
+  while (Date.now() < deadline) {
+    const sid = getBootstrapSessionId();
+    if (sid) return sid;
+    await new Promise(r => setTimeout(r, 1500));
+  }
+  return null;
+}
+
+if (!isRemote) tool('auth', 'Sign in to Drafted. On a local install the DESKTOP APP is the sign-in surface: both actions open the Drafted app to its sign-in window — no device link is shown. `action=login` opens the app and waits for the in-app sign-in to complete; `action=get_link` opens the app and returns immediately (the next Drafted tool call picks up the captured session). A device-code link is used ONLY as a fallback on platforms without the desktop app (the web MCP uses OAuth2, not this tool).', {
   action: z.enum(['get_link', 'login']).describe('Operation to perform.'),
 }, async ({ action }) => {
   try {
+    // Local install → open the desktop app's sign-in window (no link). Falls through to the
+    // device-code flow below only when no desktop app is installed on this platform.
+    {
+      const existing = getState().sessionId || getBootstrapSessionId();
+      if (existing) {
+        try {
+          const meRes = await serverFetch(`${getServerUrl()}/auth/me`, { headers: { Cookie: `gc_session=${existing}` } });
+          if (meRes.ok) {
+            const me = await meRes.json();
+            return ok({ status: 'already_authenticated', userId: me.userId, email: me.userEmail, org: me.currentOrg?.name });
+          }
+        } catch { /* stale session — continue to sign-in */ }
+      }
+      if (await launchDesktopSignin()) {
+        if (action === 'get_link') {
+          return ok('Opening the Drafted app to sign in — approve in the app window, then retry your request.');
+        }
+        const sid = await waitForBootstrapAuth(Date.now() + 180000);
+        if (!sid) throw new Error('Timed out waiting for sign-in. Complete sign-in in the Drafted app window, then retry.');
+        getState().sessionId = null;
+        await cloneSession();
+        connectAgentWs();
+        return ok({ status: 'logged_in', via: 'desktop-app' });
+      }
+    }
     if (action === 'get_link') {
       const codeRes = await serverFetch(`${getServerUrl()}/auth/device/code`, { method: 'POST' });
       if (!codeRes.ok) throw new Error(`Failed to start device authorization (HTTP ${codeRes.status})`);
@@ -4096,51 +4171,51 @@ tool('wiki', 'Per-org wiki. Markdown pages with paths as hierarchy. You and othe
   } catch (error) { return err(error); }
 });
 
-// ── Collectors ────────────────────────────────────────────────────
+// ── Minions ───────────────────────────────────────────────────────
 
-function compactCollectorEntry(c) {
+function compactMinionEntry(c) {
   if (!c || typeof c !== 'object') return c;
   return { id: c.id, slug: c.slug, name: c.name, enabled: c.enabled, projectId: c.projectId };
 }
 
-// Shape a {collectors:[...]} list with limit/offset pagination + optional compact
+// Shape a {minions:[...]} list with limit/offset pagination + optional compact
 // mode, mirroring shapeSkillCatalog so large lists stay within token budget.
-function shapeCollectorList(result, { limit, offset = 0, compact = false } = {}) {
-  if (!Array.isArray(result?.collectors)) return result;
-  const total = result.collectors.length;
+function shapeMinionList(result, { limit, offset = 0, compact = false } = {}) {
+  if (!Array.isArray(result?.minions)) return result;
+  const total = result.minions.length;
   const start = Math.max(0, Math.floor(Number(offset) || 0));
   const cap = Math.min(Math.max(1, Math.floor(Number(limit) || 25)), 100);
-  const page = result.collectors.slice(start, start + cap);
+  const page = result.minions.slice(start, start + cap);
   result.totalAvailable = total;
   result.offset = start;
   result.returned = page.length;
   result.truncated = start + page.length < total;
-  result.collectors = compact ? page.map(compactCollectorEntry) : page;
+  result.minions = compact ? page.map(compactMinionEntry) : page;
   result.note = compact
-    ? 'Compact list: {id,slug,name,enabled,projectId} only. Use collector(action="get", id="<id>") for full config; limit/offset to page.'
-    : 'Collectors are scoped to the active project (all org collectors when no project is open). Use limit/offset to page; compact=true for a leaner list.';
+    ? 'Compact list: {id,slug,name,enabled,projectId} only. Use minion(action="get", id="<id>") for full config; limit/offset to page.'
+    : 'Minions are scoped to the active project (all org Minions when no project is open). Use limit/offset to page; compact=true for a leaner list.';
   return result;
 }
 
 // Friendlier message when the agent allowlist gate (requireAgentAccess) rejects.
-function collectorGateError(e) {
+function minionGateError(e) {
   if (e?.status === 403 || e?.code === 'agent_disabled') {
-    return new Error('Collector management is not enabled for this org/account (agent allowlist). Ask an admin to add your org or email to DRAFTED_AGENT_ALLOWED_ORGS / DRAFTED_AGENT_ALLOWED_EMAILS.');
+    return new Error('Minion management is not enabled for this org/account (agent allowlist). Ask an admin to add your org or email to DRAFTED_AGENT_ALLOWED_ORGS / DRAFTED_AGENT_ALLOWED_EMAILS.');
   }
   return e;
 }
 
-tool('collector', {
-  action: z.enum(['meta', 'list', 'get', 'create', 'update', 'enable', 'disable', 'delete', 'test_start', 'test_say', 'test_resolve']).describe('Operation to perform. test_* drive a QA conversation against a collector you own (even disabled) to verify it end-to-end.'),
-  id: z.string().optional().describe('[get|update|enable|disable|delete|test_*] collector ID (UUID)'),
+tool('minion', {
+  action: z.enum(['meta', 'list', 'get', 'create', 'update', 'enable', 'disable', 'delete', 'test_start', 'test_say', 'test_resolve']).describe('Operation to perform. test_* drive a QA conversation against a Minion you own (even disabled) to verify it end-to-end.'),
+  id: z.string().optional().describe('[get|update|enable|disable|delete|test_*] Minion ID (UUID)'),
   text: z.string().optional().describe('[test_say] the consumer message to send to your test run'),
   fresh: z.boolean().optional().describe('[test_start] start a brand-new run instead of resuming your latest'),
   actionId: z.string().optional().describe('[test_resolve] id of the pending action to resolve'),
   approve: z.boolean().optional().describe('[test_resolve] approve (default true) or reject the pending action'),
   projectId: z.string().optional().describe('[create|meta] project to bind/scope to (defaults to the active project). The org derives from this project — open the target project first via project(action="open") if none is active.'),
-  name: z.string().optional().describe('[create|update] collector name'),
+  name: z.string().optional().describe('[create|update] Minion name'),
   description: z.string().optional().describe('[create|update] one-line description shown to the consumer'),
-  enabled: z.boolean().optional().describe('[create|update] whether the collector is live; a disabled collector 404s on its /c/<slug> link. enable/disable set this directly.'),
+  enabled: z.boolean().optional().describe('[create|update] whether the Minion is live; a disabled Minion 404s on its /c/<slug> link. enable/disable set this directly.'),
   target: z.object({
     type: z.enum(['new-record', 'layer', 'frame']).describe('what the run writes against'),
     layer: z.string().optional(),
@@ -4169,7 +4244,7 @@ tool('collector', {
   }).optional().describe('[create|update] where/how the producible lands'),
   limit: z.number().optional().describe('[list] max results per page (default 25, max 100)'),
   offset: z.number().optional().describe('[list] skip N results for pagination (default 0)'),
-  compact: z.boolean().optional().describe('[list] return only {id,slug,name,enabled,projectId} per collector'),
+  compact: z.boolean().optional().describe('[list] return only {id,slug,name,enabled,projectId} per Minion'),
 }, async (args) => {
   try {
     const { action } = args;
@@ -4179,18 +4254,18 @@ tool('collector', {
         const pid = active || args.projectId;
         if (!pid) throw new Error('No active project. Call project(action="open") first, or pass projectId.');
         // api() auto-appends the active project; add projectId explicitly only when none is active.
-        const path = active ? '/api/collectors/meta' : `/api/collectors/meta?projectId=${encodeURIComponent(pid)}`;
+        const path = active ? '/api/minions/meta' : `/api/minions/meta?projectId=${encodeURIComponent(pid)}`;
         return ok(await api('GET', path));
       }
       case 'list': {
         // api() auto-appends the active project as ?projectId — so this lists the
-        // active project's collectors, or all org collectors when none is open.
-        const result = await api('GET', '/api/collectors');
-        return ok(shapeCollectorList(result, { limit: args.limit, offset: args.offset, compact: args.compact }));
+        // active project's Minions, or all org Minions when none is open.
+        const result = await api('GET', '/api/minions');
+        return ok(shapeMinionList(result, { limit: args.limit, offset: args.offset, compact: args.compact }));
       }
       case 'get': {
         if (!args.id) throw new Error('id is required for action=get');
-        return ok(await api('GET', `/api/collectors/${args.id}`));
+        return ok(await api('GET', `/api/minions/${args.id}`));
       }
       case 'create': {
         // projectId lives in the BODY (the POST route reads body, ignores the query).
@@ -4203,7 +4278,7 @@ tool('collector', {
         const body = { projectId, name, target, checklist, output };
         if (description !== undefined) body.description = description;
         if (enabled !== undefined) body.enabled = enabled;
-        return ok(await api('POST', '/api/collectors', body));
+        return ok(await api('POST', '/api/minions', body));
       }
       case 'update': {
         if (!args.id) throw new Error('id is required for action=update');
@@ -4212,35 +4287,35 @@ tool('collector', {
           if (args[k] !== undefined) body[k] = args[k];
         }
         if (Object.keys(body).length === 0) throw new Error('At least one field is required for action=update');
-        return ok(await api('PATCH', `/api/collectors/${args.id}`, body));
+        return ok(await api('PATCH', `/api/minions/${args.id}`, body));
       }
       case 'enable':
       case 'disable': {
         if (!args.id) throw new Error(`id is required for action=${action}`);
-        return ok(await api('PATCH', `/api/collectors/${args.id}`, { enabled: action === 'enable' }));
+        return ok(await api('PATCH', `/api/minions/${args.id}`, { enabled: action === 'enable' }));
       }
       case 'delete': {
         if (!args.id) throw new Error('id is required for action=delete');
-        return ok(await api('DELETE', `/api/collectors/${args.id}`));
+        return ok(await api('DELETE', `/api/minions/${args.id}`));
       }
       case 'test_start': {
         if (!args.id) throw new Error('id is required for action=test_start');
-        return ok(await api('POST', `/api/collectors/${args.id}/test-start`, { fresh: !!args.fresh }));
+        return ok(await api('POST', `/api/minions/${args.id}/test-start`, { fresh: !!args.fresh }));
       }
       case 'test_say': {
         if (!args.id) throw new Error('id is required for action=test_say');
         if (!args.text) throw new Error('text is required for action=test_say');
-        return ok(await api('POST', `/api/collectors/${args.id}/test-message`, { content: args.text }));
+        return ok(await api('POST', `/api/minions/${args.id}/test-message`, { content: args.text }));
       }
       case 'test_resolve': {
         if (!args.id) throw new Error('id is required for action=test_resolve');
         if (!args.actionId) throw new Error('actionId is required for action=test_resolve');
-        return ok(await api('POST', `/api/collectors/${args.id}/test-resolve`, { actionId: args.actionId, approve: args.approve !== false }));
+        return ok(await api('POST', `/api/minions/${args.id}/test-resolve`, { actionId: args.actionId, approve: args.approve !== false }));
       }
       default:
-        throw new Error(`Unknown collector action: ${action}`);
+        throw new Error(`Unknown minion action: ${action}`);
     }
-  } catch (error) { return err(collectorGateError(error)); }
+  } catch (error) { return err(minionGateError(error)); }
 });
 
 // ── Resource: canvas info ─────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drafted",
-  "version": "1.13.0",
+  "version": "1.14.1",
   "description": "Drafted — visual thinking surface for humans and AI agents. Renders HTML, markdown, images, and code as frames on a zoomable canvas, with MCP tools for AI agents and real-time sync for humans.",
   "type": "module",
   "files": [