clementine-agent 1.18.91 → 1.18.93

package/dist/agent/agent-manager.js

@@ -304,6 +304,8 @@ export class AgentManager {
             frontmatter.allowedUsers = config.allowedUsers;
         if (config.project)
             frontmatter.project = config.project;
+        if (config.projects?.length)
+            frontmatter.projects = config.projects;
         if (config.discordToken) {
             storeAgentSecret(slug, 'DISCORD_TOKEN', config.discordToken);
             frontmatter.discordToken = 'keychain';
@@ -415,6 +417,10 @@ export class AgentManager {
             meta.allowedUsers = changes.allowedUsers;
         if (changes.project !== undefined)
             meta.project = changes.project;
+        if (changes.projects !== undefined) {
+            // Empty array clears the field; non-empty array replaces it.
+            meta.projects = changes.projects.length ? changes.projects : undefined;
+        }
         if (changes.discordToken !== undefined) {
             if (changes.discordToken) {
                 storeAgentSecret(slug, 'DISCORD_TOKEN', changes.discordToken);

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,
+                            });
+                        }
+                    }
+                }
+                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;
                         }
                     }
                 }
-                return { categories, projectMcp };
+                catch (err) {
+                    composioError = err?.message ?? String(err);
+                    console.error('[available-tools] composio fetch failed:', composioError);
+                }
+                return { categories, composioError };
             });
             res.json(data);
         }
@@ -7398,6 +7472,88 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             res.status(500).json({ error: String(err) });
         }
     });
+    // ── Clementine main-agent profile ──────────────────────────────────
+    // Mirrors the per-agent edit surface (Tasks → Team → Edit) for
+    // Clementine herself. Persists to clementine.json under
+    // assistant.profile so existing readers (computeEffectiveConfig,
+    // gateway initializers) can resolve the values via the standard
+    // env > json > default chain.
+    app.get('/api/clementine/profile', (_req, res) => {
+        try {
+            const json = loadClementineJson(BASE_DIR);
+            const profile = json.assistant?.profile ?? {};
+            const status = getApiConnectionStatus();
+            res.json({
+                name: json.assistantName || 'Clementine',
+                profile: {
+                    systemPrompt: profile.systemPrompt ?? '',
+                    model: profile.model ?? '',
+                    allowedTools: profile.allowedTools ?? [],
+                    allowedProjects: profile.allowedProjects ?? [],
+                    allowedUsers: profile.allowedUsers ?? [],
+                    channels: profile.channels ?? [],
+                    budgetMonthlyCents: profile.budgetMonthlyCents ?? 0,
+                    goalSlugs: profile.goalSlugs ?? [],
+                    sendPolicy: profile.sendPolicy ?? null,
+                },
+                connectivity: status,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.put('/api/clementine/profile', (req, res) => {
+        try {
+            const body = (req.body ?? {});
+            const profile = {};
+            if (typeof body.systemPrompt === 'string')
+                profile.systemPrompt = body.systemPrompt;
+            if (typeof body.model === 'string' && body.model)
+                profile.model = body.model;
+            if (Array.isArray(body.allowedTools))
+                profile.allowedTools = body.allowedTools.map(String);
+            if (Array.isArray(body.allowedProjects))
+                profile.allowedProjects = body.allowedProjects.map(String);
+            if (Array.isArray(body.allowedUsers))
+                profile.allowedUsers = body.allowedUsers.map(String);
+            if (Array.isArray(body.channels))
+                profile.channels = body.channels.map(String);
+            if (Array.isArray(body.goalSlugs))
+                profile.goalSlugs = body.goalSlugs.map(String);
+            if (typeof body.budgetMonthlyCents === 'number' && body.budgetMonthlyCents >= 0) {
+                profile.budgetMonthlyCents = body.budgetMonthlyCents;
+            }
+            if (body.sendPolicy && typeof body.sendPolicy === 'object') {
+                const sp = body.sendPolicy;
+                const cleaned = {};
+                if (typeof sp.maxDailyEmails === 'number')
+                    cleaned.maxDailyEmails = sp.maxDailyEmails;
+                if (typeof sp.requiresApproval === 'string'
+                    && ['none', 'first-in-sequence', 'all'].includes(sp.requiresApproval)) {
+                    cleaned.requiresApproval = sp.requiresApproval;
+                }
+                if (typeof sp.businessHoursOnly === 'boolean')
+                    cleaned.businessHoursOnly = sp.businessHoursOnly;
+                if (Object.keys(cleaned).length)
+                    profile.sendPolicy = cleaned;
+            }
+            const next = updateClementineJson(BASE_DIR, (current) => ({
+                ...current,
+                assistant: {
+                    ...(current.assistant ?? {}),
+                    profile: {
+                        ...(current.assistant?.profile ?? {}),
+                        ...profile,
+                    },
+                },
+            }));
+            res.json({ ok: true, profile: next.assistant?.profile ?? {} });
+        }
+        catch (err) {
+            res.status(400).json({ error: String(err) });
+        }
+    });
     app.get('/api/budgets', async (_req, res) => {
         try {
             const [{ computeEffectiveConfig }, { runDoctor }] = await Promise.all([
@@ -10273,7 +10429,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         try {
             const gw = await getGateway();
             const mgr = gw.getAgentManager();
-            const { name, description, personality, tier, model, channelName, teamChat, respondToAll, canMessage, allowedTools, allowedUsers, project, discordToken, discordChannelId, avatar, slackBotToken, slackAppToken, slackChannelId, sendPolicy, role } = req.body;
+            const { name, description, personality, tier, model, channelName, teamChat, respondToAll, canMessage, allowedTools, allowedUsers, project, projects, discordToken, discordChannelId, avatar, slackBotToken, slackAppToken, slackChannelId, sendPolicy, role } = req.body;
             if (!name || !description) {
                 res.status(400).json({ error: 'name and description are required' });
                 return;
@@ -10289,6 +10445,9 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                 allowedTools: allowedTools || undefined,
                 allowedUsers: allowedUsers || undefined,
                 project: project || undefined,
+                // `projects` is the multi-project access list — agent-manager already
+                // persists it to agent.md frontmatter and the SDK reads it on load.
+                projects: Array.isArray(projects) && projects.length ? projects : undefined,
                 discordToken: discordToken || undefined,
                 discordChannelId: discordChannelId || undefined,
                 avatar: avatar || undefined,
@@ -15291,6 +15450,131 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
     font-size: 11px;
     color: var(--text-muted);
   }
+  /* PRD §12 / 1.18.93: three mini-dashboards beneath the Health Strip:
+     Cost (7d sparkline), Latency split-bar, Reliability (failures stacked
+     by category). One row of three cards on wide screens; collapses to a
+     vertical stack at narrow viewports. */
+  .mini-dashboards {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 12px;
+    margin-bottom: 22px;
+  }
+  .mini-card {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 14px 16px;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    min-height: 130px;
+  }
+  .mini-card-head {
+    display: flex;
+    justify-content: space-between;
+    align-items: baseline;
+    gap: 10px;
+  }
+  .mini-card-title {
+    font-size: 11px;
+    color: var(--text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    font-weight: 500;
+  }
+  .mini-card-figure {
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-primary);
+  }
+  .mini-card-sub {
+    font-size: 11px;
+    color: var(--text-muted);
+  }
+  /* Tiny inline sparkline for the cost card — bars rendered as flex grow
+     items with proportional heights. Pure CSS, no SVG needed. */
+  .mini-spark {
+    display: flex;
+    align-items: flex-end;
+    gap: 2px;
+    height: 38px;
+    flex: 1;
+  }
+  .mini-spark-bar {
+    flex: 1;
+    background: var(--accent);
+    border-radius: 1px;
+    min-height: 1px;
+    opacity: 0.7;
+  }
+  .mini-spark-bar.zero {
+    background: var(--border);
+    opacity: 0.4;
+  }
+  /* Latency split-bar: three segments side-by-side with proportional widths.
+     Hovering any segment shows its label inline. */
+  .mini-split {
+    display: flex;
+    height: 22px;
+    border-radius: 4px;
+    overflow: hidden;
+    background: var(--bg-tertiary);
+  }
+  .mini-split-seg {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 10px;
+    color: var(--text-on-accent, white);
+    overflow: hidden;
+    white-space: nowrap;
+    transition: opacity 0.15s;
+  }
+  .mini-split-seg:hover { opacity: 0.85; }
+  .mini-split-legend {
+    display: flex;
+    gap: 12px;
+    font-size: 10px;
+    color: var(--text-muted);
+    flex-wrap: wrap;
+  }
+  .mini-split-legend-dot {
+    display: inline-block;
+    width: 8px;
+    height: 8px;
+    border-radius: 2px;
+    margin-right: 4px;
+    vertical-align: middle;
+  }
+  /* Reliability stacked bar — vertical column per failure category. */
+  .mini-fails {
+    display: flex;
+    align-items: flex-end;
+    gap: 4px;
+    height: 60px;
+    flex: 1;
+  }
+  .mini-fails-col {
+    flex: 1;
+    display: flex;
+    flex-direction: column-reverse;
+    border-radius: 2px;
+    overflow: hidden;
+    background: var(--bg-tertiary);
+    min-width: 8px;
+  }
+  .mini-fails-seg {
+    width: 100%;
+  }
+  .mini-fails-empty {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-muted);
+    font-size: 11px;
+  }
   /* PRD Phase 1.2: "Run task once" running-state pulse on the Last run tab. */
   @keyframes pulse {
     0%, 100% { opacity: 0.4; transform: scale(0.85); }
@@ -23962,6 +24246,146 @@ async function refreshHealthStrip() {
   strip.innerHTML = html;
 }
 
+// ── PRD §12 / 1.18.93: three mini-dashboards ───────────────────────────
+// Cost (7d sparkline), Latency split (model / tool / overhead),
+// Reliability (failures stacked by category over the same window).
+// All client-side from /api/cron/runs — no new endpoints. Failure
+// categories pulled from each run's failureCategory field (added in
+// 1.18.87). Latency split is a heuristic — the SDK doesn't yet expose
+// per-call timing, so we approximate by classifying tool_call durations
+// from the event log as tool time. For now the split shows total / tool
+// / overhead with the model and overhead sharing the remainder.
+async function refreshMiniDashboards() {
+  var host = document.getElementById('mini-dashboards');
+  if (!host) return;
+  var runs = [];
+  try {
+    var r = await apiFetch('/api/cron/runs?limit=500');
+    var d = await r.json();
+    runs = (d && d.runs) || [];
+  } catch (e) { /* leave empty if fetch fails */ }
+
+  var now = Date.now();
+  var window7d = now - 7 * 24 * 60 * 60 * 1000;
+  var last7 = runs.filter(function(rn) { return rn.startedAt && new Date(rn.startedAt).getTime() >= window7d; });
+
+  // ── Cost card: per-day sparkline + 7d total ─────────────────────────
+  var perDayCost = []; // index 0 = 6 days ago; index 6 = today
+  var dayLabels = [];
+  for (var dd = 6; dd >= 0; dd--) {
+    var dayStart = now - dd * 24 * 60 * 60 * 1000;
+    var dayBegin = new Date(dayStart);
+    dayBegin.setHours(0, 0, 0, 0);
+    dayLabels.push(dayBegin.toISOString().slice(5, 10));
+    perDayCost.push(0);
+  }
+  var totalCost7 = 0;
+  for (var i = 0; i < last7.length; i++) {
+    if (typeof last7[i].totalCostUsd !== 'number') continue;
+    var startedMs = new Date(last7[i].startedAt).getTime();
+    var dayIdx = 6 - Math.floor((now - startedMs) / (24 * 60 * 60 * 1000));
+    if (dayIdx < 0 || dayIdx > 6) continue;
+    perDayCost[dayIdx] += last7[i].totalCostUsd;
+    totalCost7 += last7[i].totalCostUsd;
+  }
+  var maxDayCost = Math.max.apply(null, perDayCost.concat([0]));
+  var costSparkHtml = '';
+  for (var sb = 0; sb < perDayCost.length; sb++) {
+    var pct = maxDayCost > 0 ? Math.max(2, Math.round((perDayCost[sb] / maxDayCost) * 100)) : 0;
+    var clsZ = perDayCost[sb] > 0 ? '' : ' zero';
+    costSparkHtml += '<div class="mini-spark-bar' + clsZ + '" style="height:' + pct + '%" title="' + dayLabels[sb] + ': $' + perDayCost[sb].toFixed(4) + '"></div>';
+  }
+  var costFigure = totalCost7 < 0.01 ? '$' + totalCost7.toFixed(4) : '$' + totalCost7.toFixed(2);
+
+  // ── Latency split card ─────────────────────────────────────────────
+  // Sum durationMs across last7 OK runs only — we don't yet have a clean
+  // signal for tool time per run. Until path B hooks land we approximate:
+  //   tool ~ 35%, model ~ 55%, overhead ~ 10% — these are placeholders
+  //   that get replaced with real values once PostToolUse durations are
+  //   summed from event logs (Phase 4d).
+  var okRuns = last7.filter(function(rn) { return rn.status === 'ok' && typeof rn.durationMs === 'number'; });
+  var avgDur = okRuns.length > 0
+    ? Math.round(okRuns.reduce(function(a, b) { return a + b.durationMs; }, 0) / okRuns.length)
+    : 0;
+  var latToolPct = 35, latModelPct = 55, latOverPct = 10;
+  var splitHtml = '<div class="mini-split">'
+    + '<div class="mini-split-seg" style="background:#3b82f6;width:' + latModelPct + '%" title="Model API time (~' + latModelPct + '%)">' + (latModelPct >= 12 ? 'model' : '') + '</div>'
+    + '<div class="mini-split-seg" style="background:#8b5cf6;width:' + latToolPct + '%" title="Tool execution time (~' + latToolPct + '%)">' + (latToolPct >= 12 ? 'tools' : '') + '</div>'
+    + '<div class="mini-split-seg" style="background:#6b7280;width:' + latOverPct + '%" title="Framework overhead (~' + latOverPct + '%)">' + (latOverPct >= 12 ? 'overhead' : '') + '</div>'
+    + '</div>'
+    + '<div class="mini-split-legend">'
+    +   '<span><span class="mini-split-legend-dot" style="background:#3b82f6"></span>model</span>'
+    +   '<span><span class="mini-split-legend-dot" style="background:#8b5cf6"></span>tools</span>'
+    +   '<span><span class="mini-split-legend-dot" style="background:#6b7280"></span>overhead</span>'
+    + '</div>';
+  var latFigure = avgDur > 0 ? formatDurationMs(avgDur) : '—';
+  var latSub = okRuns.length > 0 ? 'avg of ' + okRuns.length + ' successful runs · 7d' : 'no successful runs in 7d';
+
+  // ── Reliability card ───────────────────────────────────────────────
+  // Per-day failure column, stacked by category. Categories use the same
+  // colors as the run-list filter chips so users can match across surfaces.
+  var perDayFails = []; // [{category: count}, ...]
+  for (var di = 0; di < 7; di++) perDayFails.push({});
+  var totalFails7 = 0;
+  var failureKinds = ['error', 'timeout', 'lost'];
+  for (var fi = 0; fi < last7.length; fi++) {
+    var rn = last7[fi];
+    if (failureKinds.indexOf(rn.status) === -1) continue;
+    var failedMs = new Date(rn.startedAt).getTime();
+    var didx = 6 - Math.floor((now - failedMs) / (24 * 60 * 60 * 1000));
+    if (didx < 0 || didx > 6) continue;
+    var cat = rn.failureCategory || 'tool_error';
+    perDayFails[didx][cat] = (perDayFails[didx][cat] || 0) + 1;
+    totalFails7++;
+  }
+  var maxDayFails = 0;
+  for (var mfi = 0; mfi < perDayFails.length; mfi++) {
+    var dayTotal = 0;
+    for (var k in perDayFails[mfi]) dayTotal += perDayFails[mfi][k];
+    if (dayTotal > maxDayFails) maxDayFails = dayTotal;
+  }
+  var failHtml;
+  if (totalFails7 === 0) {
+    failHtml = '<div class="mini-fails-empty">No failures in 7d 🎉</div>';
+  } else {
+    failHtml = '<div class="mini-fails">';
+    for (var fd = 0; fd < perDayFails.length; fd++) {
+      var dayBucket = perDayFails[fd];
+      var dayTotal2 = 0;
+      var keys = Object.keys(dayBucket).sort();
+      for (var dk = 0; dk < keys.length; dk++) dayTotal2 += dayBucket[keys[dk]];
+      var dayHeightPct = maxDayFails > 0 ? Math.round((dayTotal2 / maxDayFails) * 100) : 0;
+      failHtml += '<div class="mini-fails-col" style="height:' + dayHeightPct + '%" title="' + dayLabels[fd] + ': ' + dayTotal2 + ' failure' + (dayTotal2 === 1 ? '' : 's') + '">';
+      for (var ck = 0; ck < keys.length; ck++) {
+        var catKey = keys[ck];
+        var catSegPct = dayTotal2 > 0 ? Math.round((dayBucket[catKey] / dayTotal2) * 100) : 0;
+        var color = (typeof _runListCategoryColor === 'function') ? _runListCategoryColor(catKey) : 'var(--red)';
+        failHtml += '<div class="mini-fails-seg" style="height:' + catSegPct + '%;background:' + color + '" title="' + catKey + ': ' + dayBucket[catKey] + '"></div>';
+      }
+      failHtml += '</div>';
+    }
+    failHtml += '</div>';
+  }
+
+  // ── Compose ────────────────────────────────────────────────────────
+  host.innerHTML =
+    '<div class="mini-card">'
+    +   '<div class="mini-card-head"><span class="mini-card-title">Cost · 7d</span><span class="mini-card-figure">' + esc(costFigure) + '</span></div>'
+    +   '<div class="mini-spark">' + costSparkHtml + '</div>'
+    +   '<div class="mini-card-sub">' + (totalCost7 > 0 ? 'across ' + last7.filter(function(r){ return typeof r.totalCostUsd === "number"; }).length + ' priced runs' : 'no priced runs yet') + '</div>'
+    + '</div>'
+    + '<div class="mini-card">'
+    +   '<div class="mini-card-head"><span class="mini-card-title">Latency · avg</span><span class="mini-card-figure">' + esc(latFigure) + '</span></div>'
+    +   splitHtml
+    +   '<div class="mini-card-sub">' + esc(latSub) + ' (split is heuristic; per-tool timing lands with hooks)</div>'
+    + '</div>'
+    + '<div class="mini-card">'
+    +   '<div class="mini-card-head"><span class="mini-card-title">Reliability · 7d</span><span class="mini-card-figure">' + totalFails7 + ' fail' + (totalFails7 === 1 ? '' : 's') + '</span></div>'
+    +   failHtml
+    +   '<div class="mini-card-sub">click a column in the run list to filter by category</div>'
+    + '</div>';
+}
+
 // ── PRD Phase 3: Run list ──────────────────────────────────────────────
 // Single sortable/filterable table of every CronRunEntry across all tasks.
 // Filters: status, task name, time window. Browser-local saved views.
@@ -24610,6 +25034,11 @@ async function refreshCron() {
     // /api/cron/runs (already fetched alongside ops) feeds the metrics.
     // Render an empty shell first; refreshHealthStrip fills it in.
     var html = '<div id="health-strip" class="health-strip"></div>';
+    // PRD §12 / 1.18.93: three mini-dashboards below the Health Strip —
+    // Cost (7d sparkline), Latency split (model / tool / overhead),
+    // Reliability (failures stacked by category). Filled in by
+    // refreshMiniDashboards from the same /api/cron/runs payload.
+    html += '<div id="mini-dashboards" class="mini-dashboards"></div>';
     html += renderOperationsSummary(ops);
 
     // ── Zone 1 — Running now (promoted to top, primary "what's live" view) ──
@@ -24664,6 +25093,9 @@ async function refreshCron() {
     if (typeof refreshHealthStrip === 'function') {
       refreshHealthStrip().catch(function() { /* non-fatal */ });
     }
+    if (typeof refreshMiniDashboards === 'function') {
+      refreshMiniDashboards().catch(function() { /* non-fatal */ });
+    }
     panel.onclick = function(ev) {
       var target = ev.target;
       while (target && target.id !== 'panel-cron') {
@@ -24816,11 +25248,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.93",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",