clementine-agent 1.18.22 → 1.18.24

package/dist/agent/assistant.d.ts

@@ -291,6 +291,10 @@ export declare class PersonalAssistant {
         };
         delegateProfile?: AgentProfile;
         abortSignal?: AbortSignal;
+        usageSource?: string;
+        usageSessionKey?: string;
+        usageLabel?: string;
+        usageAgentSlug?: string;
     }): Promise<string>;
     runCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, timeoutMs?: number, successCriteria?: string[], agentSlug?: string, opts?: {
         disableAllTools?: boolean;

package/dist/agent/assistant.js

@@ -179,6 +179,27 @@ 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);
 }
+function inferTerminalReasonFromFailure(value) {
+    const text = String(value ?? '').toLowerCase();
+    if (looksLikeContextThrashText(text) || /rapid_refill_breaker|maximum context|context.?length/.test(text)) {
+        return 'rapid_refill_breaker';
+    }
+    if (/prompt is too long|prompt too long|input is too long|request too large/.test(text)) {
+        return 'prompt_too_long';
+    }
+    if (/maximum number of turns|max_turns/.test(text)) {
+        return 'max_turns';
+    }
+    return undefined;
+}
+class UnleashedTaskFailedError extends Error {
+    terminalReason;
+    constructor(message, terminalReason) {
+        super(message);
+        this.terminalReason = terminalReason;
+        this.name = 'UnleashedTaskFailedError';
+    }
+}
 export function contextThrashRecoveryNotice() {
     return [
         'I hit a context-size recovery issue while working on that.',
@@ -4987,7 +5008,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
     }
     // ── Plan Step Execution ───────────────────────────────────────────
     async runPlanStep(stepId, prompt, opts = {}) {
-        const { tier = 2, maxTurns = 15, model, disableTools = false, outputFormat, delegateProfile, abortSignal } = opts;
+        const { tier = 2, maxTurns = 15, model, disableTools = false, outputFormat, delegateProfile, abortSignal, usageSource = 'plan_step', usageSessionKey, usageLabel, usageAgentSlug, } = opts;
         // Don't mutate the global — pass source through the closure instead
         // Per-step stall guard so concurrent steps don't cross-contaminate
         const stepGuard = new StallGuard();
@@ -5034,7 +5055,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                 }
             }
             else if (message.type === 'result') {
-                this.logQueryResult(message, 'plan_step', `plan:${stepId}`, stepId);
+                this.logQueryResult(message, usageSource, usageSessionKey ?? `plan:${stepId}`, usageLabel ?? stepId, usageAgentSlug);
             }
         }
         return extractDeliverable(trace) ||
@@ -5529,6 +5550,12 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         let lastOutput = '';
         let consecutiveErrors = 0;
         const MAX_CONSECUTIVE_ERRORS = 3;
+        const unleashedContextSafety = [
+            'CONTEXT SAFETY:',
+            '- Keep each phase bounded. Do not read full run logs, full CRON.md, raw exports, or large integration responses.',
+            '- Pull records in small batches, summarize IDs/counts/statuses, and write bulky intermediate data to files instead of pasting it into the conversation.',
+            '- If the task looks too broad for the remaining context, stop with a compact status summary and pending list rather than retrying broader reads.',
+        ].join('\n');
         while (phase < UNLEASHED_MAX_PHASES) {
             // Check cancellation
             if (fs.existsSync(cancelFile)) {
@@ -5644,6 +5671,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         `After each phase completes, your session will be resumed with fresh context.\n\n` +
                         `TASK:\n${jobPrompt}\n\n` +
                         unleashedSkillContext +
+                        `${unleashedContextSafety}\n\n` +
                         `IMPORTANT:\n` +
                         `- Work methodically through the task in phases\n` +
                         `- At the end of this phase, output a STATUS SUMMARY of what you accomplished and what remains\n` +
@@ -5682,6 +5710,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             `Continuing unleashed task. This is phase ${phase}.\n` +
                             `Time remaining: ${remainingHours} hours. You have ${turnsPerPhase} turns this phase.\n` +
                             checkpointContext +
+                            `\n${unleashedContextSafety}\n` +
                             `\nContinue working on the task. Pick up where you left off.\n` +
                             `If the task is COMPLETE, output "TASK_COMPLETE:" followed by a final summary.\n\n` +
                             `IMPORTANT: Output a STATUS SUMMARY at the end of this phase.`;
@@ -5695,6 +5724,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             `Previous phases encountered an error and the session was reset.\n\n` +
                             `TASK:\n${jobPrompt}\n` +
                             checkpointContext +
+                            `\n${unleashedContextSafety}\n` +
                             `\nCheck any files or progress from prior phases, then continue the work.\n` +
                             `If the task is COMPLETE, output "TASK_COMPLETE:" followed by a final summary.\n\n` +
                             `IMPORTANT: Output a STATUS SUMMARY at the end of this phase.`;
@@ -5827,8 +5857,27 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             catch (err) {
                 clearTimeout(phaseTimer);
                 clearInterval(beaconTimer);
+                const terminalReason = inferTerminalReasonFromFailure(err);
+                if (terminalReason && !this._lastTerminalReason) {
+                    this._lastTerminalReason = terminalReason;
+                }
                 logger.error({ err, jobName, phase }, `Unleashed task phase ${phase} error`);
-                appendProgress({ event: 'phase_error', phase, error: String(err) });
+                appendProgress({ event: 'phase_error', phase, error: String(err), terminalReason });
+                if (terminalReason === 'rapid_refill_breaker' || terminalReason === 'prompt_too_long') {
+                    appendProgress({ event: 'aborted', phase, reason: terminalReason });
+                    writeStatus({
+                        jobName,
+                        status: 'error',
+                        phase,
+                        startedAt,
+                        finishedAt: new Date().toISOString(),
+                        terminalReason,
+                    });
+                    const message = (`Task "${jobName}" aborted in phase ${phase}: ${terminalReason}. ` +
+                        `The phase exceeded the context window, so Clementine stopped instead of retrying the same broad task shape.`);
+                    logger.error({ jobName, phase, terminalReason }, 'Unleashed task aborted on context-size failure');
+                    throw new UnleashedTaskFailedError(message, terminalReason);
+                }
                 consecutiveErrors++;
                 if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
                     appendProgress({ event: 'aborted', phase, reason: `${MAX_CONSECUTIVE_ERRORS} consecutive phase errors` });
@@ -5837,13 +5886,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     const errorResult = lastOutput || (`Task "${jobName}" aborted after ${MAX_CONSECUTIVE_ERRORS} consecutive phase errors. ` +
                         `Check \`clementine cron runs ${jobName}\` for the failing phase, or retry with ` +
                         `\`clementine cron run ${jobName}\`.`);
-                    if (this.onUnleashedComplete) {
-                        try {
-                            this.onUnleashedComplete(jobName, errorResult);
-                        }
-                        catch { /* non-fatal */ }
-                    }
-                    return errorResult;
+                    throw new UnleashedTaskFailedError(errorResult, this._lastTerminalReason);
                 }
                 // On error, try to continue with a fresh session
                 sessionId = '';
@@ -5930,13 +5973,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         writeStatus({ jobName, status: 'max_phases', phase, startedAt, finishedAt: new Date().toISOString() });
         logger.warn(`Unleashed task ${jobName} hit max phases (${UNLEASHED_MAX_PHASES})`);
         const maxPhasesResult = lastOutput || `Task "${jobName}" reached maximum phase limit (${UNLEASHED_MAX_PHASES}).`;
-        if (this.onUnleashedComplete) {
-            try {
-                this.onUnleashedComplete(jobName, maxPhasesResult);
-            }
-            catch { /* non-fatal */ }
-        }
-        return maxPhasesResult;
+        throw new UnleashedTaskFailedError(maxPhasesResult, this._lastTerminalReason);
     }
     // ── Team Task Execution (Unleashed for Team Messages) ────────────
     /**

package/dist/agent/background-tasks.d.ts

@@ -31,6 +31,7 @@ export declare function createBackgroundTask(input: {
     fromAgent: string;
     prompt: string;
     maxMinutes: number;
+    sessionKey?: string;
 }, opts?: BackgroundTaskOptions): BackgroundTask;
 /** Load a task by id, or null if not found / malformed. */
 export declare function loadBackgroundTask(id: string, opts?: BackgroundTaskOptions): BackgroundTask | null;
@@ -51,6 +52,8 @@ export declare function markFailed(id: string, error: string, reason?: 'failed'
  * Returns the count of tasks aborted.
  */
 export declare function abortStaleRunningTasks(opts?: BackgroundTaskOptions): number;
-/** Test-only: delete a task file. Production code never deletes — history matters. */
-export declare function _deleteBackgroundTask(id: string, opts?: BackgroundTaskOptions): void;
+/** Delete a task file. Callers should avoid deleting active tasks. */
+export declare function deleteBackgroundTask(id: string, opts?: BackgroundTaskOptions): void;
+/** Backward-compatible test helper alias. */
+export declare const _deleteBackgroundTask: typeof deleteBackgroundTask;
 //# sourceMappingURL=background-tasks.d.ts.map

package/dist/agent/background-tasks.js

@@ -56,6 +56,8 @@ export function createBackgroundTask(input, opts) {
         status: 'pending',
         createdAt: now.toISOString(),
     };
+    if (input.sessionKey)
+        task.sessionKey = input.sessionKey;
     safeWrite(pathFor(task.id, opts), task);
     return task;
 }
@@ -104,6 +106,8 @@ export function markRunning(id, opts) {
     const task = loadBackgroundTask(id, opts);
     if (!task)
         return null;
+    if (task.status !== 'pending')
+        return null;
     task.status = 'running';
     task.startedAt = new Date().toISOString();
     safeWrite(pathFor(id, opts), task);
@@ -114,6 +118,8 @@ export function markDone(id, result, deliverableNote, opts) {
     const task = loadBackgroundTask(id, opts);
     if (!task)
         return null;
+    if (task.status !== 'running')
+        return task;
     task.status = 'done';
     task.completedAt = new Date().toISOString();
     task.result = result;
@@ -127,6 +133,8 @@ export function markFailed(id, error, reason = 'failed', opts) {
     const task = loadBackgroundTask(id, opts);
     if (!task)
         return null;
+    if (task.status === 'done' || task.status === 'failed' || task.status === 'aborted')
+        return task;
     task.status = reason;
     task.completedAt = new Date().toISOString();
     task.error = error.slice(0, 1000);
@@ -147,8 +155,8 @@ export function abortStaleRunningTasks(opts) {
     }
     return aborted;
 }
-/** Test-only: delete a task file. Production code never deletes — history matters. */
-export function _deleteBackgroundTask(id, opts) {
+/** Delete a task file. Callers should avoid deleting active tasks. */
+export function deleteBackgroundTask(id, opts) {
     try {
         const file = pathFor(id, opts);
         if (existsSync(file))
@@ -156,4 +164,6 @@ export function _deleteBackgroundTask(id, opts) {
     }
     catch { /* ignore */ }
 }
+/** Backward-compatible test helper alias. */
+export const _deleteBackgroundTask = deleteBackgroundTask;
 //# sourceMappingURL=background-tasks.js.map

package/dist/agent/local-turn.js

@@ -14,15 +14,20 @@ function wordCount(text) {
 }
 export function isStopRequest(text) {
     const n = normalize(text);
+    if (/\bbg-[a-z0-9]+-[a-f0-9]{6}\b/i.test(n) && /^(stop|cancel|abort)\b/.test(n))
+        return true;
     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);
+    return /^(stop|cancel|abort|halt|pause|nevermind|never mind|wait stop|stop please|cancel that|stop that|cancel it|stop it|cancel task|stop task|cancel the task|stop the task|cancel background|stop background)$/.test(n);
 }
 export function isStatusRequest(text) {
     const n = normalize(text);
-    if (wordCount(n) > 8)
+    if (wordCount(n) > 12)
         return false;
-    return /^(status|task status|deep status|progress|what'?s happening|what'?s going on|what are you doing|what are you working on|what are you running|are you working|anything running|what'?s runnin?g?(?: now| right now)?|what is runnin?g?(?: now| right now)?|background status|check status|where are we)$/.test(n);
+    if (/\bbg-[a-z0-9]+-[a-f0-9]{6}\b/i.test(n) && /\b(status|progress|check|update|running|done|finished)\b/.test(n)) {
+        return true;
+    }
+    return /^(status|task status|deep status|progress|progress update|what'?s happening|what'?s going on|what are you doing|what are you working on|what are you running|are you working|anything running|what'?s runnin?g?(?: now| right now)?|what is runnin?g?(?: now| right now)?|background status|check status|where are we|any update|any updates|can i get an update|do you have an update|update me|is it done|is it done yet|is it finished|is it finished yet|done yet|did it finish|still running|is it still running|are we done|how'?s (?:it|that|this|the task|the job|the run|the background task) (?:coming along|progressing)|how is (?:it|that|this|the task|the job|the run|the background task) (?:coming along|progressing)|how'?s (?:the task|the job|the run|the background task) going|how is (?:the task|the job|the run|the background task) going)$/.test(n);
 }
 export function isLastActionRequest(text) {
     const n = normalize(text);

package/dist/agent/prompt-overrides/loader.js

@@ -105,7 +105,7 @@ export function loadPromptOverridesForJob(jobName, agentSlug, opts) {
         if (o.scope === 'agent')
             return agentSlug != null && o.scopeKey === agentSlug;
         if (o.scope === 'job')
-            return o.scopeKey === jobName;
+            return o.scopeKey === jobName || o.scopeKey === bareJobName(jobName);
         return false;
     });
     if (applicable.length === 0)
@@ -113,6 +113,9 @@ export function loadPromptOverridesForJob(jobName, agentSlug, opts) {
     applicable.sort((a, b) => a.priority - b.priority);
     return applicable.map(o => o.body).join('\n\n');
 }
+function bareJobName(jobName) {
+    return jobName.includes(':') ? jobName.split(':').slice(1).join(':') : jobName;
+}
 /** Install fs.watch on the overrides directory tree. Safe to call multiple times. */
 export function watchPromptOverrides(opts) {
     if (watcherInstalled)

package/dist/agent/turn-policy.js

@@ -12,6 +12,7 @@ const GOAL_REF_RE = /\b(goal|goals|objective|objectives|blocker|next action|next
 const LOCAL_TOOL_RE = /\b(repo|repository|code|file|files|folder|directory|path|log|logs|config|build|test|typecheck|lint|npm|git|commit|push|pull|branch|diff|patch|edit|write|implement|fix|refactor|run|diagnose|investigate|troubleshoot|cron|scheduler|lease)\b/i;
 const COMPLEX_RE = /\b(multiple|several|many|bulk|batch|parallel|deep mode|background|research|analyze|audit|review|across|end to end|entire)\b/i;
 const ADMIN_RE = /\b(self[- ]?update|restart|daemon|npm publish|publish to npm|doctor|integration|credential|env var|environment variable|set up|setup|configure)\b/i;
+const BACKGROUND_STATUS_FOLLOWUP_RE = /\bbg-[a-z0-9]+-[a-f0-9]{6}\b|\b(status|progress|progress update|any updates?|done yet|did it finish|still running|coming along|background status)\b/i;
 const STANDALONE_GREETINGS = new Set([
     'hi',
     'hey',
@@ -90,6 +91,18 @@ export function decideTurnPolicy(input) {
             reason: 'explicit-full-surface',
         };
     }
+    if (input.hasRecentContext && BACKGROUND_STATUS_FOLLOWUP_RE.test(text)) {
+        return {
+            retrievalTier: 'search',
+            disableAllTools: false,
+            enableTeams: false,
+            maxTurns: Math.min(intent.suggestedMaxTurns, 6),
+            effort: 'low',
+            allowProactiveGoals: false,
+            fetchLinks: false,
+            reason: 'background-status-followup',
+        };
+    }
     if (isStandaloneGreeting(text)) {
         return {
             retrievalTier: 'none',

package/dist/agent/workflow-runner.js

@@ -230,6 +230,10 @@ export class WorkflowRunner {
                     tier: resolvedStep.tier,
                     maxTurns: resolvedStep.maxTurns,
                     model: resolvedStep.model,
+                    usageSource: 'workflow_step',
+                    usageSessionKey: `workflow:${workflow.name}:${step.id}`,
+                    usageLabel: `${workflow.name}:${step.id}`,
+                    usageAgentSlug: workflow.agentSlug,
                 });
                 return { stepId: step.id, result, durationMs: Date.now() - stepStart };
             }), MAX_CONCURRENT_STEPS);
@@ -269,6 +273,10 @@ export class WorkflowRunner {
             try {
                 finalOutput = await this.assistant.runPlanStep('__synthesis__', synthPrompt, {
                     tier: 2, maxTurns: 5, disableTools: true,
+                    usageSource: 'workflow_step',
+                    usageSessionKey: `workflow:${workflow.name}:__synthesis__`,
+                    usageLabel: `${workflow.name}:__synthesis__`,
+                    usageAgentSlug: workflow.agentSlug,
                 });
             }
             catch (err) {