clementine-agent 1.18.83 → 1.18.84

package/dist/agent/assistant.d.ts

@@ -70,8 +70,6 @@ export declare class PersonalAssistant {
     private memoryStore;
     private _lastUserMessage?;
     onSkillProposed: ((skill: import('../types.js').SkillDocument) => void) | null;
-    private _lastMcpStatus;
-    private _lastMcpStatusTime;
     /** Terminal reason from the last SDK query — consumed by cron scheduler for precise error classification. */
     private _lastTerminalReason?;
     /** Per-session stall nudge — set after a query shows stall signals, consumed on the next query. */

package/dist/agent/assistant.js

@@ -17,6 +17,7 @@ import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE,
 import { summarizeIntegrationStatus } from '../config/integrations-registry.js';
 import { loadToolPreferences, computeAvailability, buildPromptInstruction, buildComposioStatusBlock, KNOWN_SERVICES, } from '../integrations/tool-preferences.js';
 import { loadClaudeIntegrations } from './mcp-bridge.js';
+import { getLatestMcpStatusSnapshot, recordMcpStatusFromSystemInit, invalidateMcpStatusEntry } from './run-agent.js';
 import { detectFrustrationSignals, detectRepeatedTopics } from './insight-engine.js';
 import { DEFAULT_CHANNEL_CAPABILITIES } from '../types.js';
 import { enforceToolPermissions, getSecurityPrompt, getHeartbeatSecurityPrompt, getCronSecurityPrompt, getHeartbeatDisallowedTools, logToolUse, logAuditJsonl, } from './hooks.js';
@@ -710,8 +711,10 @@ export class PersonalAssistant {
     memoryStore = null; // Typed as any — MemoryStore may not be available yet
     _lastUserMessage;
     onSkillProposed = null;
-    _lastMcpStatus = [];
-    _lastMcpStatusTime = '';
+    // PRD Phase 2 / 1.18.84: superseded by the shared module-level cache in
+    // run-agent.ts (getLatestMcpStatusSnapshot / recordMcpStatusFromSystemInit).
+    // The fields below were declared but never written pre-1.18.84; the
+    // module cache populates from every system/init message instead.
     /** Terminal reason from the last SDK query — consumed by cron scheduler for precise error classification. */
     _lastTerminalReason;
     /** Per-session stall nudge — set after a query shows stall signals, consumed on the next query. */
@@ -808,7 +811,12 @@ export class PersonalAssistant {
         this.onSkillProposed = cb;
     }
     getMcpStatus() {
-        return { servers: this._lastMcpStatus, updatedAt: this._lastMcpStatusTime };
+        // 1.18.84 correctness fix: delegate to the shared module-level cache.
+        // Pre-1.18.84 we returned this._lastMcpStatus, which was declared but
+        // never written — getMcpStatus() always returned empty. Now run-agent
+        // and assistant query streams record into a shared snapshot via
+        // recordMcpStatusFromSystemInit when the SDK init message lands.
+        return getLatestMcpStatusSnapshot();
     }
     /**
      * PRD Phase 2.1: clear the cached status for one server so the next query
@@ -818,12 +826,9 @@ export class PersonalAssistant {
      * stale error/auth state. Returns the post-clear cached snapshot.
      */
     invalidateMcpStatus(serverName) {
-        const beforeLen = this._lastMcpStatus.length;
-        this._lastMcpStatus = this._lastMcpStatus.filter((s) => s.name !== serverName);
-        const cleared = this._lastMcpStatus.length < beforeLen;
-        if (cleared)
-            this._lastMcpStatusTime = new Date().toISOString();
-        return { servers: this._lastMcpStatus, updatedAt: this._lastMcpStatusTime, cleared };
+        const result = invalidateMcpStatusEntry(serverName);
+        const snapshot = getLatestMcpStatusSnapshot();
+        return { servers: snapshot.servers, updatedAt: snapshot.updatedAt, cleared: result.cleared };
     }
     /** Inject a background work result into the session as silent follow-up context. */
     injectPendingContext(sessionKey, userPrompt, result) {
@@ -2999,6 +3004,15 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         const trace = [];
         const stream = query({ prompt, options: sdkOptions });
         for await (const message of stream) {
+            // 1.18.84 correctness: capture MCP server status from SDK init.
+            if (message.type === 'system' && message.subtype === 'init') {
+                const mcpServersRaw = message.mcp_servers;
+                if (mcpServersRaw)
+                    try {
+                        recordMcpStatusFromSystemInit(mcpServersRaw);
+                    }
+                    catch { /* non-fatal */ }
+            }
             if (message.type === 'assistant') {
                 const blocks = getContentBlocks(message);
                 for (const block of blocks) {

package/dist/agent/run-agent.d.ts

@@ -22,6 +22,21 @@
  *    long-task preflight, NO mode=unleashed wrapper.
  */
 import { type AgentDefinition } from '@anthropic-ai/claude-agent-sdk';
+/** Read the latest MCP status snapshot. Safe to call from any module. */
+export declare function getLatestMcpStatusSnapshot(): {
+    servers: Array<{
+        name: string;
+        status: string;
+    }>;
+    updatedAt: string;
+};
+/** Write a fresh snapshot. Called from system/init handlers. */
+export declare function recordMcpStatusFromSystemInit(rawMcpServers: unknown): void;
+/** Drop one server from the cache so the next query repopulates it. */
+export declare function invalidateMcpStatusEntry(name: string): {
+    cleared: boolean;
+    updatedAt: string;
+};
 import type { AgentProfile } from '../types.js';
 import type { AgentManager } from './agent-manager.js';
 import type { MemoryStore } from '../memory/store.js';

package/dist/agent/run-agent.js

@@ -24,6 +24,49 @@
 import path from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
+/**
+ * Module-level cache of MCP server statuses from the most recent SDK
+ * init message. Populated by every runAgent / PersonalAssistant query
+ * stream that captures `system/init`. Read by Assistant.getMcpStatus()
+ * and the dashboard's Tools & MCP catalog page.
+ *
+ * Pre-1.18.84 the assistant declared a private _lastMcpStatus but no
+ * code wrote to it — getMcpStatus() always returned empty, making the
+ * catalog status pills misleading. The shared module cache fixes that
+ * without coupling assistant.ts to runAgent's stream loop.
+ */
+let _lastMcpStatusSnapshot = {
+    servers: [],
+    updatedAt: '',
+};
+/** Read the latest MCP status snapshot. Safe to call from any module. */
+export function getLatestMcpStatusSnapshot() {
+    return { servers: [..._lastMcpStatusSnapshot.servers], updatedAt: _lastMcpStatusSnapshot.updatedAt };
+}
+/** Write a fresh snapshot. Called from system/init handlers. */
+export function recordMcpStatusFromSystemInit(rawMcpServers) {
+    if (!Array.isArray(rawMcpServers))
+        return;
+    const servers = [];
+    for (const entry of rawMcpServers) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        if (typeof e.name !== 'string' || !e.name)
+            continue;
+        servers.push({ name: e.name, status: typeof e.status === 'string' ? e.status : 'unknown' });
+    }
+    _lastMcpStatusSnapshot = { servers, updatedAt: new Date().toISOString() };
+}
+/** Drop one server from the cache so the next query repopulates it. */
+export function invalidateMcpStatusEntry(name) {
+    const before = _lastMcpStatusSnapshot.servers.length;
+    _lastMcpStatusSnapshot = {
+        servers: _lastMcpStatusSnapshot.servers.filter((s) => s.name !== name),
+        updatedAt: new Date().toISOString(),
+    };
+    return { cleared: _lastMcpStatusSnapshot.servers.length < before, updatedAt: _lastMcpStatusSnapshot.updatedAt };
+}
 import { BASE_DIR, PKG_DIR, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
 import { buildAgentMap } from './agent-definitions.js';
 const MCP_SERVER_SCRIPT = path.join(PKG_DIR, 'dist', 'tools', 'mcp-server.js');
@@ -229,6 +272,17 @@ export async function runAgent(prompt, opts) {
         for await (const message of stream) {
             if (message.type === 'system' && message.subtype === 'init') {
                 sessionId = message.session_id ?? '';
+                // PRD Phase 2 / 1.18.84 correctness: capture the SDK-reported MCP
+                // server status so getMcpStatus() (and the dashboard's Tools & MCP
+                // catalog) actually has data. The init message includes
+                // mcp_servers: Array<{ name, status }> per the SDK protocol.
+                const mcpServersRaw = message.mcp_servers;
+                if (mcpServersRaw) {
+                    try {
+                        recordMcpStatusFromSystemInit(mcpServersRaw);
+                    }
+                    catch { /* non-fatal */ }
+                }
                 logger.debug({ sessionKey: opts.sessionKey, sdkSessionId: sessionId }, 'runAgent: SDK session initialized');
                 continue;
             }

package/dist/cli/cron.js

@@ -140,6 +140,10 @@ export async function cmdCronRun(jobName) {
     try {
         const response = await gateway.handleCronJob(job.name, job.prompt, job.tier, job.maxTurns, job.model, job.workDir, job.mode, job.maxHours);
         const finishedAt = new Date();
+        // 1.18.84: trigger source comes from the CRON_RUN_TRIGGER env var set
+        // by the dashboard's manual-run endpoint. Defaults to 'scheduled' for
+        // any other invocation path (CLI, daemon-internal callsites).
+        const trigger = process.env.CRON_RUN_TRIGGER || 'scheduled';
         const entry = {
             jobName: job.name,
             startedAt: startedAt.toISOString(),
@@ -148,6 +152,7 @@ export async function cmdCronRun(jobName) {
             durationMs: finishedAt.getTime() - startedAt.getTime(),
             attempt: 1,
             outputPreview: response ? response.slice(0, 200) : undefined,
+            trigger,
         };
         // PRD Phase 1.1: goal-orientation evaluator (mirrors the daemon path).
         if (job.successSchema || (job.successCriteriaText && job.successCriteriaText.trim())) {
@@ -170,6 +175,7 @@ export async function cmdCronRun(jobName) {
     }
     catch (err) {
         const finishedAt = new Date();
+        const trigger = process.env.CRON_RUN_TRIGGER || 'scheduled';
         runLog.append({
             jobName: job.name,
             startedAt: startedAt.toISOString(),
@@ -179,6 +185,7 @@ export async function cmdCronRun(jobName) {
             error: String(err).slice(0, 500),
             errorType: classifyError(err),
             attempt: 1,
+            trigger,
         });
         console.error(`Error: ${err}`);
         process.exit(1);

package/dist/cli/dashboard.js

@@ -4613,7 +4613,8 @@ export async function cmdDashboard(opts) {
                 detached: true,
                 stdio: ['ignore', 'pipe', 'pipe'],
                 cwd: BASE_DIR,
-                env: { ...process.env, CLEMENTINE_HOME: BASE_DIR },
+                // 1.18.84: pass the trigger source so cron.ts stamps it on the run entry.
+                env: { ...process.env, CLEMENTINE_HOME: BASE_DIR, CRON_RUN_TRIGGER: 'manual' },
             });
             // Capture stderr for error reporting
             let stderr = '';
@@ -23811,12 +23812,13 @@ function renderRunListBody(allRuns) {
     var startedAt = entry.startedAt ? new Date(entry.startedAt) : null;
     var startedLabel = startedAt ? startedAt.toLocaleString() : '—';
     var durationLabel = entry.durationMs != null ? formatDurationMs(entry.durationMs) : '—';
-    // Trigger heuristic until we persist it for real (Phase 3.1):
-    //   'unleashed' mode + manual cron run = manual; otherwise scheduled.
-    // The cron-running.json sidecar already carries pid which can hint at
-    // manual but isn't on terminal entries. Best-effort label only.
-    var triggerLabel = entry.attempt > 1 ? 'retry' : 'scheduled';
-    var triggerColor = 'var(--text-muted)';
+    // 1.18.84: real persisted trigger field. Falls back to a heuristic for
+    // pre-1.18.84 run entries that don't have the field set.
+    var triggerLabel = entry.trigger || (entry.attempt > 1 ? 'retry' : 'scheduled');
+    var triggerColor = entry.trigger === 'manual' ? 'var(--accent)'
+      : entry.trigger === 'after' ? 'var(--purple)'
+      : entry.trigger === 'discord' ? 'var(--blue)'
+      : 'var(--text-muted)';
     // Goal cell
     var goalCell = '<div></div>';
     if (entry.goalCheck) {
@@ -23932,7 +23934,14 @@ async function refreshToolsMcpCatalog() {
   try {
     var sR = await apiFetch('/api/mcp-status');
     var statusJson = await sR.json();
-    statusMap = statusJson || {};
+    // /api/mcp-status returns { servers: [{name, status}], updatedAt }.
+    // Build a name → entry lookup so renderMcpCatalogCard can probe by name.
+    if (statusJson && Array.isArray(statusJson.servers)) {
+      for (var si = 0; si < statusJson.servers.length; si++) {
+        var entry = statusJson.servers[si];
+        if (entry && entry.name) statusMap[entry.name] = entry;
+      }
+    }
   } catch (e) { /* status is optional — servers still render without it */ }
   try {
     var lR = await apiFetch('/api/mcp-servers');

package/dist/gateway/cron-scheduler.js

@@ -888,7 +888,7 @@ export class CronScheduler {
             ctx.agentSlug = wf.agentSlug;
         return ctx;
     }
-    async runJob(job) {
+    async runJob(job, trigger = 'scheduled') {
         const creditBlock = getBackgroundCreditBlock();
         if (creditBlock) {
             logger.warn({ job: job.name, until: creditBlock.until }, 'Cron job skipped — Claude credit block active');
@@ -1206,6 +1206,8 @@ export class CronScheduler {
                         outputPreview: response ? response.slice(0, 200) : undefined,
                         advisorApplied,
                         terminalReason,
+                        // 1.18.84: persist the actual trigger source for the Run list filter.
+                        trigger,
                         // Trick capability metadata — surfaced by the dashboard's
                         // "ran with: …" line. Omit empty arrays to keep the JSONL light.
                         ...(cronMetadata?.skillsApplied?.length ? { skillsApplied: cronMetadata.skillsApplied } : {}),
@@ -1268,7 +1270,8 @@ export class CronScheduler {
                     const dependents = this.jobs.filter(j => j.after === job.name && j.enabled && !this.disabledJobs.has(j.name));
                     for (const dep of dependents) {
                         logger.info(`Chain: '${job.name}' succeeded — triggering '${dep.name}'`);
-                        this.runJob(dep).catch((err) => {
+                        // 1.18.84: chained-after triggers carry trigger='after' for the Run list filter.
+                        this.runJob(dep, 'after').catch((err) => {
                             logger.error({ err, job: dep.name }, `Chained job '${dep.name}' failed`);
                         });
                     }

package/dist/types.d.ts

@@ -447,6 +447,11 @@ export interface CronRunEntry {
     allowedToolsApplied?: string[];
     /** MCP servers live for this run (post profile + trick allowlist intersection). */
     mcpServersApplied?: string[];
+    /** PRD §6 / 1.18.84: how this run was triggered. Persisted by the
+     *  scheduler (cron tick / chained 'after' / manual-run endpoint /
+     *  Discord) so the Run list can filter by source instead of guessing
+     *  via heuristics on attempt count. */
+    trigger?: 'manual' | 'scheduled' | 'webhook' | 'api' | 'fork' | 'resume' | 'discord' | 'after';
     /** PRD Phase 1: did the run accomplish what it was supposed to?
      *  Computed at run-end when the Task has successSchema or successCriteriaText.
      *  - status='pass'      both configured checks passed (or the only one configured did)

package/package.json

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