clementine-agent 1.0.72 → 1.0.74

package/dist/brain/connector-recipes.d.ts

@@ -17,6 +17,27 @@
  *   {{fieldKey}}   — user-supplied value
  *   {{slug}}       — the feed's computed slug (used for folder + dedup)
  */
+export interface RecipeFieldPicker {
+    /** Full tool name, e.g. "mcp__claude_ai_Google_Drive__search_files" */
+    tool: string;
+    /** Natural-language instruction to the probe agent — becomes the body of
+     *  "Call the tool X to {intent}, return a JSON array of {id, label}".
+     *  For typeahead pickers, may include the placeholder `{{query}}` which
+     *  the server substitutes with the user's typed search string. */
+    intent: string;
+    /** When set, the picker renders as a typeahead: user types at least
+     *  `minQueryLength` chars (default 2), we debounce ~400ms, then fire the
+     *  probe with `{{query}}` replaced. Use for tools whose list operation
+     *  requires a query argument (e.g. search_contacts, Gmail search). */
+    queryArg?: string;
+    /** Minimum characters the user must type before firing the probe. Ignored
+     *  when queryArg is unset. Default 2. */
+    minQueryLength?: number;
+    /** If true, user can type a custom value instead of picking from the list
+     *  (falls back to the raw text). Useful when the source allows queries
+     *  that aren't enumerable. */
+    allowCustom?: boolean;
+}
 export interface RecipeField {
     key: string;
     label: string;
@@ -24,6 +45,8 @@ export interface RecipeField {
     help?: string;
     required?: boolean;
     defaultValue?: string;
+    /** When present, render as a searchable picker populated by /api/brain/mcp/probe. */
+    picker?: RecipeFieldPicker;
 }
 export interface ConnectorRecipe {
     /** Stable id, used as the job-name prefix. */

package/dist/brain/connector-recipes.js

@@ -40,8 +40,17 @@ export const RECIPES = [
         integration: 'Google_Drive',
         requiredTools: ['search_files', 'read_file_content'],
         fields: [
-            { key: 'folder', label: 'Folder name or partial path', placeholder: 'Active Projects', required: true,
-                help: 'The wizard searches Drive for folders matching this text. Exact name is safest.' },
+            {
+                key: 'folder',
+                label: 'Folder',
+                required: true,
+                help: 'Pick a folder from your Google Drive. You can also type a name to filter the list.',
+                picker: {
+                    tool: 'mcp__claude_ai_Google_Drive__search_files',
+                    intent: 'find up to 20 Google Drive folders. Call search_files exactly once with mimeType filter "application/vnd.google-apps.folder". For each returned folder, output {id: folder.id, label: folder.name, sublabel: "Modified " + folder.modifiedTime}.',
+                    allowCustom: true,
+                },
+            },
         ],
         defaultSchedule: '0 8 * * *',
         tier: 2,
@@ -163,7 +172,17 @@ Steps:
         integration: 'Microsoft_365',
         requiredTools: ['sharepoint_folder_search', 'read_resource'],
         fields: [
-            { key: 'folder', label: 'Folder path or name', placeholder: 'Shared Documents/Proposals', required: true },
+            {
+                key: 'folder',
+                label: 'Folder',
+                required: true,
+                help: 'Pick a SharePoint folder. Type to filter.',
+                picker: {
+                    tool: 'mcp__claude_ai_Microsoft_365__sharepoint_folder_search',
+                    intent: 'list available SharePoint folders and document libraries. Use the folder\'s drive-item id as id, the folder name as label, and the site/library path as sublabel.',
+                    allowCustom: true,
+                },
+            },
         ],
         defaultSchedule: '0 8 * * *',
         tier: 2,
@@ -177,6 +196,42 @@ Steps:
 2. For each file, use \`read_resource\` to fetch content.
 3. For each record: \`externalId\` = the SharePoint item id, \`title\` = the file name, \`content\` = the extracted text, \`metadata\` = \`{path, modifiedAt, author, size}\`.
 4. ${COMMIT_INSTRUCTIONS.replace(/{{slug}}/g, ctx.slug).replace(/{{targetFolder}}/g, ctx.targetFolder)}
+`,
+    },
+    {
+        id: 'imessage-thread',
+        label: 'iMessage: watch a conversation',
+        description: 'Ingest recent messages from a specific iMessage contact into the brain.',
+        icon: '💬',
+        integration: 'imessage',
+        requiredTools: ['search_contacts', 'read_imessages'],
+        fields: [
+            {
+                key: 'contact',
+                label: 'Contact',
+                required: true,
+                help: 'Pick an iMessage contact. Their phone number or email becomes the thread id.',
+                picker: {
+                    tool: 'mcp__imessage__search_contacts',
+                    intent: 'call search_contacts with query "{{query}}". For each match, output {id: the contact\'s phone number or email handle, label: the display name (or the handle if no name), sublabel: "handle: " + handle}. Return up to 15 results.',
+                    queryArg: 'query',
+                    minQueryLength: 2,
+                    allowCustom: true,
+                },
+            },
+            { key: 'limit', label: 'Max messages per run', placeholder: '50', defaultValue: '50' },
+        ],
+        defaultSchedule: '0 */6 * * *',
+        tier: 2,
+        slugFromValues: (v) => `imessage-${slugify(v.contact || 'thread')}`,
+        buildPrompt: (v, ctx) => `You are running the iMessage feed for contact "${v.contact}".
+
+Goal: ingest up to ${v.limit || '50'} recent iMessage messages from the thread with ${v.contact} into the brain.
+
+Steps:
+1. Call \`read_imessages\` (iMessage) for contact "${v.contact}" with limit ${v.limit || '50'}.
+2. For each message: \`externalId\` = the message id (or a stable hash of contact + timestamp + text if no id), \`title\` = first 60 chars of the text or "[attachment]", \`content\` = "From: <handle>\\nDate: <iso>\\n\\n<text>", \`metadata\` = \`{contact, sender, timestamp, isFromMe, service}\`.
+3. ${COMMIT_INSTRUCTIONS.replace(/{{slug}}/g, ctx.slug).replace(/{{targetFolder}}/g, ctx.targetFolder)}
 `,
     },
     {

package/dist/cli/dashboard.js

@@ -2560,17 +2560,61 @@ export async function cmdDashboard(opts) {
     // calls brain_ingest_folder to commit them.
     app.get('/api/brain/connectors', async (_req, res) => {
         try {
-            const { getClaudeIntegrations } = await import('../agent/mcp-bridge.js');
+            const { getClaudeIntegrations, loadToolInventory } = await import('../agent/mcp-bridge.js');
             const { RECIPES } = await import('../brain/connector-recipes.js');
-            const integrations = getClaudeIntegrations();
-            // A connector is "useful" for feeds only if it has surfaced some
-            // substantive tools (not just the stubbed authenticate/complete pair).
-            const meaningful = integrations.map((i) => ({
-                ...i,
-                hasFeedReadyTools: i.tools.some((t) => !/^(authenticate|complete_authentication)$/.test(t)),
-            }));
+            // Claude Desktop integrations carry richer metadata (label, connected
+            // state, firstSeen/lastUsed). Everything else we infer from the SDK
+            // tool inventory by grouping mcp__<server>__<tool> by server prefix.
+            const claudeDesktop = getClaudeIntegrations();
+            const claudeDesktopByName = new Map(claudeDesktop.map((c) => [c.name, c]));
+            const inv = loadToolInventory();
+            const mcpByServer = new Map();
+            for (const toolName of (inv?.tools ?? [])) {
+                if (!toolName.startsWith('mcp__'))
+                    continue;
+                const body = toolName.slice(5); // strip "mcp__"
+                const idx = body.indexOf('__');
+                if (idx < 1)
+                    continue;
+                const server = body.slice(0, idx);
+                const tool = body.slice(idx + 2);
+                if (!mcpByServer.has(server))
+                    mcpByServer.set(server, []);
+                mcpByServer.get(server).push(tool);
+            }
+            const integrations = [];
+            // First, Claude Desktop integrations (match claude_ai_<Name>)
+            for (const [server, tools] of mcpByServer.entries()) {
+                if (!server.startsWith('claude_ai_'))
+                    continue;
+                const name = server.slice('claude_ai_'.length);
+                const cd = claudeDesktopByName.get(name);
+                integrations.push({
+                    name,
+                    label: cd?.label ?? name.replace(/_/g, ' '),
+                    kind: 'claude-desktop',
+                    tools,
+                    connected: cd?.connected ?? true,
+                    hasFeedReadyTools: tools.some((t) => !/^(authenticate|complete_authentication)$/.test(t)),
+                });
+            }
+            // Then, every other MCP server. These are directly reachable through
+            // the Agent SDK because probeAvailableTools() saw them in init.tools.
+            for (const [server, tools] of mcpByServer.entries()) {
+                if (server.startsWith('claude_ai_'))
+                    continue;
+                integrations.push({
+                    name: server,
+                    label: server.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+                    kind: 'mcp-server',
+                    tools,
+                    connected: true, // if it's in the inventory, the SDK can call it
+                    hasFeedReadyTools: tools.length > 0,
+                });
+            }
+            integrations.sort((a, b) => a.label.localeCompare(b.label));
             res.json({
-                integrations: meaningful,
+                integrations,
                 recipes: RECIPES.map((r) => ({
                     id: r.id, label: r.label, description: r.description, icon: r.icon,
                     integration: r.integration, fields: r.fields,
@@ -2582,6 +2626,85 @@ export async function cmdDashboard(opts) {
             res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
         }
     });
+    // In-memory probe cache. Each entry is (tool, intent) → {items, expiresAt}.
+    // 10-minute TTL so repeated wizard opens don't repeatedly hit Haiku, but
+    // fresh enough that newly-created folders / labels appear within minutes.
+    const brainProbeCache = new Map();
+    const BRAIN_PROBE_TTL_MS = 10 * 60 * 1000;
+    app.post('/api/brain/mcp/probe', async (req, res) => {
+        try {
+            const body = (req.body ?? {});
+            const tool = String(body.tool ?? '').trim();
+            const rawIntent = String(body.intent ?? '').trim();
+            const userQuery = String(body.query ?? '').trim();
+            if (!tool) {
+                res.status(400).json({ error: 'tool is required' });
+                return;
+            }
+            if (!rawIntent) {
+                res.status(400).json({ error: 'intent is required' });
+                return;
+            }
+            // Typeahead pickers include a {{query}} placeholder. Substitute (and
+            // escape any JSON-breakers) before cache key + prompt.
+            const safeQuery = userQuery.replace(/"/g, '\\"').slice(0, 200);
+            const intent = rawIntent.replace(/\{\{query\}\}/g, safeQuery);
+            const cacheKey = `${tool}::${intent}`;
+            if (!body.force) {
+                const cached = brainProbeCache.get(cacheKey);
+                if (cached && cached.expiresAt > Date.now()) {
+                    res.json({ items: cached.items, cached: true });
+                    return;
+                }
+            }
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            const { parseJsonResponse } = await import('../brain/llm-client.js');
+            const { MODELS } = await import('../config.js');
+            // Strict prompt: force JSON-only output. The tool lookup goes through
+            // the SDK so claude_ai_* and regular MCP servers work uniformly.
+            const stream = query({
+                prompt: `Call the tool \`${tool}\` to ${intent}.
+Return ONLY a JSON array. Each element must be an object with shape \`{"id": string, "label": string, "sublabel"?: string}\`. Use the source system's stable id for \`id\` (so the feed can reference it later). Use a short human-readable title for \`label\`. Optional \`sublabel\` can include path, email, date, or any disambiguating detail.
+Do NOT include prose, markdown, code fences, or explanation. Just the JSON array.
+If the tool returns nothing or errors, return an empty array \`[]\`.`,
+                options: {
+                    model: MODELS.haiku,
+                    maxTurns: 3,
+                    systemPrompt: 'You are a data enumerator. You call the given tool once, extract the items from its response, and emit a strict JSON array. No commentary.',
+                    allowedTools: [tool],
+                    permissionMode: 'bypassPermissions',
+                    settingSources: [],
+                },
+            });
+            let text = '';
+            for await (const msg of stream) {
+                if (msg.type === 'assistant') {
+                    const content = msg.message?.content ?? [];
+                    for (const block of content) {
+                        if (block.type === 'text' && typeof block.text === 'string')
+                            text += block.text;
+                    }
+                }
+                else if (msg.type === 'result') {
+                    break;
+                }
+            }
+            const parsed = parseJsonResponse(text);
+            const items = Array.isArray(parsed)
+                ? parsed
+                    .filter((p) => p && typeof p.id === 'string' && typeof p.label === 'string')
+                    .map((p) => ({ id: p.id, label: p.label, sublabel: typeof p.sublabel === 'string' ? p.sublabel : undefined }))
+                : [];
+            brainProbeCache.set(cacheKey, { items, expiresAt: Date.now() + BRAIN_PROBE_TTL_MS });
+            // Always include a short preview of the agent's raw output so the UI
+            // can explain why a picker is empty (common causes: tool errored, tool
+            // returned nothing matching, agent refused in prose).
+            res.json({ items, cached: false, rawPreview: text.slice(0, 400) });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
     app.get('/api/brain/feeds', (_req, res) => {
         try {
             const { parsed, jobs } = readCronFileAt(CRON_FILE);
@@ -10666,6 +10789,156 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
           brainFeedWizardRender();
         }
 
+        // Per-field typeahead state: { [fieldKey]: { timer, lastQuery } }
+        const brainPickerTypeahead = {};
+
+        async function brainRenderFieldPicker(field, values) {
+          const container = document.querySelector('[data-field-picker="' + field.key + '"]');
+          const hidden = document.querySelector('input[type=hidden][data-field="' + field.key + '"]');
+          if (!container || !hidden) return;
+          const picker = field.picker;
+
+          // Typeahead mode: render a search box. User types → debounce → probe.
+          if (picker.queryArg) {
+            const minLen = picker.minQueryLength || 2;
+            const currentVal = hidden.value || values[field.key] || '';
+            container.innerHTML =
+              '<input type="text" id="brain-picker-search-' + field.key + '" placeholder="Type to search (min ' + minLen + ' chars)…" style="width:100%" value="">' +
+              '<div id="brain-picker-results-' + field.key + '" style="margin-top:6px;max-height:240px;overflow-y:auto"></div>' +
+              (currentVal
+                ? '<div style="font-size:12px;margin-top:6px">Selected: <code>' + escapeHtml(currentVal) + '</code></div>'
+                : '');
+            const searchEl = document.getElementById('brain-picker-search-' + field.key);
+            searchEl.oninput = function() {
+              const q = this.value.trim();
+              if (brainPickerTypeahead[field.key] && brainPickerTypeahead[field.key].timer) {
+                clearTimeout(brainPickerTypeahead[field.key].timer);
+              }
+              if (q.length < minLen) {
+                document.getElementById('brain-picker-results-' + field.key).innerHTML =
+                  '<div style="color:var(--muted);font-size:12px;padding:6px">Type at least ' + minLen + ' characters…</div>';
+                return;
+              }
+              brainPickerTypeahead[field.key] = {
+                timer: setTimeout(function() { brainFireTypeaheadProbe(field, q); }, 400),
+              };
+            };
+            return;
+          }
+
+          try {
+            const resp = await apiFetch('/api/brain/mcp/probe', {
+              method: 'POST', headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ tool: picker.tool, intent: picker.intent }),
+            });
+            const data = await resp.json();
+            if (!resp.ok) throw new Error(data.error || 'probe failed');
+
+            const items = data.items || [];
+            const currentVal = hidden.value || values[field.key] || '';
+
+            if (!items.length) {
+              // No items returned. Fall back to a plain text input so the user
+              // can still set the value manually.
+              container.innerHTML =
+                '<input type="text" value="' + escapeHtml(currentVal) + '" placeholder="(type a value)" style="width:100%" oninput="(document.querySelector(\\'input[type=hidden][data-field=' + field.key + ']\\')||{}).value=this.value">' +
+                '<div style="color:#8a5a00;font-size:11px;margin-top:4px">Nothing returned from the probe — type a value manually' + (data.rawPreview ? ' (probe output: ' + escapeHtml(data.rawPreview.slice(0, 120)) + '…)' : '') + '</div>';
+              return;
+            }
+
+            const options = items.map(function(it) {
+              const selected = it.id === currentVal ? ' selected' : '';
+              const lbl = it.label + (it.sublabel ? ' — ' + it.sublabel : '');
+              return '<option value="' + escapeHtml(it.id) + '"' + selected + '>' + escapeHtml(lbl) + '</option>';
+            }).join('');
+
+            const customAllowed = picker.allowCustom;
+            container.innerHTML =
+              '<select style="width:100%;padding:6px" onchange="(document.querySelector(\\'input[type=hidden][data-field=' + field.key + ']\\')||{}).value=this.value">' +
+                (currentVal && !items.find(function(i) { return i.id === currentVal; }) ? '<option value="' + escapeHtml(currentVal) + '" selected>' + escapeHtml(currentVal) + ' (custom)</option>' : '') +
+                '<option value="">— pick one —</option>' +
+                options +
+              '</select>' +
+              '<div style="font-size:11px;color:var(--muted);margin-top:4px">' +
+                items.length + ' result' + (items.length === 1 ? '' : 's') + (data.cached ? ' (cached)' : ' from ' + escapeHtml(picker.tool)) +
+                (customAllowed ? ' · <a href="#" onclick="brainFieldPickerToggleCustom(\\'' + field.key + '\\', \\'' + encodeURIComponent(JSON.stringify(picker)) + '\\');return false">type a custom value instead</a>' : '') +
+              '</div>';
+            // Ensure the hidden input matches the initial selection
+            if (!hidden.value && items[0]) hidden.value = '';
+          } catch (err) {
+            container.innerHTML =
+              '<input type="text" value="' + escapeHtml(values[field.key] || '') + '" placeholder="(probe failed — type manually)" style="width:100%" oninput="(document.querySelector(\\'input[type=hidden][data-field=' + field.key + ']\\')||{}).value=this.value">' +
+              '<div style="color:#e66;font-size:11px;margin-top:4px">Picker failed: ' + escapeHtml(String(err && err.message ? err.message : err)) + ' — type a value manually.</div>';
+          }
+        }
+
+        async function brainFireTypeaheadProbe(field, query) {
+          const resultsEl = document.getElementById('brain-picker-results-' + field.key);
+          const hidden = document.querySelector('input[type=hidden][data-field="' + field.key + '"]');
+          if (!resultsEl || !hidden) return;
+          resultsEl.innerHTML = '<div style="color:var(--muted);font-size:12px;padding:6px">Searching…</div>';
+          try {
+            const resp = await apiFetch('/api/brain/mcp/probe', {
+              method: 'POST', headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ tool: field.picker.tool, intent: field.picker.intent, query }),
+            });
+            const data = await resp.json();
+            if (!resp.ok) throw new Error(data.error || 'probe failed');
+            const items = data.items || [];
+            if (!items.length) {
+              resultsEl.innerHTML = '<div style="color:#8a5a00;font-size:12px;padding:6px">No matches for "' + escapeHtml(query) + '"' + (data.rawPreview ? ' (' + escapeHtml(data.rawPreview.slice(0, 100)) + ')' : '') + '</div>';
+              return;
+            }
+            resultsEl.innerHTML = items.map(function(it) {
+              const lbl = escapeHtml(it.label) + (it.sublabel ? ' <span style="color:var(--muted);font-size:11px">— ' + escapeHtml(it.sublabel) + '</span>' : '');
+              return '<button class="btn" onclick="brainPickTypeaheadItem(\\'' + field.key + '\\', \\'' + encodeURIComponent(it.id) + '\\', \\'' + encodeURIComponent(it.label) + '\\')" style="display:block;width:100%;text-align:left;padding:6px 10px;margin-bottom:2px">' + lbl + '</button>';
+            }).join('') +
+              '<div style="font-size:11px;color:var(--muted);margin-top:4px">' + items.length + ' result' + (items.length === 1 ? '' : 's') + (data.cached ? ' (cached)' : '') + '</div>';
+          } catch (err) {
+            resultsEl.innerHTML = '<div style="color:#e66;font-size:12px;padding:6px">' + escapeHtml(String(err && err.message ? err.message : err)) + '</div>';
+          }
+        }
+
+        function brainPickTypeaheadItem(fieldKey, encodedId, encodedLabel) {
+          const id = decodeURIComponent(encodedId);
+          const label = decodeURIComponent(encodedLabel);
+          const hidden = document.querySelector('input[type=hidden][data-field="' + fieldKey + '"]');
+          if (hidden) hidden.value = id;
+          // Show a confirmation chip and collapse the results.
+          const container = document.querySelector('[data-field-picker="' + fieldKey + '"]');
+          if (!container) return;
+          const searchEl = document.getElementById('brain-picker-search-' + fieldKey);
+          if (searchEl) searchEl.value = label;
+          const resultsEl = document.getElementById('brain-picker-results-' + fieldKey);
+          if (resultsEl) resultsEl.innerHTML = '';
+          // Inject a "selected" line
+          let sel = container.querySelector('.brain-picker-selected');
+          if (!sel) {
+            sel = document.createElement('div');
+            sel.className = 'brain-picker-selected';
+            sel.style.cssText = 'font-size:12px;margin-top:6px';
+            container.appendChild(sel);
+          }
+          sel.innerHTML = '✓ Selected: <b>' + escapeHtml(label) + '</b> <code style="font-size:11px;color:var(--muted)">' + escapeHtml(id) + '</code>';
+        }
+
+        function brainFieldPickerToggleCustom(fieldKey, encodedPicker) {
+          const container = document.querySelector('[data-field-picker="' + fieldKey + '"]');
+          const hidden = document.querySelector('input[type=hidden][data-field="' + fieldKey + '"]');
+          if (!container || !hidden) return;
+          container.innerHTML =
+            '<input type="text" value="' + escapeHtml(hidden.value || '') + '" placeholder="(type a value)" style="width:100%" oninput="(document.querySelector(\\'input[type=hidden][data-field=' + fieldKey + ']\\')||{}).value=this.value">' +
+            '<div style="font-size:11px;margin-top:4px"><a href="#" onclick="brainFieldPickerReload(\\'' + fieldKey + '\\', \\'' + encodedPicker + '\\');return false">← back to picker</a></div>';
+        }
+
+        async function brainFieldPickerReload(fieldKey, encodedPicker) {
+          const picker = JSON.parse(decodeURIComponent(encodedPicker));
+          const s = brainFeedWizardState;
+          if (!s) return;
+          const field = (s.recipe.fields || []).find(function(f) { return f.key === fieldKey; });
+          if (field) await brainRenderFieldPicker(field, s.values);
+        }
+
         function brainFeedWizardRender() {
           if (!brainFeedWizardState) return;
           const s = brainFeedWizardState;
@@ -10711,13 +10984,30 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
             if (!fields.length) {
               html = '<div style="color:var(--muted)">This recipe has no fields. Click Next to pick a schedule.</div>';
             } else {
-              html = '<div style="display:grid;grid-template-columns:180px 1fr;gap:10px;align-items:center">' +
+              html = '<div style="display:grid;grid-template-columns:180px 1fr;gap:10px;align-items:start">' +
                 fields.map(function(f) {
                   const val = s.values[f.key] != null ? s.values[f.key] : (f.defaultValue || '');
                   const help = f.help ? '<div style="font-size:11px;color:var(--muted);margin-top:2px">' + escapeHtml(f.help) + '</div>' : '';
-                  return '<label style="font-weight:500">' + escapeHtml(f.label) + (f.required ? ' <span style="color:#e66">*</span>' : '') + '</label>' +
-                    '<div><input type="text" data-field="' + f.key + '" value="' + escapeHtml(val) + '" placeholder="' + escapeHtml(f.placeholder || '') + '" style="width:100%">' + help + '</div>';
+                  let control;
+                  if (f.picker) {
+                    // Pickers render their own container; fetchPicker fills it.
+                    control = '<div data-field-picker="' + f.key + '" style="width:100%">' +
+                      '<div style="color:var(--muted);font-size:13px;padding:6px">Loading choices…</div>' +
+                    '</div>' +
+                    '<input type="hidden" data-field="' + f.key + '" value="' + escapeHtml(val) + '">';
+                  } else {
+                    control = '<input type="text" data-field="' + f.key + '" value="' + escapeHtml(val) + '" placeholder="' + escapeHtml(f.placeholder || '') + '" style="width:100%">';
+                  }
+                  return '<label style="font-weight:500;padding-top:6px">' + escapeHtml(f.label) + (f.required ? ' <span style="color:#e66">*</span>' : '') + '</label>' +
+                    '<div>' + control + help + '</div>';
                 }).join('') + '</div>';
+
+              // After render, fire probes for any picker fields.
+              setTimeout(function() {
+                for (const f of fields) {
+                  if (f.picker) brainRenderFieldPicker(f, s.values);
+                }
+              }, 0);
             }
           } else if (s.step === 3) {
             const chips = brainScheduleChips();

package/package.json

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