clementine-agent 1.18.9 → 1.18.11

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;

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.`);
@@ -1858,11 +1959,18 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 reason: bundles.length > 0 ? 'matched' : 'empty',
             };
         };
+        const autonomousToolRun = isHeartbeat || isCron || isPlanStep || isUnleashed;
         const promptToolRoute = routeToolSurface(promptScopeText);
         const profileToolRoute = routeToolSurface(profileScopeText);
         const contextToolRoute = routeToolSurface(contextRoutingText);
+        const promptHasToolRoute = promptToolRoute.fullSurface || promptToolRoute.bundles.length > 0;
+        const directFollowupNeedsContextTools = intentClassification?.type === 'followup'
+            || /^(yes|yep|yeah|go|go ahead|do it|continue|pick up|use that|run it|send it|same thing)\b/i.test(promptScopeText.trim());
+        const allowContextToolRoute = autonomousToolRun || (!promptHasToolRoute && directFollowupNeedsContextTools);
         const safeProfileToolRoute = profileToolRoute.fullSurface ? emptyToolRoute() : profileToolRoute;
-        const safeContextToolRoute = contextToolRoute.fullSurface ? emptyToolRoute() : contextToolRoute;
+        const safeContextToolRoute = allowContextToolRoute && !contextToolRoute.fullSurface
+            ? contextToolRoute
+            : emptyToolRoute();
         const toolRoute = mergeToolRoutes(promptToolRoute, mergeToolRoutes(safeProfileToolRoute, safeContextToolRoute));
         let allowedTools = [];
         const addAllowed = (...tools) => {
@@ -1876,10 +1984,9 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         };
         const scopeText = [
             directScopeText,
-            contextRoutingText,
+            allowContextToolRoute ? contextRoutingText : '',
         ].filter(Boolean).join('\n').toLowerCase();
         const promptScopeLower = promptScopeText.toLowerCase();
-        const autonomousToolRun = isHeartbeat || isCron || isPlanStep || isUnleashed;
         const taskIntent = intentClassification?.type === 'task' || autonomousToolRun;
         const memoryNeeded = autonomousToolRun
             || retrievalContext.trim().length > 0
@@ -2667,8 +2774,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 +2808,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 +2821,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 +2841,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 +2862,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 +2874,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 +2892,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 +2901,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 +2944,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));
@@ -3005,6 +3116,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // Flipped true on the first intervention; subsequent replies go through
         // un-validated (but still logged).
         let contradictionRetried = false;
+        let contextRecoveryRetries = 0;
         try {
             for (let attempt = 0; attempt <= PersonalAssistant.RATE_LIMIT_MAX_RETRIES; attempt++) {
                 const sdkOptions = await this.buildOptions({
@@ -3034,7 +3146,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.
@@ -3257,7 +3369,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
@@ -3297,6 +3409,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;
@@ -3358,7 +3489,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');
@@ -3377,13 +3508,14 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             this.exchangeCounts.set(sessionKey, 0);
                             this._compactedSessions.delete(sessionKey);
                         }
-                        if (attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES) {
+                        if (attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES && contextRecoveryRetries < 1) {
+                            contextRecoveryRetries++;
                             prompt = buildContextRecoveredPrompt(prompt, preRotationSnapshot);
                             preRotationSnapshot = null;
                             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). ' +
@@ -3430,11 +3562,25 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 if (staleSession && attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES) {
                     responseText = '';
                     if (contextRecovery) {
-                        prompt = buildContextRecoveredPrompt(prompt, preRotationSnapshot);
-                        preRotationSnapshot = null;
-                        contextRecovery = false;
+                        if (contextRecoveryRetries >= 1) {
+                            responseText = contextThrashRecoveryNotice();
+                            staleSession = false;
+                            contextRecovery = false;
+                        }
+                        else {
+                            contextRecoveryRetries++;
+                            prompt = buildContextRecoveredPrompt(prompt, preRotationSnapshot);
+                            preRotationSnapshot = null;
+                            contextRecovery = false;
+                            continue;
+                        }
                     }
-                    continue;
+                    else {
+                        continue;
+                    }
+                }
+                if (staleSession && contextRecovery && !responseText.trim()) {
+                    responseText = contextThrashRecoveryNotice();
                 }
                 if (hitRateLimit && attempt < PersonalAssistant.RATE_LIMIT_MAX_RETRIES) {
                     const base = rateLimitRetryAfterMs
@@ -3450,6 +3596,26 @@ 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 && contextRecoveryRetries < 1) {
+                        contextRecoveryRetries++;
+                        prompt = buildContextRecoveredPrompt(prompt, preRotationSnapshot);
+                        preRotationSnapshot = null;
+                        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.
@@ -4894,7 +5060,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)
@@ -5425,6 +5591,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') {

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

@@ -15,6 +15,10 @@ export interface TurnPolicy {
     effort: 'low' | 'medium' | 'high';
     allowProactiveGoals: boolean;
     fetchLinks: boolean;
+    /** Do not resume the prior Claude SDK session for this turn. */
+    suppressSessionResume?: boolean;
+    /** Do not inject restored/pending/background context for this turn. */
+    suppressContextInjection?: boolean;
     reason: string;
 }
 export interface TurnPolicyInput {
@@ -23,5 +27,6 @@ export interface TurnPolicyInput {
     hasRecentContext: boolean;
     isAutonomous?: boolean;
 }
+export declare function isStandaloneGreeting(text: string): boolean;
 export declare function decideTurnPolicy(input: TurnPolicyInput): TurnPolicy;
 //# sourceMappingURL=turn-policy.d.ts.map