@code-yeongyu/senpi 2026.8.23 → 2026.8.25

package/node_modules/@anthropic-ai/claude-agent-sdk/manifest.json

@@ -1,53 +1,51 @@
 {
-  "version": "2.1.238",
-  "commit": "46283063a4c23f7afadb8440f549264ad93b7c06",
-  "buildDate": "2026-08-20T15:26:31Z",
+  "version": "2.1.241",
+  "commit": "c87e2742fc9ad269ec8920460d00a091b1e410f0",
+  "buildDate": "2026-08-22T23:04:33Z",
   "platforms": {
     "darwin-arm64": {
       "binary": "claude",
-      "checksum": "1c196c456373b57818ae87df84aecee96cb659448c0d6a6bbb401ac5758431b2",
-      "size": 321263536
+      "checksum": "1495eb7c42d3b4451f5f1cd38b6d498d22a4a38c802bc2be5c1cf1795e64820d",
+      "size": 325055632
     },
     "darwin-x64": {
       "binary": "claude",
-      "checksum": "d10bc7bb1720435f8830aa3ee74085f09348d2b1a2a152bdee251b770d76cc73",
-      "size": 329970544
+      "checksum": "cf01b8cace66485ef5b476f14d96f69af61194a38c3df8412a80eb8f1316c10d",
+      "size": 333784816
     },
     "linux-arm64": {
       "binary": "claude",
-      "checksum": "28d736120a6b14c5eae1ad1470e73371818c9c2fa41e0b3c7040207aa2d4edee",
-      "size": 335993064
+      "checksum": "2db0cb893ebed8ef8aee46656da45bc6801fa2586293dae64abfa3ade894a2fe",
+      "size": 339794152
     },
     "linux-x64": {
       "binary": "claude",
-      "checksum": "0933b286cf94e1b2504b35ac165ab76b8f822735d53371c56393988c23040d58",
-      "size": 338860336
+      "checksum": "0771bd866cff82b76581fc0499f6529e1a36845078f144f8c81dccb3bc7037b8",
+      "size": 342636848
     },
     "linux-arm64-musl": {
       "binary": "claude",
-      "checksum": "a47d45149ea7c74e4474bce3c7628c4643b0541801b42053d6e26fd5e3203fdd",
-      "size": 329137944
+      "checksum": "e12c773a5173319f99ceb2b00445d30216e3529e1fd1fe12b4bfced1fc3f8b04",
+      "size": 332939032
     },
     "linux-x64-musl": {
       "binary": "claude",
-      "checksum": "33546c2f7947bbfdb46a969123c5329e607c414045cd3645a29aa3cfe023c6ab",
-      "size": 332988384
+      "checksum": "820351f6b5fd78314240c21c6f20077c77091e5ffbcd7cd246e969ec417ffb2c",
+      "size": 336756704
     },
     "win32-x64": {
       "binary": "claude.exe",
-      "checksum": "223bc058b5aef48138876e28de5d00387e4fd7362a18e733143bf00819c01aab",
-      "size": 334150816
+      "checksum": "c49a05922a787c33478067a5164002932235f6611948523b55ae1fbdb303ac1f",
+      "size": 337745056
     },
     "win32-arm64": {
       "binary": "claude.exe",
-      "checksum": "645800d24201c93e5fd6f4308e0292bba9a75900693667401cdffb4361f8e616",
-      "size": 322051744
+      "checksum": "540f12dd4031fa964cd8f05c7e37d43c13677800faf4cad2fec553bd7bb7833a",
+      "size": 325645472
     }
   },
   "sdkCompat": {
     "testedWrapperVersions": [
-      "0.3.201",
-      "0.3.202",
       "0.3.204",
       "0.3.205",
       "0.3.206",
@@ -67,6 +65,7 @@
       "0.3.221",
       "0.3.222",
       "0.3.223",
+      "0.3.224",
       "0.3.226",
       "0.3.227"
     ],

package/node_modules/@anthropic-ai/claude-agent-sdk/manifest.zst.json

@@ -1,61 +1,59 @@
 {
-  "version": "2.1.238",
-  "commit": "46283063a4c23f7afadb8440f549264ad93b7c06",
-  "buildDate": "2026-08-20T15:28:38Z",
+  "version": "2.1.241",
+  "commit": "c87e2742fc9ad269ec8920460d00a091b1e410f0",
+  "buildDate": "2026-08-22T23:07:04Z",
   "platforms": {
     "darwin-arm64": {
       "binary": "claude.zst",
-      "checksum": "d9b3b89dd4a0ce4deb9b35eff326e8aceef957b59ea8170afbbe29e0801d6a22",
-      "size": 63807531,
+      "checksum": "239155f84019476e9624d864769cf6946f94f7a707c33d57246e1e74ab94f817",
+      "size": 64578859,
       "bundle": {
-        "checksum": "f01e093504e89c6fb3724417f2ebf9a615f1f46770cc6a8fced0daccff55aa47",
-        "size": 63810771
+        "checksum": "a01fb958a662a9a896faaef18a878f1885b7c3b8c81d16b01a7090f57ad879cd",
+        "size": 64579256
       }
     },
     "darwin-x64": {
       "binary": "claude.zst",
-      "checksum": "c9f5de6fefd0394b21c0e7e037a5471482c440a7780e21fffae512d5fdbcdc30",
-      "size": 68484623,
+      "checksum": "0aaf39f605514391192973c7c97e6c8ae6d432f05e7d91e914dcc5f582cab2b8",
+      "size": 69188990,
       "bundle": {
-        "checksum": "ef80b7b9e5ef8c9b2a7735782a0ecd67655cb3c847af55215d9cf6bb366b8325",
-        "size": 68483882
+        "checksum": "573ae01fea364f9e29a5d5c0ceba8310854556d237b5974d3c8264d5caebf76d",
+        "size": 69175655
       }
     },
     "linux-arm64": {
       "binary": "claude.zst",
-      "checksum": "9b4d5e5598b71420a2e31bab26325dacd3b2b2ad7c5c388c6430855ced6a81fe",
-      "size": 72698452
+      "checksum": "af0c1a3e5392c6852f9fc59a337920c8e6efcc9886b87770c9694f460a60dab8",
+      "size": 73495746
     },
     "linux-x64": {
       "binary": "claude.zst",
-      "checksum": "0af6c2cf837dd6c8805f465581718d89b943921f427a2c13fb2577ec8c69e249",
-      "size": 73796765
+      "checksum": "947ceafc4e7593baa87120fdd9bf0859a08d6fc35ce8ceb65e0194a8acce66c3",
+      "size": 74487570
     },
     "linux-arm64-musl": {
       "binary": "claude.zst",
-      "checksum": "db85271f2cc0e6040318b6e8bbd8c3e812829c1c8c50c964f80a76ac83c75a8a",
-      "size": 71209714
+      "checksum": "e5c998409e79245dd3d737284a0e2b676e50e1f90bfa9f0b2ec69767509ee344",
+      "size": 72016241
     },
     "linux-x64-musl": {
       "binary": "claude.zst",
-      "checksum": "e43e05792a1c034dd54ac7c4f43ae2df01c00181c67d362879bdf119a8098e96",
-      "size": 72251647
+      "checksum": "84d6488d6fe327fcd4f9344725f01bf38831769ce0777e8ca99ba1a763e7d689",
+      "size": 73100955
     },
     "win32-x64": {
       "binary": "claude.exe.zst",
-      "checksum": "b558a80984d13bd3bc8fc2eb011f44051b61078367a91f2458b10beaeee55c96",
-      "size": 76157543
+      "checksum": "df55188ea12a03b35a3db7481bd726615dc982eca0b8d0b55fe5c432304384a7",
+      "size": 76706997
     },
     "win32-arm64": {
       "binary": "claude.exe.zst",
-      "checksum": "912b8524477193d0340cc438cd66cea379441dc815efdcfe262e3c39bcf41ed7",
-      "size": 72467187
+      "checksum": "389f2ec9a83a0f8bb90d3a766f3861ef40250aaeb20e5a3404eecd30d0b08178",
+      "size": 73204306
     }
   },
   "sdkCompat": {
     "testedWrapperVersions": [
-      "0.3.201",
-      "0.3.202",
       "0.3.204",
       "0.3.205",
       "0.3.206",
@@ -75,6 +73,7 @@
       "0.3.221",
       "0.3.222",
       "0.3.223",
+      "0.3.224",
       "0.3.226",
       "0.3.227"
     ],

package/node_modules/@anthropic-ai/claude-agent-sdk/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@anthropic-ai/claude-agent-sdk",
-	"version": "0.3.238",
+	"version": "0.3.241",
 	"main": "sdk.mjs",
 	"types": "sdk.d.ts",
 	"exports": {
@@ -71,5 +71,5 @@
 		"manifest.json",
 		"manifest.zst.json"
 	],
-	"claudeCodeVersion": "2.1.238"
+	"claudeCodeVersion": "2.1.241"
 }

package/node_modules/@anthropic-ai/claude-agent-sdk/sdk-tools.d.ts

@@ -426,6 +426,88 @@ export type ArtifactOutput =
       truncated?: boolean;
       scope?: "shared" | "all";
     }
+  | {
+      read: {
+        url: string;
+        bytes: number;
+        code: number;
+        codeText: string;
+        result: string;
+        durationMs: number;
+      };
+      artifactRead?: {
+        slug: string;
+        ver?: string;
+        seeded?: false;
+      };
+    }
+  | {
+      watch: {
+        url: string;
+        watching: boolean;
+        outcome: string;
+        reason?: string;
+        durable_skip_reason?: string;
+        task_id?: string;
+        since?: number;
+        token_expires_at?: number;
+        rail?: string;
+        trigger_id?: string;
+        durable_since?: string;
+        status?: number;
+        note?: string;
+        events?: string[];
+      };
+    }
+  | {
+      unwatch: {
+        url: string;
+        was_watching: boolean;
+      };
+    }
+  | {
+      watches: (
+        | {
+            url: string;
+            task_id: string;
+            since: number;
+            explicit: boolean;
+            connected: boolean;
+            connecting?: boolean;
+            token_expires_at: number;
+            armed_via?: string;
+          }
+        | {
+            url: string;
+            rail: "durable_wake";
+            trigger_id: string;
+            since: string;
+            events?: string[];
+            restored?: boolean;
+          }
+        | {
+            url: string;
+            rail: "live_stopped";
+            since?: number;
+            explicit?: boolean;
+            armed_via?: string;
+            stop_kind: string;
+          }
+      )[];
+      filter_url?: string;
+      arms?: {
+        url: string;
+        rail?: string;
+        state: string;
+        reconnect?: boolean;
+        failures?: number;
+        max_failures?: number;
+        next_in_s?: number;
+        last_failure?: string;
+        reason?: string;
+        at?: number;
+      }[];
+    }
   | {
       asset_upload: {
         id: string;
@@ -2927,11 +3009,21 @@ export interface ProposeGoalInput {
 }
 export interface ArtifactInput {
   /**
-   * Omit (or 'publish') to publish file_path. 'list' enumerates artifacts — the user's own by default, see `scope`; only `limit` and `scope` may accompany it. 'upload_asset' adds one local media, PDF, or font file to an existing artifact — pass `url` and `file_path`. 'list_assets' lists the files in an artifact's asset store (pass `url`; `after` continues a listing), 'read_asset' saves one of them to a local file named by its id (pass `url` and `asset_id`, optionally `out_dir`), and 'delete_asset' permanently removes one (pass `url` and `asset_id`). See **Artifact assets** above.
+   * Omit (or 'publish') to publish file_path. 'list' enumerates artifacts — the user's own by default, see `scope`; only `limit` and `scope` may accompany it. 'read' returns the content of the published artifact at `url` (raw HTML for the user's own; an isolated summary, steered by the optional `prompt`, for one shared with them, though a page published in this session's own Slack channel can come back in full as untrusted content) — see **To read an existing artifact's content**. 'watch', 'unwatch', and 'status' manage live-update subscriptions that notify a session when an artifact is republished elsewhere, and those aren't available in this session: 'watch' only reports that — no republish notification reaches this session — and 'status' lists this session's artifact watches (pass `url` to check one). 'upload_asset' adds one local media, PDF, or font file to an existing artifact — pass `url` and `file_path`. 'list_assets' lists the files in an artifact's asset store (pass `url`; `after` continues a listing), 'read_asset' saves one of them to a local file named by its id (pass `url` and `asset_id`, optionally `out_dir`), and 'delete_asset' permanently removes one (pass `url` and `asset_id`). See **Artifact assets** above.
    */
-  action?: "publish" | "list" | "upload_asset" | "list_assets" | "read_asset" | "delete_asset";
+  action?:
+    | "publish"
+    | "list"
+    | "read"
+    | "watch"
+    | "unwatch"
+    | "status"
+    | "upload_asset"
+    | "list_assets"
+    | "read_asset"
+    | "delete_asset";
   /**
-   * Path to an .html or .md file to render. Required to publish (the default action). Use a short, distinctive basename — it is the last-resort title when the HTML has no <title> and no `title` parameter is given. For 'upload_asset', the local image, video, PDF, or font file to upload.
+   * Path to the .html file to render. Required to publish (the default action). Use a short, distinctive basename — it is the last-resort title when the HTML has no <title> and no `title` parameter is given. For 'upload_asset', the local image, video, PDF, or font file to upload.
    */
   file_path?: string;
   /**
@@ -2959,11 +3051,15 @@ export interface ArtifactInput {
    */
   label?: string;
   /**
-   * Existing artifact URL to update in place. Pass whenever the user wants to update an artifact this conversation did not publish — "update my artifact", "keep the same link", a pasted artifact URL — and find the URL with action: "list" or ask the user for the link if you don't have it; without this, the publish creates a separate artifact instead of updating the existing one. Omit for new artifacts and same-conversation redeploys. Must be an artifact the user owns.
+   * Existing artifact URL to update in place. Pass whenever the user wants to update an artifact this conversation did not publish — "update my artifact", "keep the same link", a pasted artifact URL — and find the URL with action: "list" or ask the user for the link if you don't have it; without this, the publish creates a separate artifact instead of updating the existing one. Omit for new artifacts and same-conversation redeploys. Must be an artifact the user owns. For 'read' and the other url-addressed actions: the artifact to act on.
    */
   url?: string;
   /**
-   * Last-resort overwrite that DISCARDS another session's published version. On a 409 conflict the normal fix is to re-read the artifact, merge your edits on top of the newer content, and publish again — not force. Pass force:true only when the user explicitly wants to replace the other session's version. The tracked baseVersion is still sent; with force:true the server treats it as informational and overwrites. Omit (or false) so a concurrent write 409s instead of being silently clobbered.
+   * read only: what to extract from an artifact shared with the user — its content reaches you as an isolated summary answering this. Ignored for artifacts the user owns and for a page published in this session's own Slack channel (raw content is returned); optional.
+   */
+  prompt?: string;
+  /**
+   * Last-resort overwrite that DISCARDS the newer published version — another session's publish, or someone's save from a page that can publish new versions of itself. On a conflict the fix is to merge your changes onto the newer content (handed to you in the rejection, or re-read) and publish again — not force. Pass force:true only when the user has explicitly said to discard that specific version; never to get past a conflict on your own judgment. The tracked baseVersion is still sent; with force:true the server treats it as informational and overwrites, unless it refuses force over a version saved from inside the page. Omit (or false) so a concurrent write conflicts instead of being silently clobbered.
    */
   force?: boolean;
   /**
@@ -3479,6 +3575,7 @@ export interface WebFetchOutput {
   artifactRead?: {
     slug: string;
     ver?: string;
+    seeded?: false;
   };
 }
 export interface WebSearchOutput {

package/node_modules/@anthropic-ai/claude-agent-sdk/sdk.d.ts

@@ -2449,11 +2449,11 @@ export declare interface Query extends AsyncGenerator<SDKMessage, void> {
      *
      * @param maxThinkingTokens - Maximum tokens for thinking, or null to clear the limit
      * @param thinkingDisplay - Optional thinking display mode for the rest of
-     * the session: a value replaces the session display mode, `null` clears it
-     * back to the API default, and when omitted the display mode from session
-     * start (`thinking.display` / `--thinking-display`) is kept — note a
-     * session started with thinking disabled has none, so re-enabling thinking
-     * without this param yields the API's default display.
+     * the session: a value replaces the session display mode, `null` clears
+     * that override so Claude Code's default display handling applies again,
+     * and when omitted the display mode from session start (`thinking.display`
+     * / `--thinking-display`) is kept — a session started with thinking
+     * disabled has none, so re-enabling without this param gets that default.
      */
     setMaxThinkingTokens(maxThinkingTokens: number | null, thinkingDisplay?: 'summarized' | 'omitted' | null): Promise<void>;
     /**
@@ -3126,7 +3126,7 @@ export declare type SDKAuthStatusMessage = {
 };
 
 /**
- * The full set of live background tasks, emitted whenever membership changes (start, completion, kill, a foreground agent being backgrounded). A level signal, unlike the task_started/task_notification edge bookends: consumers that only need 'is background work running' should replace their set with each payload rather than pairing edges, so a missed bookend cannot wedge a stale running indicator. Ordering relative to the bookends for the same transition is unspecified (in practice the level precedes them) and the payload carries ids only, so do not correlate it with the edge stream. The level is per-process: nothing is emitted at startup, so consumers must reset to the empty set whenever the session's CLI process (re)starts and let the next membership change repopulate it.
+ * The full set of live background tasks, emitted whenever membership changes (start, completion, kill, a foreground agent being backgrounded). A level signal, unlike the task_started/task_notification edge bookends: consumers that only need 'is background work running' should replace their set with each payload rather than pairing edges, so a missed bookend cannot wedge a stale running indicator. Ordering relative to the bookends for the same transition is unspecified (in practice the level precedes them) and the payload carries ids only, so do not correlate it with the edge stream. The level is per-process: nothing is emitted at startup, so consumers must reset to the empty set whenever the session's CLI process (re)starts and let the next membership change repopulate it. A host that re-initializes an already-running process (a repeated `initialize` control request, e.g. after reconnecting) is sent a snapshot of the current set right behind the success response to that request, even when it is empty, so it need not wait for a change; CLIs that predate this send nothing there.
  */
 export declare type SDKBackgroundTasksChangedMessage = {
     type: 'system';
@@ -3769,7 +3769,7 @@ declare type SDKControlInterruptRequest = {
     subtype: 'interrupt';
 
     /**
-     * When true, the interrupt also cancels every uuid-stamped main-thread command still in the queue or already dequeued for the imminent turn but not yet reachable by the abort (the first-command prewait window) — the same set the response would otherwise list under `still_queued`. Each is closed with a terminal 'cancelled' lifecycle and listed on the response's `cancelled` field. `still_queued` is always empty. (The isFoldInFlight guard cancel_async_message uses does not apply here: this request also aborts the running turn, so a fold-in-flight uuid is never delivered and is swept with the rest. A fold-in-flight uuid's queued_command attachment may already appear in the aborted turn's transcript if the abort landed after the fold's attachment yield — pre-existing leave-queued semantics; it never runs as its own turn.) Uuid-less commands (task notifications) still in the queue are also dequeued but cannot be listed; a uuid-less command already in the prewait window is unreachable by either leg and still runs. When false or absent, queued commands survive the interrupt and are listed under `still_queued` — the interrupt_receipt_v1 contract is unchanged. A Stop-means-stop-everything client (a remote UI's Stop button) sets this true so one round-trip halts the session; a wrapper that wants per-uuid control leaves it false and follows up with cancel_async_message. Advertised by the `interrupt_cancel_queued_v1` capability on system/init; older CLIs ignore the field and behave as if false.
+     * When true, the interrupt also cancels every uuid-stamped main-thread command still in the queue or already dequeued for the imminent turn but not yet reachable by the abort (the first-command prewait window) — the same set the response would otherwise list under `still_queued`. Each is closed with a terminal 'cancelled' lifecycle and listed on the response's `cancelled` field. `still_queued` is then empty, except that a client driving a hosted session lists there what it can no longer recall (a send already in flight to that session, or the first prompt the session was created with). (The isFoldInFlight guard cancel_async_message uses does not apply here: this request also aborts the running turn, so a fold-in-flight uuid is never delivered and is swept with the rest. A fold-in-flight uuid's queued_command attachment may already appear in the aborted turn's transcript if the abort landed after the fold's attachment yield — pre-existing leave-queued semantics; it never runs as its own turn.) Uuid-less commands (task notifications) still in the queue are also dequeued but cannot be listed; a uuid-less command already in the prewait window is unreachable by either leg and still runs. When false or absent, queued commands survive the interrupt and are listed under `still_queued` — the interrupt_receipt_v1 contract is unchanged. A Stop-means-stop-everything client (a remote UI's Stop button) sets this true so one round-trip halts the session; a wrapper that wants per-uuid control leaves it false and follows up with cancel_async_message. Advertised by the `interrupt_cancel_queued_v1` capability on system/init; older CLIs ignore the field and behave as if false.
      */
     cancel_queued?: boolean;
 };
@@ -3779,7 +3779,7 @@ declare type SDKControlInterruptRequest = {
  */
 export declare type SDKControlInterruptResponse = {
     /**
-     * Uuids of async user messages that survive this interrupt: commands still in the queue, plus any batch already dequeued for the imminent turn but not yet reachable by the abort. These WILL run unless cancelled first (or unless the request set cancel_queued:true, in which case this list is always empty — every uuid-stamped survivor is removed, emitted a terminal `cancelled` synchronously, and listed under `cancelled` instead). Cancellation granularity: uuids still in the queue are individually cancellable via cancel_async_message; once a batch is dequeued and coalesced into one turn, cancelling a NON-representative member uuid is a no-op (its content still runs), while cancelling the batch-representative uuid drops the WHOLE coalesced batch — in both cases the cancel response reports cancelled:false because the message was no longer in the queue. Coverage caveats: only uuid-STAMPED messages appear (a message enqueued without a uuid still runs but is never listed, so [] does not mean "nothing will run"); only main-thread messages are listed (subagent-addressed messages are out of scope); and the list may include internally-enqueued uuids the client never sent (cron triggers, auto-resume continuations) — ignore unknown uuids rather than treating them as an error. Ordering: on a clean interrupt this receipt is written before the interrupted turn result; a turn that crashes during interrupt handling emits its error result on a direct-write path that may precede the receipt. Snapshot is taken synchronously with abort processing — probing the queue after the interrupted result instead always loses the race against the drain loop, which starts the next queued turn immediately.
+     * Uuids of async user messages that survive this interrupt: commands still in the queue, plus any batch already dequeued for the imminent turn but not yet reachable by the abort. These WILL run unless cancelled first (or unless the request set cancel_queued:true, in which case every uuid-stamped survivor this process holds is removed, emitted a terminal `cancelled` synchronously, and listed under `cancelled` instead — leaving here only what a client driving a hosted session can no longer recall: a send already in flight to that session, or the first prompt the session was created with). Cancellation granularity: uuids still in the queue are individually cancellable via cancel_async_message; once a batch is dequeued and coalesced into one turn, cancelling a NON-representative member uuid is a no-op (its content still runs), while cancelling the batch-representative uuid drops the WHOLE coalesced batch — in both cases the cancel response reports cancelled:false because the message was no longer in the queue. Coverage caveats: only uuid-STAMPED messages appear (a message enqueued without a uuid still runs but is never listed, so [] does not mean "nothing will run"); only main-thread messages are listed (subagent-addressed messages are out of scope); and the list may include internally-enqueued uuids the client never sent (cron triggers, auto-resume continuations) — ignore unknown uuids rather than treating them as an error. Ordering: on a clean interrupt this receipt is written before the interrupted turn result; a turn that crashes during interrupt handling emits its error result on a direct-write path that may precede the receipt. Snapshot is taken synchronously with abort processing — probing the queue after the interrupted result instead always loses the race against the drain loop, which starts the next queued turn immediately.
      */
     still_queued: string[];
     /**
@@ -4102,7 +4102,7 @@ declare type SDKControlSetColorRequest = {
 };
 
 /**
- * Sets the maximum number of thinking tokens for extended thinking. When max_thinking_tokens is omitted or null, thinking resets to the session default: any mid-session budget override is cleared (back to the spawn-time budget, if one was set), and thinking stays off for sessions that have it disabled. thinking_display optionally sets the thinking display mode for the rest of the session: a value replaces the session display mode, null clears it back to the API default, and when omitted the display mode from session start (--thinking-display) is kept.
+ * Sets the maximum number of thinking tokens for extended thinking. When max_thinking_tokens is omitted or null, thinking resets to the session default: any mid-session budget override is cleared (back to the spawn-time budget, if one was set), and thinking stays off for sessions that have it disabled. thinking_display optionally sets the thinking display mode for the rest of the session: a value replaces the session display mode, null clears that override so Claude Code's default display handling applies again, and when omitted the display mode from session start (--thinking-display) is kept.
  */
 declare type SDKControlSetMaxThinkingTokensRequest = {
     subtype: 'set_max_thinking_tokens';
@@ -4372,9 +4372,9 @@ export declare type SDKMessageOrigin = {
 } | {
     kind: 'task-notification';
     /**
-     * Present when the delivery is the fired stored prompt of a scheduled task/routine ('scheduled-trigger', stamped from server-asserted provenance; the schedule attests storage, not authorship), or a coordinator co-member SendMessage delivery ('peer-send-message': model-authored text from another of the same user's sessions, verified by the server-stamped receiver co-membership — task-notification for prompt authority, but distinguishable so the receive-side crossSessionInbound setting can apply to it). The harness frames a scheduled-trigger delivery as the session's assigned task instead of the generic background-notification frame. Absent on webhook, PR-steward, plugin, and background-event deliveries.
+     * Present when the delivery is the fired stored prompt of a scheduled task/routine ('scheduled-trigger', stamped from server-asserted provenance; the schedule attests storage, not authorship), a coordinator co-member SendMessage delivery ('peer-send-message': model-authored text from another of the same user's sessions, verified by the server-stamped receiver co-membership — task-notification for prompt authority, but distinguishable so the receive-side crossSessionInbound setting can apply to it), or a Claude Code Projects delivery that Anthropic servers composed for the project's coordinator session and addressed to one of its thread sessions ('projects-relay': the thread's first message, or a relay carrying project messages — stamped from server-asserted provenance). The harness frames a scheduled-trigger delivery as the session's assigned task and a projects-relay delivery that carries the server's relay stamps as a message from the coordinator session (one without them keeps the generic background-notification frame), instead of the generic background-notification frame. Absent on webhook, PR-steward, plugin, and background-event deliveries.
      */
-    subkind?: 'scheduled-trigger' | 'peer-send-message';
+    subkind?: 'scheduled-trigger' | 'peer-send-message' | 'projects-relay';
 } | {
     kind: 'coordinator';
 } | {
@@ -4815,7 +4815,7 @@ export declare type SDKSystemMessage = {
      */
     effort?: ('low' | 'medium' | 'high' | 'xhigh' | 'max') | null;
     /**
-     * Protocol capabilities this CLI supports, so SDK consumers can feature-detect instead of version-sniffing. Open set — ignore unknown values; check each capability for exactly the behavior you use. 'interrupt_receipt_v1' = the interrupt control_response success payload carries still_queued (uuids of async user messages that survive the interrupt). 'interrupt_cancel_queued_v1' = the interrupt control_request honors cancel_queued:true (queued and pending-dispatch commands are cancelled alongside the abort, listed on the response's cancelled field; still_queued is always empty — including any uuid that was mid-fold at the interrupt instant, since this request also aborts and the fold never delivers it). 'queued_notifications' = the CLI accepts inbound queued_notification stream messages and drains them via ReadNotifications (the CCR backend reads this from the persisted init event to decide whether it may send them). Absent on older CLIs.
+     * Protocol capabilities this CLI supports, so SDK consumers can feature-detect instead of version-sniffing. Open set — ignore unknown values; check each capability for exactly the behavior you use. 'interrupt_receipt_v1' = the interrupt control_response success payload carries still_queued (uuids of async user messages that survive the interrupt). 'interrupt_cancel_queued_v1' = the interrupt control_request honors cancel_queued:true (queued and pending-dispatch commands are cancelled alongside the abort, listed on the response's cancelled field; still_queued is then empty — including any uuid that was mid-fold at the interrupt instant, since this request also aborts and the fold never delivers it — except that a client driving a hosted session lists there what it can no longer recall: a send already in flight to that session, or the first prompt the session was created with). 'queued_notifications' = the CLI accepts inbound queued_notification stream messages and drains them via ReadNotifications (the CCR backend reads this from the persisted init event to decide whether it may send them). Absent on older CLIs.
      */
     capabilities?: string[];
 
@@ -5741,7 +5741,7 @@ export declare interface Settings {
         }[];
     };
     /**
-     * Git worktree configuration for --worktree flag.
+     * Git worktree configuration: the CLI --worktree flag, EnterWorktree and agent isolation, plus the location Claude Code Desktop uses for SSH-session worktrees on this machine.
      */
     worktree?: {
         /**
@@ -5760,6 +5760,10 @@ export declare interface Settings {
          * Isolation mode for background sessions in this repo. 'worktree' (default) blocks Edit/Write in the main checkout until EnterWorktree is called. 'none' lets background jobs edit the working copy directly.
          */
         bgIsolation?: 'worktree' | 'none';
+        /**
+         * Directory under which Claude Code Desktop creates the worktrees of SSH sessions that run on this machine (an absolute path or one starting with ~/), instead of <project>/.claude/worktrees. Read by the desktop app from the SSH host user settings; a location chosen in the desktop app's SSH connection settings takes precedence. The CLI (--worktree, EnterWorktree, agent isolation) does not read it yet.
+         */
+        location?: string;
     };
     /**
      * Disable all hooks and statusLine execution
@@ -7405,6 +7409,18 @@ export declare interface Settings {
      * Persisted effort level for supported models.
      */
     effortLevel?: 'low' | 'medium' | 'high' | 'xhigh';
+    /**
+     * Per-model settings keyed by canonical model name.
+     */
+    modelSettings?: {
+        [k: string]: {
+            /**
+             * Persisted effort level for this model.
+             */
+            effortLevel?: 'low' | 'medium' | 'high' | 'xhigh';
+            [k: string]: unknown;
+        };
+    };
     /**
      * Enable ultracode for the session: xhigh effort plus standing dynamic-workflow orchestration. Session-scoped — typically provided via --settings or the apply_flag_settings control request; interactive toggles never persist it. Requires workflows to be enabled and an xhigh-capable model.
      */
@@ -7619,7 +7635,7 @@ export declare interface Settings {
      */
     editorMode?: 'normal' | 'vim';
     /**
-     * Which conventions the prompt's editing keys follow: "readline" matches Bash and other readline programs (Ctrl+W deletes back to the previous whitespace); "classic" (default) keeps Claude Code's long-standing behavior (Ctrl+W deletes the previous word)
+     * Which conventions the prompt's word-editing keys follow: "readline" matches Bash and other readline programs (Ctrl+W deletes back to the previous whitespace; Alt+F and Alt+D stop at the end of the current word and Ctrl+Y can paste back what Alt+D deleted; for Alt+B, Alt+F, Alt+D, Ctrl/Option+Arrow and Option/Ctrl+Backspace a word is a run of letters and digits, so punctuation separates words); "classic" (default) keeps Claude Code's long-standing behavior (Ctrl+W deletes the previous word; the word keys use Unicode word segmentation, so foo_bar and 3.14 are one word)
      */
     keybindingFlavor?: 'classic' | 'readline';
     /**
@@ -8207,7 +8223,7 @@ export declare type UserPromptSubmitHookInput = BaseHookInput & {
     hook_event_name: 'UserPromptSubmit';
     prompt: string;
     /**
-     * Who authored/injected the prompt: `user` = submitted from the interactive composer, `sdk` = non-interactive entrypoint (`-p` / Agent SDK), `loop_wakeup` = dynamic /loop wakeup, `schedule_wakeup` = scheduled-task fire (CronCreate/routine), `system` = other machine-injected turns (peer/channel messages, task notifications, auto-continuation), `poll_event` = the poll-event channel enqueue-time pass (the hook fires when the host submits an event, before its delivery ack exists — a blocking verdict rejects the event). Currently only set for Anthropic-internal sessions while the field is trialed; external payloads omit it.
+     * Who authored/injected the prompt: `user` = submitted from the interactive composer, `sdk` = non-interactive entrypoint (`-p` / Agent SDK), `loop_wakeup` = dynamic /loop wakeup, `schedule_wakeup` = scheduled-task fire (CronCreate/routine), `system` = other machine-injected turns (peer/channel messages, task notifications, auto-continuation), `poll_event` = the poll-event channel enqueue-time pass (the hook fires when the host submits an event, before its delivery ack exists — a blocking verdict rejects the event). Payloads may omit it while the field rolls out.
      */
     source?: 'user' | 'sdk' | 'system' | 'loop_wakeup' | 'schedule_wakeup' | 'poll_event';
     session_title?: string;