clementine-agent 1.6.0 → 1.6.1

package/dist/cli/browser.d.ts

@@ -20,5 +20,16 @@
 export declare function cmdBrowserStatus(): Promise<void>;
 export declare function cmdBrowserInstall(): Promise<void>;
 export declare function cmdBrowserEnable(): Promise<void>;
+/**
+ * Auto-prompt during `clementine update`. Stays silent unless there's
+ * something actionable — mirrors the keychain wizard's behavior.
+ *
+ * Skips prompting when:
+ *   - Not in an interactive TTY
+ *   - The MCP wrapper isn't shipped with this version
+ *   - Browser harness is already installed AND enabled
+ *   - User previously dismissed the prompt
+ */
+export declare function maybePromptBrowserHarness(): Promise<void>;
 export declare function cmdBrowserDisable(): Promise<void>;
 //# sourceMappingURL=browser.d.ts.map

package/dist/cli/browser.js

@@ -22,6 +22,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { confirm } from '@inquirer/prompts';
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[0;90m';
 const GREEN = '\x1b[0;32m';
@@ -40,6 +41,7 @@ const VENV_PYTHON = path.join(VENV_DIR, 'bin', 'python3');
 const MCP_SERVERS_FILE = path.join(BASE_DIR, 'mcp-servers.json');
 const HARNESS_REPO = 'https://github.com/browser-use/browser-harness.git';
 const SERVER_NAME = 'browser-harness';
+const DISMISSED_MARKER = path.join(BASE_DIR, '.browser-harness-dismissed');
 function commandExists(cmd) {
     const result = spawnSync('which', [cmd], { stdio: 'pipe' });
     return result.status === 0;
@@ -102,7 +104,11 @@ export async function cmdBrowserStatus() {
         console.log();
     }
 }
-export async function cmdBrowserInstall() {
+/**
+ * Core install logic. Returns true on success, false on any failure.
+ * Prints progress + errors to stdout/stderr but never calls process.exit.
+ */
+async function runInstall() {
     console.log();
     console.log(`  ${BOLD}Installing browser-harness${RESET} ${DIM}(beta)${RESET}`);
     console.log();
@@ -110,13 +116,13 @@ export async function cmdBrowserInstall() {
         console.error(`  ${RED}python3 not found.${RESET} Install Python 3.10+ first:`);
         console.error(`    ${CYAN}brew install python@3.12${RESET}`);
         console.error();
-        process.exit(1);
+        return false;
     }
     if (!existsSync(MCP_SCRIPT)) {
         console.error(`  ${RED}MCP wrapper not found at:${RESET} ${MCP_SCRIPT}`);
         console.error(`  ${DIM}This means the package was installed without vendor/ files. Reinstall:${RESET}`);
         console.error(`    ${CYAN}npm install -g clementine-agent@latest${RESET}`);
-        process.exit(1);
+        return false;
     }
     if (!existsSync(BASE_DIR))
         mkdirSync(BASE_DIR, { recursive: true });
@@ -124,7 +130,7 @@ export async function cmdBrowserInstall() {
     if (!existsSync(HARNESS_HOME)) {
         if (!commandExists('git')) {
             console.error(`  ${RED}git not found.${RESET} Install git, then re-run.`);
-            process.exit(1);
+            return false;
         }
         console.log(`  ${DIM}→ cloning ${HARNESS_REPO}${RESET}`);
         try {
@@ -132,7 +138,7 @@ export async function cmdBrowserInstall() {
         }
         catch {
             console.error(`  ${RED}Clone failed.${RESET} Check network / git access and try again.`);
-            process.exit(1);
+            return false;
         }
     }
     else {
@@ -146,7 +152,7 @@ export async function cmdBrowserInstall() {
         }
         catch {
             console.error(`  ${RED}venv creation failed.${RESET}`);
-            process.exit(1);
+            return false;
         }
     }
     else {
@@ -165,25 +171,21 @@ export async function cmdBrowserInstall() {
     }
     catch {
         console.error(`  ${RED}pip install failed.${RESET} Inspect output above and re-run when fixed.`);
-        process.exit(1);
+        return false;
     }
     console.log();
     console.log(`  ${GREEN}✓${RESET} Install complete.`);
-    console.log();
-    console.log(`  ${BOLD}Next steps:${RESET}`);
-    console.log(`  1. Enable Chrome remote debugging — open Chrome with:`);
-    console.log(`       ${CYAN}/Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome \\${RESET}`);
-    console.log(`         ${CYAN}--remote-debugging-port=9222${RESET}`);
-    console.log(`  2. Enable the MCP server:  ${BOLD}clementine browser enable${RESET}`);
-    console.log(`  3. Restart the daemon:     ${BOLD}clementine restart${RESET}`);
-    console.log();
+    return true;
 }
-export async function cmdBrowserEnable() {
+/**
+ * Core enable logic. Returns true on success, false on any failure.
+ */
+function runEnable() {
     if (!existsSync(VENV_PYTHON) || !existsSync(MCP_SCRIPT)) {
         console.error();
         console.error(`  ${RED}Not installed yet.${RESET} Run ${BOLD}clementine browser install${RESET} first.`);
         console.error();
-        process.exit(1);
+        return false;
     }
     const servers = loadMcpServers();
     servers[SERVER_NAME] = {
@@ -201,9 +203,93 @@ export async function cmdBrowserEnable() {
     saveMcpServers(servers);
     console.log();
     console.log(`  ${GREEN}✓${RESET} Registered ${BOLD}${SERVER_NAME}${RESET} in mcp-servers.json`);
+    return true;
+}
+export async function cmdBrowserInstall() {
+    const ok = await runInstall();
+    if (!ok)
+        process.exit(1);
+    console.log();
+    console.log(`  ${BOLD}Next steps:${RESET}`);
+    console.log(`  1. Enable Chrome remote debugging — open Chrome with:`);
+    console.log(`       ${CYAN}/Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome \\${RESET}`);
+    console.log(`         ${CYAN}--remote-debugging-port=9222${RESET}`);
+    console.log(`  2. Enable the MCP server:  ${BOLD}clementine browser enable${RESET}`);
+    console.log(`  3. Restart the daemon:     ${BOLD}clementine restart${RESET}`);
+    console.log();
+}
+export async function cmdBrowserEnable() {
+    const ok = runEnable();
+    if (!ok)
+        process.exit(1);
     console.log(`  ${DIM}Restart the daemon to pick up the change: clementine restart${RESET}`);
     console.log();
 }
+/**
+ * Auto-prompt during `clementine update`. Stays silent unless there's
+ * something actionable — mirrors the keychain wizard's behavior.
+ *
+ * Skips prompting when:
+ *   - Not in an interactive TTY
+ *   - The MCP wrapper isn't shipped with this version
+ *   - Browser harness is already installed AND enabled
+ *   - User previously dismissed the prompt
+ */
+export async function maybePromptBrowserHarness() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return;
+    if (!existsSync(MCP_SCRIPT))
+        return;
+    const servers = loadMcpServers();
+    const enabled = Object.prototype.hasOwnProperty.call(servers, SERVER_NAME);
+    const installed = existsSync(VENV_PYTHON);
+    if (enabled && installed)
+        return;
+    if (existsSync(DISMISSED_MARKER))
+        return;
+    console.log();
+    console.log(`  ${BOLD}Browser Harness available${RESET} ${DIM}(beta, opt-in)${RESET}`);
+    console.log(`  ${DIM}Lets Clementine drive your real Chrome — fill forms, post on LinkedIn,${RESET}`);
+    console.log(`  ${DIM}book appointments — using your live browser session.${RESET}`);
+    console.log();
+    let answer;
+    try {
+        answer = await confirm({
+            message: 'Install Browser Harness now?',
+            default: false,
+        });
+    }
+    catch {
+        // User Ctrl+C'd or terminal closed — treat as decline, don't dismiss permanently
+        return;
+    }
+    if (!answer) {
+        try {
+            writeFileSync(DISMISSED_MARKER, new Date().toISOString() + '\n');
+        }
+        catch { /* non-fatal */ }
+        console.log(`  ${DIM}Skipped. To install later: clementine browser install${RESET}`);
+        console.log();
+        return;
+    }
+    // User said yes — run install + enable inline
+    const installOk = await runInstall();
+    if (!installOk) {
+        console.error(`  ${YELLOW}Install failed.${RESET} ${DIM}You can retry with: clementine browser install${RESET}`);
+        console.log();
+        return;
+    }
+    const enableOk = runEnable();
+    if (!enableOk) {
+        console.error(`  ${YELLOW}Enable failed.${RESET} ${DIM}Retry with: clementine browser enable${RESET}`);
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(`  ${GREEN}✓${RESET} Browser Harness installed and enabled.`);
+    console.log(`  ${DIM}Open Chrome with --remote-debugging-port=9222 to connect.${RESET}`);
+    console.log();
+}
 export async function cmdBrowserDisable() {
     const servers = loadMcpServers();
     if (!Object.prototype.hasOwnProperty.call(servers, SERVER_NAME)) {

package/dist/cli/dashboard.js

@@ -3174,8 +3174,9 @@ export async function cmdDashboard(opts) {
                         maxTurns: 15,
                     }],
                 sourceFile: '',
+                agentSlug: body.agentSlug || undefined,
             };
-            const id = workflowId(slug);
+            const id = workflowId(slug, body.agentSlug || undefined);
             const result = saveWorkflow(id, wf);
             if (!result.ok) {
                 res.status(400).json({ error: result.error });
@@ -5620,6 +5621,55 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
     // ── Builder chat endpoint ──────────────────────────────────────────
     // Track which builder sessions have received the full system prefix
     const builderSessionInited = new Set();
+    async function buildBuilderCapabilityContext(agentSlug) {
+        const lines = [];
+        try {
+            const { discoverMcpServers, loadToolInventory } = await import('../agent/mcp-bridge.js');
+            const servers = discoverMcpServers();
+            const inv = loadToolInventory();
+            const serverLines = servers.map((s) => {
+                const tools = (inv?.tools ?? [])
+                    .filter((t) => t.startsWith(`mcp__${s.name}__`))
+                    .map((t) => t.split('__')[2])
+                    .filter(Boolean)
+                    .slice(0, 40);
+                return `- ${s.name} [${s.enabled ? 'on' : 'off'}]: ${tools.length ? tools.join(', ') : '(no tools cached yet)'}`;
+            });
+            lines.push('[AVAILABLE MCP SERVERS AND TOOLS]');
+            lines.push(serverLines.length ? serverLines.join('\n') : '- none configured');
+        }
+        catch {
+            lines.push('[AVAILABLE MCP SERVERS AND TOOLS]\n- unavailable');
+        }
+        const readSkills = (dir, scope) => {
+            if (!existsSync(dir))
+                return [];
+            return readdirSync(dir)
+                .filter(f => f.endsWith('.md'))
+                .slice(0, 80)
+                .map(f => {
+                try {
+                    const parsed = matter(readFileSync(path.join(dir, f), 'utf-8'));
+                    const name = f.replace(/\.md$/, '');
+                    const title = String(parsed.data.title ?? name);
+                    const triggers = Array.isArray(parsed.data.triggers) ? parsed.data.triggers.join(', ') : '';
+                    const tools = Array.isArray(parsed.data.toolsUsed) ? parsed.data.toolsUsed.join(', ') : '';
+                    return `- ${title} (${scope}${name !== title ? `/${name}` : ''})${triggers ? ` triggers: ${triggers}` : ''}${tools ? ` tools: ${tools}` : ''}`;
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((x) => Boolean(x));
+        };
+        const globalSkills = readSkills(path.join(VAULT_DIR, '00-System', 'skills'), 'global');
+        const agentSkills = agentSlug
+            ? readSkills(path.join(VAULT_DIR, '00-System', 'agents', agentSlug, 'skills'), `agent:${agentSlug}`)
+            : [];
+        lines.push('[AVAILABLE SKILLS]');
+        lines.push([...agentSkills, ...globalSkills].length ? [...agentSkills, ...globalSkills].join('\n') : '- none saved yet');
+        return `\n${lines.join('\n\n')}\n`;
+    }
     app.post('/api/builder/chat', async (req, res) => {
         const { message, artifactType, agentSlug, currentArtifact, attachments, linkedTools } = req.body;
         if (!message || typeof message !== 'string') {
@@ -5686,7 +5736,8 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                                 `Workflows are defined as markdown files with YAML frontmatter. Each step has an id, prompt, optional agent, and optional dependsOn array.\n` +
                                 `When the user says "save" or approves, output the final artifact block.]\n\n`
                             : `[BUILDER MODE: You are helping configure an artifact. Output structured JSON blocks as you build.]\n\n`;
-            enrichedMessage = builderPrefix + fileContext + toolContext + artifactContext + message;
+            const capabilityContext = await buildBuilderCapabilityContext(agentSlug);
+            enrichedMessage = builderPrefix + capabilityContext + fileContext + toolContext + artifactContext + message;
             builderSessionInited.add(sessionKey);
         }
         else {
@@ -5808,35 +5859,26 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             }
             else if (artifactType === 'cron') {
                 // Scope cron to agent if selected
-                const jobName = agentSlug && !artifact.name.startsWith(agentSlug + ':')
-                    ? `${agentSlug}:${artifact.name}`
-                    : artifact.name;
-                const { cronFile } = agentSlug
-                    ? (() => {
-                        const agentCronFile = path.join(VAULT_DIR, '00-System', 'agents', agentSlug, 'CRON.md');
-                        return { cronFile: existsSync(agentCronFile) ? agentCronFile : path.join(VAULT_DIR, '00-System', 'CRON.md') };
-                    })()
-                    : { cronFile: path.join(VAULT_DIR, '00-System', 'CRON.md') };
-                if (!existsSync(cronFile)) {
-                    res.status(500).json({ error: 'CRON.md not found' });
-                    return;
-                }
-                const matterMod = require('gray-matter');
-                const parsed = matterMod(readFileSync(cronFile, 'utf-8'));
-                const jobs = parsed.data.jobs || [];
+                const rawName = String(artifact.name || 'new-cron').trim();
+                const jobName = agentSlug && rawName.startsWith(agentSlug + ':')
+                    ? rawName.slice(agentSlug.length + 1)
+                    : rawName;
+                const cronFile = agentSlug
+                    ? path.join(VAULT_DIR, '00-System', 'agents', agentSlug, 'CRON.md')
+                    : path.join(VAULT_DIR, '00-System', 'CRON.md');
+                const { parsed, jobs } = readCronFileAt(cronFile);
                 jobs.push({
                     name: jobName,
                     schedule: artifact.schedule,
                     prompt: artifact.prompt,
                     tier: artifact.tier || 1,
                     enabled: artifact.enabled !== false,
-                    ...(agentSlug ? { agent: agentSlug } : {}),
                     ...(artifact.mode === 'unleashed' ? { mode: 'unleashed', max_hours: artifact.max_hours || 1 } : {}),
                     ...(artifact.work_dir ? { work_dir: artifact.work_dir } : {}),
                 });
-                parsed.data.jobs = jobs;
-                writeFileSync(cronFile, matterMod.stringify(parsed.content, parsed.data));
-                res.json({ ok: true, name: jobName, message: `Cron job "${jobName}" saved` });
+                writeCronFileAt(cronFile, parsed, jobs);
+                const displayName = agentSlug ? `${agentSlug}:${jobName}` : jobName;
+                res.json({ ok: true, name: displayName, message: `Cron job "${displayName}" saved` });
             }
             else if (artifactType === 'agent') {
                 // Create agent via the same mechanism as the manual form
@@ -5865,15 +5907,19 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             }
             else if (artifactType === 'workflow') {
                 // Save workflow as markdown file
-                const wfDir = path.join(VAULT_DIR, '00-System', 'workflows');
+                const wfDir = agentSlug
+                    ? path.join(VAULT_DIR, '00-System', 'agents', agentSlug, 'workflows')
+                    : path.join(VAULT_DIR, '00-System', 'workflows');
                 if (!existsSync(wfDir))
                     mkdirSync(wfDir, { recursive: true });
                 const wfName = (artifact.name || 'new-workflow').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60);
                 const matterMod = require('gray-matter');
                 const meta = {
+                    type: 'workflow',
                     name: artifact.name || wfName,
                     description: artifact.description || '',
                     enabled: true,
+                    ...(agentSlug ? { agentSlug } : {}),
                     ...(artifact.schedule ? { trigger: { schedule: artifact.schedule } } : {}),
                 };
                 const content = matterMod.stringify(`\n# ${artifact.name || wfName}\n\n${artifact.description || ''}\n\n## Steps\n\n${artifact.steps || ''}\n`, meta);
@@ -12315,7 +12361,13 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
           <option value="agent">agent</option>
           <option value="workflow">workflow</option>
         </select>
-        <span id="builder-agent-label" style="padding:0;font-size:13px;color:var(--text-secondary);font-weight:500"></span>
+        <label for="builder-agent-scope" style="font-size:11px;color:var(--text-muted);font-weight:600">Owner</label>
+        <select id="builder-agent-scope" onchange="setBuilderAgentScope(this.value)" style="padding:4px 8px;border:1px solid var(--border);border-radius:6px;background:var(--bg-secondary);color:var(--text-primary);font-size:12px;max-width:220px">
+          <option value="__all">All owners</option>
+          <option value="__global">Clementine (global)</option>
+        </select>
+        <span id="builder-capability-summary" style="font-size:11px;color:var(--text-muted)"></span>
+        <span id="builder-agent-label" style="display:none;padding:0;font-size:13px;color:var(--text-secondary);font-weight:500"></span>
         <input type="hidden" id="builder-agent" value="">
         <span style="flex:1"></span>
         <button class="btn-sm btn-primary" onclick="newFromBuildHeader()" title="Create a new artifact for this tab" style="padding:4px 14px;border-radius:6px;cursor:pointer;font-size:12px">New</button>
@@ -15152,9 +15204,24 @@ async function newFromBuildHeader() {
   var name = prompt('Name your new ' + noun + ':');
   if (!name || !name.trim()) return;
   try {
-    var body = { name: name.trim() };
-    if (activeTab === 'crons') body.schedule = '0 9 * * *';  // sensible default; user edits in canvas
-    var r = await apiJson('POST', '/api/builder/workflows', body);
+    var agentSlug = getBuilderSelectedAgentSlug();
+    var r;
+    if (activeTab === 'crons') {
+      r = await apiJson('POST', '/api/cron', {
+        name: name.trim(),
+        schedule: '0 9 * * *',
+        prompt: 'Describe what this scheduled automation should do.',
+        tier: 1,
+        enabled: true,
+        agent: agentSlug || undefined,
+      });
+      if (r && !r.error) r.id = builderScopedId('cron', name.trim(), agentSlug);
+    } else {
+      r = await apiJson('POST', '/api/builder/workflows', {
+        name: name.trim(),
+        agentSlug: agentSlug || undefined,
+      });
+    }
     if (r && r.error) { toast('Create failed: ' + r.error, 'error'); return; }
     if (r && r.id) {
       await refreshBuilderCanvasPicker(activeTab === 'crons' ? 'cron' : 'workflow');
@@ -15209,12 +15276,26 @@ async function forkBuildTemplate(templateId) {
   var name = prompt('Name for the new workflow:', tpl.name);
   if (!name) return;
   try {
-    var r = await apiJson('POST', '/api/builder/workflows', {
-      name: name,
-      description: tpl.description,
-      schedule: tpl.schedule,
-      initialPrompt: tpl.initialPrompt,
-    });
+    var agentSlug = getBuilderSelectedAgentSlug();
+    var r;
+    if (tpl.schedule) {
+      r = await apiJson('POST', '/api/cron', {
+        name: name,
+        schedule: tpl.schedule,
+        prompt: tpl.initialPrompt,
+        tier: 1,
+        enabled: true,
+        agent: agentSlug || undefined,
+      });
+      if (r && !r.error) r.id = builderScopedId('cron', name, agentSlug);
+    } else {
+      r = await apiJson('POST', '/api/builder/workflows', {
+        name: name,
+        description: tpl.description,
+        initialPrompt: tpl.initialPrompt,
+        agentSlug: agentSlug || undefined,
+      });
+    }
     if (r && r.error) { toast('Create failed: ' + r.error, 'error'); return; }
     if (r && r.id) {
       switchBuildTab(tpl.schedule ? 'crons' : 'workflows');
@@ -19351,6 +19432,26 @@ var _builderCanvasOpenId = null;
 var _builderCanvasLastWorkflow = null;
 var _builderDrawflowLoading = null;
 
+function getBuilderOwnerScope() {
+  var sel = document.getElementById('builder-agent-scope');
+  return (sel && sel.value) || '__all';
+}
+
+function getBuilderSelectedAgentSlug() {
+  var scope = getBuilderOwnerScope();
+  return (scope && scope !== '__all' && scope !== '__global') ? scope : '';
+}
+
+function builderScopedId(type, name, agentSlug) {
+  var prefix = type === 'cron' ? 'cron:' : 'workflow:';
+  return agentSlug ? (prefix + 'agent:' + agentSlug + ':' + name) : (prefix + 'global:' + name);
+}
+
+function builderOwnerLabel(item) {
+  if (!item || !item.agentSlug) return 'Clementine';
+  return item.agentSlug;
+}
+
 function _ensureDrawflowLoaded() {
   if (window.Drawflow) return Promise.resolve();
   if (_builderDrawflowLoading) return _builderDrawflowLoading;
@@ -19370,11 +19471,17 @@ async function refreshBuilderCanvasPicker(type) {
   try {
     var r = await apiFetch('/api/builder/workflows');
     var d = await r.json();
-    var items = (d.workflows || []).filter(function(w) { return w.origin === type; });
+    var ownerScope = getBuilderOwnerScope();
+    var items = (d.workflows || []).filter(function(w) {
+      if (w.origin !== type) return false;
+      if (ownerScope === '__all') return true;
+      if (ownerScope === '__global') return !w.agentSlug;
+      return w.agentSlug === ownerScope;
+    });
     var opts = '<option value="">' + (items.length ? '— pick a ' + type + ' —' : '(none yet)') + '</option>';
     for (var i = 0; i < items.length; i++) {
       var w = items[i];
-      var lbl = w.name + (w.schedule ? '  ·  ' + w.schedule : '') + (w.enabled ? '' : '  · off');
+      var lbl = builderOwnerLabel(w) + '  ·  ' + w.name + (w.schedule ? '  ·  ' + w.schedule : '') + (w.enabled ? '' : '  · off');
       opts += '<option value="' + esc(w.id) + '">' + esc(lbl) + '</option>';
     }
     picker.innerHTML = opts;
@@ -20031,7 +20138,8 @@ async function refreshBuilderSkills() {
   var countEl = document.getElementById('builder-skills-count');
   if (!container) return;
   try {
-    var r = await apiFetch('/api/skills');
+    var agentSlug = getBuilderSelectedAgentSlug();
+    var r = await apiFetch(agentSlug ? ('/api/agents/' + encodeURIComponent(agentSlug) + '/skills') : '/api/skills');
     var d = await r.json();
     var skills = d.skills || [];
     if (countEl) countEl.textContent = skills.length + ' skill' + (skills.length !== 1 ? 's' : '');
@@ -20041,12 +20149,13 @@ async function refreshBuilderSkills() {
     }
     var html = '';
     for (var s of skills) {
+      var scopeTag = s.scope === 'agent' ? '<span style="font-size:9px;background:var(--blue);color:white;padding:1px 5px;border-radius:3px">agent</span> ' : '';
       var sourceTag = s.source === 'builder' ? '<span style="font-size:9px;background:var(--accent);color:white;padding:1px 5px;border-radius:3px">built</span>'
         : s.source === 'manual' ? '<span style="font-size:9px;background:var(--blue);color:white;padding:1px 5px;border-radius:3px">taught</span>'
         : '<span style="font-size:9px;background:var(--bg-tertiary);color:var(--text-muted);padding:1px 5px;border-radius:3px">' + esc(s.source || 'auto') + '</span>';
       html += '<div style="display:flex;align-items:center;gap:6px;padding:6px 4px;border-bottom:1px solid var(--border);font-size:12px">'
         + '<div style="flex:1;min-width:0">'
-        + '<div style="font-weight:500;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">' + esc(s.title) + ' ' + sourceTag + '</div>'
+        + '<div style="font-weight:500;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">' + esc(s.title) + ' ' + scopeTag + sourceTag + '</div>'
         + '<div style="font-size:10px;color:var(--text-muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis">' + esc(s.description || '') + '</div>'
         + '</div>'
         + '<button onclick="editSkillInBuilder(\\x27' + esc(s.name) + '\\x27)" style="background:none;border:1px solid var(--border);border-radius:4px;padding:2px 8px;font-size:10px;color:var(--accent);cursor:pointer;white-space:nowrap">Edit</button>'
@@ -20094,6 +20203,17 @@ async function editSkillInBuilder(name, agentSlug) {
     var agentLabel = document.getElementById('builder-agent-label');
     if (agentHidden) agentHidden.value = agentSlug || '';
     if (agentLabel) agentLabel.textContent = agentSlug ? 'Agent: ' + agentSlug : '';
+    var ownerSel = document.getElementById('builder-agent-scope');
+    if (ownerSel) {
+      if (agentSlug && !Array.prototype.some.call(ownerSel.options, function(o) { return o.value === agentSlug; })) {
+        var opt = document.createElement('option');
+        opt.value = agentSlug;
+        opt.textContent = agentSlug;
+        ownerSel.appendChild(opt);
+      }
+      ownerSel.value = agentSlug || '__global';
+      setBuilderAgentScope(ownerSel.value);
+    }
 
     // Reset session on server so next message gets full prefix
     await apiJson('POST', '/api/builder/reset', { artifactType: 'skill', agentSlug: agentSlug || undefined }).catch(function(){});
@@ -20417,23 +20537,45 @@ async function saveBuilderArtifact() {
   } catch(e) { toast('Error: ' + e, 'error'); }
 }
 
-// Populate agent dropdown when builder page loads
-function refreshBuilderAgents(preselect) {
+function setBuilderAgentScope(value) {
   var hidden = document.getElementById('builder-agent');
   var label = document.getElementById('builder-agent-label');
-  if (!hidden || !label) return;
-  hidden.value = preselect || '';
-  if (!preselect) {
-    label.textContent = 'Clementine (global)';
-    return;
+  var agentSlug = (value && value !== '__all' && value !== '__global') ? value : '';
+  if (hidden) hidden.value = agentSlug;
+  if (label) {
+    label.textContent = value === '__all'
+      ? 'All owners'
+      : value === '__global'
+      ? 'Clementine (global)'
+      : agentSlug;
   }
-  // Look up agent name from sidebar
-  var teamItem = document.querySelector('.team-nav-item[data-slug="' + preselect + '"] span');
-  if (teamItem) {
-    label.textContent = teamItem.textContent;
-  } else {
-    label.textContent = preselect;
+  var type = (document.getElementById('builder-type') || {}).value;
+  if (type === 'cron' || type === 'workflow') refreshBuilderCanvasPicker(type);
+  if (type === 'skill') refreshBuilderSkills();
+  apiJson('POST', '/api/builder/reset', { artifactType: type, agentSlug: agentSlug || undefined }).catch(function(){});
+}
+
+// Populate owner dropdown when builder page loads
+async function refreshBuilderAgents(preselect) {
+  var hidden = document.getElementById('builder-agent');
+  var label = document.getElementById('builder-agent-label');
+  var select = document.getElementById('builder-agent-scope');
+  if (!hidden || !label || !select) return;
+  var current = preselect ? preselect : (select.value || '__all');
+  try {
+    var r = await apiFetch('/api/agents');
+    var agents = await r.json();
+    var opts = '<option value="__all">All owners</option><option value="__global">Clementine (global)</option>';
+    (agents || []).forEach(function(a) {
+      opts += '<option value="' + esc(a.slug) + '">' + esc(a.name || a.slug) + '</option>';
+    });
+    select.innerHTML = opts;
+  } catch(e) {
+    select.innerHTML = '<option value="__all">All owners</option><option value="__global">Clementine (global)</option>';
   }
+  var hasCurrent = Array.prototype.some.call(select.options, function(o) { return o.value === current; });
+  select.value = hasCurrent ? current : '__all';
+  setBuilderAgentScope(select.value);
 }
 
 // ── Builder Linked Tools ──────────────────
@@ -20804,7 +20946,7 @@ function openBuilderForNewWorkflow() {
     if (typeSel) { typeSel.value = 'workflow'; updateBuilderMode(); }
     var name = prompt('Name your new workflow:');
     if (!name) return;
-    apiJson('POST', '/api/builder/workflows', { name: name }).then(function(r) {
+    apiJson('POST', '/api/builder/workflows', { name: name, agentSlug: getBuilderSelectedAgentSlug() || undefined }).then(function(r) {
       if (r && r.error) { toast('Create failed: ' + r.error, 'error'); return; }
       if (r && r.id) {
         // Refresh picker, then open the new workflow

package/dist/cli/index.js

@@ -24,7 +24,7 @@ import { cmdCronList, cmdCronRun, cmdCronRunDue, cmdCronRuns, cmdCronAdd, cmdCro
 import { cmdDashboard } from './dashboard.js';
 import { cmdChat } from './chat.js';
 import { cmdIngestSeed, cmdIngestRun, cmdIngestList, cmdIngestStatus } from './ingest.js';
-import { cmdBrowserStatus, cmdBrowserInstall, cmdBrowserEnable, cmdBrowserDisable } from './browser.js';
+import { cmdBrowserStatus, cmdBrowserInstall, cmdBrowserEnable, cmdBrowserDisable, maybePromptBrowserHarness } from './browser.js';
 import { isSensitiveEnvKey } from '../secrets/sensitivity.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -3171,6 +3171,8 @@ async function cmdUpdate(options) {
             console.log(`  ${DIM}Restart your daemon to pick up the new code:${RESET}`);
             console.log(`    clementine restart`);
         }
+        // Surface new opt-in integrations (silent unless action needed)
+        await maybePromptBrowserHarness();
         return;
     }
     let step = 0;
@@ -3830,6 +3832,8 @@ async function cmdUpdate(options) {
     }
     console.log(`  ${DIM}Config backup: ${backupDir}${RESET}`);
     console.log();
+    // Surface new opt-in integrations (silent unless action needed)
+    await maybePromptBrowserHarness();
 }
 // ── Cron commands ───────────────────────────────────────────────────
 const cronCmd = program

package/dist/dashboard/builder/serializer.d.ts

@@ -15,12 +15,15 @@
  * unless edited through this module, and edits preserve unrelated fields.
  */
 import type { WorkflowDefinition, CronJobDefinition, BuilderWorkflowSummary, WorkflowOriginKind } from '../../types.js';
-export declare function cronId(name: string): string;
-export declare function workflowId(filename: string): string;
-export declare function parseBuilderId(id: string): {
+export interface ParsedBuilderId {
     origin: WorkflowOriginKind;
     key: string;
-} | null;
+    scope: 'global' | 'agent';
+    agentSlug?: string;
+}
+export declare function cronId(name: string, agentSlug?: string): string;
+export declare function workflowId(filename: string, agentSlug?: string): string;
+export declare function parseBuilderId(id: string): ParsedBuilderId | null;
 export declare function listAllForBuilder(): BuilderWorkflowSummary[];
 export declare function readWorkflow(id: string): WorkflowDefinition | null;
 export declare function cronJobToWorkflow(job: CronJobDefinition): WorkflowDefinition;
@@ -32,11 +35,8 @@ export declare function saveWorkflow(id: string, wf: WorkflowDefinition): {
     ok: false;
     error: string;
 };
-/** Resolve the on-disk file path for a builder id (cron entries all share CRON_FILE). */
-export declare function sourceFileForId(id: string, parsedHint?: {
-    origin: WorkflowOriginKind;
-    key: string;
-}): string | null;
+/** Resolve the on-disk file path for a builder id. */
+export declare function sourceFileForId(id: string, parsedHint?: ParsedBuilderId): string | null;
 /** Drawflow node shape (subset we use). */
 interface DrawflowNode {
     id: number;

package/dist/dashboard/builder/serializer.js

@@ -18,30 +18,86 @@ import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from
 import path from 'node:path';
 import matter from 'gray-matter';
 import yaml from 'js-yaml';
-import { CRON_FILE, WORKFLOWS_DIR } from '../../config.js';
+import { AGENTS_DIR, CRON_FILE, WORKFLOWS_DIR } from '../../config.js';
 import { snapshotWorkflow } from './snapshots.js';
 // ── ID scheme ───────────────────────────────────────────────────────
 const CRON_ID_PREFIX = 'cron:';
 const WORKFLOW_ID_PREFIX = 'workflow:';
-export function cronId(name) {
-    return CRON_ID_PREFIX + name;
+export function cronId(name, agentSlug) {
+    return agentSlug
+        ? `${CRON_ID_PREFIX}agent:${agentSlug}:${name}`
+        : `${CRON_ID_PREFIX}global:${name}`;
 }
-export function workflowId(filename) {
+export function workflowId(filename, agentSlug) {
     const base = filename.endsWith('.md') ? filename.slice(0, -3) : filename;
-    return WORKFLOW_ID_PREFIX + base;
+    return agentSlug
+        ? `${WORKFLOW_ID_PREFIX}agent:${agentSlug}:${base}`
+        : `${WORKFLOW_ID_PREFIX}global:${base}`;
 }
 export function parseBuilderId(id) {
     if (id.startsWith(CRON_ID_PREFIX))
-        return { origin: 'cron', key: id.slice(CRON_ID_PREFIX.length) };
+        return parseScopedTail('cron', id.slice(CRON_ID_PREFIX.length));
     if (id.startsWith(WORKFLOW_ID_PREFIX))
-        return { origin: 'workflow', key: id.slice(WORKFLOW_ID_PREFIX.length) };
+        return parseScopedTail('workflow', id.slice(WORKFLOW_ID_PREFIX.length));
     return null;
 }
+function parseScopedTail(origin, tail) {
+    if (tail.startsWith('global:')) {
+        return { origin, scope: 'global', key: tail.slice('global:'.length) };
+    }
+    if (tail.startsWith('agent:')) {
+        const rest = tail.slice('agent:'.length);
+        const idx = rest.indexOf(':');
+        if (idx > 0) {
+            return {
+                origin,
+                scope: 'agent',
+                agentSlug: rest.slice(0, idx),
+                key: rest.slice(idx + 1),
+            };
+        }
+    }
+    // Backwards-compatible legacy ids: cron:job-name / workflow:file-name.
+    return { origin, scope: 'global', key: tail };
+}
+function listAgentSlugs() {
+    if (!existsSync(AGENTS_DIR))
+        return [];
+    try {
+        const entries = readdirSync(AGENTS_DIR, { withFileTypes: true });
+        return entries
+            .filter((d) => d.isDirectory() && !d.name.startsWith('_'))
+            .map((d) => d.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function cronFileForParsed(parsed) {
+    if (parsed.scope === 'agent' && parsed.agentSlug) {
+        return path.join(AGENTS_DIR, parsed.agentSlug, 'CRON.md');
+    }
+    return CRON_FILE;
+}
+function workflowsDirForParsed(parsed) {
+    if (parsed.scope === 'agent' && parsed.agentSlug) {
+        return path.join(AGENTS_DIR, parsed.agentSlug, 'workflows');
+    }
+    return WORKFLOWS_DIR;
+}
+function bareNameForScope(name, agentSlug) {
+    if (!agentSlug)
+        return name;
+    const prefix = `${agentSlug}:`;
+    return name.startsWith(prefix) ? name.slice(prefix.length) : name;
+}
 // ── List ────────────────────────────────────────────────────────────
 export function listAllForBuilder() {
     const out = [];
-    // Crons from CRON.md
-    for (const job of readCronJobs()) {
+    // Global crons from CRON.md. A global entry may still run as an agent via
+    // agentSlug; its source remains global so saves write back to the right file.
+    for (const job of readCronJobs(CRON_FILE)) {
         out.push({
             id: cronId(job.name),
             origin: 'cron',
@@ -52,9 +108,30 @@ export function listAllForBuilder() {
             stepCount: 1,
             sourceFile: CRON_FILE,
             agentSlug: job.agentSlug,
+            scope: 'global',
         });
     }
-    // Workflows from workflows dir
+    // Agent crons from agents/<slug>/CRON.md.
+    for (const slug of listAgentSlugs()) {
+        const cronFile = path.join(AGENTS_DIR, slug, 'CRON.md');
+        if (!existsSync(cronFile))
+            continue;
+        for (const job of readCronJobs(cronFile, slug)) {
+            out.push({
+                id: cronId(job.name, slug),
+                origin: 'cron',
+                name: job.name,
+                description: '',
+                enabled: job.enabled,
+                schedule: job.schedule,
+                stepCount: 1,
+                sourceFile: cronFile,
+                agentSlug: slug,
+                scope: 'agent',
+            });
+        }
+    }
+    // Global workflows from workflows dir.
     if (existsSync(WORKFLOWS_DIR)) {
         for (const file of readdirSync(WORKFLOWS_DIR).filter(f => f.endsWith('.md'))) {
             try {
@@ -69,6 +146,33 @@ export function listAllForBuilder() {
                     stepCount: wf.steps.length,
                     sourceFile: wf.sourceFile,
                     agentSlug: wf.agentSlug,
+                    scope: 'global',
+                });
+            }
+            catch {
+                // Skip unparseable workflow files
+            }
+        }
+    }
+    // Agent workflows from agents/<slug>/workflows.
+    for (const slug of listAgentSlugs()) {
+        const wfDir = path.join(AGENTS_DIR, slug, 'workflows');
+        if (!existsSync(wfDir))
+            continue;
+        for (const file of readdirSync(wfDir).filter(f => f.endsWith('.md'))) {
+            try {
+                const wf = parseWorkflowFile(path.join(wfDir, file), slug);
+                out.push({
+                    id: workflowId(file, slug),
+                    origin: 'workflow',
+                    name: wf.name,
+                    description: wf.description,
+                    enabled: wf.enabled,
+                    schedule: wf.trigger.schedule,
+                    stepCount: wf.steps.length,
+                    sourceFile: wf.sourceFile,
+                    agentSlug: slug,
+                    scope: 'agent',
                 });
             }
             catch {
@@ -76,7 +180,11 @@ export function listAllForBuilder() {
             }
         }
     }
-    return out.sort((a, b) => a.name.localeCompare(b.name));
+    return out.sort((a, b) => {
+        const ownerA = a.agentSlug ?? '';
+        const ownerB = b.agentSlug ?? '';
+        return ownerA.localeCompare(ownerB) || a.name.localeCompare(b.name);
+    });
 }
 // ── Read ────────────────────────────────────────────────────────────
 export function readWorkflow(id) {
@@ -84,25 +192,28 @@ export function readWorkflow(id) {
     if (!parsed)
         return null;
     if (parsed.origin === 'cron') {
-        const job = readCronJobs().find(j => j.name === parsed.key);
+        const cronFile = cronFileForParsed(parsed);
+        const job = readCronJobs(cronFile, parsed.agentSlug).find(j => j.name === parsed.key);
         if (!job)
             return null;
-        return cronJobToWorkflow(job);
+        const wf = cronJobToWorkflow(job);
+        wf.sourceFile = cronFile;
+        return wf;
     }
-    const file = path.join(WORKFLOWS_DIR, parsed.key + '.md');
+    const file = path.join(workflowsDirForParsed(parsed), parsed.key + '.md');
     if (!existsSync(file))
         return null;
     try {
-        return parseWorkflowFile(file);
+        return parseWorkflowFile(file, parsed.agentSlug);
     }
     catch {
         return null;
     }
 }
-function readCronJobs() {
-    if (!existsSync(CRON_FILE))
+function readCronJobs(cronFile = CRON_FILE, agentSlug) {
+    if (!existsSync(cronFile))
         return [];
-    const raw = readFileSync(CRON_FILE, 'utf-8');
+    const raw = readFileSync(cronFile, 'utf-8');
     let parsed;
     try {
         parsed = matter(raw);
@@ -137,16 +248,16 @@ function readCronJobs() {
             alwaysDeliver: job.always_deliver === true ? true : undefined,
             context: job.context != null ? String(job.context) : undefined,
             preCheck: job.pre_check != null ? String(job.pre_check) : undefined,
-            agentSlug: typeof job.agentSlug === 'string'
+            agentSlug: agentSlug ?? (typeof job.agentSlug === 'string'
                 ? job.agentSlug
                 : typeof job.agent_slug === 'string'
                     ? job.agent_slug
-                    : undefined,
+                    : undefined),
         });
     }
     return jobs;
 }
-function parseWorkflowFile(filePath) {
+function parseWorkflowFile(filePath, fallbackAgentSlug) {
     const raw = readFileSync(filePath, 'utf-8');
     const parsed = matter(raw);
     const data = parsed.data;
@@ -215,7 +326,7 @@ function parseWorkflowFile(filePath) {
         steps,
         synthesis,
         sourceFile: filePath,
-        agentSlug: typeof data.agentSlug === 'string' ? data.agentSlug : undefined,
+        agentSlug: typeof data.agentSlug === 'string' ? data.agentSlug : fallbackAgentSlug,
     };
 }
 // ── Cron ⇄ Workflow ─────────────────────────────────────────────────
@@ -265,23 +376,25 @@ export function saveWorkflow(id, wf) {
         if (!isCronShape(wf)) {
             return { ok: false, error: 'Cron entry must remain a single prompt step with a cron schedule' };
         }
-        return saveCronEntry(parsed.key, wf);
+        return saveCronEntryAt(cronFileForParsed(parsed), parsed.key, wf, parsed.agentSlug);
     }
-    return saveWorkflowFile(parsed.key, wf);
+    return saveWorkflowFileAt(workflowsDirForParsed(parsed), parsed.key, wf, parsed.agentSlug);
 }
-/** Resolve the on-disk file path for a builder id (cron entries all share CRON_FILE). */
+/** Resolve the on-disk file path for a builder id. */
 export function sourceFileForId(id, parsedHint) {
     const parsed = parsedHint ?? parseBuilderId(id);
     if (!parsed)
         return null;
     if (parsed.origin === 'cron')
-        return CRON_FILE;
-    return path.join(WORKFLOWS_DIR, parsed.key + '.md');
+        return cronFileForParsed(parsed);
+    return path.join(workflowsDirForParsed(parsed), parsed.key + '.md');
 }
-function saveCronEntry(originalName, wf) {
-    if (!existsSync(CRON_FILE))
-        return { ok: false, error: 'CRON.md does not exist' };
-    const raw = readFileSync(CRON_FILE, 'utf-8');
+function saveCronEntryAt(cronFile, originalName, wf, agentSlug) {
+    if (!existsSync(cronFile)) {
+        mkdirSync(path.dirname(cronFile), { recursive: true });
+        writeFileSync(cronFile, matter.stringify('', { jobs: [] }), 'utf-8');
+    }
+    const raw = readFileSync(cronFile, 'utf-8');
     let parsed;
     try {
         parsed = matter(raw);
@@ -297,7 +410,7 @@ function saveCronEntry(originalName, wf) {
     const prev = jobs[idx];
     const updated = {
         ...prev,
-        name: wf.name,
+        name: bareNameForScope(wf.name, agentSlug),
         schedule: wf.trigger.schedule,
         prompt: step.prompt,
         enabled: wf.enabled,
@@ -309,18 +422,27 @@ function saveCronEntry(originalName, wf) {
         updated.model = step.model;
     if (step.workDir != null)
         updated.work_dir = step.workDir;
-    if (wf.agentSlug)
+    if (agentSlug) {
+        delete updated.agentSlug;
+        delete updated.agent_slug;
+    }
+    else if (wf.agentSlug) {
         updated.agentSlug = wf.agentSlug;
+    }
+    else {
+        delete updated.agentSlug;
+        delete updated.agent_slug;
+    }
     jobs[idx] = updated;
     parsed.data.jobs = jobs;
     const out = matter.stringify(parsed.content ?? '', parsed.data);
-    writeFileSync(CRON_FILE, out, 'utf-8');
+    writeFileSync(cronFile, out, 'utf-8');
     return { ok: true };
 }
-function saveWorkflowFile(key, wf) {
-    if (!existsSync(WORKFLOWS_DIR))
-        mkdirSync(WORKFLOWS_DIR, { recursive: true });
-    const file = path.join(WORKFLOWS_DIR, key + '.md');
+function saveWorkflowFileAt(workflowsDir, key, wf, agentSlug) {
+    if (!existsSync(workflowsDir))
+        mkdirSync(workflowsDir, { recursive: true });
+    const file = path.join(workflowsDir, key + '.md');
     // Preserve body content if the file exists; otherwise empty body.
     let body = '';
     if (existsSync(file)) {
@@ -339,8 +461,8 @@ function saveWorkflowFile(key, wf) {
         enabled: wf.enabled,
         trigger: wf.trigger,
     };
-    if (wf.agentSlug)
-        data.agentSlug = wf.agentSlug;
+    if (agentSlug || wf.agentSlug)
+        data.agentSlug = agentSlug ?? wf.agentSlug;
     if (Object.keys(wf.inputs).length > 0)
         data.inputs = wf.inputs;
     data.steps = wf.steps.map(serializeStep);

package/dist/tools/builder-tools.js

@@ -34,7 +34,7 @@ const stepShape = z.object({
 });
 export function registerBuilderTools(server) {
     // ── Discovery ──────────────────────────────────────────────────────────
-    server.tool('workflow_list', 'List all workflows and crons visible in the Builder. Returns one per line: id|name|origin|enabled|schedule|stepCount.', {
+    server.tool('workflow_list', 'List all workflows and crons visible in the Builder. Returns one per line: id|owner|name|origin|enabled|schedule|stepCount.', {
         enabledOnly: z.boolean().optional().describe('If true, return only enabled workflows'),
         verbose: z.boolean().optional(),
     }, async ({ enabledOnly, verbose }) => {
@@ -43,7 +43,7 @@ export function registerBuilderTools(server) {
             return textResult(JSON.stringify(items, null, 2));
         if (items.length === 0)
             return textResult('(no workflows or crons found)');
-        return textResult(items.map(i => `${i.id}|${i.name}|${i.origin}|${i.enabled ? 'on' : 'off'}|${i.schedule ?? '-'}|${i.stepCount}step${i.stepCount === 1 ? '' : 's'}`).join('\n'));
+        return textResult(items.map(i => `${i.id}|${i.agentSlug ?? 'global'}|${i.name}|${i.origin}|${i.enabled ? 'on' : 'off'}|${i.schedule ?? '-'}|${i.stepCount}step${i.stepCount === 1 ? '' : 's'}`).join('\n'));
     });
     server.tool('workflow_read', 'Read a workflow as canonical JSON. Use this before editing — patches reference current step ids.', {
         id: z.string().describe('Builder id (e.g., cron:morning-briefing or workflow:daily-digest)'),

package/dist/types.d.ts

@@ -524,6 +524,7 @@ export interface BuilderWorkflowSummary {
     stepCount: number;
     sourceFile: string;
     agentSlug?: string;
+    scope?: 'global' | 'agent';
 }
 export interface WorkflowRunEntry {
     workflowName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",