@bastani/atomic 0.9.23-alpha.1 → 0.9.24-alpha.1

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.23-alpha.1",
+  "version": "0.9.24-alpha.1",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.24-alpha.1] - 2026-09-28
+
+### Added
+
+- Added source-attributed Claude Sonnet 5.5 guidance to the prompt-engineering skill, covering recalibrated effort, carrying coding work through without unrequested additions, visible progress during tool loops, search and verification prompts, and placement of mid-turn user messages.
+
+### Fixed
+
+- A schema-backed stage whose structured-output correction hits a provider failure (for example a 429) that moves the stage to a new session now sends that session the original stage prompt followed by the correction request. Previously the new session received only the correction, so a model that never saw the task could complete the stage with a schema-valid but empty result ([#3323](https://github.com/bastani-inc/atomic/issues/3323)).
+- Workflows from a package listed in a project's `.atomic/settings.json` are now registered as soon as you trust the project at startup. Previously `/workflow <name>` reported `Workflow not found` and `/workflow list` showed only the builtin workflows until you ran `/workflow reload`, even though the package's extensions and skills had loaded ([#3354](https://github.com/bastani-inc/atomic/issues/3354)).
+
+## [0.9.23] - 2026-09-27
+
+### Fixed
+
+- Resuming a run that failed in a `ctx.tool` call now works when the call ran in parallel with other tools. Siblings that were cancelled or also threw when the run failed are run again on resume, in any order, instead of failing with `replay topology mismatch` or `unfinished or missing completed tool checkpoint`. A resume rejected by changed code no longer runs the failed tool or makes the run unresumable, including after Atomic restarts ([#3314](https://github.com/bastani-inc/atomic/issues/3314)).
+- `model: "auto"` routing no longer ignores benchmark results when fewer than four models are available. Each model's results are now ranked against every model in the evals catalog rather than only the models you can route to, so with just two or three models (for example Opus and Haiku) the stronger model is no longer outranked on price alone, and a model scores the same however many models are enabled.
+
 ## [0.9.23-alpha.1] - 2026-09-27
 
 ### Fixed

package/dist/builtin/workflows/builtin/{chunk-d3xhj946.js → chunk-cpw5gtzg.js}

@@ -39,7 +39,7 @@ import {
   reviewerFailureText,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-kgn5wz1c.js";
+} from "./chunk-e1254zvd.js";
 import {
   fold_usage
 } from "./chunk-tgt0s5e5.js";

package/dist/builtin/workflows/builtin/{chunk-kgn5wz1c.js → chunk-e1254zvd.js}

@@ -2062,7 +2062,7 @@ var require_query = __commonJS(function(exports, module) {
       if (typeof this.text !== "string" && typeof this.name !== "string") {
         return new Error("A query must have either text or a name. Supplying neither is unsupported.");
       }
-      const previous = connection.parsedStatements[this.name];
+      const previous = connection.parsedStatements[this.name] || connection.submittedNamedStatements[this.name];
       if (this.text && previous && this.text !== previous) {
         return new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
       }
@@ -2082,7 +2082,7 @@ var require_query = __commonJS(function(exports, module) {
       return null;
     }
     hasBeenParsed(connection) {
-      return this.name && connection.parsedStatements[this.name];
+      return this.name && (connection.parsedStatements[this.name] || connection.submittedNamedStatements[this.name]);
     }
     handlePortalSuspended(connection) {
       this._getRows(connection, this.rows);
@@ -2105,6 +2105,9 @@ var require_query = __commonJS(function(exports, module) {
           name: this.name,
           types: this.types
         });
+        if (this.name) {
+          connection.submittedNamedStatements[this.name] = this.text;
+        }
       }
       try {
         connection.bind({
@@ -2836,7 +2839,7 @@ var require_parser = __commonJS(function(exports) {
     const parameterCount = reader.int16();
     const message = new messages_1.ParameterDescriptionMessage(LATEINIT_LENGTH, parameterCount);
     for (let i = 0;i < parameterCount; i++) {
-      message.dataTypeIDs[i] = reader.int32();
+      message.dataTypeIDs[i] = reader.uint32();
     }
     return message;
   };
@@ -3038,6 +3041,7 @@ var require_connection = __commonJS(function(exports, module) {
       this._keepAlive = config.keepAlive;
       this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis;
       this.parsedStatements = {};
+      this.submittedNamedStatements = {};
       this.ssl = config.ssl || false;
       this.sslNegotiation = config.sslNegotiation || "postgres";
       this._ending = false;
@@ -3558,6 +3562,8 @@ var require_client = __commonJS(function(exports, module) {
         encoding: this.connectionParameters.client_encoding || "utf8"
       });
       this._queryQueue = [];
+      this._sentQueryQueue = [];
+      this.pipeline = Boolean(c.pipeline);
       this.binary = c.binary || defaults.binary;
       this.processID = null;
       this.secretKey = null;
@@ -3592,6 +3598,8 @@ var require_client = __commonJS(function(exports, module) {
         enqueueError(activeQuery);
         this._activeQuery = null;
       }
+      this._sentQueryQueue.forEach(enqueueError);
+      this._sentQueryQueue.length = 0;
       this._queryQueue.forEach(enqueueError);
       this._queryQueue.length = 0;
     }
@@ -3819,6 +3827,9 @@ var require_client = __commonJS(function(exports, module) {
         return;
       }
       this._activeQuery = null;
+      if (activeQuery.name) {
+        delete this.connection.submittedNamedStatements[activeQuery.name];
+      }
       activeQuery.handleError(msg, this.connection);
     }
     _handleRowDescription(msg) {
@@ -3875,6 +3886,7 @@ var require_client = __commonJS(function(exports, module) {
       }
       if (activeQuery.name) {
         this.connection.parsedStatements[activeQuery.name] = activeQuery.text;
+        delete this.connection.submittedNamedStatements[activeQuery.name];
       }
     }
     _handleCopyInResponse(msg) {
@@ -3941,6 +3953,8 @@ var require_client = __commonJS(function(exports, module) {
         });
       } else if (client._queryQueue.indexOf(query) !== -1) {
         client._queryQueue.splice(client._queryQueue.indexOf(query), 1);
+      } else if (client._sentQueryQueue.indexOf(query) !== -1) {
+        query.callback = () => {};
       }
     }
     setTypeParser(oid, format, parseFn) {
@@ -3956,6 +3970,10 @@ var require_client = __commonJS(function(exports, module) {
       return utils.escapeLiteral(str);
     }
     _pulseQueryQueue() {
+      if (this.pipeline) {
+        this._pulsePipelinedQueryQueue();
+        return;
+      }
       if (this.readyForQuery === true) {
         this._activeQuery = this._queryQueue.shift();
         const activeQuery = this._getActiveQuery();
@@ -3976,6 +3994,30 @@ var require_client = __commonJS(function(exports, module) {
         }
       }
     }
+    _pulsePipelinedQueryQueue() {
+      if (!this._connected || !this._queryable) {
+        return;
+      }
+      while (this._queryQueue.length > 0) {
+        const query = this._queryQueue.shift();
+        this.hasExecuted = true;
+        const queryError = query.submit(this.connection);
+        if (queryError) {
+          process.nextTick(() => {
+            query.handleError(queryError, this.connection);
+          });
+          continue;
+        }
+        this._sentQueryQueue.push(query);
+      }
+      if (this.readyForQuery && !this._activeQuery && this._sentQueryQueue.length > 0) {
+        this._activeQuery = this._sentQueryQueue.shift();
+        this.readyForQuery = false;
+      }
+      if (!this._activeQuery && this._sentQueryQueue.length === 0 && this._queryQueue.length === 0 && this.hasExecuted) {
+        this.emit("drain");
+      }
+    }
     query(config, values, callback) {
       let query;
       let result;
@@ -4017,6 +4059,9 @@ var require_client = __commonJS(function(exports, module) {
           const index = this._queryQueue.indexOf(query);
           if (index > -1) {
             this._queryQueue.splice(index, 1);
+          } else if (this.pipeline) {
+            this.connection.stream.destroy();
+            return;
           }
           this._pulseQueryQueue();
         }, readTimeout);
@@ -4043,7 +4088,7 @@ var require_client = __commonJS(function(exports, module) {
         });
         return result;
       }
-      if (this._queryQueue.length > 0) {
+      if (this._queryQueue.length > 0 && !this.pipeline) {
         queryQueueLengthDeprecationNotice();
       }
       this._queryQueue.push(query);
@@ -4069,7 +4114,11 @@ var require_client = __commonJS(function(exports, module) {
           return this._Promise.resolve();
         }
       }
-      if (this._getActiveQuery() || !this._queryable) {
+      if (!this._queryable) {
+        this.connection.stream.destroy();
+      } else if (this.pipeline && (this._getActiveQuery() || this._sentQueryQueue.length > 0 || this._queryQueue.length > 0)) {
+        this.once("drain", () => this.connection.end());
+      } else if (this._getActiveQuery()) {
         this.connection.stream.destroy();
       } else {
         this.connection.end();
@@ -4540,7 +4589,7 @@ var require_query2 = __commonJS(function(exports, module) {
     sourceFunction: "routine"
   };
   NativeQuery.prototype.handleError = function(err) {
-    const fields = this.native.pq.resultErrorFields();
+    const fields = this.native && this.native.pq.resultErrorFields();
     if (fields) {
       for (const key in fields) {
         const normalizedFieldName = errorFieldMap[key] || key;
@@ -4667,6 +4716,8 @@ var require_client2 = __commonJS(function(exports, module) {
     this._connecting = false;
     this._connected = false;
     this._queryable = true;
+    this.pipeline = Boolean(config.pipeline);
+    this._pipelineInFlight = false;
     const cp = this.connectionParameters = new ConnectionParameters(config);
     if (config.nativeConnectionString)
       cp.nativeConnectionString = config.nativeConnectionString;
@@ -4811,7 +4862,7 @@ var require_client2 = __commonJS(function(exports, module) {
       });
       return result;
     }
-    if (this._queryQueue.length > 0) {
+    if (this._queryQueue.length > 0 && !this.pipeline) {
       queryQueueLengthDeprecationNotice();
     }
     this._queryQueue.push(query);
@@ -4832,15 +4883,22 @@ var require_client2 = __commonJS(function(exports, module) {
         cb = (err) => err ? reject(err) : resolve();
       });
     }
-    this.native.end(function() {
-      self._connected = false;
-      self._errorAllQueries(new Error("Connection terminated"));
-      process.nextTick(() => {
-        self.emit("end");
-        if (cb)
-          cb();
+    const doEnd = function() {
+      self.native.end(function() {
+        self._connected = false;
+        self._errorAllQueries(new Error("Connection terminated"));
+        process.nextTick(() => {
+          self.emit("end");
+          if (cb)
+            cb();
+        });
       });
-    });
+    };
+    if (this.pipeline && (this._pipelineInFlight || this._queryQueue.length > 0)) {
+      this.once("drain", doEnd);
+    } else {
+      doEnd();
+    }
     return result;
   };
   Client.prototype._hasActiveQuery = function() {
@@ -4850,6 +4908,9 @@ var require_client2 = __commonJS(function(exports, module) {
     if (!this._connected) {
       return;
     }
+    if (this.pipeline && !initialConnection) {
+      return this._pulsePipelinedQueryQueue();
+    }
     if (this._hasActiveQuery()) {
       return;
     }
@@ -4867,6 +4928,69 @@ var require_client2 = __commonJS(function(exports, module) {
       self._pulseQueryQueue();
     });
   };
+  Client.prototype._pulsePipelinedQueryQueue = function() {
+    if (!this._connected || this._pipelineInFlight) {
+      return;
+    }
+    if (this._queryQueue.length === 0) {
+      if (this.hasExecuted) {
+        this.emit("drain");
+      }
+      return;
+    }
+    this._pipelineInFlight = true;
+    const self = this;
+    const queries = [];
+    const nativeQueries = [];
+    const utils = require_utils();
+    while (this._queryQueue.length > 0) {
+      const query = this._queryQueue.shift();
+      this.hasExecuted = true;
+      nativeQueries.push(query);
+      const values = query.values ? query.values.map(utils.prepareValue) : null;
+      const pipelineEntry = { text: query.text, name: query.name };
+      if (values) {
+        pipelineEntry.values = values;
+      }
+      if (query.name && this.namedQueries[query.name]) {
+        pipelineEntry._alreadyPrepared = true;
+      }
+      queries.push(pipelineEntry);
+    }
+    this.native.pipeline(queries, function(err, results) {
+      self._pipelineInFlight = false;
+      if (err) {
+        for (let i = 0;i < nativeQueries.length; i++) {
+          const q = nativeQueries[i];
+          q.native = self.native;
+          q.handleError(err);
+        }
+        self._pulsePipelinedQueryQueue();
+        return;
+      }
+      for (let i = 0;i < nativeQueries.length; i++) {
+        const q = nativeQueries[i];
+        const r = results[i];
+        q.native = self.native;
+        if (r.err) {
+          q.handleError(r.err);
+        } else {
+          if (q.name) {
+            self.namedQueries[q.name] = q.text;
+          }
+          q.state = "end";
+          q.emit("end", r.result);
+          if (q.callback) {
+            q.callback(null, r.result);
+          }
+        }
+        setImmediate(function() {
+          q.emit("_done");
+        });
+      }
+      self._pulsePipelinedQueryQueue();
+    });
+  };
   Client.prototype.cancel = function(query) {
     if (this._activeQuery === query) {
       this.native.cancel(function() {});

package/dist/builtin/workflows/builtin/{chunk-hj8mh07f.js → chunk-qy6g0baf.js}

@@ -38,7 +38,7 @@ import {
   reviewerFailureText,
   summarizeReviewConvergence,
   reverify_consolidated_batch
-} from "./chunk-kgn5wz1c.js";
+} from "./chunk-e1254zvd.js";
 import {
   VERIFICATION_SCALE
 } from "./chunk-n1910xc4.js";

package/dist/builtin/workflows/builtin/goal.js

@@ -1,7 +1,7 @@
 import {
   goal_default
-} from "./chunk-hj8mh07f.js";
-import"./chunk-kgn5wz1c.js";
+} from "./chunk-qy6g0baf.js";
+import"./chunk-e1254zvd.js";
 import"./chunk-2377r57g.js";
 import"./chunk-z0d03ktm.js";
 import"./chunk-n1910xc4.js";

package/dist/builtin/workflows/builtin/index.js

@@ -14,11 +14,11 @@ import {
 import {
   generate_and_filter_default
 } from "./chunk-kb7s3gx2.js";
-import"./chunk-kgn5wz1c.js";
+import"./chunk-e1254zvd.js";
 import"./chunk-z0d03ktm.js";
 import {
   goal_default
-} from "./chunk-hj8mh07f.js";
+} from "./chunk-qy6g0baf.js";
 import {
   open_claude_design_default
 } from "./chunk-nkj4qhj6.js";
@@ -27,7 +27,7 @@ import {
 } from "./chunk-94f8zfz1.js";
 import {
   ralph_default
-} from "./chunk-d3xhj946.js";
+} from "./chunk-cpw5gtzg.js";
 import {
   tournament_default
 } from "./chunk-wf876n16.js";

package/dist/builtin/workflows/builtin/ralph.js

@@ -1,7 +1,7 @@
 import {
   ralph_default
-} from "./chunk-d3xhj946.js";
-import"./chunk-kgn5wz1c.js";
+} from "./chunk-cpw5gtzg.js";
+import"./chunk-e1254zvd.js";
 import"./chunk-2377r57g.js";
 import"./chunk-z0d03ktm.js";
 import"./chunk-n1910xc4.js";

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.23-alpha.1",
+  "version": "0.9.24-alpha.1",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [

package/dist/builtin/workflows/skills/prompt-engineer/SKILL.md

@@ -36,6 +36,7 @@ Create or revise prompts for the user's target model. Keep the common prompt por
 | Claude Opus 5.5 | `references/claude_opus_5_5.md` | Always-on thinking, progress cadence, bounded unattended continuation, pasted-content boundaries |
 | Claude Opus 5 | `references/claude_opus_5.md` | Separate response length from effort, remove redundant verification, bound delegation |
 | Claude Opus 4.8 | `references/claude_opus_4_8.md` | Steerable thinking, literal scope, tool triggering, design alternatives |
+| Claude Sonnet 5.5 | `references/claude_sonnet_5_5.md` | Recalibrated effort, carrying coding work through, scope limits, silent tool loops, search and verification prompts, mid-turn message placement |
 | Claude Sonnet 5 | `references/claude_sonnet_5.md` | Thinking on by default, variety through prompts instead of sampling, literal scope and review recall |
 
 For a migration, read both source and target pages when both are listed. For a cross-model prompt, keep common requirements in the main contract and isolate only the differences that affect behavior. Do not load every page for a single-model task.

package/dist/builtin/workflows/skills/prompt-engineer/references/claude_sonnet_5_5.md

@@ -0,0 +1,131 @@
+# Claude Sonnet 5.5 prompting
+
+Distilled from [Anthropic's Sonnet 5.5 prompting guide](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5), [What's new in Claude Sonnet 5.5](https://platform.claude.com/docs/en/models/sonnet-5-5/whats-new-sonnet-5-5), and the [migration guide](https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide), checked September 28, 2026. Anthropic says existing Sonnet 5 prompts should perform well unchanged and the [Sonnet 5 page](claude_sonnet_5.md) remains a reasonable starting point; for the hardest long-horizon work, it recommends an Opus model. The snippets below are adaptations, not verbatim source quotations. Use the section matching the observed behavior, not every snippet at once.
+
+## When coding work stops to check in before it is done
+
+At lower effort on long agentic coding tasks, the model sometimes pauses to confirm a plan, asks a question it could answer itself, or stops after one part of a multipart task. Try a higher effort level first. To keep the effort level, add a completion rule:
+
+```text
+Keep working until everything the user asked for is done. Stop to ask only when you cannot continue without the user, or before a risky step.
+```
+
+Sessions then run longer and cost more at low and medium effort. The rule does not replace your own rules about risky or irreversible actions; keep those in the system prompt.
+
+## When coding changes include work nobody asked for
+
+The model tends to add tests, documentation, and small supporting files that fit the repository's conventions, at every effort level and more at higher effort. The requested change itself stays close to the request. Many teams want this. If yours does not, add a scope rule:
+
+```text
+When the requested work is done and checked, stop and report. Do not add features, tests, files, docs, or refactors that were not requested. If one would help, mention it at the end instead of doing it.
+```
+
+At the highest effort levels, this rule also makes changes smaller overall.
+
+## When high-effort runs start their own review rounds
+
+At the highest effort levels, the model can start extra rounds of review and verification after finishing, sometimes through reviewer subagents if the harness provides them, and make related fixes it noticed along the way. Run routine work at a lower effort, where this is rare. To keep the higher effort but aim it at the task:
+
+```text
+When the requested work is done and its checks pass, stop and report. Do not start extra rounds of review or hardening on your own, and do not launch reviewer subagents unless the user asked for a review. If a deeper review seems worthwhile, say so at the end.
+```
+
+The source reports that this makes self-started review rounds less frequent without removing them entirely.
+
+## When a request for ideas turns into a build
+
+On an open-ended request such as "show me what you can do with this", the model can start building a presentation, report, or video when the user only wanted ideas. Say so in the request, or add:
+
+```text
+When the user asks for ideas, options, or a plan, give them that and stop. Do not build or change anything until the user says to go ahead.
+```
+
+## When JSON answers to multistep problems are wrong or do not parse
+
+For tasks that need a few steps of working out, such as totaling figures, applying a rule, or ranking items, the model often answers without thinking first, especially at lower effort. When thinking is available, end the system prompt with:
+
+```text
+Think the problem through before you answer.
+```
+
+The line has no effect when the model runs without up-front thinking in a request without tools; use thinking for these tasks. Raising effort also helps.
+
+If the application asks for JSON only through the prompt rather than an enforced schema, the model often works the problem out in the text and writes the JSON at the end. Have the parser take the last complete JSON value from the text, not everything from the first brace to the last, because a draft can precede the final JSON. Check the expected fields and retry once if they are missing. Treat a response that stopped at the output limit as failed even if it contains valid JSON.
+
+## When long agentic turns look silent
+
+Between tool calls, the model writes short notes on what it found and what it will do next. Longer notes come back as progress-update thinking blocks, which are empty by default, so a client that renders only text can look silent. A prompt cannot fix that; the application must request and render those notes, as the migration guide describes.
+
+Then remove inherited instructions such as "hold all findings for the final response." If you want updates at predictable points, which helps most in human-in-the-loop work, say where:
+
+```text
+Before your first tool call, say in one line what you are about to do. End with a short recap of what you did and what remains.
+```
+
+If long turns still go quiet, the harness can count consecutive tool steps with no user-visible update and, after several (the source's example is five), append a one-turn system reminder after the latest tool results:
+
+```text
+The user has not heard from you in a while. Say in a few words what you are doing, then continue.
+```
+
+Stop after the second or third reminder, and leave earlier reminders in the history rather than deleting them. Frequent harness text after tool results can make the model suspect prompt injection. When the model must show exact text mid-turn, such as a code snippet or a question it needs answered, give it a simple tool for messaging the user, declared from the first request, and say to use it only for such content.
+
+## When the model answers from memory instead of searching
+
+On chat and knowledge-work tasks, the model sometimes answers from training knowledge when a search would catch changed details, such as what is allowed, required, or charged. First remove language that discourages tool use, such as "only use tools when strictly necessary" or "minimize tool calls." If the product exposes a search tool, add:
+
+```text
+Use the search tool to check specifics that may have changed since your training, such as what is allowed, required, or charged, even when you feel confident. For researched work such as a report or comparison, gather current sources rather than writing from training knowledge.
+```
+
+This matters most for research and support products.
+
+## When mid-task user messages are ignored or flagged as injected
+
+The model is trained to resist instructions that arrive through tool results and other content it reads. Text placed right after tool results can therefore be mistaken for injection, and the model may ignore a genuine user message or ask the user to confirm it. Fix the message layout rather than the prompt:
+
+- Never put the user's words inside a tool result.
+- Deliver mid-turn user input as user text after the last tool result in the same user message.
+- Keep harness notices, such as reminders, in a separate system message after the user's words, never in the same block.
+- In interactive sessions where users can type mid-turn, do not append your own token or budget countdown after every tool result.
+
+If an occasional reminder of your own triggers this reaction, send it less often.
+
+## When code changes are reported done without a real check
+
+The model generally checks its work before reporting a change done. At low effort, it sometimes skips a check that exercises the change, for example because dependencies are not installed. If transcripts show completion claims without test or build output, add:
+
+```text
+When you change code that can be run, built, or type-checked, run a real check that exercises the change before reporting it done: the project's tests, type-checker, or build, or the changed command itself. A syntax-only check, or a check command that failed to start, does not count. If only the project's declared dependencies are missing, install them with the project's own package manager and lockfile, never with sudo or the system package manager, unless told not to. If no real check can run, say which check you did not run and why instead of reporting the change as done.
+```
+
+Drop or adjust the dependency sentence where installation is not authorized.
+
+## When tool calls use the wrong name or parameter spelling
+
+The model occasionally calls a declared tool by a name that differs only in letter case, such as `bash` for `Bash`, or passes a known parameter under a slightly different name. Do not treat this as fatal. The harness can accept an unambiguous match, or return a tool error that names the exact expected spelling; the model usually corrects the call on its next turn.
+
+```text
+Unknown tool "bash". Did you mean "Bash"? Call it with that exact name.
+```
+
+## When dense charts or technical drawings are misread
+
+Give the model a way to crop, zoom, or run code on the image. For charts, tools help at every effort level and more than raising effort does. For technical drawings, they help only at higher effort. Anthropic's [crop tool recipe](https://platform.claude.com/cookbook/multimodal-crop-tool) has a working definition.
+
+```text
+Read the requested values from the supplied image. Use the image tools to inspect the relevant regions, and check axes, units, and legend before reporting a value. If a detail stays unreadable, say which one instead of guessing a precise value.
+```
+
+## Thinking, effort, tool, and refusal notes
+
+- Effort is the main control for how much the model thinks. Levels are recalibrated, so re-run your effort evaluation instead of carrying over the Sonnet 5 setting. Anthropic suggests starting at high in general, at medium for well-specified agentic coding and multistep tool use (high for harder or longer tasks), and at medium or low for chat and latency-sensitive work.
+- Asking the model in the system prompt to think less does not reliably reduce its thinking; lower effort instead. When running without up-front thinking, remove "don't think" instructions, which make internal XML tags more likely to appear in visible output.
+- Forced tool choice is not available. The model decides whether to call a tool, so say in the prompt when each tool applies.
+- Keep conversations append-only. Change instructions or tools by appending a system message rather than editing earlier history.
+- Prefill is not available. Ask for a direct answer in the system prompt instead of prefilling a preamble, and move continuations into the user turn, for example: "Your previous response was interrupted and ended with [previous response]. Continue from where you left off."
+- Remove instructions that ask the model to include its reasoning in the response; they invite reasoning-extraction refusals. Request conclusions and evidence instead. Safety classifiers can also decline requests in cyber, biology, and other usage-policy areas, and benign work occasionally triggers them. The application handles those declines through refusal handling and fallback; removing reasoning requests is the only prompt-side fix the source gives.
+
+## Validate the selected adjustment
+
+Compare representative cases before and after one change: a multipart coding task at your chosen effort, an open-ended request, a JSON answer to a multistep problem, a long tool loop viewed through your client, a question that depends on current facts, and a mid-turn user message. Check task completion, unrequested additions, visible updates, actual tool calls, parse success, latency, tokens, and cost. Label every check not run.