clementine-agent 1.18.190 → 1.18.192

package/dist/agent/assistant.js

@@ -13,7 +13,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { query as rawQuery, listSubagents, getSubagentMessages, SYSTEM_PROMPT_DYNAMIC_BOUNDARY, } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
-import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, BUDGET, TASK_BUDGET_TOKENS, currentTimeZone, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, claudeCodeDisableOneMillionForModel, currentOneMillionContextMode, normalizeClaudeModelForOneMillionContext, normalizeClaudeSdkOptionsForOneMillionContext, looksLikeClaudeOneMillionContextError, envSnapshot, } from '../config.js';
+import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, BUDGET, TASK_BUDGET_TOKENS, currentTimeZone, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, claudeCodeDisableOneMillionForModel, claudeCodeSystemPrompt, currentOneMillionContextMode, normalizeClaudeModelForOneMillionContext, normalizeClaudeSdkOptionsForOneMillionContext, looksLikeClaudeOneMillionContextError, envSnapshot, } from '../config.js';
 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';
@@ -2841,7 +2841,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             const stream = query({
                 prompt: memPrompt,
                 options: {
-                    systemPrompt: 'You are a silent memory extraction agent. Save facts to the vault and exit.',
+                    // 1.18.192 — preset form so Haiku call uses Claude Code subscription
+                    // auth. Without this, every chat exchange's auto-memory extractor
+                    // hit "Not logged in" silently in the background.
+                    systemPrompt: claudeCodeSystemPrompt('You are a silent memory extraction agent. Save facts to the vault and exit.', { minimal: true }),
                     model: AUTO_MEMORY_MODEL,
                     permissionMode: 'dontAsk',
                     // MCP tool names live in allowedTools, not tools. See note at
@@ -3092,7 +3095,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             const stream = query({
                 prompt: reflectionPrompt,
                 options: {
-                    systemPrompt: 'You are a task output verifier. Assess the output quality.',
+                    // 1.18.192 — preset form so the verifier authenticates via the
+                    // Claude Code subscription. Every cron-job reflection was silently
+                    // skipping verification before this fix.
+                    systemPrompt: claudeCodeSystemPrompt('You are a task output verifier. Assess the output quality.', { minimal: true }),
                     model: MODELS.haiku,
                     permissionMode: 'dontAsk',
                     tools: [],

package/dist/agent/bg-planner.js

@@ -44,7 +44,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import pino from 'pino';
-import { BASE_DIR, MODELS, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext } from '../config.js';
+import { BASE_DIR, MODELS, applyOneMillionContextRecovery, claudeCodeSystemPrompt, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext } from '../config.js';
 const logger = pino({ name: 'clementine.bg-planner' });
 // ── Persistence ──────────────────────────────────────────────────────
 /**
@@ -268,12 +268,25 @@ function buildPlannerUserPrompt(opts) {
 async function runPlannerLlm(userPrompt, systemPrompt, model) {
     const { query } = await import('@anthropic-ai/claude-agent-sdk');
     let text = '';
+    // 1.18.192 — CRITICAL: use the `claude_code` preset for systemPrompt
+    // so this query uses Claude Code subscription auth (Max plan etc.).
+    // Raw `systemPrompt: string` tells the SDK to use API-key auth, which
+    // 99% of installs don't have configured — they're logged into Claude
+    // Code, not the Anthropic API. This was the "Not logged in · Please
+    // run /login" failure Ross's owner hit on 2026-05-12.
+    //
+    // The preset injects Claude Code's default system prompt; our planning
+    // instructions go in `append` and dominate behavior for the single
+    // turn (maxTurns: 1, so no agentic loop where bleed could compound).
     const stream = query({
         prompt: userPrompt,
         options: normalizeClaudeSdkOptionsForOneMillionContext({
             model,
             maxTurns: 1, // single shot — emit JSON, done
-            systemPrompt,
+            // Planner uses the full preset (not `minimal`) — the planner benefits
+            // from knowing the working directory + git status so it can decompose
+            // accurately. See claudeCodeSystemPrompt() in config.ts.
+            systemPrompt: claudeCodeSystemPrompt(systemPrompt),
         }),
     });
     for await (const msg of stream) {

package/dist/agent/clementine-turn-context.d.ts

@@ -85,6 +85,13 @@ export interface BuildTurnContextOptions {
      *  source/output file inventory, and deploy.json summary (if any).
      *  Set by the router's resolver before the chat call. */
     activeProject?: ProjectMeta | null;
+    /** 1.18.191 — message shape from intent-classifier. When 'simple',
+     *  we skip the heavyweight sections (memory recall, bg-task headlines,
+     *  dispute gate) and only emit identity + live state. Saves ~3-4KB
+     *  of injected tokens per routine chat turn. 'multi-step' and
+     *  'unknown' keep the full block. Defaults to 'unknown' = full block
+     *  for back-compat. */
+    messageShape?: 'simple' | 'multi-step' | 'unknown';
 }
 export interface BuildTurnContextResult {
     /** The full ready-to-prepend context block, INCLUDING outer

package/dist/agent/clementine-turn-context.js

@@ -68,12 +68,26 @@ export function buildClementineTurnContext(opts) {
     const parts = [];
     const nowMs = (opts.now ?? Date.now)();
     const nowDate = new Date(nowMs);
+    // 1.18.191 — intent-aware section gating. For 'simple' messages
+    // (one-line questions, casual chat, brief asks), the heavy sections
+    // (memory recall, bg-task headlines, dispute gate) are skipped so
+    // every routine turn doesn't pay 3-4KB of injected tokens for
+    // context the model doesn't need. Identity + live state still
+    // render — they're cheap and always useful. Active project still
+    // renders when the message references it. 'multi-step' and
+    // 'unknown' keep the full block.
+    const messageShape = opts.messageShape ?? 'unknown';
+    const isSimpleMessage = messageShape === 'simple';
     // 1.18.187 — detect dispute pattern (Part E). When the owner is
     // reporting a failure of prior work, we want to suppress "past
     // success" recall items (they bias the model toward defending its
     // memory instead of verifying reality) and add a verification
     // directive at the top of the block.
-    const disputeDetected = detectDisputePattern(opts.userMessage);
+    // 1.18.191 — also suppressed for 'simple' shape since dispute
+    // patterns rarely co-occur with simple messages, and the gate
+    // produces a multi-paragraph directive we don't want to inject
+    // when the message is just "what time is it".
+    const disputeDetected = !isSimpleMessage && detectDisputePattern(opts.userMessage);
     sections.disputeDetected = disputeDetected;
     if (disputeDetected) {
         parts.push('### Dispute mode — verification posture\n' +
@@ -103,7 +117,14 @@ export function buildClementineTurnContext(opts) {
     // hits from the SQLite memory store, scored against the user's
     // current message. Without this, Clementine has no automatic recall
     // — she'd have to spontaneously call memory_search every turn.
-    if (opts.memoryStore?.searchContext && opts.userMessage.trim().length > 0) {
+    //
+    // 1.18.191 — skipped for 'simple' messages. "What time is it" doesn't
+    // need 6 memory hits injected; she has the recall tools and can call
+    // them on demand when the message warrants it. Saves ~2KB/turn on
+    // routine chat. The owner's own posture directive
+    // (BEHAVIORAL_POSTURE in run-agent-context.ts) tells the model to
+    // call memory_search proactively when relevant — that still works.
+    if (!isSimpleMessage && opts.memoryStore?.searchContext && opts.userMessage.trim().length > 0) {
         try {
             const hits = opts.memoryStore.searchContext(opts.userMessage, {
                 limit: MAX_MEMORY_HITS,
@@ -139,7 +160,12 @@ export function buildClementineTurnContext(opts) {
     // that bias the model toward "but my memory says it succeeded."
     // Failed/aborted/interrupted tasks STAY because they're useful
     // signal for the verification posture.
-    if (opts.listBackgroundTasks) {
+    //
+    // 1.18.191 — skipped for 'simple' messages. Routine chat doesn't
+    // need to know what bg tasks landed in the last 24h. If the user
+    // asks "what happened with X" — that's a multi-step / unknown
+    // shape, this section will fire normally.
+    if (!isSimpleMessage && opts.listBackgroundTasks) {
         try {
             const TERMINAL = disputeDetected
                 ? ['failed', 'interrupted', 'aborted']

package/dist/agent/daily-planner.js

@@ -8,7 +8,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
-import { BASE_DIR, CRON_REFLECTIONS_DIR, TASKS_FILE, INBOX_DIR, MODELS, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
+import { BASE_DIR, CRON_REFLECTIONS_DIR, TASKS_FILE, INBOX_DIR, MODELS, applyOneMillionContextRecovery, claudeCodeSystemPrompt, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
 import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.daily-planner' });
 const PLANS_DIR = path.join(BASE_DIR, 'plans', 'daily');
@@ -256,7 +256,9 @@ Rules:
                 options: normalizeClaudeSdkOptionsForOneMillionContext({
                     model: MODELS.haiku,
                     maxTurns: 1,
-                    systemPrompt: 'You are a planning assistant. Analyze the context and produce a prioritized daily plan as JSON. Return only valid JSON, no markdown fencing.',
+                    // 1.18.192 — preset form so SDK uses Claude Code subscription auth
+                    // (raw string → API-key auth → "Not logged in" failure for Max users).
+                    systemPrompt: claudeCodeSystemPrompt('You are a planning assistant. Analyze the context and produce a prioritized daily plan as JSON. Return only valid JSON, no markdown fencing.', { minimal: true }),
                 }),
             });
             for await (const msg of stream) {

package/dist/agent/intent-classifier.d.ts

@@ -31,6 +31,51 @@ export declare function classifyIntent(text: string, recentExchanges?: Array<{
  * Injected into the system prompt to steer the agent's response style.
  */
 export declare function getStrategyGuidance(strategy: ResponseStrategy): string;
+export type MessageShape = 
+/** Single ask, single response. "what time is it", "remind me to call X". */
+'simple'
+/** Multiple distinct actions across phases. "send 25 emails after
+ *  scraping data from Salesforce and SEO sources, then summarize". */
+ | 'multi-step'
+/** Ambiguous — falls through to today's full chat path (safe default). */
+ | 'unknown';
+export interface MessageShapeResult {
+    shape: MessageShape;
+    score: number;
+    reasons: string[];
+}
+/**
+ * Classify a chat message's structural shape (simple / multi-step).
+ *
+ * Scoring (sum of triggered signals):
+ *   - 2+ shape-action verbs: +1
+ *   - 3+ shape-action verbs: +2 cumulatively
+ *   - each sequence marker ("and then", "after that"): +1 (up to +2)
+ *   - batch marker ("for each", "25 emails"): +1
+ *   - numbered list: +2
+ *   - 2+ distinct integration domains in same message: +1
+ *   - length > 200 chars: +1
+ *   - length > 500 chars: +2 cumulatively
+ *
+ * Decision:
+ *   - score >= threshold (default 3) → 'multi-step'
+ *   - score === 0 AND <= 1 action verb AND length <= 200 → 'simple'
+ *   - otherwise → 'unknown' (today's chat path, no change)
+ */
+export declare function classifyMessageShape(text: string, opts?: {
+    threshold?: number;
+}): MessageShapeResult;
+/**
+ * Detect whether the user's message is approving / revising / canceling
+ * a pending plan. Used by the chat-side plan-mode state machine when
+ * `sess.planAwaitingApproval` is set.
+ *
+ * Conservative: only short, clearly-affirmative messages qualify as
+ * approval. "yes but also do X" is NOT approval — it's a revision
+ * request and the state machine should re-plan with the feedback.
+ */
+export type PlanApprovalSignal = 'approve' | 'revise' | 'cancel' | 'other';
+export declare function detectPlanApproval(message: string): PlanApprovalSignal;
 /**
  * Generate a follow-up suggestion prompt suffix based on completed work.
  *

package/dist/agent/intent-classifier.js

@@ -188,6 +188,150 @@ No tool calls needed. Just be conversational.
 If there's relevant context from recent work or pending items, briefly mention it.`;
     }
 }
+/** Action verbs that strongly suggest "do work" rather than "answer". */
+const SHAPE_ACTION_VERBS = [
+    'send', 'create', 'build', 'generate', 'write', 'draft', 'compose',
+    'publish', 'deploy', 'upload', 'post', 'push',
+    'scrape', 'fetch', 'pull', 'extract', 'gather', 'collect',
+    'convert', 'merge', 'combine', 'transform', 'consolidate', 'aggregate',
+    'schedule', 'queue', 'run', 'execute', 'process',
+    'email', 'message', 'notify', 'alert', 'reply', 'forward',
+    'import', 'export', 'sync', 'backup',
+];
+const SHAPE_SEQUENCE_MARKERS = [
+    /\band\s+then\b/i,
+    /\b(?:after|once|when)\s+(?:that|you|done|finished|complete)/i,
+    /\b(?:then|next|finally|last)\s*[,]?\s+\w+/i,
+    /\bfollowed\s+by\b/i,
+    /\b(?:step|phase)\s+\d+/i,
+];
+const SHAPE_BATCH_MARKERS = [
+    /\b(?:for|on|to)\s+each\b/i,
+    /\b\d{2,}\s+\w+/, // "25 emails", "100 records"
+    /\beach\s+of\s+(?:them|the)\b/i,
+    /\b(?:all|every)\s+(?:of\s+)?(?:them|the\s+\w+)/i,
+    /\b(?:bulk|batch|mass)\b/i,
+];
+const SHAPE_NUMBERED_LIST = /\n\s*\d+[.)]\s+\w+/;
+const SHAPE_DOMAIN_MARKERS = [
+    /\bsalesforce\b/i, /\bgmail\b/i, /\boutlook\b/i, /\bslack\b/i,
+    /\bdiscord\b/i, /\bnetlify\b/i, /\bvercel\b/i, /\bgithub\b/i,
+    /\bsupabase\b/i, /\bairtable\b/i, /\bhubspot\b/i, /\bnotion\b/i,
+    /\blinkedin\b/i, /\bcalendar\b/i, /\bdrive\b/i, /\bsheets\b/i,
+];
+/**
+ * Classify a chat message's structural shape (simple / multi-step).
+ *
+ * Scoring (sum of triggered signals):
+ *   - 2+ shape-action verbs: +1
+ *   - 3+ shape-action verbs: +2 cumulatively
+ *   - each sequence marker ("and then", "after that"): +1 (up to +2)
+ *   - batch marker ("for each", "25 emails"): +1
+ *   - numbered list: +2
+ *   - 2+ distinct integration domains in same message: +1
+ *   - length > 200 chars: +1
+ *   - length > 500 chars: +2 cumulatively
+ *
+ * Decision:
+ *   - score >= threshold (default 3) → 'multi-step'
+ *   - score === 0 AND <= 1 action verb AND length <= 200 → 'simple'
+ *   - otherwise → 'unknown' (today's chat path, no change)
+ */
+export function classifyMessageShape(text, opts = {}) {
+    const reasons = [];
+    let score = 0;
+    if (!text || !text.trim()) {
+        return { shape: 'simple', score: 0, reasons: ['empty'] };
+    }
+    const trimmed = text.trim();
+    const lower = trimmed.toLowerCase();
+    const words = new Set(lower.replace(/[^\w\s-]/g, ' ').split(/\s+/).filter(Boolean));
+    // Action verbs
+    const matchedVerbs = [];
+    for (const verb of SHAPE_ACTION_VERBS) {
+        if (words.has(verb))
+            matchedVerbs.push(verb);
+    }
+    if (matchedVerbs.length >= 2) {
+        score += 1;
+        reasons.push(`2+ action verbs (${matchedVerbs.slice(0, 4).join(', ')})`);
+    }
+    if (matchedVerbs.length >= 3) {
+        score += 1;
+        reasons.push('3+ action verbs');
+    }
+    // Sequence markers
+    for (const rx of SHAPE_SEQUENCE_MARKERS) {
+        const matches = lower.match(new RegExp(rx.source, 'gi'));
+        if (matches && matches.length > 0) {
+            score += Math.min(matches.length, 2);
+            reasons.push(`sequence marker: ${matches[0]}`);
+            break;
+        }
+    }
+    // Batch markers
+    for (const rx of SHAPE_BATCH_MARKERS) {
+        if (rx.test(trimmed)) {
+            score += 1;
+            reasons.push('batch marker (for each / N items / bulk)');
+            break;
+        }
+    }
+    // Numbered list
+    if (SHAPE_NUMBERED_LIST.test(trimmed)) {
+        score += 2;
+        reasons.push('numbered list');
+    }
+    // Cross-domain
+    let domainCount = 0;
+    for (const rx of SHAPE_DOMAIN_MARKERS) {
+        if (rx.test(trimmed))
+            domainCount += 1;
+    }
+    if (domainCount >= 2) {
+        score += 1;
+        reasons.push(`${domainCount} integration domains mentioned`);
+    }
+    // Length
+    if (trimmed.length > 200) {
+        score += 1;
+        reasons.push(`length > 200 (${trimmed.length})`);
+    }
+    if (trimmed.length > 500) {
+        score += 1;
+        reasons.push(`length > 500`);
+    }
+    // Decision
+    const threshold = opts.threshold ?? 3;
+    let shape;
+    if (score >= threshold) {
+        shape = 'multi-step';
+    }
+    else if (score === 0 && matchedVerbs.length <= 1 && trimmed.length <= 200) {
+        shape = 'simple';
+    }
+    else {
+        shape = 'unknown';
+    }
+    return { shape, score, reasons };
+}
+const APPROVE_RE = /^(?:yes|y|yep|yeah|yup|sure|ok|okay|approve|approved|go|go ahead|run it|do it|sounds good|lgtm|ship it|👍|✅)[\s.!]*$/i;
+const CANCEL_RE = /^(?:cancel|stop|nvm|nevermind|never\s*mind|forget it|don['']?t|abort|kill it)\b/i;
+const REVISE_RE = /\b(?:but|except|instead|change|modify|add(?:\s+also)?|remove|skip|swap|wait|actually|hold on)\b/i;
+export function detectPlanApproval(message) {
+    if (!message)
+        return 'other';
+    const text = message.trim();
+    if (!text)
+        return 'other';
+    if (CANCEL_RE.test(text))
+        return 'cancel';
+    if (text.length <= 30 && APPROVE_RE.test(text))
+        return 'approve';
+    if (text.length > 30 || REVISE_RE.test(text))
+        return 'revise';
+    return 'other';
+}
 /**
  * Generate a follow-up suggestion prompt suffix based on completed work.
  *

package/dist/agent/mcp-bridge.js

@@ -10,7 +10,7 @@ import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import pino from 'pino';
-import { BASE_DIR, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
+import { BASE_DIR, applyOneMillionContextRecovery, claudeCodeSystemPrompt, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
 const logger = pino({ name: 'clementine.mcp-bridge' });
 const MCP_SERVERS_FILE = path.join(BASE_DIR, 'mcp-servers.json');
 const INTEGRATIONS_FILE = path.join(BASE_DIR, 'claude-integrations.json');
@@ -451,7 +451,8 @@ export async function probeAvailableTools(force = false) {
         const stream = query({
             prompt: 'ok',
             options: normalizeClaudeSdkOptionsForOneMillionContext({
-                systemPrompt: 'Reply ok.',
+                // 1.18.192 — preset form for Claude Code subscription auth.
+                systemPrompt: claudeCodeSystemPrompt('Reply ok.', { minimal: true }),
                 model: 'claude-haiku-4-5',
                 permissionMode: 'dontAsk',
                 mcpServers: externalMcpServers,

package/dist/agent/strategic-planner.js

@@ -12,7 +12,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
-import { BASE_DIR, GOALS_DIR, MODELS, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
+import { BASE_DIR, GOALS_DIR, MODELS, applyOneMillionContextRecovery, claudeCodeSystemPrompt, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
 import { listAllGoals } from '../tools/shared.js';
 const logger = pino({ name: 'clementine.strategic-planner' });
 const DAILY_PLANS_DIR = path.join(BASE_DIR, 'plans', 'daily');
@@ -26,7 +26,11 @@ async function llmJsonCall(prompt, systemPrompt) {
         options: normalizeClaudeSdkOptionsForOneMillionContext({
             model: MODELS.haiku,
             maxTurns: 1,
-            systemPrompt,
+            // 1.18.192 — preset form so the SDK uses Claude Code subscription auth.
+            // Raw `systemPrompt: string` triggers API-key auth and "Not logged in"
+            // failures on Max-only installs. Logs confirmed weekly review was
+            // silently falling through to the fallback path here since the bug landed.
+            systemPrompt: claudeCodeSystemPrompt(systemPrompt, { minimal: true }),
         }),
     });
     for await (const msg of stream) {

package/dist/brain/adapters/pdf.js

@@ -14,7 +14,7 @@ import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import pdfParse from 'pdf-parse';
 import { contentHash } from './common.js';
-import { MODELS, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../../config.js';
+import { MODELS, applyOneMillionContextRecovery, claudeCodeSystemPrompt, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../../config.js';
 export async function* parsePdf(filePath) {
     let buf;
     try {
@@ -94,7 +94,10 @@ async function ocrPdfViaClaude(filePath) {
             options: normalizeClaudeSdkOptionsForOneMillionContext({
                 model: MODELS.haiku,
                 maxTurns: 4, // Read tool call + response (a few turns of thinking is fine)
-                systemPrompt: 'You are a faithful OCR transcriber. Copy text exactly as written. When the PDF has images or scans, read the text from them using vision. Never invent content.',
+                // 1.18.192 — preset form for Claude Code subscription auth.
+                // Without this, every scanned-PDF ingest hit "Not logged in" and
+                // silently fell back to empty OCR output.
+                systemPrompt: claudeCodeSystemPrompt('You are a faithful OCR transcriber. Copy text exactly as written. When the PDF has images or scans, read the text from them using vision. Never invent content.', { minimal: true }),
                 // Claude Code's built-in Read tool handles PDFs (text + vision)
                 tools: ['Read'],
                 allowedTools: ['Read'],

package/dist/cli/dashboard.js

@@ -19,7 +19,7 @@ import { TunnelManager } from './tunnel.js';
 import { AgentManager } from '../agent/agent-manager.js';
 import { discoverMcpServers, getClaudeIntegrations, KNOWN_MCP_DESCRIPTIONS } from '../agent/mcp-bridge.js';
 import { buildBuilderEnrichedMessage, builderSessionKey } from '../dashboard/builder/prompt.js';
-import { AGENTS_DIR, MEMORY_FILE, MODELS, SESSIONS_FILE, TIMEZONE, applyOneMillionContextRecovery, currentTimeZone, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, setEnvOverride, } from '../config.js';
+import { AGENTS_DIR, MEMORY_FILE, MODELS, SESSIONS_FILE, TIMEZONE, applyOneMillionContextRecovery, claudeCodeSystemPrompt, currentTimeZone, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, setEnvOverride, } from '../config.js';
 import { parseTasks } from '../tools/shared.js';
 // 1.18.160 — also pull parseCronJobs + parseAgentCronJobs so getCronJobs()
 // returns the same merged set the runtime fires (CRON.md + agent CRON +
@@ -6399,7 +6399,8 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                 options: normalizeClaudeSdkOptionsForOneMillionContext({
                     model: MODELS.haiku,
                     maxTurns: 3,
-                    systemPrompt: 'You are a data enumerator. You call the given tool once, extract the items from its response, and emit a strict JSON array. No commentary.',
+                    // 1.18.192 — preset form for Claude Code subscription auth.
+                    systemPrompt: claudeCodeSystemPrompt('You are a data enumerator. You call the given tool once, extract the items from its response, and emit a strict JSON array. No commentary.', { minimal: true }),
                     allowedTools: [tool],
                     mcpServers,
                     permissionMode: 'dontAsk',
@@ -9725,7 +9726,8 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                         options: normalizeClaudeSdkOptionsForOneMillionContext({
                             model: 'claude-haiku-4-5-20251001',
                             maxTurns: 1,
-                            systemPrompt: 'You are a memory consolidation assistant. Extract only facts directly evidenced by the corpus. Be terse. Output exactly the requested format.',
+                            // 1.18.192 — preset form for Claude Code subscription auth.
+                            systemPrompt: claudeCodeSystemPrompt('You are a memory consolidation assistant. Extract only facts directly evidenced by the corpus. Be terse. Output exactly the requested format.', { minimal: true }),
                         }),
                     });
                     for await (const msg of stream) {

package/dist/config.d.ts

@@ -30,6 +30,39 @@ type ClaudeSdkOptionsLike = {
     [key: string]: unknown;
 };
 export declare function normalizeClaudeSdkOptionsForOneMillionContext<T extends ClaudeSdkOptionsLike>(options: T): T;
+/**
+ * 1.18.192 — Build a `systemPrompt` value that uses the `claude_code` preset
+ * so the SDK query authenticates via Claude Code subscription (Max plan,
+ * CLAUDE_CODE_OAUTH_TOKEN) instead of falling back to ANTHROPIC_API_KEY.
+ *
+ * Why this matters: passing `systemPrompt` as a raw string tells the SDK
+ * "custom prompt, no preset" — which silently routes auth to API-key mode.
+ * On an install with no API key (the default for Max subscribers), the
+ * query fails with `Error: Not logged in · Please run /login`.
+ *
+ * Hot paths affected by this bug before 1.18.192: bg-planner, daily-planner,
+ * strategic-planner (weekly review), auto-memory extractor, task output
+ * verifier, MCP tool-inventory probe, dashboard data-enumerator, dashboard
+ * memory-consolidator, PDF OCR, periodic memory consolidation.
+ *
+ * Use `excludeDynamicSections: true` for lightweight Haiku utility calls
+ * where the Claude Code preamble (working-dir, git status, memory paths)
+ * is irrelevant noise — saves ~1-2K input tokens per call.
+ *
+ * @example Full preset (planner, agentic work)
+ *   systemPrompt: claudeCodeSystemPrompt('You are a planner. Emit JSON.')
+ *
+ * @example Minimal preset (single-shot Haiku utility)
+ *   systemPrompt: claudeCodeSystemPrompt('Be terse.', { minimal: true })
+ */
+export declare function claudeCodeSystemPrompt(append: string, opts?: {
+    minimal?: boolean;
+}): {
+    type: 'preset';
+    preset: 'claude_code';
+    append: string;
+    excludeDynamicSections?: boolean;
+};
 export declare function normalizeClaudeModelForOneMillionContext(model: string, mode?: OneMillionContextMode): string;
 export declare function usesOneMillionContext(model: string | null | undefined, mode?: OneMillionContextMode, plan?: ClaudePlan): boolean;
 /**

package/dist/config.js

@@ -192,6 +192,39 @@ export function normalizeClaudeSdkOptionsForOneMillionContext(options) {
     }
     return next;
 }
+/**
+ * 1.18.192 — Build a `systemPrompt` value that uses the `claude_code` preset
+ * so the SDK query authenticates via Claude Code subscription (Max plan,
+ * CLAUDE_CODE_OAUTH_TOKEN) instead of falling back to ANTHROPIC_API_KEY.
+ *
+ * Why this matters: passing `systemPrompt` as a raw string tells the SDK
+ * "custom prompt, no preset" — which silently routes auth to API-key mode.
+ * On an install with no API key (the default for Max subscribers), the
+ * query fails with `Error: Not logged in · Please run /login`.
+ *
+ * Hot paths affected by this bug before 1.18.192: bg-planner, daily-planner,
+ * strategic-planner (weekly review), auto-memory extractor, task output
+ * verifier, MCP tool-inventory probe, dashboard data-enumerator, dashboard
+ * memory-consolidator, PDF OCR, periodic memory consolidation.
+ *
+ * Use `excludeDynamicSections: true` for lightweight Haiku utility calls
+ * where the Claude Code preamble (working-dir, git status, memory paths)
+ * is irrelevant noise — saves ~1-2K input tokens per call.
+ *
+ * @example Full preset (planner, agentic work)
+ *   systemPrompt: claudeCodeSystemPrompt('You are a planner. Emit JSON.')
+ *
+ * @example Minimal preset (single-shot Haiku utility)
+ *   systemPrompt: claudeCodeSystemPrompt('Be terse.', { minimal: true })
+ */
+export function claudeCodeSystemPrompt(append, opts) {
+    return {
+        type: 'preset',
+        preset: 'claude_code',
+        append,
+        ...(opts?.minimal ? { excludeDynamicSections: true } : {}),
+    };
+}
 export function normalizeClaudeModelForOneMillionContext(model, mode = currentOneMillionContextMode()) {
     const family = modelFamily(model);
     if (mode === 'on')

package/dist/gateway/router.d.ts

@@ -88,6 +88,31 @@ export declare class Gateway {
     private queueBackgroundOffer;
     private formatBackgroundQueuedResponse;
     private queueBackgroundTaskAfterContextOverflow;
+    /**
+     * 1.18.191 — chat-side plan mode state machine.
+     *
+     * Two paths it handles:
+     *
+     *   A. Approval-pending path. If sess.planAwaitingApproval is set,
+     *      the user's message NOW is either approval / revision / cancel.
+     *      Approval → dispatch the chain. Revision → re-plan with feedback.
+     *      Cancel → clear pending state.
+     *
+     *   B. Multi-step entry path. shape='multi-step' AND no pending plan:
+     *      run planRequest synchronously, post the plan to chat asking
+     *      for approval, set pending state. The owner's NEXT message
+     *      advances via path A.
+     *
+     * Returns `{ handled: true, response }` when plan mode owns this turn
+     * (caller should return the response without running normal chat).
+     * Returns `{ handled: false }` to fall through to normal chat.
+     *
+     * Defensive on every external call — failures degrade to normal chat
+     * rather than blocking the owner's conversation.
+     */
+    private _maybeHandlePlanMode;
+    /** Format a plan for owner approval in chat. */
+    private _formatPlanForApproval;
     acceptBackgroundOffer(sessionKey: string, id: string): {
         ok: boolean;
         response: string;

package/dist/gateway/router.js

@@ -469,6 +469,163 @@ export class Gateway {
             ].join('\n'),
         };
     }
+    /**
+     * 1.18.191 — chat-side plan mode state machine.
+     *
+     * Two paths it handles:
+     *
+     *   A. Approval-pending path. If sess.planAwaitingApproval is set,
+     *      the user's message NOW is either approval / revision / cancel.
+     *      Approval → dispatch the chain. Revision → re-plan with feedback.
+     *      Cancel → clear pending state.
+     *
+     *   B. Multi-step entry path. shape='multi-step' AND no pending plan:
+     *      run planRequest synchronously, post the plan to chat asking
+     *      for approval, set pending state. The owner's NEXT message
+     *      advances via path A.
+     *
+     * Returns `{ handled: true, response }` when plan mode owns this turn
+     * (caller should return the response without running normal chat).
+     * Returns `{ handled: false }` to fall through to normal chat.
+     *
+     * Defensive on every external call — failures degrade to normal chat
+     * rather than blocking the owner's conversation.
+     */
+    async _maybeHandlePlanMode(opts) {
+        const sess = this.sessions.get(opts.sessionKey);
+        const { detectPlanApproval } = await import('../agent/intent-classifier.js');
+        const { planRequest, savePlan, loadPlan } = await import('../agent/bg-planner.js');
+        const { dispatchChain } = await import('../agent/bg-orchestrator.js');
+        // ── Path A: approval-pending ────────────────────────────────────
+        if (sess?.planAwaitingApproval) {
+            const pending = sess.planAwaitingApproval;
+            const signal = detectPlanApproval(opts.userMessage);
+            logger.info({
+                sessionKey: opts.sessionKey,
+                planId: pending.planId,
+                chainId: pending.chainId,
+                signal,
+            }, 'Plan mode: approval signal received');
+            const plan = loadPlan(pending.planId, opts.activeProject?.path);
+            if (!plan) {
+                // Plan disappeared from disk — clear the pending state and
+                // let the message fall through to normal chat.
+                delete sess.planAwaitingApproval;
+                logger.warn({ planId: pending.planId }, 'Plan mode: pending plan not found on disk — clearing');
+                return { handled: false };
+            }
+            if (signal === 'approve') {
+                try {
+                    const firstTask = dispatchChain(plan);
+                    delete sess.planAwaitingApproval;
+                    const response = [
+                        `**Plan approved — starting step 1: ${plan.steps[0]?.title ?? '(first step)'}**`,
+                        '',
+                        `Background task **${firstTask.id}** is now running.`,
+                        'I\'ll post step-by-step updates as each step completes.',
+                    ].join('\n');
+                    return { handled: true, response };
+                }
+                catch (err) {
+                    logger.warn({ err, planId: plan.id }, 'Plan mode: dispatchChain failed on approval');
+                    return { handled: true, response: `Couldn't start the chain: ${String(err).slice(0, 200)}. Tell me to retry or try a different approach.` };
+                }
+            }
+            if (signal === 'cancel') {
+                delete sess.planAwaitingApproval;
+                return { handled: true, response: 'Cancelled the plan. Tell me what you\'d like to do instead.' };
+            }
+            if (signal === 'revise') {
+                // Re-plan with the user's revision as additional context.
+                try {
+                    const revisedRequest = `${plan.userRequest}\n\n[Revision from owner: ${opts.userMessage}]`;
+                    const newPlan = await planRequest({
+                        userRequest: revisedRequest,
+                        originatingSessionKey: opts.sessionKey,
+                        ...(opts.activeProject ? { project: opts.activeProject } : {}),
+                    });
+                    savePlan(newPlan, newPlan.projectPath);
+                    sess.planAwaitingApproval = {
+                        planId: newPlan.id,
+                        chainId: newPlan.chainId,
+                        proposedAt: Date.now(),
+                    };
+                    return {
+                        handled: true,
+                        response: this._formatPlanForApproval(newPlan, /* revised */ true),
+                    };
+                }
+                catch (err) {
+                    logger.warn({ err }, 'Plan mode: revision planRequest failed');
+                    return { handled: true, response: `Couldn't revise the plan: ${String(err).slice(0, 200)}. Want me to start fresh or try something else?` };
+                }
+            }
+            // signal='other' — let it fall through to normal chat, but keep
+            // pending state. The model will see the user message normally.
+            return { handled: false };
+        }
+        // ── Path B: multi-step entry ────────────────────────────────────
+        if (opts.shape === 'multi-step' && sess) {
+            try {
+                // Stream a "thinking..." update so the user knows planning is
+                // happening rather than seeing 30s of silence.
+                if (opts.onText) {
+                    try {
+                        opts.onText('🤔 Planning the steps...');
+                    }
+                    catch { /* non-fatal */ }
+                }
+                const plan = await planRequest({
+                    userRequest: opts.userMessage,
+                    originatingSessionKey: opts.sessionKey,
+                    ...(opts.activeProject ? { project: opts.activeProject } : {}),
+                });
+                savePlan(plan, plan.projectPath);
+                sess.planAwaitingApproval = {
+                    planId: plan.id,
+                    chainId: plan.chainId,
+                    proposedAt: Date.now(),
+                };
+                return {
+                    handled: true,
+                    response: this._formatPlanForApproval(plan, /* revised */ false),
+                };
+            }
+            catch (err) {
+                logger.warn({ err, sessionKey: opts.sessionKey }, 'Plan mode: planRequest failed at entry');
+                // Fall through to normal chat. Better than blocking the owner.
+                return { handled: false };
+            }
+        }
+        // Not a plan-mode case — fall through to normal chat.
+        return { handled: false };
+    }
+    /** Format a plan for owner approval in chat. */
+    _formatPlanForApproval(plan, revised) {
+        const lines = [];
+        lines.push(revised
+            ? `**Revised plan (${plan.steps.length} steps)**`
+            : `**Here's how I'd do this (${plan.steps.length} steps)**`);
+        lines.push('');
+        for (const step of plan.steps) {
+            lines.push(`${step.index + 1}. **${step.title}**`);
+            if (step.scope)
+                lines.push(`   ${step.scope}`);
+            if (step.deliverable)
+                lines.push(`   → ${step.deliverable}`);
+        }
+        if (plan.notes) {
+            lines.push('');
+            lines.push(`_Notes_: ${plan.notes}`);
+        }
+        if (typeof plan.estimatedCostUsd === 'number') {
+            lines.push('');
+            lines.push(`Estimated cost: ~$${plan.estimatedCostUsd.toFixed(2)}`);
+        }
+        lines.push('');
+        lines.push('Say **yes / approve / go** to start, **cancel** to skip, or describe a revision (e.g., "swap step 3" or "add a verification step").');
+        return lines.join('\n');
+    }
     // Offer-message formatter was removed in the Saturday-feel restoration —
     // the chat path no longer asks "want me to run this in the background?".
     // Auto-queue on explicit user intent is silent; everything else just runs.
@@ -2183,6 +2340,56 @@ export class Gateway {
                     const { buildClementineTurnContext } = await import('../agent/clementine-turn-context.js');
                     const { listBackgroundTasks } = await import('../agent/background-tasks.js');
                     const { resolveProjectFromMessage } = await import('../agent/project-resolver.js');
+                    const { classifyMessageShape } = await import('../agent/intent-classifier.js');
+                    // 1.18.191 — classify message shape early. Simple messages
+                    // get a lean turn-context block (no memory recall, no bg
+                    // headlines, no dispute gate); multi-step messages keep
+                    // the full block AND may trigger plan mode (below).
+                    // Builder sessions skip — they have their own routing.
+                    const shapeResult = !isBuilderSession
+                        ? classifyMessageShape(originalText)
+                        : { shape: 'simple', score: 0, reasons: ['builder-session'] };
+                    logger.debug({
+                        sessionKey: effectiveSessionKey,
+                        shape: shapeResult.shape,
+                        score: shapeResult.score,
+                        reasons: shapeResult.reasons,
+                    }, 'Message shape classified');
+                    // 1.18.191 — plan mode state machine.
+                    //
+                    // Two entry points for plan mode:
+                    //
+                    //   A. Approval-pending path. If the previous turn proposed a
+                    //      plan, the user's message NOW is either approval,
+                    //      revision, or cancel. Handle and return without
+                    //      running normal chat.
+                    //
+                    //   B. Multi-step entry path. If shape='multi-step' AND no
+                    //      pending plan, generate a plan, post it, set pending
+                    //      state, return. The owner's NEXT message advances via
+                    //      path A.
+                    //
+                    // Builder sessions skip both paths.
+                    if (!isBuilderSession) {
+                        const planMode = await this._maybeHandlePlanMode({
+                            sessionKey: effectiveSessionKey,
+                            userMessage: originalText,
+                            shape: shapeResult.shape,
+                            activeProject: this.getSessionProject(effectiveSessionKey) ?? null,
+                            onText: wrappedOnText,
+                        });
+                        if (planMode.handled) {
+                            clearTimeout(chatTimer);
+                            if (hardWallTimer)
+                                clearTimeout(hardWallTimer);
+                            {
+                                const cs = this.sessions.get(sessionKey);
+                                if (cs)
+                                    delete cs.abortController;
+                            }
+                            return planMode.response;
+                        }
+                    }
                     // 1.18.187 — auto-resolve project from the user's message.
                     // If a linked project's name/keyword matches with high
                     // confidence, set sess.project for this turn so cwd shifts,
@@ -2294,6 +2501,10 @@ export class Gateway {
                                 // 1.18.187 — pass active project so the turn-context block
                                 // can include path / STATUS.md / inventory / deploy config.
                                 activeProject: this.getSessionProject(effectiveSessionKey) ?? null,
+                                // 1.18.191 — pass message shape so simple messages get the
+                                // lean turn-context (skip memory recall, bg-task headlines,
+                                // dispute gate). Token-optimization for routine chat.
+                                messageShape: shapeResult.shape,
                             });
                             clementineContextBlock = turnCtx.block;
                             logger.debug({

package/dist/index.js

@@ -635,7 +635,9 @@ async function asyncMain() {
                         options: config.normalizeClaudeSdkOptionsForOneMillionContext({
                             model: 'claude-haiku-4-5-20251001',
                             maxTurns: 1,
-                            systemPrompt: 'You are a memory consolidation assistant. Be concise.',
+                            // 1.18.192 — preset form so SDK uses Claude Code subscription
+                            // auth (raw string → API-key path → "Not logged in" for Max users).
+                            systemPrompt: config.claudeCodeSystemPrompt('You are a memory consolidation assistant. Be concise.', { minimal: true }),
                         }),
                     });
                     for await (const msg of stream) {

package/package.json

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