clementine-agent 1.18.207 → 1.18.209

package/dist/agent/run-agent.js

@@ -441,7 +441,7 @@ export async function runAgent(prompt, opts) {
                         filePath: info.filePath,
                         contentBytes: info.contentBytes,
                         ...(info.archivePath ? { archivePath: info.archivePath } : {}),
-                        message: 'Large Write completed out-of-band; native Write tool denied to protect parent context.',
+                        message: 'Large Write content restored after placeholder Write to protect parent context.',
                     },
                 });
             },

package/dist/agent/run-summary.js

@@ -212,6 +212,11 @@ function extractProviderLogId(raw) {
         ?? (obj.data && typeof obj.data === 'object' ? extractProviderLogId(obj.data) : undefined);
 }
 function statusPhrase(call) {
+    if (call.result && !call.result.successful) {
+        const error = call.result.error ? `: ${call.result.error}` : '';
+        const status = call.result.statusCode ? ` (${call.result.statusCode})` : '';
+        return `failed${status}${error}`.slice(0, 260);
+    }
     const status = call.result?.statusCode;
     if (status && toolKindLabel(call.toolName) === 'email sends')
         return `accepted (${status})`;
@@ -289,10 +294,20 @@ export function formatOverflowRecoveryMessage(summary) {
         || summary.failedDelegations.length > 0
         || summary.pendingDelegations.length > 0) {
         lines.push('Needs attention:');
-        if (summary.failedSideEffects.length > 0)
-            lines.push(...formatGroupedLines('failed', summary.failedSideEffects));
-        if (summary.pendingSideEffects.length > 0)
-            lines.push(...formatGroupedLines('started, no confirmation', summary.pendingSideEffects));
+        if (summary.failedSideEffects.length > 0) {
+            for (const call of summary.failedSideEffects.slice(0, 5))
+                lines.push(formatDetailedCall(call));
+            if (summary.failedSideEffects.length > 5) {
+                lines.push(`- ...and ${summary.failedSideEffects.length - 5} more failed side effects`);
+            }
+        }
+        if (summary.pendingSideEffects.length > 0) {
+            for (const call of summary.pendingSideEffects.slice(0, 5))
+                lines.push(formatDetailedCall(call));
+            if (summary.pendingSideEffects.length > 5) {
+                lines.push(`- ...and ${summary.pendingSideEffects.length - 5} more side effects started with no confirmation`);
+            }
+        }
         for (const call of summary.failedDelegations.slice(0, 5))
             lines.push(formatDelegationCall(call, 'failed'));
         for (const call of summary.pendingDelegations.slice(0, 5))
@@ -312,10 +327,14 @@ function formatDetailedCall(call) {
     const recipients = extractRecipients(call.input);
     const subject = extractSubject(call.input);
     const filePath = extractFilePath(call.input, call.result?.raw);
+    const command = call.toolName === 'Bash'
+        ? firstString(call.input.command)?.replace(/\s+/g, ' ').slice(0, 180)
+        : undefined;
     const logId = call.result ? extractProviderLogId(call.result.raw) : undefined;
     const parts = [
         toolKindLabel(call.toolName),
         filePath ? `file ${filePath}` : undefined,
+        command ? `command "${command}"` : undefined,
         recipients.length ? `to ${recipients.join(', ')}` : undefined,
         subject ? `subject "${subject}"` : undefined,
         call.result ? statusPhrase(call) : 'started, no confirmation',

package/dist/agent/side-effect-classifier.js

@@ -85,6 +85,8 @@ const BASH_SIDE_EFFECT_PATTERNS = [
     /\btee\b/i,
     /\bgit\s+(commit|push|merge|rebase|tag)\b/i,
     /\bnpm\s+(install|publish|update)\b/i,
+    /\bnetlify\s+deploy\b/i,
+    /\bvercel\s+(deploy|--prod)\b/i,
     /\b(?:sf|sfdx)\s+data\s+(update|delete|create|upsert)\b/i,
     /\b(?:sf|sfdx)\s+org\s+(create|delete)\b/i,
     /\bcurl\b.*(?:-X|--request)\s*(POST|PUT|DELETE|PATCH)\b/i,
@@ -200,10 +202,26 @@ function findError(value) {
     }
     return undefined;
 }
+function findStringError(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.trim();
+    if (!text)
+        return undefined;
+    const firstLine = text.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? text;
+    const prefixed = firstLine.match(/^(?:›\s*)?(?:error|failed|fatal):\s+(.+)$/i);
+    if (prefixed)
+        return prefixed[1]?.slice(0, 500);
+    const known = text.match(/\b(Project not found\. Please rerun "netlify link"|command not found|No such file or directory|deploy failed|build failed)\b/i);
+    return known?.[1]?.slice(0, 500);
+}
 export function isToolResultSuccessful(rawResult, sdkIsError = false) {
     if (sdkIsError)
         return { successful: false, reason: 'sdk-is-error' };
     const result = normalizeResultPayload(rawResult);
+    const stringError = findStringError(result);
+    if (stringError)
+        return { successful: false, reason: 'tool-result-error-string', error: stringError };
     if (result && typeof result === 'object') {
         const obj = result;
         if (obj.is_error === true || obj.isError === true) {

package/dist/agent/tool-output-guard.d.ts

@@ -22,8 +22,9 @@
  * The fix is the canonical Anthropic primitive: a `PostToolUse` hook that
  * returns `hookSpecificOutput.updatedToolOutput` to replace the result
  * before it reaches the model. A companion `PreToolUse` hook handles large
- * `Write` inputs by writing the artifact to disk before the native tool can
- * echo a giant file body into the parent conversation.
+ * `Write` inputs by swapping the native call to a small placeholder; the
+ * `PostToolUse` hook then restores the real artifact on disk after the
+ * placeholder write succeeds.
  *
  * Design properties
  * ─────────────────

package/dist/agent/tool-output-guard.js

@@ -22,8 +22,9 @@
  * The fix is the canonical Anthropic primitive: a `PostToolUse` hook that
  * returns `hookSpecificOutput.updatedToolOutput` to replace the result
  * before it reaches the model. A companion `PreToolUse` hook handles large
- * `Write` inputs by writing the artifact to disk before the native tool can
- * echo a giant file body into the parent conversation.
+ * `Write` inputs by swapping the native call to a small placeholder; the
+ * `PostToolUse` hook then restores the real artifact on disk after the
+ * placeholder write succeeds.
  *
  * Design properties
  * ─────────────────
@@ -100,6 +101,7 @@ const VERBOSE_FIELDS = [
     'message', 'transcript', 'raw', 'rawBody', 'rawMessage', 'contentText', 'plainText',
 ];
 const LARGE_WRITE_INPUT_BYTES = 8_000;
+const LARGE_WRITE_PLACEHOLDER = '[Clementine large-write guard placeholder: full content is restored after native Write succeeds.]';
 function writeArchiveFile(baseDir, runId, toolUseId, toolName, suffix, payload) {
     try {
         const dir = join(baseDir, 'tool-archive', runId);
@@ -418,6 +420,7 @@ export function buildGuardHooks(opts) {
         return { hooks: {}, stats };
     }
     const config = opts.config ?? defaultGuardConfig();
+    const pendingLargeWrites = new Map();
     const preToolUse = async (input, toolUseID) => {
         if (input.hook_event_name !== 'PreToolUse') {
             return {};
@@ -431,20 +434,12 @@ export function buildGuardHooks(opts) {
         if (!large)
             return {};
         const archivePath = writeArchiveFile(opts.archiveBaseDir ?? BASE_DIR, opts.runId, toolUseId, toolName, 'input', evt.tool_input);
-        try {
-            writeLargeFileOutOfBand(large.filePath, large.content);
-        }
-        catch (err) {
-            logger.warn({
-                err,
-                toolName,
-                toolUseId,
-                filePath: large.filePath,
-                contentBytes: large.contentBytes,
-            }, 'tool-output-guard: large Write out-of-band write failed; allowing native tool');
-            return {};
-        }
-        stats.largeWrites += 1;
+        pendingLargeWrites.set(toolUseId, {
+            filePath: large.filePath,
+            content: large.content,
+            contentBytes: large.contentBytes,
+            archivePath,
+        });
         stats.bytesShed += Math.max(0, large.contentBytes - 400);
         logger.info({
             toolName,
@@ -452,33 +447,21 @@ export function buildGuardHooks(opts) {
             filePath: large.filePath,
             contentBytes: large.contentBytes,
             archivePath,
-        }, 'tool-output-guard: completed large Write out-of-band');
-        if (opts.onLargeWrite) {
-            try {
-                opts.onLargeWrite({
-                    toolName,
-                    toolUseId,
-                    filePath: large.filePath,
-                    contentBytes: large.contentBytes,
-                    archivePath,
-                });
-            }
-            catch { /* best-effort */ }
-        }
+        }, 'tool-output-guard: staged large Write with placeholder input');
         const reason = [
-            `Clementine large-write guard already wrote ${formatBytes(large.contentBytes)} to ${large.filePath}.`,
+            `Clementine large-write guard staged ${formatBytes(large.contentBytes)} for ${large.filePath}.`,
             archivePath ? `Full original Write input archived at ${archivePath}.` : undefined,
-            'Do not retry Write. Treat the file creation as complete and continue with the remaining requested steps, such as verification or deploy.',
+            'The native Write will use a small placeholder, then Clementine will restore the full content after the write succeeds. Continue with the remaining requested steps after this tool result.',
         ].filter(Boolean).join(' ');
         return {
             hookSpecificOutput: {
                 hookEventName: 'PreToolUse',
-                permissionDecision: 'deny',
+                permissionDecision: 'allow',
                 permissionDecisionReason: reason,
                 additionalContext: reason,
                 updatedInput: {
                     file_path: large.filePath,
-                    content: `[Clementine large-write guard wrote the full ${formatBytes(large.contentBytes)} content out-of-band. ${archivePath ? `Original input: ${archivePath}` : 'Original input was not archived.'}]`,
+                    content: LARGE_WRITE_PLACEHOLDER,
                 },
             },
         };
@@ -494,6 +477,65 @@ export function buildGuardHooks(opts) {
         const toolUseId = String(toolUseID ?? evt.tool_use_id ?? 'unknown');
         const rawOutput = evt.tool_response;
         stats.inspected += 1;
+        const pendingLargeWrite = toolName === 'Write' ? pendingLargeWrites.get(toolUseId) : undefined;
+        if (pendingLargeWrite) {
+            pendingLargeWrites.delete(toolUseId);
+            try {
+                writeLargeFileOutOfBand(pendingLargeWrite.filePath, pendingLargeWrite.content);
+            }
+            catch (err) {
+                logger.warn({
+                    err,
+                    toolName,
+                    toolUseId,
+                    filePath: pendingLargeWrite.filePath,
+                    contentBytes: pendingLargeWrite.contentBytes,
+                    archivePath: pendingLargeWrite.archivePath,
+                }, 'tool-output-guard: failed to restore large Write content after placeholder write');
+                return {
+                    hookSpecificOutput: {
+                        hookEventName: 'PostToolUse',
+                        additionalContext: [
+                            `Clementine could not restore the staged ${formatBytes(pendingLargeWrite.contentBytes)} Write content to ${pendingLargeWrite.filePath}.`,
+                            pendingLargeWrite.archivePath ? `The original input is archived at ${pendingLargeWrite.archivePath}.` : undefined,
+                            'Retry by writing the file in a smaller way or ask the owner for the archive path.',
+                        ].filter(Boolean).join(' '),
+                    },
+                };
+            }
+            stats.largeWrites += 1;
+            logger.info({
+                toolName,
+                toolUseId,
+                filePath: pendingLargeWrite.filePath,
+                contentBytes: pendingLargeWrite.contentBytes,
+                archivePath: pendingLargeWrite.archivePath,
+            }, 'tool-output-guard: restored large Write content after placeholder write');
+            if (opts.onLargeWrite) {
+                try {
+                    opts.onLargeWrite({
+                        toolName,
+                        toolUseId,
+                        filePath: pendingLargeWrite.filePath,
+                        contentBytes: pendingLargeWrite.contentBytes,
+                        archivePath: pendingLargeWrite.archivePath,
+                    });
+                }
+                catch { /* best-effort */ }
+            }
+            const restoredMessage = [
+                `File created successfully at: ${pendingLargeWrite.filePath}`,
+                `(Clementine restored ${formatBytes(pendingLargeWrite.contentBytes)} of large generated content after native Write used a placeholder to protect context.)`,
+                pendingLargeWrite.archivePath ? `Original Write input archived at: ${pendingLargeWrite.archivePath}` : undefined,
+            ].filter(Boolean).join(' ');
+            return {
+                hookSpecificOutput: {
+                    hookEventName: 'PostToolUse',
+                    additionalContext: `The full file content is present at ${pendingLargeWrite.filePath}. Do not rewrite it; continue with verification, deployment, or the next requested step.`,
+                    updatedToolOutput: restoredMessage,
+                },
+            };
+        }
         const usageRatio = Math.max(opts.usageRatio ? safeRatio(opts.usageRatio) : 0, stats.compactions > 0 ? 0.75 : 0);
         const { softCap } = resolveCap(toolName, config, usageRatio);
         const originalBytes = estimateBytes(rawOutput);

package/dist/config.js

@@ -553,9 +553,10 @@ export const TOOL_OUTPUT_GUARD = {
     hardLimitBytes: getEnvOrJsonNumber('TOOL_OUTPUT_GUARD_HARD_BYTES', json.toolOutputGuard?.hardLimitBytes, 200_000),
     adaptive: boolEnv('TOOL_OUTPUT_GUARD_ADAPTIVE', json.toolOutputGuard?.adaptive, true),
     // Agent results are especially dangerous: even a "medium" subagent report
-    // refills the parent orchestrator after compaction. Keep the handoff tight;
+    // refills the parent orchestrator after compaction. Full-file `Read` calls
+    // are the same failure class for generated HTML/reports. Keep both tight;
     // the full result is archived by tool-output-guard.
-    perTool: { Agent: 4_000, ...(json.toolOutputGuard?.perTool ?? {}) },
+    perTool: { Agent: 4_000, Read: 10_000, ...(json.toolOutputGuard?.perTool ?? {}) },
 };
 export const DEFAULT_MODEL_TIER = (getEnvOrJson('DEFAULT_MODEL_TIER', json.models?.default, 'sonnet'));
 export const MODEL = MODELS[DEFAULT_MODEL_TIER] ?? MODELS.sonnet;

package/package.json

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