clementine-agent 1.18.8 → 1.18.10

package/dist/agent/assistant.d.ts

@@ -27,6 +27,11 @@ import { AgentManager } from './agent-manager.js';
  * SDK result; this function is for pre-flight planning only.
  */
 export declare function estimateTokens(text: string): number;
+export declare function looksLikeContextThrashText(value: unknown): boolean;
+export declare function contextThrashRecoveryNotice(): string;
+export declare function buildContextThrashRecoveryPrompt(userRequest: string, priorFailureText?: string): string;
+/** Autonomous jobs use this sentinel to mean "completed, but do not notify the owner." */
+export declare function isAutonomousNothingOutput(response: string): boolean;
 export interface ProjectMeta {
     path: string;
     description?: string;
@@ -251,8 +256,10 @@ export declare class PersonalAssistant {
     /** Fire-and-forget: extract a reusable skill from a successful execution. */
     private extractSkillFromExecution;
     private preRotationFlush;
-    private lastExtractionTime;
-    private worthExtracting;
+    private lastExtractionTimes;
+    private memoryExtractionKey;
+    private assessMemoryExtraction;
+    private logMemoryExtractionSkip;
     private spawnMemoryExtraction;
     private static readonly MEMORY_TOOL_NAMES;
     private extractMemory;

package/dist/agent/assistant.js

@@ -35,6 +35,7 @@ import { classifyIntent, getStrategyGuidance } from './intent-classifier.js';
 import { getEventLog } from './session-event-log.js';
 import { routeToolSurface, TOOL_SURFACE_WARN_THRESHOLD } from './tool-router.js';
 import { decideTurnPolicy } from './turn-policy.js';
+import { loadClementineJson } from '../config/clementine-json.js';
 // ── Channel capabilities ────────────────────────────────────────────
 /** Map channel label to its capabilities so the agent adapts its responses. */
 function getChannelCapabilities(channel) {
@@ -172,6 +173,37 @@ export function estimateTokens(text) {
         return 0;
     return Math.ceil(text.length / 3.3);
 }
+export function looksLikeContextThrashText(value) {
+    const text = String(value ?? '');
+    return /autocompact\s+is\s+thrashing|context\s+refilled\s+to\s+the\s+limit|refilled\s+to\s+the\s+limit\s+within/i.test(text);
+}
+export function contextThrashRecoveryNotice() {
+    return [
+        'I hit a context-size recovery issue while working on that.',
+        'I saved the request and reset the session so I can continue with smaller reads instead of repeating the same large-output path.',
+    ].join(' ');
+}
+export function buildContextThrashRecoveryPrompt(userRequest, priorFailureText = '') {
+    const parts = [
+        '[CONTEXT-THRASH RECOVERY]',
+        '',
+        'The previous interactive attempt failed because tool output filled the context window and SDK autocompact thrashed. Continue the user request, but use a small diagnostic pass.',
+        '',
+        'User request:',
+        userRequest,
+        '',
+        'Recovery rules:',
+        '- Do not repeat broad reads, full log dumps, full JSON dumps, or unbounded API/list commands.',
+        '- Prefer status files, summaries, indexes, `rg`, `tail -80`, `head -80`, and `sed -n` slices.',
+        '- For cron or unleashed jobs, inspect only `status.json`, the tail of `progress.jsonl`, and the latest run preview first. Do not read full run logs unless a short slice identifies the exact file and range.',
+        '- Preserve the user intent. Identify what failed, what you changed or verified, and the next action.',
+        '- Finish with `TASK_COMPLETE:` followed by a concise user-facing summary.',
+    ];
+    if (priorFailureText.trim()) {
+        parts.push('', 'Prior failure excerpt:', priorFailureText.trim().slice(0, 1200));
+    }
+    return parts.join('\n');
+}
 /**
  * Strip lone Unicode surrogates (U+D800–U+DFFF) from a string so it can be
  * safely serialized to JSON. Lone surrogates are valid in JS strings but
@@ -640,6 +672,27 @@ function yesterdayISO() {
     return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
 }
 // ── Cron Output Extraction ──────────────────────────────────────────
+/** Autonomous jobs use this sentinel to mean "completed, but do not notify the owner." */
+export function isAutonomousNothingOutput(response) {
+    const trimmed = response.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed === '__NOTHING__')
+        return true;
+    if (/^_*NOTHING_*$/i.test(trimmed))
+        return true;
+    if (/^_*NOTHING_*\s*(\(|$)/im.test(trimmed))
+        return true;
+    if (/^(_*NOTHING_*\s*)?\[MONITORING\]\s*$/i.test(trimmed))
+        return true;
+    if (trimmed.length > 80)
+        return false;
+    const lower = trimmed.toLowerCase();
+    return lower === 'nothing to report'
+        || lower === 'nothing new to report'
+        || lower === 'no updates'
+        || lower === 'all clear';
+}
 /** Return the last non-empty text block that came after the last tool call, or '' if nothing/sentinel. */
 function extractDeliverable(trace) {
     if (trace.length === 0)
@@ -657,7 +710,7 @@ function extractDeliverable(trace) {
     for (let i = trace.length - 1; i > lastToolIdx; i--) {
         if (trace[i].type === 'text') {
             const text = trace[i].content.trim();
-            if (text === '__NOTHING__')
+            if (isAutonomousNothingOutput(text))
                 return '';
             if (text.length > 0)
                 return text;
@@ -1609,6 +1662,54 @@ Never spawn a sub-agent with vague instructions like "handle this brief."
 
 When ${owner} expresses satisfaction ("nice", "perfect", "great job", "thanks") or dissatisfaction ("no", "wrong", "that's not right", "ugh"), call \`feedback_log\` with an appropriate rating ('positive' or 'negative') and a brief comment summarizing the context. This helps me learn from interactions.`);
             }
+            try {
+                const jsonExperience = loadClementineJson(BASE_DIR).assistant ?? {};
+                const pick = (value, allowed) => allowed.includes(value) ? value : undefined;
+                const experience = {
+                    proactivity: pick(process.env.ASSISTANT_PROACTIVITY, ['quiet', 'balanced', 'proactive', 'operator']) ?? jsonExperience.proactivity,
+                    responseStyle: pick(process.env.ASSISTANT_RESPONSE_STYLE, ['concise', 'balanced', 'detailed']) ?? jsonExperience.responseStyle,
+                    progressVisibility: pick(process.env.ASSISTANT_PROGRESS_VISIBILITY, ['quiet', 'normal', 'detailed']) ?? jsonExperience.progressVisibility,
+                    autonomy: pick(process.env.ASSISTANT_AUTONOMY, ['ask_first', 'balanced', 'act_when_safe']) ?? jsonExperience.autonomy,
+                };
+                const lines = [];
+                if (experience.proactivity) {
+                    const guidance = {
+                        quiet: 'Only interrupt for urgent or explicitly requested work. Avoid unsolicited next steps.',
+                        balanced: 'Offer useful next steps when natural, but do not create extra work without a clear reason.',
+                        proactive: 'Surface likely next actions, risks, and background-work opportunities before the owner has to ask.',
+                        operator: 'Operate forward: propose plans, queue safe background work, monitor progress, and keep the owner informed.',
+                    };
+                    lines.push(`- Proactivity: ${experience.proactivity}. ${guidance[experience.proactivity]}`);
+                }
+                if (experience.responseStyle) {
+                    const guidance = {
+                        concise: 'Default to short, direct answers. Expand only when the task needs it.',
+                        balanced: 'Match detail to task complexity.',
+                        detailed: 'Include more reasoning, context, and verification detail for substantive work.',
+                    };
+                    lines.push(`- Response style: ${experience.responseStyle}. ${guidance[experience.responseStyle]}`);
+                }
+                if (experience.progressVisibility) {
+                    const guidance = {
+                        quiet: 'Minimize process narration unless work is slow, blocked, or risky.',
+                        normal: 'Share important progress and decision points.',
+                        detailed: 'Keep the owner posted during background or multi-tool work, including failures and recoveries.',
+                    };
+                    lines.push(`- Progress visibility: ${experience.progressVisibility}. ${guidance[experience.progressVisibility]}`);
+                }
+                if (experience.autonomy) {
+                    const guidance = {
+                        ask_first: 'Ask before taking actions that change external systems or user data.',
+                        balanced: 'Act on low-risk reversible steps; ask on irreversible, costly, or ambiguous steps.',
+                        act_when_safe: 'Use judgment and proceed on safe, reversible, clearly beneficial work.',
+                    };
+                    lines.push(`- Autonomy: ${experience.autonomy}. ${guidance[experience.autonomy]}`);
+                }
+                if (lines.length > 0) {
+                    parts.push(`## Owner Experience Preferences\n\n${lines.join('\n')}`);
+                }
+            }
+            catch { /* config preferences are optional */ }
             // Verbose level overrides
             if (verboseLevel === 'quiet') {
                 parts.push(`## Verbosity: Quiet\n\nGive results directly. Skip reasoning and progress updates unless asked.`);
@@ -2667,8 +2768,22 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         }
         // Lone-surrogate sanitization happens at the SDK boundary (see query() wrapper).
         let effectivePrompt = text;
+        const recentExchangesForIntent = key ? this.lastExchanges.get(key) : undefined;
+        const intent = classifyIntent(text, recentExchangesForIntent);
+        const turnPolicy = decideTurnPolicy({
+            text,
+            intent,
+            hasRecentContext: !!(recentExchangesForIntent?.length || (key && this.sessions.has(key))),
+        });
+        const suppressContextInjection = turnPolicy.suppressContextInjection === true;
+        if (key && turnPolicy.suppressSessionResume) {
+            this.sessions.delete(key);
+            this.exchangeCounts.set(key, 0);
+            this.restoredSessions.delete(key);
+            this._compactedSessions.delete(key);
+        }
         // If session rotated, use instant local summary + handoff + kick off LLM summary in background
-        if (sessionRotated && key) {
+        if (sessionRotated && key && !suppressContextInjection) {
             const summary = this.buildLocalSummary(key);
             const handoff = this.loadHandoff(key);
             const contextParts = [];
@@ -2687,7 +2802,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             this.summarizeSessionAsync(key).catch(err => logger.debug({ err, key }, 'Session summarization failed'));
         }
         // Resilience: inject exchange history if no session_id stored
-        if (key && !this.sessions.has(key) && !sessionRotated) {
+        if (key && !suppressContextInjection && !this.sessions.has(key) && !sessionRotated) {
             const exchanges = this.lastExchanges.get(key) ?? [];
             if (exchanges.length > 0) {
                 const historyLines = [];
@@ -2700,7 +2815,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             }
         }
         // Inject context on first message after a daemon restart (session restored from disk)
-        if (key && this.restoredSessions.has(key)) {
+        if (key && !suppressContextInjection && this.restoredSessions.has(key)) {
             const exchanges = this.lastExchanges.get(key) ?? [];
             if (exchanges.length > 0) {
                 const olderSummary = this.buildOlderTurnsContext(key, exchanges);
@@ -2720,7 +2835,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             this.restoredSessions.delete(key); // Only inject once per restored session
         }
         // Fresh session with no history — inject last conversation context
-        if (key && !sessionRotated && !this.restoredSessions.has(key)) {
+        if (key && !suppressContextInjection && !sessionRotated && !this.restoredSessions.has(key)) {
             const exchanges = this.lastExchanges.get(key) ?? [];
             if (exchanges.length === 0 && this.memoryStore) {
                 try {
@@ -2741,7 +2856,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             }
         }
         // Time-gap awareness: let the agent know how long it's been
-        if (key && this.sessionTimestamps.has(key)) {
+        if (key && !suppressContextInjection && this.sessionTimestamps.has(key)) {
             const gapMs = Date.now() - this.sessionTimestamps.get(key).getTime();
             const gapHours = Math.round(gapMs / 3_600_000);
             if (gapHours >= 8) {
@@ -2753,7 +2868,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // injectContext uses the base session key (e.g. discord:user:123) but
         // chat may use a profile-suffixed key (discord:user:123:sales-agent),
         // so also check any pending key that the current key starts with.
-        if (key) {
+        if (key && !suppressContextInjection) {
             const allPending = [];
             for (const [pendingKey, pending] of this.pendingContext) {
                 if (key === pendingKey || key.startsWith(pendingKey + ':')) {
@@ -2771,7 +2886,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             }
         }
         // Inject stall nudge if the previous query for this session showed stall signals
-        if (key && this.stallNudges.has(key)) {
+        if (key && !suppressContextInjection && this.stallNudges.has(key)) {
             const nudge = this.stallNudges.get(key);
             this.stallNudges.delete(key);
             effectivePrompt =
@@ -2780,16 +2895,6 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     `Either take the action NOW using your tools, or tell the user exactly what is blocking you. ` +
                     `If a file can't be read, say so. If you're stuck, say so. Never stall silently.]\n\n${effectivePrompt}`;
         }
-        // ── Intent classification ─────────────────────────────────────
-        // Classify intent before the main query to dynamically tune response
-        // strategy, maxTurns, and effort level
-        const recentExchanges = key ? this.lastExchanges.get(key) : undefined;
-        const intent = classifyIntent(text, recentExchanges);
-        const turnPolicy = decideTurnPolicy({
-            text,
-            intent,
-            hasRecentContext: !!(recentExchanges?.length || (key && this.sessions.has(key))),
-        });
         logger.debug({
             intent: intent.type,
             confidence: intent.confidence,
@@ -2833,7 +2938,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         if (key && !isApiError) {
             this.exchangeCounts.set(key, (this.exchangeCounts.get(key) ?? 0) + 1);
             this.sessionTimestamps.set(key, new Date());
-            const history = this.lastExchanges.get(key) ?? [];
+            const history = turnPolicy.suppressContextInjection ? [] : (this.lastExchanges.get(key) ?? []);
             history.push({ user: text, assistant: responseText });
             if (history.length > SESSION_EXCHANGE_HISTORY_SIZE) {
                 this.lastExchanges.set(key, history.slice(-SESSION_EXCHANGE_HISTORY_SIZE));
@@ -2872,12 +2977,16 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 logger.warn({ err, sessionKey: key }, 'Transcript save failed');
             }
         }
-        // Fire background memory extraction (non-blocking)
-        if (text.length >= AUTO_MEMORY_MIN_LENGTH &&
-            responseText &&
-            !responseText.startsWith('Error:') &&
-            this.worthExtracting(text, responseText)) {
-            this.spawnMemoryExtraction(text, responseText, key, profile).catch(err => logger.debug({ err }, 'Memory extraction failed'));
+        // Fire background memory extraction (non-blocking). Skips are logged with
+        // structured reasons so memory gaps are diagnosable without reading chats.
+        if (responseText && !responseText.startsWith('Error:')) {
+            const extractionDecision = this.assessMemoryExtraction(text, responseText, key, profile);
+            if (extractionDecision.ok) {
+                this.spawnMemoryExtraction(text, responseText, key, profile).catch(err => logger.debug({ err }, 'Memory extraction failed'));
+            }
+            else {
+                this.logMemoryExtractionSkip(extractionDecision.reason, text, responseText, key, profile);
+            }
         }
         // Score outcome-driven salience: for the chunks we retrieved this turn,
         // check which actually showed up in the response and adjust their
@@ -3030,7 +3139,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     sdkOptions.cwd = matchedProject.path;
                 }
                 // Set resume session if available
-                if (sessionKey && this.sessions.has(sessionKey)) {
+                if (sessionKey && this.sessions.has(sessionKey) && !effectiveTurnPolicy?.suppressSessionResume) {
                     sdkOptions.resume = this.sessions.get(sessionKey);
                 }
                 // Context window guard: estimate token usage and bail if too tight.
@@ -3253,7 +3362,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                                         // Auth errors — throw so the gateway circuit breaker catches it
                                         throw new Error(errorText);
                                     }
-                                    else if (lower.includes('autocompact') || lower.includes('thrash') || lower.includes('context refilled to the limit')) {
+                                    else if (looksLikeContextThrashText(errorText)) {
                                         // Autocompact thrashing — treat like the exception path
                                         logger.warn({ sessionKey }, 'Autocompact thrashing (result error) — will rotate session');
                                         // Capture mid-task state BEFORE rotating, so the retry
@@ -3293,6 +3402,25 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             else if ('result' in result && result.result) {
                                 // Success: use SDK result text if streaming didn't capture a substantive response
                                 const sdkResult = result.result;
+                                if (looksLikeContextThrashText(sdkResult)) {
+                                    logger.warn({ sessionKey }, 'Autocompact thrashing surfaced as SDK result text — rotating session');
+                                    preRotationSnapshot = {
+                                        toolCalls: stallGuard?.getToolCalls() ?? [],
+                                        partialText: responseText.slice(-1000),
+                                    };
+                                    if (sessionKey) {
+                                        try {
+                                            this.compactContext(sessionKey);
+                                        }
+                                        catch { /* best-effort */ }
+                                        this.sessions.delete(sessionKey);
+                                        this.exchangeCounts.set(sessionKey, 0);
+                                        this._compactedSessions.delete(sessionKey);
+                                    }
+                                    staleSession = true;
+                                    contextRecovery = true;
+                                    break;
+                                }
                                 logger.info({ sessionKey, streamedLen: responseText.length, resultLen: sdkResult.length }, 'SDK result text available');
                                 if (!responseText.trim()) {
                                     responseText = sdkResult;
@@ -3354,7 +3482,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             }
                         }
                     }
-                    else if (errStr.includes('autocompact') || errStr.includes('thrash') || errStr.includes('context refilled to the limit')) {
+                    else if (looksLikeContextThrashText(e)) {
                         // SDK autocompact thrashing — tool outputs are too large for the context window.
                         // Rotate session and retry with a fresh context so the agent can continue.
                         logger.warn({ sessionKey }, 'Autocompact thrashing — rotating session and retrying');
@@ -3379,7 +3507,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             responseText = '';
                             continue;
                         }
-                        responseText = responseText || 'The conversation context filled up from large tool outputs. I\'ve reset the session — please try again, and I\'ll keep query results smaller this time.';
+                        responseText = responseText || contextThrashRecoveryNotice();
                     }
                     else if (errStr.includes('prompt is too long') || errStr.includes('prompt too long') || errStr.includes('context_length')) {
                         responseText = responseText || ('The conversation got too large to process (tool responses filled the context window). ' +
@@ -3432,6 +3560,9 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     }
                     continue;
                 }
+                if (staleSession && contextRecovery && !responseText.trim()) {
+                    responseText = contextThrashRecoveryNotice();
+                }
                 if (hitRateLimit && attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES) {
                     const base = rateLimitRetryAfterMs
                         ?? PersonalAssistant.RATE_LIMIT_BACKOFF[Math.min(attempt, PersonalAssistant.RATE_LIMIT_BACKOFF.length - 1)];
@@ -3446,6 +3577,27 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 if (hitRateLimit && !responseText) {
                     responseText = "I'm being rate limited right now. Give me a minute and try again.";
                 }
+                if (looksLikeContextThrashText(responseText)) {
+                    logger.warn({ sessionKey }, 'Autocompact thrashing escaped into response text — rotating session before reply');
+                    if (sessionKey) {
+                        try {
+                            this.compactContext(sessionKey);
+                        }
+                        catch { /* best-effort */ }
+                        this.sessions.delete(sessionKey);
+                        this.exchangeCounts.set(sessionKey, 0);
+                        this._compactedSessions.delete(sessionKey);
+                    }
+                    if (attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES) {
+                        prompt = buildContextRecoveredPrompt(prompt, {
+                            toolCalls: stallGuard?.getToolCalls() ?? [],
+                            partialText: '',
+                        });
+                        responseText = '';
+                        continue;
+                    }
+                    responseText = contextThrashRecoveryNotice();
+                }
                 // ── Response guarantee ─────────────────────────────────────────
                 // The model often generates 30+ tool calls with minimal/no text. Ensure
                 // the user always gets a substantive response after real work is done.
@@ -4188,14 +4340,15 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         catch { /* non-fatal */ }
     }
     // ── Auto-Memory Extraction ────────────────────────────────────────
-    lastExtractionTime = 0;
-    worthExtracting(prompt, response) {
-        if (response.length < 100)
-            return false;
-        // Skip very short acknowledgment responses
-        if (response.length < 100)
-            return false;
-        // Only skip pure greetings with no substance at all
+    lastExtractionTimes = new Map();
+    memoryExtractionKey(sessionKey, profile) {
+        return `${profile?.slug ?? 'global'}:${sessionKey ?? 'no-session'}`;
+    }
+    assessMemoryExtraction(prompt, response, sessionKey, profile) {
+        if (!this.memoryStore)
+            return { ok: false, reason: 'no_memory_store' };
+        // Only skip pure greetings with no substance at all. Check this before
+        // length so "hey" is diagnosable as intent, not generic shortness.
         const pureGreetings = [
             'hello', 'hi', 'hey', 'thanks', 'thank you',
             'ok', 'okay', 'sure', 'got it', 'sounds good',
@@ -4203,20 +4356,54 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         ];
         const lower = prompt.toLowerCase().trim();
         if (pureGreetings.some((g) => lower === g || lower === g + '!' || lower === g + '.')) {
-            return false;
+            return { ok: false, reason: 'pure_greeting' };
+        }
+        if (prompt.length < AUTO_MEMORY_MIN_LENGTH || response.length < 100) {
+            return { ok: false, reason: 'too_short' };
         }
-        // Rate limit: max 1 extraction per 45 seconds per session
+        // Rate limit per session/agent. The old process-wide throttle meant one
+        // active chat could suppress memory extraction for unrelated agents.
         const now = Date.now();
-        if (now - this.lastExtractionTime < 45_000)
-            return false;
-        this.lastExtractionTime = now;
-        return true;
+        const key = this.memoryExtractionKey(sessionKey, profile);
+        const last = this.lastExtractionTimes.get(key) ?? 0;
+        if (now - last < 45_000)
+            return { ok: false, reason: 'rate_limited' };
+        this.lastExtractionTimes.set(key, now);
+        return { ok: true };
+    }
+    logMemoryExtractionSkip(reason, userMessage, assistantResponse, sessionKey, profile) {
+        logger.debug({
+            reason,
+            sessionKey,
+            agentSlug: profile?.slug,
+            promptChars: userMessage.length,
+            responseChars: assistantResponse.length,
+        }, 'Auto-memory extraction skipped');
+        if (!this.memoryStore)
+            return;
+        try {
+            this.memoryStore.logExtraction({
+                sessionKey: sessionKey ?? 'unknown',
+                userMessage: userMessage.slice(0, 500),
+                toolName: 'auto_memory_skip',
+                toolInput: JSON.stringify({
+                    reason,
+                    promptChars: userMessage.length,
+                    responseChars: assistantResponse.length,
+                }),
+                extractedAt: new Date().toISOString(),
+                status: `skipped:${reason}`,
+                agentSlug: profile?.slug,
+            });
+        }
+        catch { /* telemetry only */ }
     }
     async spawnMemoryExtraction(userMessage, assistantResponse, sessionKey, profile) {
         // Guard: skip memory extraction if the user message looks like injection
         const memScan = scanner.scan(userMessage);
         if (memScan.verdict === 'block') {
             logger.info('Skipping memory extraction — message was flagged as injection');
+            this.logMemoryExtractionSkip('injection_blocked', userMessage, assistantResponse, sessionKey, profile);
             return;
         }
         let currentMemory = '';
@@ -4855,7 +5042,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             if (cronGuard) {
                 const summary = cronGuard.getSummary();
                 const mc = summary.metacognition;
-                if (mc.confidenceFinal === 'low' && deliverable && deliverable !== '__NOTHING__') {
+                if (mc.confidenceFinal === 'low' && deliverable && !isAutonomousNothingOutput(deliverable)) {
                     try {
                         const escalationsFile = path.join(BASE_DIR, 'escalations.json');
                         const escalations = fs.existsSync(escalationsFile)
@@ -5386,6 +5573,21 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 lastPhaseOutputPreview: lastOutput.slice(0, 300),
             });
             logger.info(`Unleashed task ${jobName}: phase ${phase} complete (${(phaseDurationMs / 1000).toFixed(0)}s)`);
+            // The job explicitly says there is nothing to report. Treat that as a
+            // clean terminal state instead of resuming the same no-op phase until
+            // the max-phase guard fires.
+            if (isAutonomousNothingOutput(lastOutput)) {
+                appendProgress({ event: 'completed_silent', phase });
+                writeStatus({ jobName, status: 'completed', phase, startedAt, finishedAt: new Date().toISOString(), silent: true });
+                logger.info(`Unleashed task ${jobName} completed silently at phase ${phase}`);
+                if (this.onUnleashedComplete) {
+                    try {
+                        this.onUnleashedComplete(jobName, '__NOTHING__');
+                    }
+                    catch { /* non-fatal */ }
+                }
+                return '__NOTHING__';
+            }
             // Notify phase progress callback
             if (this.onPhaseComplete) {
                 try {

package/dist/agent/local-turn.d.ts

@@ -0,0 +1,32 @@
+import type { ClementineJson } from '../config/clementine-json.js';
+export type ProactivityMode = 'quiet' | 'balanced' | 'proactive' | 'operator';
+export type ResponseStyle = 'concise' | 'balanced' | 'detailed';
+export type ProgressVisibility = 'quiet' | 'normal' | 'detailed';
+export type AutonomyMode = 'ask_first' | 'balanced' | 'act_when_safe';
+export interface AssistantExperienceUpdate {
+    proactivity?: ProactivityMode;
+    responseStyle?: ResponseStyle;
+    progressVisibility?: ProgressVisibility;
+    autonomy?: AutonomyMode;
+}
+export type LocalTurnIntent = {
+    kind: 'none';
+} | {
+    kind: 'ack';
+} | {
+    kind: 'greeting';
+} | {
+    kind: 'stop';
+} | {
+    kind: 'status';
+} | {
+    kind: 'preference_update';
+    updates: AssistantExperienceUpdate;
+    summary: string;
+};
+export declare function isStopRequest(text: string): boolean;
+export declare function isStatusRequest(text: string): boolean;
+export declare function isTinyAcknowledgment(text: string): boolean;
+export declare function detectLocalTurn(text: string): LocalTurnIntent;
+export declare function applyAssistantExperienceUpdate(cfg: ClementineJson, updates: AssistantExperienceUpdate): ClementineJson;
+//# sourceMappingURL=local-turn.d.ts.map

package/dist/agent/local-turn.js

@@ -0,0 +1,107 @@
+import { isStandaloneGreeting } from './turn-policy.js';
+function normalize(text) {
+    return text
+        .trim()
+        .toLowerCase()
+        .replace(/[.!?]+$/g, '')
+        .replace(/\s+/g, ' ');
+}
+function wordCount(text) {
+    const t = text.trim();
+    return t ? t.split(/\s+/).length : 0;
+}
+export function isStopRequest(text) {
+    const n = normalize(text);
+    if (wordCount(n) > 5)
+        return false;
+    return /^(stop|cancel|abort|halt|pause|nevermind|never mind|wait stop|stop please|cancel that|stop that)$/.test(n);
+}
+export function isStatusRequest(text) {
+    const n = normalize(text);
+    if (wordCount(n) > 8)
+        return false;
+    return /^(status|task status|deep status|progress|what'?s happening|what'?s going on|what are you doing|are you working|anything running|what'?s running|background status|check status|where are we)$/.test(n);
+}
+export function isTinyAcknowledgment(text) {
+    const n = normalize(text);
+    if (wordCount(n) > 4)
+        return false;
+    return /^(thanks|thank you|thx|ty|nice|great|perfect|awesome|cool|ok|okay|sounds good|got it|makes sense|love it)$/.test(n);
+}
+function parseProactivity(text) {
+    if (/\b(operator mode|operator)\b/i.test(text))
+        return 'operator';
+    if (/\b(more proactive|be proactive|proactive mode|set proactivity to proactive)\b/i.test(text))
+        return 'proactive';
+    if (/\b(less proactive|quieter|quiet mode|be quiet|only urgent|do not interrupt)\b/i.test(text))
+        return 'quiet';
+    if (/\b(balanced proactivity|balanced mode|normal proactivity)\b/i.test(text))
+        return 'balanced';
+    return undefined;
+}
+function parseResponseStyle(text) {
+    if (/\b(be concise|keep it concise|shorter replies|brief replies|reply briefly|less verbose)\b/i.test(text))
+        return 'concise';
+    if (/\b(more detail|detailed replies|be detailed|explain more|more verbose)\b/i.test(text))
+        return 'detailed';
+    if (/\b(balanced replies|normal replies|balanced detail)\b/i.test(text))
+        return 'balanced';
+    return undefined;
+}
+function parseProgressVisibility(text) {
+    if (/\b(show more progress|keep me posted|more updates|detailed progress|tell me what'?s happening)\b/i.test(text))
+        return 'detailed';
+    if (/\b(less progress|fewer updates|quiet progress|don'?t narrate)\b/i.test(text))
+        return 'quiet';
+    if (/\b(normal progress|balanced progress)\b/i.test(text))
+        return 'normal';
+    return undefined;
+}
+function parseAutonomy(text) {
+    if (/\b(ask first|ask me first|ask before acting|do not act without asking)\b/i.test(text))
+        return 'ask_first';
+    if (/\b(act when safe|more autonomous|use your judgment|handle it when safe)\b/i.test(text))
+        return 'act_when_safe';
+    if (/\b(balanced autonomy|normal autonomy)\b/i.test(text))
+        return 'balanced';
+    return undefined;
+}
+export function detectLocalTurn(text) {
+    if (isStopRequest(text))
+        return { kind: 'stop' };
+    if (isStatusRequest(text))
+        return { kind: 'status' };
+    if (isStandaloneGreeting(text))
+        return { kind: 'greeting' };
+    if (isTinyAcknowledgment(text))
+        return { kind: 'ack' };
+    const updates = {};
+    const proactivity = parseProactivity(text);
+    const responseStyle = parseResponseStyle(text);
+    const progressVisibility = parseProgressVisibility(text);
+    const autonomy = parseAutonomy(text);
+    if (proactivity)
+        updates.proactivity = proactivity;
+    if (responseStyle)
+        updates.responseStyle = responseStyle;
+    if (progressVisibility)
+        updates.progressVisibility = progressVisibility;
+    if (autonomy)
+        updates.autonomy = autonomy;
+    const entries = Object.entries(updates);
+    if (entries.length === 0)
+        return { kind: 'none' };
+    const summary = entries.map(([k, v]) => `${k}: ${v}`).join(', ');
+    return { kind: 'preference_update', updates, summary };
+}
+export function applyAssistantExperienceUpdate(cfg, updates) {
+    return {
+        ...cfg,
+        schemaVersion: 1,
+        assistant: {
+            ...(cfg.assistant ?? {}),
+            ...updates,
+        },
+    };
+}
+//# sourceMappingURL=local-turn.js.map

package/dist/agent/self-improve-loop.js

@@ -76,6 +76,7 @@ const PATTERNS = [
         recipe: () => ({
             category: 'safe-cron-config',
             description: 'Context window blowing up mid-run. Switching to unleashed mode so each phase starts with a fresh context.',
+            fields: ['mode', 'max_hours'],
             apply: (job) => {
                 let changed = false;
                 if (job.mode !== 'unleashed') {