clementine-agent 1.18.149 → 1.18.151

package/dist/agent/path-b-installer.d.ts

@@ -17,24 +17,39 @@
  *   hand-written project settings.
  *
  * Auth: the hook commands include the dashboard token in the X-Dashboard-Token
- * header. The token is baked into the curl command at install time. If the
- * dashboard restarts and rotates its token, the user has to re-enable hooks
- * (a small UX cost we accept; the alternative is having hooks read the
- * token from disk at fire-time which adds a syscall to every tool call).
+ * header. As of 1.18.151 the token is read from disk at fire-time via
+ * `$(cat ~/.clementine/.dashboard-token)` instead of being baked into the
+ * curl command at install time. The token-file path is interpolated at
+ * install time, but its CONTENT is read on every hook fire — so dashboard
+ * token rotation (which `clementine update restart` does) no longer breaks
+ * installed hooks. The dashboard already maintains this file at startup
+ * (dashboard.ts:2097-2098); we just point the curl at it.
+ *
+ * The cost is one tiny `cat` syscall per tool call — negligible compared to
+ * the curl + dashboard ingestion already happening. The win is no more
+ * silent 401s when the token rotates.
  */
+/** Bumped on every meaningful template change. Heartbeat reads installed
+ *  files' `_clementine.installerVersion` and surfaces a re-install nudge
+ *  when it lags this constant — see heartbeat.ts (1.18.151 stale-template
+ *  detector). We never overwrite user-facing files silently; the user runs
+ *  `clementine hooks install` to opt into the new template. */
+export declare const CURRENT_INSTALLER_VERSION = "1.18.151";
 export interface SettingsTemplateOptions {
-    /** Dashboard token to include in the X-Dashboard-Token header. Required. */
-    token: string;
     /** Localhost port the dashboard is listening on. Defaults to 3030. */
     port?: number;
     /** Mark the file with a comment so users know who wrote it. */
     installerVersion?: string;
+    /** Absolute path to the token file the curl will `cat` at fire time.
+     *  Override is for tests; production always uses the canonical
+     *  ~/.clementine/.dashboard-token. */
+    tokenFilePath?: string;
 }
 /** Build the JSON content of .claude/settings.local.json. The shape matches
  *  the SDK's hook config schema: a top-level `hooks` map keyed by event name,
  *  each value an array of `{ hooks: [{ type, command }] }` matchers. The
  *  empty matcher means "always fire". */
-export declare function buildSettingsTemplate(opts: SettingsTemplateOptions): Record<string, unknown>;
+export declare function buildSettingsTemplate(opts?: SettingsTemplateOptions): Record<string, unknown>;
 export interface InstallResult {
     ok: boolean;
     filePath: string;
@@ -47,8 +62,12 @@ export interface InstallResult {
 }
 /** Write/update .claude/settings.local.json in `workDir`. If the file
  *  already exists and is NOT installer-managed (no _clementine key), we
- *  bail out and refuse to overwrite to avoid clobbering user content. */
-export declare function installPathBHooks(workDir: string, opts: SettingsTemplateOptions): InstallResult;
+ *  bail out and refuse to overwrite to avoid clobbering user content.
+ *
+ *  As of 1.18.151 no token is required at install time — the curl reads
+ *  the live token from disk at fire time. Callers can pass tokenFilePath
+ *  to override the default `~/.clementine/.dashboard-token` (tests). */
+export declare function installPathBHooks(workDir: string, opts?: SettingsTemplateOptions): InstallResult;
 export interface HooksStatus {
     /** Whether a settings.local.json exists in the workDir. */
     installed: boolean;

package/dist/agent/path-b-installer.js

@@ -17,18 +17,28 @@
  *   hand-written project settings.
  *
  * Auth: the hook commands include the dashboard token in the X-Dashboard-Token
- * header. The token is baked into the curl command at install time. If the
- * dashboard restarts and rotates its token, the user has to re-enable hooks
- * (a small UX cost we accept; the alternative is having hooks read the
- * token from disk at fire-time which adds a syscall to every tool call).
+ * header. As of 1.18.151 the token is read from disk at fire-time via
+ * `$(cat ~/.clementine/.dashboard-token)` instead of being baked into the
+ * curl command at install time. The token-file path is interpolated at
+ * install time, but its CONTENT is read on every hook fire — so dashboard
+ * token rotation (which `clementine update restart` does) no longer breaks
+ * installed hooks. The dashboard already maintains this file at startup
+ * (dashboard.ts:2097-2098); we just point the curl at it.
+ *
+ * The cost is one tiny `cat` syscall per tool call — negligible compared to
+ * the curl + dashboard ingestion already happening. The win is no more
+ * silent 401s when the token rotates.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 /** Hooks we install. Picked for the latency dashboard's needs:
  *  PreToolUse + PostToolUse give us tool durations (PostToolUse carries
  *  duration_ms). SubagentStart/Stop close the gap path C handles via
  *  transcript backfill. Stop / Notification add nice-to-have signal but
- *  are minimal cost. */
+ *  are minimal cost. PreCompact + PostCompact (added 1.18.151) carry
+ *  compaction telemetry — pre/post tokens, summary text, trigger source —
+ *  which the run-detail viewer surfaces as "what got summarized away". */
 const HOOK_EVENTS = [
     'PreToolUse',
     'PostToolUse',
@@ -39,18 +49,33 @@ const HOOK_EVENTS = [
     'UserPromptSubmit',
     'SessionStart',
     'PreCompact',
+    'PostCompact',
 ];
+/** Bumped on every meaningful template change. Heartbeat reads installed
+ *  files' `_clementine.installerVersion` and surfaces a re-install nudge
+ *  when it lags this constant — see heartbeat.ts (1.18.151 stale-template
+ *  detector). We never overwrite user-facing files silently; the user runs
+ *  `clementine hooks install` to opt into the new template. */
+export const CURRENT_INSTALLER_VERSION = '1.18.151';
+/** Default location of the dashboard token file. The dashboard writes this
+ *  on every startup (see dashboard.ts:2097-2098). Hooks read it at fire
+ *  time via `$(cat …)` so token rotations propagate without re-installing. */
+const DEFAULT_TOKEN_FILE = path.join(os.homedir(), '.clementine', '.dashboard-token');
 /** Build the JSON content of .claude/settings.local.json. The shape matches
  *  the SDK's hook config schema: a top-level `hooks` map keyed by event name,
  *  each value an array of `{ hooks: [{ type, command }] }` matchers. The
  *  empty matcher means "always fire". */
-export function buildSettingsTemplate(opts) {
+export function buildSettingsTemplate(opts = {}) {
     const port = opts.port ?? 3030;
+    const tokenFile = opts.tokenFilePath ?? DEFAULT_TOKEN_FILE;
     // Use POSIX `curl` — preinstalled on macOS and most Linuxes; Windows users
     // running WSL or Git Bash also have it. We add `--max-time 2` so a
-    // wedged dashboard can't stall the SDK's tool execution.
+    // wedged dashboard can't stall the SDK's tool execution. The
+    // `$(cat … 2>/dev/null)` substitution reads the live dashboard token at
+    // fire time; if the file is briefly missing during startup the curl
+    // sends an empty token and the dashboard 401s harmlessly (no SDK break).
     const curlCmd = `curl -s --max-time 2 -X POST `
-        + `-H "X-Dashboard-Token: ${opts.token}" `
+        + `-H "X-Dashboard-Token: $(cat ${tokenFile} 2>/dev/null)" `
         + `-H "Content-Type: application/json" `
         + `--data-binary @- `
         + `http://127.0.0.1:${port}/api/hooks/event`;
@@ -70,7 +95,7 @@ export function buildSettingsTemplate(opts) {
         _clementine: {
             managedBy: 'clementine-agent path-b-installer',
             installedAt: new Date().toISOString(),
-            installerVersion: opts.installerVersion ?? '1.18.102',
+            installerVersion: opts.installerVersion ?? CURRENT_INSTALLER_VERSION,
             port,
         },
         hooks,
@@ -78,12 +103,14 @@ export function buildSettingsTemplate(opts) {
 }
 /** Write/update .claude/settings.local.json in `workDir`. If the file
  *  already exists and is NOT installer-managed (no _clementine key), we
- *  bail out and refuse to overwrite to avoid clobbering user content. */
-export function installPathBHooks(workDir, opts) {
+ *  bail out and refuse to overwrite to avoid clobbering user content.
+ *
+ *  As of 1.18.151 no token is required at install time — the curl reads
+ *  the live token from disk at fire time. Callers can pass tokenFilePath
+ *  to override the default `~/.clementine/.dashboard-token` (tests). */
+export function installPathBHooks(workDir, opts = {}) {
     if (!workDir)
         return { ok: false, filePath: '', wasExisting: false, wasUpdate: false, error: 'workDir required' };
-    if (!opts.token)
-        return { ok: false, filePath: '', wasExisting: false, wasUpdate: false, error: 'token required' };
     const dir = path.join(workDir, '.claude');
     const file = path.join(dir, 'settings.local.json');
     let wasExisting = false;

package/dist/agent/self-improve.js

@@ -2054,13 +2054,29 @@ export class SelfImproveLoop {
             }
         }
         catch { /* non-fatal */ }
-        // Identify consistently failed approaches
+        // Identify consistently failed approaches.
+        // 1.18.150 — exact-string Set dedup let near-duplicate hypotheses ("improve
+        // cron prompt clarity" vs "improve cron prompt for clarity") both make it
+        // through and waste two of the five slots. Use the existing tokenize +
+        // jaccard helpers (Set ≥0.85 collapse) to merge near-duplicates while
+        // preserving genuinely distinct framings.
         const failedHypotheses = history
             .filter(e => !e.accepted && e.score < 0.3 && !e.type)
             .map(e => e.hypothesis.slice(0, 80));
         if (failedHypotheses.length > 0) {
             lines.push('\n### Approaches That Scored Poorly (avoid these)');
-            for (const h of [...new Set(failedHypotheses)].slice(0, 5)) {
+            const merged = [];
+            const mergedTokens = [];
+            for (const h of failedHypotheses) {
+                const ht = tokenizeForDrift(h);
+                if (mergedTokens.some(t => jaccardSimilarity(t, ht) >= 0.85))
+                    continue;
+                merged.push(h);
+                mergedTokens.push(ht);
+                if (merged.length >= 5)
+                    break;
+            }
+            for (const h of merged) {
                 lines.push(`- "${h}"`);
             }
         }

package/dist/cli/dashboard.js

@@ -5451,7 +5451,10 @@ export async function cmdDashboard(opts) {
             }
             const port = Number(process.env.PORT) || 3030;
             const { installPathBHooks } = await import('../agent/path-b-installer.js');
-            const result = installPathBHooks(job.workDir, { token: dashboardToken, port });
+            // 1.18.151 — token no longer baked into hook command (read from
+            // ~/.clementine/.dashboard-token at fire time). Path-b installer
+            // takes only port + version sentinel now.
+            const result = installPathBHooks(job.workDir, { port });
             if (!result.ok) {
                 res.status(409).json({ ...result, ok: false });
                 return;
@@ -6693,6 +6696,29 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                     ? body.tool_response.slice(0, 500)
                     : 'tool returned is_error=true';
             }
+            // 1.18.151 — compaction telemetry. PreCompact carries trigger +
+            // optional custom_instructions; PostCompact carries the summary text
+            // and pre/post token counts. We promote these to top-level fields so
+            // the run-detail viewer can render a "summarized N→M tokens" marker
+            // without needing to re-parse the original SDK payload shape.
+            if (hookEventName === 'PreCompact') {
+                ev.kind = 'pre_compact';
+                if (typeof body.trigger === 'string')
+                    ev.compactTrigger = body.trigger;
+                if (typeof body.custom_instructions === 'string')
+                    ev.compactInstructions = body.custom_instructions;
+            }
+            else if (hookEventName === 'PostCompact') {
+                ev.kind = 'post_compact';
+                if (typeof body.trigger === 'string')
+                    ev.compactTrigger = body.trigger;
+                if (typeof body.compact_summary === 'string')
+                    ev.compactSummary = body.compact_summary;
+                if (typeof body.pre_tokens === 'number')
+                    ev.preTokens = body.pre_tokens;
+                if (typeof body.post_tokens === 'number')
+                    ev.postTokens = body.post_tokens;
+            }
             entry.eventLog.append(ev);
             res.json({ ok: true, runId: entry.runId, seq });
         }
@@ -27293,10 +27319,13 @@ function renderRunDetailWaterfall(events, runId, jobName) {
     if (k === 'subagent_start' || k === 'subagent_stop') return '#a855f7';
     if (k === 'rate_limit') return 'var(--yellow)';
     if (k === 'hook') return 'var(--blue)';
+    if (k === 'pre_compact' || k === 'post_compact') return 'var(--orange, #f59e0b)';
     if (k === 'error') return 'var(--red)';
     return 'var(--text-muted)';
   }
   function kindLabel(k) {
+    if (k === 'pre_compact') return 'COMPACT START';
+    if (k === 'post_compact') return 'COMPACT DONE';
     return (k || 'event').toUpperCase().replace(/_/g, ' ');
   }
 
@@ -27369,6 +27398,29 @@ function renderRunDetailWaterfall(events, runId, jobName) {
       preview = ev.sessionId ? 'session ' + String(ev.sessionId).slice(0, 8) + '…' : '';
     } else if (ev.kind === 'session_end') {
       preview = '$' + (ev.costUsd != null ? ev.costUsd.toFixed(4) : '?') + ' · ' + (ev.stopReason || '?');
+    } else if (ev.kind === 'pre_compact') {
+      // 1.18.151 — PreCompact telemetry. Trigger tells us whether the SDK
+      // auto-compacted to stay under context limits or the user/agent
+      // requested it. custom_instructions, when present, biases what gets
+      // preserved — surface it inline so debugging "why did this run forget
+      // X?" is one click away.
+      preview = '⤓ compaction starting (' + (ev.compactTrigger || '?') + ')';
+      fullContent = ev.compactInstructions
+        ? 'Custom instructions for compaction:\\n' + String(ev.compactInstructions)
+        : 'No custom instructions — SDK uses its default summarization.';
+    } else if (ev.kind === 'post_compact') {
+      // 1.18.151 — PostCompact carries the summary text + token deltas.
+      // Showing pre→post tokens makes compaction efficiency visible at a
+      // glance; the summary itself is the canonical "what got remembered"
+      // record for the rest of the run.
+      var tokenDelta = '';
+      if (typeof ev.preTokens === 'number' && typeof ev.postTokens === 'number') {
+        tokenDelta = ' · ' + ev.preTokens.toLocaleString() + '→' + ev.postTokens.toLocaleString() + ' tokens';
+      }
+      preview = '⤴ compaction done' + tokenDelta;
+      fullContent = ev.compactSummary
+        ? 'Summary the SDK kept:\\n\\n' + String(ev.compactSummary)
+        : '(no summary text returned)';
     }
 
     var rowId = 'run-evt-' + j;

package/dist/memory/maintenance.js

@@ -159,6 +159,39 @@ export async function runStartupMaintenance(store) {
     catch (err) {
         logger.warn({ err }, 'Startup .md.bak sweep failed');
     }
+    // Path-B installer-version sweep (1.18.151). For every cron with a workDir
+    // that has a clementine-managed .claude/settings.local.json, check whether
+    // the installerVersion sentinel matches CURRENT_INSTALLER_VERSION. Any
+    // older install is missing the token-at-fire-time fix and will silently
+    // 401 against /api/hooks/event after the next dashboard token rotation.
+    // We log once per startup with the list of paths so the user knows to
+    // re-run `clementine hooks install` (we never silently overwrite — user
+    // owns their .claude/).
+    try {
+        const { parseCronJobs } = await import('../gateway/cron-scheduler.js');
+        const { getHooksStatus, CURRENT_INSTALLER_VERSION } = await import('../agent/path-b-installer.js');
+        const stale = [];
+        const seen = new Set();
+        for (const job of parseCronJobs()) {
+            if (!job.workDir || seen.has(job.workDir))
+                continue;
+            seen.add(job.workDir);
+            const s = getHooksStatus(job.workDir);
+            if (s.managedByUs && s.installerVersion !== CURRENT_INSTALLER_VERSION) {
+                stale.push({ workDir: job.workDir, installerVersion: s.installerVersion });
+            }
+        }
+        if (stale.length > 0) {
+            logger.warn({
+                stale,
+                currentVersion: CURRENT_INSTALLER_VERSION,
+                action: 'Re-run `clementine hooks install` per project to pick up the token-at-fire-time fix (1.18.151) — until then those projects 401 silently after each dashboard token rotation.',
+            }, 'Path-B hook installs are stale');
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'Path-B stale-version sweep failed');
+    }
     // Embedding warm-up — pre-embed the most-cited chunks in the background so
     // the first retrievals after startup don't pay cold-start latency. Fire
     // and forget; never blocks startup.

package/dist/tools/admin-tools.js

@@ -325,7 +325,7 @@ export function registerAdminTools(server) {
         const unique = [...new Set(tools)].sort();
         writeFileSync(ALLOWED_TOOLS_EXTRA, JSON.stringify(unique, null, 2));
     }
-    server.tool('allow_tool', 'Add a tool name to your self-managed allowedTools list. Use when you see a tool in the SDK inventory but get "not in function schema" when you try to call it. Writes to ~/.clementine/allowed-tools-extra.json; takes effect on your NEXT query. If the tool name isn\'t yet in the cached inventory, this auto-refreshes the probe first — covers the case where the owner just added a new claude.ai connector or local MCP server. Owner-DM only.', {
+    server.tool('allow_tool', 'Add a tool name to your self-managed allowedTools list (~/.clementine/allowed-tools-extra.json). Use when an SDK-inventory tool returns "not in function schema". Effective on your next query. Auto-refreshes the inventory probe if the tool isn\'t cached. Owner-DM only.', {
         name: z.string().describe('Exact tool name (e.g. "mcp__claude_ai_Google_Drive__search_files")'),
         reason: z.string().optional().describe('Brief note: why you need this tool. For audit trail.'),
     }, async ({ name, reason }) => {
@@ -368,7 +368,7 @@ export function registerAdminTools(server) {
         logger.info({ name: trimmed, reason, totalExtras: current.length }, 'allow_tool');
         return textResult(`Added ${trimmed} to ~/.clementine/allowed-tools-extra.json (${current.length} total extras)${refreshNote}. Active on your next query — no daemon restart needed.${reason ? ` Reason: ${reason}` : ''}`);
     });
-    server.tool('refresh_tool_inventory', 'Force a fresh probe of the SDK\'s tool inventory, picking up any claude.ai connectors, Composio toolkits, or local MCP servers the owner has added since the last cache refresh. Owner-DM only. Use this when the owner says "I just added X at claude.ai" or when an expected integration isn\'t showing up. Updates ~/.clementine/.tool-inventory.json and syncs claude-integrations.json. Returns a diff of what changed.', {}, async () => {
+    server.tool('refresh_tool_inventory', 'Force a fresh probe of the SDK tool inventory to pick up newly added claude.ai connectors, Composio toolkits, or local MCP servers. Updates ~/.clementine/.tool-inventory.json + syncs claude-integrations.json and returns a diff. Owner-DM only.', {}, async () => {
         const gate = requireOwnerDm();
         if (!gate.ok)
             return textResult(gate.message);
@@ -1025,7 +1025,7 @@ export function registerAdminTools(server) {
         return textResult(lines.join('\n\n'));
     });
     // ── Add Cron Job ────────────────────────────────────────────────────────
-    server.tool('add_cron_job', 'Add a new scheduled task. ⚠ BEFORE CALLING THIS TOOL: propose the concrete plan to the user in chat and get explicit approval. The `prompt` you save should be SELF-CONTAINED — list the actual recipients, the actual template/content, the actual criteria. AVOID vague references like "recent leads" or "this week\'s items" that the trick will re-derive at fire-time, because re-derivation reads from MEMORY.md which drifts between chat-time agreement and fire-time execution. Good prompt: "Send template `monday-followup` to alice@x.com, bob@y.com, carol@z.com." Bad prompt: "Send follow-up to recent leads." The default `predictable: true` mode runs the trick with ONLY the prompt + explicitly-attached skills/tools — no MEMORY.md, no team-comms injection, no runtime skill auto-match. Set `predictable: false` ONLY if the user explicitly wants a dynamic trick that re-resolves data each fire (e.g., "summarize yesterday\'s daily note" where the data legitimately changes).', {
+    server.tool('add_cron_job', 'Add a new scheduled task. Propose the plan in chat and get user approval first. The `prompt` MUST be self-contained: name the actual recipients, template, and criteria — vague references ("recent leads", "this week\'s items") drift between chat-time and fire-time. Default `predictable: true` runs with only prompt + pinned skills/tools (no MEMORY.md, no auto-match). Set `predictable: false` only when the user explicitly wants dynamic re-resolution each fire.', {
         name: z.string().describe('Job name (unique identifier)'),
         schedule: z.string().describe('Cron expression (e.g., "0 9 * * 1" for Monday 9 AM)'),
         prompt: z.string().describe('The prompt/instruction for the assistant to execute. SHOULD BE CONCRETE — list actual recipients, criteria, content. Vague prompts re-derive at fire-time and cause "agent agreed in chat but emailed wrong people" failures.'),
@@ -1143,7 +1143,7 @@ export function registerAdminTools(server) {
         return textResult(`Added cron job "${jobName}":\n${details.join('\n')}\n\n${verifyMsg}${goalHint}`);
     });
     // ── Update Cron Job ─────────────────────────────────────────────────────
-    server.tool('update_cron_job', 'Update an existing cron job in CRON.md. Partial — only fields you supply change. To CLEAR a capability allowlist (skills/allowed_tools/allowed_mcp_servers/tags), pass an empty array. To clear category, pass an empty string. The daemon auto-reloads on file change. Use preview_cron_job to confirm what will run before the next fire. ⚠ Flipping `predictable` from true to false changes whether the trick reads MEMORY.md at fire-time — make sure the user understands the tradeoff before you toggle it.', {
+    server.tool('update_cron_job', 'Update an existing cron job in CRON.md. Partial — only fields you supply change. Pass an empty array to clear a capability allowlist (skills/allowed_tools/allowed_mcp_servers/tags); empty string clears category. Daemon auto-reloads. Run preview_cron_job before relying on the change. Flipping `predictable` true→false makes the trick read MEMORY.md at fire-time — confirm the tradeoff with the user.', {
         name: z.string().describe('Existing job name to update.'),
         schedule: z.string().optional().describe('New cron expression.'),
         prompt: z.string().optional().describe('New prompt.'),
@@ -1279,7 +1279,7 @@ export function registerAdminTools(server) {
         return textResult(`Updated cron job "${jobName}":\n  ${changed.join('\n  ')}\n\nDaemon will pick up the new definition within ~2s. Use \`preview_cron_job\` to confirm what will actually run.`);
     });
     // ── Preview Cron Job ────────────────────────────────────────────────────
-    server.tool('preview_cron_job', 'Show EXACTLY what a cron job ("trick") will send the agent on its next fire — without dispatching to the agent. Composes the same context blocks (memory, progress, goals, skills, team, criteria, prompt, how-to-respond) the runner would compose at fire time. Returns the built prompt + resolved skills (full content) + effective tool/MCP allowlists + warnings (missing pins). Use this to sanity-check tricks after configuring them via chat or the dashboard, especially when you want predictable morning behavior.', {
+    server.tool('preview_cron_job', 'Show what a cron job will send the agent on its next fire without dispatching. Composes the same context blocks the runner uses at fire time and returns the built prompt + resolved skills + effective tool/MCP allowlists + warnings. Use to sanity-check tricks after configuration.', {
         name: z.string().describe('Exact name of the cron job to preview (use list_cron_jobs to see available).'),
     }, async ({ name: jobName }) => {
         const [{ parseCronJobs, parseAgentCronJobs }, { buildCronExecutionPlan }, { loadSkillByName }, { discoverMcpServers }] = await Promise.all([

package/package.json

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