clementine-agent 1.18.90 → 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

@@ -4587,6 +4587,56 @@ export async function cmdDashboard(opts) {
     });
     // SSE events handler moved before auth middleware (see above)
     // ── POST routes (actions) ──────────────────────────────────────
+    // PRD §10 / 1.18.91: cancel an in-flight cron run. The daemon runs every
+    // cron job in-process (cron-running.json's `pid` is the daemon's PID — we
+    // can't SIGTERM it without crashing everything else). Instead we look up
+    // the job's AbortController in the gateway registry and abort it; the SDK
+    // path on runAgentCron honors the signal and unwinds cleanly. The
+    // CronScheduler's own catch path then writes the closing CronRunEntry
+    // with status='error' + an "AbortError" message.
+    app.post('/api/cron/run/:job/cancel', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const gw = await getGateway();
+            if (!gw || typeof gw.cancelCronJob !== 'function') {
+                res.status(503).json({ ok: false, error: 'gateway not initialized — try again in a moment' });
+                return;
+            }
+            const runningFile = path.join(BASE_DIR, 'cron-running.json');
+            let runId;
+            if (existsSync(runningFile)) {
+                try {
+                    const entries = JSON.parse(readFileSync(runningFile, 'utf-8'));
+                    const match = Array.isArray(entries) ? entries.find((e) => String(e.jobName ?? '').toLowerCase() === jobName.toLowerCase()) : null;
+                    if (match?.runId)
+                        runId = match.runId;
+                }
+                catch { /* non-fatal — cancel can still proceed without runId */ }
+            }
+            const aborted = gw.cancelCronJob(jobName, 'cancelled-by-dashboard');
+            if (!aborted) {
+                res.status(404).json({ ok: false, error: `Job "${jobName}" is not running on this daemon` });
+                return;
+            }
+            // Broadcast so other tabs drop the running card without polling.
+            try {
+                broadcastEvent({ type: 'cron_cancelled', data: { job: jobName, runId } });
+            }
+            catch { /* non-fatal */ }
+            res.json({
+                ok: true,
+                message: `Cancel signal sent to "${jobName}". The runner will close the run within a few seconds.`,
+                runId,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
     app.post('/api/cron/run/:job', (req, res) => {
         const jobName = req.params.job;
         try {
@@ -5875,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': [
@@ -5966,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);
         }
@@ -22682,6 +22806,24 @@ async function toggleCronJob(name) {
   } catch(e) { toast('Failed to toggle: ' + e, 'error'); }
 }
 
+// PRD §10 / 1.18.91: SIGTERM the in-flight runner for this cron job. The
+// daemon endpoint reads PID from cron-running.json (already written by
+// CronScheduler). The runner's signal handler closes the run gracefully —
+// the SSE cron_cancelled broadcast will refresh the card.
+async function cancelCronRun(name) {
+  if (!confirm('Cancel the in-flight run for "' + name + '"? The runner will stop within a few seconds.')) return;
+  try {
+    var r = await apiFetch('/api/cron/run/' + encodeURIComponent(name) + '/cancel', { method: 'POST' });
+    var d = await r.json();
+    if (!r.ok || d.ok === false) {
+      toast(d.error || ('Cancel failed (HTTP ' + r.status + ')'), 'error');
+      return;
+    }
+    toast(d.message || ('Cancel signal sent to ' + name), 'success');
+    setTimeout(refreshCron, 800);
+  } catch(e) { toast('Failed to cancel: ' + e, 'error'); }
+}
+
 async function toggleScheduledWorkflow(id) {
   try {
     var r = await apiFetch('/api/builder/workflows/' + encodeURIComponent(id));
@@ -23663,6 +23805,14 @@ function renderScheduledTaskCard(task) {
   badges += '<span class="badge ' + (enabled ? 'badge-green' : 'badge-gray') + '">' + (enabled ? 'Enabled' : 'Disabled') + '</span>';
   badges += '<span class="badge ' + (task.health === 'broken' || task.health === 'failed' ? 'badge-yellow' : 'badge-gray') + '">' + esc(task.healthLabel || task.health) + '</span>';
   var safeName = jsStr(task.name);
+  // PRD §10 / 1.18.91: when a task is mid-flight, Run Now is meaningless and
+  // would race against the concurrency lock; replace it with a Cancel button
+  // that calls /api/cron/run/:job/cancel (SIGTERMs the runner via the PID
+  // recorded in cron-running.json).
+  var isRunning = task.health === 'running';
+  var runOrCancelBtn = isRunning
+    ? '<button class="btn-sm secondary btn-danger" onclick="cancelCronRun(\\x27' + safeName + '\\x27)" title="Stop this in-flight run (SIGTERM)">Cancel</button>'
+    : '<button class="btn-sm secondary btn-success" onclick="apiPost(\\x27/api/cron/run/' + encodeURIComponent(task.name) + '\\x27)" title="Run this task once now">Run Now</button>';
   return '<div class="' + cardCls + '" style="' + style + '">'
     + '<div class="task-card-header"><strong>' + esc(task.displayName || task.name) + '</strong>'
     + '<label class="toggle-switch"><input type="checkbox"' + (enabled ? ' checked' : '') + ' onchange="toggleCronJob(\\x27' + safeName + '\\x27)"><span class="toggle-slider"></span></label></div>'
@@ -23674,7 +23824,7 @@ function renderScheduledTaskCard(task) {
     + '<div class="task-card-badges">' + badges + '</div>'
     + '<div class="task-card-actions">'
     + '<button class="btn-sm primary" onclick="openEditCronModal(\\x27' + safeName + '\\x27)" title="Edit task" style="background:var(--bg-tertiary);border:1px solid var(--border);color:var(--text-primary)">Edit</button>'
-    + '<button class="btn-sm secondary btn-success" onclick="apiPost(\\x27/api/cron/run/' + encodeURIComponent(task.name) + '\\x27)" title="Run this task once now">Run Now</button>'
+    + runOrCancelBtn
     + '<button class="btn-sm secondary" onclick="openCronPreview(\\x27' + safeName + '\\x27)" title="See exactly what will run">Preview</button>'
     + '<button class="btn-sm secondary" data-trace-job="' + esc(task.name) + '" title="View execution trace">Trace</button>'
     + '<button class="btn-sm secondary btn-danger" onclick="confirmDeleteCron(\\x27' + safeName + '\\x27)" title="Delete task">Del</button>'
@@ -24740,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/gateway/router.d.ts

@@ -30,6 +30,11 @@ export declare class Gateway {
      *  `CronRunEntry`. Mirrors the `consumeLastTerminalReason` pattern so we
      *  don't have to refactor `handleCronJob`'s positional return shape. */
     private _lastCronRunMetadata?;
+    /** PRD §10 / 1.18.91: registry of in-flight cron AbortControllers keyed by
+     *  jobName. Lets the dashboard cancel endpoint abort an in-progress run
+     *  without SIGTERMing the whole daemon. Populated/cleaned up by
+     *  handleCronJob. */
+    private cronAbortControllers;
     /** Persisted set of channel keys the owner has approved. Loaded lazily. */
     private seenChannels;
     private _authFailCount;
@@ -178,6 +183,12 @@ export declare class Gateway {
     _mode?: 'standard' | 'unleashed', maxHours?: number, timeoutMs?: number, successCriteria?: string[], agentSlug?: string, pinnedSkills?: string[], allowedTools?: string[], allowedMcpServers?: string[], 
     /** Predictable (contract) mode — runner skips memory/team/auto-skills. */
     predictable?: boolean): Promise<string>;
+    /**
+     * PRD §10 / 1.18.91 — cancel an in-flight cron run by name. Returns true if
+     * an AbortController was found and abort() was called, false if nothing was
+     * registered (job wasn't running on this daemon). Safe to call repeatedly.
+     */
+    cancelCronJob(jobName: string, reason?: string): boolean;
     /**
      * Process a team message as an autonomous task — same multi-phase execution
      * as cron unleashed jobs, so agents can work until done instead of being

package/dist/gateway/router.js

@@ -112,6 +112,11 @@ export class Gateway {
      *  `CronRunEntry`. Mirrors the `consumeLastTerminalReason` pattern so we
      *  don't have to refactor `handleCronJob`'s positional return shape. */
     _lastCronRunMetadata;
+    /** PRD §10 / 1.18.91: registry of in-flight cron AbortControllers keyed by
+     *  jobName. Lets the dashboard cancel endpoint abort an in-progress run
+     *  without SIGTERMing the whole daemon. Populated/cleaned up by
+     *  handleCronJob. */
+    cronAbortControllers = new Map();
     /** Persisted set of channel keys the owner has approved. Loaded lazily. */
     seenChannels = null;
     // Auth circuit breaker — suppresses repeated error spam after consecutive failures
@@ -1987,6 +1992,10 @@ export class Gateway {
             cronAc.abort();
             logger.warn({ jobName, wallMs }, 'Cron job hit wall-clock cap — aborting');
         }, wallMs);
+        // PRD §10 / 1.18.91: register so the dashboard cancel endpoint can find
+        // and abort this controller. Last-write-wins if a duplicate fires (the
+        // concurrency lock prevents that for manual runs, but be defensive).
+        this.cronAbortControllers.set(jobName, cronAc);
         try {
             logger.info(`Running cron job: ${jobName}${workDir ? ` in ${workDir}` : ''}${agentSlug && agentSlug !== 'clementine' ? ` as ${agentSlug}` : ''}`);
             const cronStart = Date.now();
@@ -2047,7 +2056,29 @@ export class Gateway {
         finally {
             clearTimeout(cronTimer);
             releaseLane();
+            // PRD §10 / 1.18.91: deregister only if we're still the owner (a
+            // theoretical re-entry could have replaced us; don't clobber).
+            if (this.cronAbortControllers.get(jobName) === cronAc) {
+                this.cronAbortControllers.delete(jobName);
+            }
+        }
+    }
+    /**
+     * PRD §10 / 1.18.91 — cancel an in-flight cron run by name. Returns true if
+     * an AbortController was found and abort() was called, false if nothing was
+     * registered (job wasn't running on this daemon). Safe to call repeatedly.
+     */
+    cancelCronJob(jobName, reason = 'cancelled-by-dashboard') {
+        const ac = this.cronAbortControllers.get(jobName);
+        if (!ac)
+            return false;
+        if (!ac.signal.aborted) {
+            try {
+                ac.abort(reason);
+            }
+            catch { /* ignore */ }
         }
+        return true;
     }
     // ── Team task execution ──────────────────────────────────────────────
     /**

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.90",
+  "version": "1.18.92",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",