clementine-agent 1.18.91 → 1.18.92

package/dist/agent/run-agent.js

@@ -489,6 +489,34 @@ export async function runAgent(prompt, opts) {
         durationMs: Date.now() - startedAt,
         finalTextChars: finalText.length,
     }, 'runAgent: query complete');
+    // PRD §6 Phase 4e: subagent transcript backfill (Path C). The SDK persists
+    // every subagent's full message stream to ~/.claude/projects/<encoded-cwd>/
+    // <sessionId>/subagents/agent-*.jsonl. Path A only sees the parent's Task
+    // tool_use, so subagent-internal LLM/tool calls are invisible without this.
+    // Best-effort — telemetry must never block the run from returning.
+    try {
+        const { backfillSubagentEvents } = await import('./subagent-backfill.js');
+        const projectCwd = sdkOptionsRaw.cwd || BASE_DIR;
+        const backfillResult = await backfillSubagentEvents({
+            runId,
+            sessionId,
+            cwd: projectCwd,
+            eventLog,
+            startSeq: eventSeq,
+        });
+        eventSeq += backfillResult.backfilled;
+        if (backfillResult.backfilled > 0) {
+            logger.info({
+                runId,
+                sessionId,
+                backfilled: backfillResult.backfilled,
+                agents: backfillResult.agents,
+            }, 'runAgent: subagent backfill (Path C) complete');
+        }
+    }
+    catch (err) {
+        logger.debug({ err }, 'runAgent: subagent backfill failed (non-fatal)');
+    }
     return {
         text: finalText,
         totalCostUsd,

package/dist/agent/subagent-backfill.d.ts

@@ -0,0 +1,51 @@
+/**
+ * PRD §6 / Phase 4e — Path C: subagent transcript backfill.
+ *
+ * The Claude Agent SDK persists every subagent's full message stream to
+ *   ~/.claude/projects/<encoded-cwd>/<sessionId>/subagents/agent-*.jsonl
+ *
+ * The parent run's in-process tap (path A in `run-agent.ts`) only sees the
+ * top-level Task tool_use + tool_result, so subagent-internal LLM/tool calls
+ * are invisible in the Run detail waterfall. After the parent run ends, this
+ * module reads any matching agent-*.jsonl files for the run's sessionId and
+ * appends synthesized Event rows so the waterfall can render nested subagent
+ * activity.
+ *
+ * Best-effort by design — never throws back to the caller. Missing dir / parse
+ * errors / timing skew are all acceptable; the worst case is the parent run
+ * looks the same as before the backfill.
+ */
+import type { EventLog } from '../gateway/event-log.js';
+/**
+ * Encode a cwd path the way the SDK does for `~/.claude/projects/<encoded>`:
+ * every slash, backslash, and whitespace character becomes `-`. Confirmed
+ * against existing on-disk dirs (e.g. paths containing spaces and `..`).
+ */
+export declare function encodeProjectCwd(cwd: string): string;
+interface BackfillResult {
+    /** Number of synthesized RunEvent rows appended to the run's event log. */
+    backfilled: number;
+    /** Number of agent-*.jsonl files parsed. */
+    agents: number;
+    /** Resolved subagents directory (helpful in audit logs when nothing matches). */
+    scannedDir: string | null;
+}
+interface BackfillOpts {
+    runId: string;
+    sessionId: string;
+    cwd: string;
+    /** Pass the parent run's EventLog so we can append in-place. */
+    eventLog: EventLog;
+    /** Sequence number to start at. The caller already wrote N events; we
+     *  continue from there to keep the file ordered. */
+    startSeq: number;
+}
+/**
+ * Scan ~/.claude/projects/<encoded(cwd)>/<sessionId>/subagents/agent-*.jsonl
+ * and append synthesized RunEvent rows to the parent run's event log.
+ *
+ * The function is fire-and-forget from runAgent's POV — it never rejects.
+ */
+export declare function backfillSubagentEvents(opts: BackfillOpts): Promise<BackfillResult>;
+export {};
+//# sourceMappingURL=subagent-backfill.d.ts.map

package/dist/agent/subagent-backfill.js

@@ -0,0 +1,177 @@
+/**
+ * PRD §6 / Phase 4e — Path C: subagent transcript backfill.
+ *
+ * The Claude Agent SDK persists every subagent's full message stream to
+ *   ~/.claude/projects/<encoded-cwd>/<sessionId>/subagents/agent-*.jsonl
+ *
+ * The parent run's in-process tap (path A in `run-agent.ts`) only sees the
+ * top-level Task tool_use + tool_result, so subagent-internal LLM/tool calls
+ * are invisible in the Run detail waterfall. After the parent run ends, this
+ * module reads any matching agent-*.jsonl files for the run's sessionId and
+ * appends synthesized Event rows so the waterfall can render nested subagent
+ * activity.
+ *
+ * Best-effort by design — never throws back to the caller. Missing dir / parse
+ * errors / timing skew are all acceptable; the worst case is the parent run
+ * looks the same as before the backfill.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import pino from 'pino';
+const logger = pino({ name: 'clementine.subagent-backfill' });
+/**
+ * Encode a cwd path the way the SDK does for `~/.claude/projects/<encoded>`:
+ * every slash, backslash, and whitespace character becomes `-`. Confirmed
+ * against existing on-disk dirs (e.g. paths containing spaces and `..`).
+ */
+export function encodeProjectCwd(cwd) {
+    return cwd.replace(/[/\\\s.]/g, '-');
+}
+/**
+ * Walk a single agent-*.jsonl file and synthesize RunEvent rows.
+ * Returns the events as a flat array; the caller appends them to the
+ * shared event log so we can offset their `seq` correctly.
+ */
+function synthesizeFromFile(filePath, runId) {
+    const out = [];
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf-8');
+    }
+    catch (err) {
+        logger.debug({ err, filePath }, 'subagent-backfill: read failed');
+        return out;
+    }
+    const lines = raw.split('\n');
+    // The agentId in the filename (agent-<id>.jsonl) is the stable handle for
+    // this subagent; we tag every synthesized event with it so the waterfall
+    // can group them under one swimlane.
+    const baseName = path.basename(filePath, '.jsonl'); // "agent-a333f70"
+    const agentId = baseName.replace(/^agent-/, '');
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            // Tolerate the rare half-flushed line at EOF.
+            continue;
+        }
+        const ts = parsed.timestamp || new Date().toISOString();
+        const slug = parsed.slug;
+        const subagentId = parsed.agentId || agentId;
+        const blocks = parsed.message?.content;
+        if (!Array.isArray(blocks))
+            continue;
+        for (const block of blocks) {
+            // Build the same RunEvent kinds the parent run uses, but tagged with
+            // agentId/subagentSlug + source='backfill' so the Run detail viewer
+            // can render them in a nested swimlane. seq is filled in by the
+            // caller; common fields go through to match path A's shape.
+            const common = {
+                runId,
+                ts,
+                agentId: subagentId,
+                subagentSlug: slug,
+                source: 'backfill',
+            };
+            if (block.type === 'text' && block.text) {
+                out.push({ ...common, kind: 'llm_text', text: block.text, seq: -1 });
+            }
+            else if (block.type === 'thinking' && block.thinking) {
+                out.push({ ...common, kind: 'thinking', thinking: block.thinking, seq: -1 });
+            }
+            else if (block.type === 'tool_use') {
+                out.push({
+                    ...common,
+                    kind: 'tool_call',
+                    toolName: block.name || 'unknown',
+                    toolUseId: block.id,
+                    toolInput: block.input,
+                    seq: -1,
+                });
+            }
+            else if (block.type === 'tool_result') {
+                const previewSrc = typeof block.content === 'string'
+                    ? block.content
+                    : JSON.stringify(block.content ?? '');
+                out.push({
+                    ...common,
+                    kind: 'tool_result',
+                    toolUseId: block.tool_use_id,
+                    // truncate huge tool_results to keep event-log size sane
+                    toolResult: previewSrc.slice(0, 4000),
+                    ...(block.is_error ? { toolError: previewSrc.slice(0, 1000) } : {}),
+                    seq: -1,
+                });
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Scan ~/.claude/projects/<encoded(cwd)>/<sessionId>/subagents/agent-*.jsonl
+ * and append synthesized RunEvent rows to the parent run's event log.
+ *
+ * The function is fire-and-forget from runAgent's POV — it never rejects.
+ */
+export async function backfillSubagentEvents(opts) {
+    const { runId, sessionId, cwd, eventLog, startSeq } = opts;
+    const result = { backfilled: 0, agents: 0, scannedDir: null };
+    if (!sessionId || !cwd)
+        return result;
+    let projectsRoot;
+    try {
+        projectsRoot = path.join(os.homedir(), '.claude', 'projects');
+        if (!existsSync(projectsRoot))
+            return result;
+    }
+    catch {
+        return result;
+    }
+    const encoded = encodeProjectCwd(cwd);
+    const subDir = path.join(projectsRoot, encoded, sessionId, 'subagents');
+    result.scannedDir = subDir;
+    if (!existsSync(subDir))
+        return result;
+    let files;
+    try {
+        files = readdirSync(subDir).filter((f) => f.startsWith('agent-') && f.endsWith('.jsonl'));
+    }
+    catch (err) {
+        logger.debug({ err, subDir }, 'subagent-backfill: readdir failed');
+        return result;
+    }
+    if (files.length === 0)
+        return result;
+    // Aggregate across all subagent files, then sort by ts so the waterfall
+    // renders in chronological order regardless of which agent file we read first.
+    const all = [];
+    for (const f of files) {
+        const fp = path.join(subDir, f);
+        const synthesized = synthesizeFromFile(fp, runId);
+        if (synthesized.length > 0) {
+            all.push(...synthesized);
+            result.agents += 1;
+        }
+    }
+    all.sort((a, b) => {
+        const ta = a.ts ?? '';
+        const tb = b.ts ?? '';
+        return ta < tb ? -1 : ta > tb ? 1 : 0;
+    });
+    // Stamp seq + append. EventLog.append swallows its own errors so we just
+    // call it in a loop. The starting seq comes from the caller (the parent
+    // run's last writeEvent counter) so backfill rows sort after live rows.
+    let seq = startSeq;
+    for (const ev of all) {
+        ev.seq = seq++;
+        eventLog.append(ev);
+        result.backfilled += 1;
+    }
+    return result;
+}
+//# sourceMappingURL=subagent-backfill.js.map

package/dist/cli/dashboard.js

@@ -5925,10 +5925,11 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         }
     });
     // ── Available Tools ──────────────────────────────────────────
-    app.get('/api/available-tools', (_req, res) => {
+    app.get('/api/available-tools', async (_req, res) => {
         try {
-            const data = cached('available-tools', 30_000, () => {
+            const data = await cachedAsync('available-tools', 60_000, async () => {
                 const apiStatus = getApiConnectionStatus();
+                let composioError = null;
                 const categories = {
                     'CLI Tools': discoverCliTools(),
                     'Core SDK': [
@@ -6016,19 +6017,92 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                 if (globalMcp.length > 0) {
                     categories['Global MCP Servers'] = globalMcp;
                 }
-                // Discover project-scoped MCP servers
-                const projectMcp = {};
+                // Local Projects: surface every linked project as a single togglable
+                // entry so an agent can be granted access to a whole project (and the
+                // dashboard can render the project's MCP servers as nested children).
+                // Source of truth is `cachedProjects`, populated by the background
+                // workspace scanner.
                 const projects = cachedProjects ?? [];
+                if (projects.length > 0) {
+                    categories['Local Projects'] = projects.map((p) => {
+                        const exists = (() => {
+                            try {
+                                return existsSync(p.path);
+                            }
+                            catch {
+                                return false;
+                            }
+                        })();
+                        return {
+                            name: `project:${p.path}`,
+                            description: p.description || p.path,
+                            type: 'project',
+                            path: p.path,
+                            projectName: p.name,
+                            connected: exists,
+                            mcpServers: Array.isArray(p.mcpServers) ? p.mcpServers : [],
+                            hasClaude: !!p.hasClaude,
+                        };
+                    });
+                }
+                // Project-scoped MCP servers — flatten what was previously a sibling
+                // `projectMcp` map (which the renderer ignored) into one category per
+                // server, so they show up alongside everything else in the picker.
+                const projectMcpByServer = {};
                 for (const p of projects) {
                     if (p.mcpServers.length) {
                         for (const server of p.mcpServers) {
-                            if (!projectMcp[server])
-                                projectMcp[server] = [];
-                            projectMcp[server].push({ name: `mcp__${server} (all tools)`, description: `Project MCP: ${p.name}`, type: 'project-mcp' });
+                            if (!projectMcpByServer[server])
+                                projectMcpByServer[server] = [];
+                            projectMcpByServer[server].push({
+                                name: `mcp__${server}`,
+                                description: `Project MCP from ${p.name}`,
+                                type: 'project-mcp',
+                                connected: true,
+                            });
                         }
                     }
                 }
-                return { categories, projectMcp };
+                for (const [server, entries] of Object.entries(projectMcpByServer)) {
+                    // De-dup if the same server appears in multiple projects.
+                    const seen = new Set();
+                    const deduped = entries.filter((e) => {
+                        if (seen.has(e.name))
+                            return false;
+                        seen.add(e.name);
+                        return true;
+                    });
+                    categories[`Project MCP — ${server}`] = deduped;
+                }
+                // Composio Toolkits: 1000+ third-party services. We surface every
+                // toolkit so the agent owner can opt in; the `connected` pill tells
+                // them whether OAuth is wired up. Failures are non-fatal — we just
+                // omit the category and stash the error for the client.
+                try {
+                    const composio = await import('../integrations/composio/client.js');
+                    if (composio.isComposioEnabled()) {
+                        const [catalog, connected] = await Promise.all([
+                            composio.listAllToolkits(),
+                            composio.listConnectedToolkits(),
+                        ]);
+                        const connectedSet = new Set(connected.map((c) => c.slug));
+                        const toolkits = catalog.map((tk) => ({
+                            name: `composio:${tk.slug}`,
+                            description: tk.description || tk.name || tk.slug,
+                            type: 'composio',
+                            connected: connectedSet.has(tk.slug),
+                            displayName: tk.name || tk.slug,
+                        }));
+                        if (toolkits.length > 0) {
+                            categories['Composio Toolkits'] = toolkits;
+                        }
+                    }
+                }
+                catch (err) {
+                    composioError = err?.message ?? String(err);
+                    console.error('[available-tools] composio fetch failed:', composioError);
+                }
+                return { categories, composioError };
             });
             res.json(data);
         }
@@ -24816,11 +24890,21 @@ function renderRunDetailWaterfall(events, runId, jobName) {
 
     var rowId = 'run-evt-' + j;
     var canExpand = !!fullContent && fullContent.length > preview.length;
-    html += '<div style="display:grid;grid-template-columns:90px 110px 1fr;gap:14px;padding:10px 20px;border-bottom:1px solid var(--border);align-items:start">';
+    // PRD §6 Phase 4e: backfilled subagent events get an indented row + a
+    // pill showing the subagent slug, so the waterfall makes it obvious
+    // which spans came from a delegated agent vs the parent task.
+    var isSubagent = ev.source === 'backfill' || !!ev.subagentSlug;
+    var rowBg = isSubagent ? 'background:var(--bg-secondary);' : '';
+    var rowPad = isSubagent ? 'padding:10px 20px 10px 48px;' : 'padding:10px 20px;';
+    var subagentBadge = isSubagent
+      ? '<span title="Backfilled from subagent transcript" style="display:inline-block;background:var(--purple,#8b5cf6)20;color:var(--purple,#8b5cf6);padding:2px 8px;border-radius:4px;font-size:10px;font-weight:500;margin-right:6px">↳ ' + esc(ev.subagentSlug || ev.agentId || 'subagent') + '</span>'
+      : '';
+    html += '<div style="display:grid;grid-template-columns:90px 110px 1fr;gap:14px;' + rowPad + 'border-bottom:1px solid var(--border);align-items:start;' + rowBg + '">';
     html += '<div style="font-size:10px;color:var(--text-muted);font-family:\\x27JetBrains Mono\\x27,monospace;line-height:18px">' + esc(offsetLabel) + '</div>';
     html += '<div><span style="display:inline-block;background:' + color + '20;color:' + color + ';padding:2px 8px;border-radius:4px;font-size:10px;font-weight:600;letter-spacing:0.04em">' + esc(label) + '</span></div>';
     html += '<div style="min-width:0">';
     html +=   '<div style="font-size:12px;color:var(--text-primary);line-height:1.45;word-break:break-word">'
+      +     subagentBadge
       +     esc(preview)
       +     (pairedDuration ? '<span style="color:var(--text-muted);font-size:11px"> ' + esc(pairedDuration) + '</span>' : '')
       +   '</div>';

package/dist/config/clementine-json.d.ts

@@ -44,6 +44,25 @@ export declare const clementineJsonSchema: z.ZodObject<{
             ask_first: "ask_first";
             act_when_safe: "act_when_safe";
         }>>;
+        profile: z.ZodOptional<z.ZodObject<{
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowedProjects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowedUsers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            channels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            budgetMonthlyCents: z.ZodOptional<z.ZodNumber>;
+            goalSlugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            sendPolicy: z.ZodOptional<z.ZodObject<{
+                maxDailyEmails: z.ZodOptional<z.ZodNumber>;
+                requiresApproval: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    "first-in-sequence": "first-in-sequence";
+                    all: "all";
+                }>>;
+                businessHoursOnly: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     models: z.ZodOptional<z.ZodObject<{
         default: z.ZodOptional<z.ZodString>;

package/dist/config/clementine-json.js

@@ -32,6 +32,28 @@ export const clementineJsonSchema = z.object({
         responseStyle: z.enum(['concise', 'balanced', 'detailed']).optional(),
         progressVisibility: z.enum(['quiet', 'normal', 'detailed']).optional(),
         autonomy: z.enum(['ask_first', 'balanced', 'act_when_safe']).optional(),
+        /**
+         * Dashboard-managed profile for the main agent (Clementine herself).
+         * Mirrors the per-agent edit surface so Tasks → Team can edit the
+         * primary persona without forcing users into Settings or env files.
+         * Every field is optional; absent fields fall through to the existing
+         * env / compiled defaults via computeEffectiveConfig.
+         */
+        profile: z.object({
+            systemPrompt: z.string().optional(),
+            model: z.string().optional(),
+            allowedTools: z.array(z.string()).optional(),
+            allowedProjects: z.array(z.string()).optional(),
+            allowedUsers: z.array(z.string()).optional(),
+            channels: z.array(z.string()).optional(),
+            budgetMonthlyCents: z.number().nonnegative().optional(),
+            goalSlugs: z.array(z.string()).optional(),
+            sendPolicy: z.object({
+                maxDailyEmails: z.number().nonnegative().optional(),
+                requiresApproval: z.enum(['none', 'first-in-sequence', 'all']).optional(),
+                businessHoursOnly: z.boolean().optional(),
+            }).optional(),
+        }).optional(),
     }).optional(),
     models: z.object({
         default: z.string().optional(),

package/dist/types.d.ts

@@ -445,8 +445,18 @@ export interface RunEvent {
     costUsd?: number;
     /** Stop reason from ResultMessage when kind='session_end'. */
     stopReason?: string;
-    /** Subagent id when kind='subagent_*'. */
+    /** Subagent id when kind='subagent_*' OR when an event was synthesized from
+     *  a subagent transcript via Path C backfill (subagent-backfill.ts). */
     agentId?: string;
+    /** PRD §6 Phase 4e: subagent slug ("bright-petting-kahn") for friendly
+     *  display in the Run detail waterfall. Only populated for events
+     *  synthesized from subagent transcripts. */
+    subagentSlug?: string;
+    /** PRD §6 Phase 4e: marks events as backfilled from a subagent transcript
+     *  rather than captured live by the in-process tap. The Run detail viewer
+     *  renders these in a nested swimlane and labels the source so users know
+     *  the data came from disk after the run. */
+    source?: 'live' | 'backfill';
 }
 /**
  * PRD §9 / 1.18.87: 11-category failure taxonomy. Replaces the existing

package/package.json

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