@murphai/murph 1.2.0 → 1.2.4

package/node_modules/@murphai/assistant-engine/dist/assistant-codex/dynamic-tools.js

@@ -1,21 +1,34 @@
 import { z } from 'zod';
-import { HOSTED_PRODUCT_FEEDBACK_KINDS, HOSTED_PRODUCT_FEEDBACK_SUMMARY_MAX_LENGTH, sanitizeHostedProductFeedbackSummary, } from '@murphai/hosted-execution/runtime-control';
+import { assistantTonePreferenceValues, assistantVoiceOptionIdValues, assistantVoiceOptions, MURPH_PRODUCT_ORIGIN, } from '@murphai/contracts';
+import { hostedRuntimeAssistantPersonalizationModelToolRequestSchema, } from '@murphai/hosted-execution/assistant-personalization';
+import { HOSTED_EXECUTION_ASSISTANT_ASK_QUESTION_MAX_CODE_POINTS, HOSTED_EXECUTION_ASSISTANT_ASK_TARGET_LABEL_MAX_CODE_POINTS, } from '@murphai/hosted-execution/contracts';
+import { HOSTED_PLAN_CODES, HOSTED_PRODUCT_FEEDBACK_KINDS, HOSTED_PRODUCT_FEEDBACK_SUMMARY_MAX_LENGTH, HOSTED_RUNTIME_GROUP_DISPLAY_NAME_MAX_LENGTH, HOSTED_RUNTIME_GROUP_JOIN_OFFER_MESSAGE_TEMPLATE_MAX_LENGTH, HOSTED_RUNTIME_GROUP_KINDS, HOSTED_RUNTIME_NEWSLETTER_HTML_MAX_LENGTH, HOSTED_RUNTIME_NEWSLETTER_SUBJECT_MAX_LENGTH, HOSTED_RUNTIME_NEWSLETTER_TEXT_MAX_LENGTH, sanitizeHostedProductFeedbackSummary, } from '@murphai/hosted-execution/runtime-control';
+import { HOSTED_ASSISTANT_PRODUCT_MODELS, HOSTED_ASSISTANT_REASONING_EFFORTS, HOSTED_ASSISTANT_SOL_MODEL, } from '@murphai/hosted-execution/assistant-model';
+import { HOSTED_VAULT_SHARE_ACTIVITY_DISTANCE_PROJECTION_KIND, HOSTED_VAULT_SHARE_ACTIVITY_DISTANCE_SELECTOR_ACTIVITY_KINDS, HOSTED_VAULT_SHARE_ACTIVITY_MINUTES_PROJECTION_KIND, HOSTED_VAULT_SHARE_ACTIVITY_MINUTES_SELECTOR_ACTIVITY_KINDS, HOSTED_VAULT_SHARE_ACTIVITY_SESSION_COUNT_PROJECTION_KIND, HOSTED_VAULT_SHARE_ACTIVITY_SESSION_COUNT_SELECTOR_ACTIVITY_KINDS, HOSTED_VAULT_SHARE_SELECTABLE_PROJECTION_KINDS, HOSTED_VAULT_SHARE_SELECTABLE_PROJECTION_SCOPES, buildHostedVaultShareProjectionScopeKey, flattenSharedVaultShareProjectionStore, parseHostedVaultShareProjectionScope, } from '@murphai/hosted-execution/vault-share';
+import { readSharedVaultShareProjectionStore, } from '@murphai/hosted-execution/vault-share-store-node';
 import { buildHostedComputerRunOperationPath, HOSTED_COMPUTER_ACT_CODE_MAX_LENGTH, HOSTED_COMPUTER_ACT_TIMEOUT_MAX_MS, HOSTED_COMPUTER_FINISH_OUTCOMES, HOSTED_COMPUTER_RUNS_PATH, hostedComputerActRequestSchema, hostedComputerOsControlRequestSchema, hostedComputerPauseForUserRequestSchema, } from '@murphai/hosted-execution/computer-use';
 import { assistantMessageReactionSchema, } from '@murphai/operator-config/assistant-cli-contracts';
 import { normalizeNullableString } from '@murphai/operator-config/text/shared';
+import { buildSharedGroupWeeklyMembers, } from '@murphai/query';
 import { normalizeAssistantResponseMediaList } from '../assistant/response-media.js';
 import { buildSafeToolCallValidationDigest, } from '../assistant/tool-validation-digest.js';
 import { executeGenerateImageTool, } from './generate-image-tool.js';
+import { resolveGenerateImageReferences, } from './image-reference-resolver.js';
 import {} from './generate-voice-memo-tool.js';
-import { executeConnectedAppsDynamicTool, MURPH_CONNECTED_APPS_DYNAMIC_TOOLS, readConnectedAppsDynamicToolRequest, } from './dynamic-tools/connected-apps.js';
+import { executeAssistantStyleDynamicTool, MURPH_ASSISTANT_STYLE_TOOL, readAssistantStyleDynamicToolRequest, } from './dynamic-tools/assistant-style.js';
+export { MURPH_ASSISTANT_STYLE_TOOL } from './dynamic-tools/assistant-style.js';
+import { executeConnectedAppsDynamicTool, MURPH_CONNECTED_APPS_EXECUTE_TOOL, MURPH_CONNECTED_APPS_DYNAMIC_TOOLS, MURPH_CONNECTED_APPS_MANAGE_TOOL, MURPH_CONNECTED_APPS_SEARCH_TOOL, readConnectedAppsDynamicToolRequest, } from './dynamic-tools/connected-apps.js';
 import { executeGenerateVoiceMemoDynamicTool, MURPH_GENERATE_VOICE_MEMO_TOOL, parseGenerateVoiceMemoArguments, } from './dynamic-tools/generate-voice-memo.js';
 import { createPhoneCallRequestKey, MURPH_CREATE_PHONE_CALL_TOOL, readPhoneCallDynamicToolRequest, } from './dynamic-tools/phone-calls.js';
 import { executeGenerateSongDynamicTool, MURPH_GENERATE_SONG_TOOL, parseGenerateSongArguments, } from './dynamic-tools/generate-song.js';
+const MURPH_CHARACTER_SHEET_REFERENCE_IMAGE_REF = 'skill-assets/murph-character-sheet-v1.png';
+const GENERATE_IMAGE_REFERENCE_IMAGE_REFS_DESCRIPTION = `Optional ordered JPG, PNG, or WebP image refs to use as visual references (up to 16). Refs may be user-sent media under raw/inbox/**, captured media under raw/captures/**, or ${MURPH_CHARACTER_SHEET_REFERENCE_IMAGE_REF}, Murph's canonical character sheet. Attach ${MURPH_CHARACTER_SHEET_REFERENCE_IMAGE_REF} whenever Murph itself appears in a generated image. Describe in the prompt how image 1, image 2, etc. should be used.`;
+const GROUP_GENERATED_AVATAR_REFERENCE_IMAGE_REFS_DESCRIPTION = `Optional ordered JPG, PNG, or WebP image refs to use as visual references when action="set_chat_avatar" and avatarSource="generate". Refs may be user-sent media under raw/inbox/**, captured media under raw/captures/**, or ${MURPH_CHARACTER_SHEET_REFERENCE_IMAGE_REF}, Murph's canonical character sheet. Attach ${MURPH_CHARACTER_SHEET_REFERENCE_IMAGE_REF} whenever Murph itself appears in a generated avatar.`;
 const HOSTED_COMPUTER_UNKNOWN_OUTCOME_TEXT = 'computer API outcome is unknown after a transport or browser execution failure; call computer_open before retrying Playwright code or taking another step';
 export const MURPH_SEND_PROGRESS_UPDATE_TOOL = {
     namespace: 'murph',
     name: 'send_progress_update',
-    description: 'Send a brief, natural user-visible progress update to the current conversation only when longer, tool-heavy, or substantial user-content-inspection work would otherwise leave the user waiting. Use as the first assistant action for genuinely long tasks that require multiple tool steps, involve research or long vault scans, or recover substantial data from PDFs, lab reports, images, screenshots, CSVs, large pasted text, meal/product/supplement labels, workout exports, wearable exports, or health documents. For work likely to finish in about a minute or less, send at most one progress update. If the turn becomes unusually long-running after substantial tool work, you may send one more brief update so the user is not left hanging; never send a third. Prefer skipping progress updates on quota-sensitive messaging surfaces such as Linq/iMessage unless the update materially improves UX. Skip automatically transcribed voice memo or audio content unless manual media tools or broader long-running work are needed. Do not use for individual tool loops, searches, reads, page checks, clicks, status churn, skill-file reads alone, setup checks, routine single-command vault reads, quick single-step replies, one-shot logging/capture/memory saves that only need a straightforward write, or final conclusions.',
+    description: 'Send a brief, natural user-visible progress update to the current conversation only when longer, tool-heavy, or substantial user-content-inspection work would otherwise leave the user waiting. Use as the first assistant action for genuinely long tasks that require multiple tool steps, involve research or long vault scans, or recover substantial data from PDFs, lab reports, images, screenshots, CSVs, large pasted text, meal/product/supplement labels, workout exports, wearable exports, or health documents. For work likely to finish in about a minute or less, send at most one progress update. If the turn becomes unusually long-running after substantial tool work, you may send up to two more brief updates so the user is not left hanging; never send a fourth. Prefer skipping progress updates on quota-sensitive messaging surfaces such as Linq/iMessage unless the update materially improves UX. Skip automatically transcribed voice memo or audio content unless manual media tools or broader long-running work are needed. Do not use for individual tool loops, searches, reads, page checks, clicks, status churn, skill-file reads alone, setup checks, routine single-command vault reads, quick single-step replies, one-shot logging/capture/memory saves that only need a straightforward write, or final conclusions.',
     inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -23,7 +36,7 @@ export const MURPH_SEND_PROGRESS_UPDATE_TOOL = {
             text: {
                 type: 'string',
                 minLength: 1,
-                description: 'Prefer one short conversational first-person sentence about the immediate next step; use two only when needed to keep the quick note clear. Use contractions when natural. Avoid stiff plan-recitation wording like "I\'m going to..." when a shorter "I\'ll..." or "Taking a look..." works. No markdown links, final answers, lab interpretations, abnormalities, diagnoses, treatment recommendations, or claims not yet verified.',
+                description: 'Prefer one short conversational first-person sentence about the immediate next step; use two only when needed to keep the quick note clear. Use contractions when natural. Avoid stiff plan-recitation wording like "I\'m going to..." when a shorter "I\'ll..." or "Taking a look..." works. Write it the way a person would text: everyday words about what the user cares about, never internal mechanics or instruction vocabulary such as "preserving the source", "structured import", "parse", "canonical records", or "delegating" — "Got your labs, pulling the numbers in now" beats "starting the structured lab import". No markdown links, final answers, lab interpretations, abnormalities, diagnoses, treatment recommendations, or claims not yet verified.',
             },
         },
         required: ['text'],
@@ -79,7 +92,7 @@ export const MURPH_ATTACH_RESPONSE_MEDIA_TOOL = {
 export const MURPH_GENERATE_IMAGE_TOOL = {
     namespace: 'murph',
     name: 'generate_image',
-    description: 'Generate one image with GPT Image 2, optionally using ordered vault image references. When referenceImageRefs is provided, describe in the prompt how image 1, image 2, etc. should be used. Hosted runs attach the generated image to the final response; local runs save it under CODEX_HOME/generated_images.',
+    description: `Generate one image with GPT Image 2, optionally using ordered reference images from vault media or ${MURPH_CHARACTER_SHEET_REFERENCE_IMAGE_REF}. Attach ${MURPH_CHARACTER_SHEET_REFERENCE_IMAGE_REF}, Murph's canonical character sheet, whenever Murph itself appears in a generated image. When referenceImageRefs is provided, describe in the prompt how image 1, image 2, etc. should be used. When a vault is available, generated images are saved as canonical capture media under raw/captures/** for later reuse. Hosted runs also attach the generated image to the final response; local runs also save it under CODEX_HOME/generated_images.`,
     inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -115,7 +128,7 @@ export const MURPH_GENERATE_IMAGE_TOOL = {
                 type: 'array',
                 maxItems: 16,
                 default: [],
-                description: 'Optional ordered vault-relative JPG, PNG, or WebP image refs to use as visual references (up to 16). Use only refs the user attached as part of the current turn (other vault paths are rejected as unauthorized). Describe in the prompt how image 1, image 2, etc. should be used.',
+                description: GENERATE_IMAGE_REFERENCE_IMAGE_REFS_DESCRIPTION,
                 items: {
                     type: 'string',
                     minLength: 1,
@@ -160,10 +173,407 @@ export const MURPH_SUBMIT_PRODUCT_FEEDBACK_TOOL = {
         required: ['kind', 'summary'],
     },
 };
+export const MURPH_FAMILY_PLAN_TOOL = {
+    namespace: 'murph',
+    name: 'family_plan',
+    description: 'Read the current hosted user\'s Murph Family plan, start Family checkout, or create an invite. Use for Murph Family plan questions, tier/seat status checks, starting Family checkout, and requests to invite a family member on Pulse or Edge. The only supported actions are read_status, start_checkout, and create_invite. For invite cancellation, member removal, member-tier changes, or Family seat/capacity changes, do not invent an action or claim a change; use murph.plan_usage\'s explicit private management handoff. Do not use for family medical history.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['read_status', 'start_checkout', 'create_invite'],
+            },
+            invite: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    targetEmail: {
+                        anyOf: [
+                            { type: 'string', minLength: 3, maxLength: 320 },
+                            { type: 'null' },
+                        ],
+                        default: null,
+                        description: 'Email address for an email-bound web invite when the user provided one.',
+                    },
+                    planCode: {
+                        type: 'string',
+                        enum: [...HOSTED_PLAN_CODES],
+                        description: 'Pulse or Edge tier requested for this Family member. Omit for Pulse.',
+                    },
+                    targetLabel: {
+                        anyOf: [
+                            { type: 'string', minLength: 1, maxLength: 80 },
+                            { type: 'null' },
+                        ],
+                        default: null,
+                        description: 'Optional natural label such as mom, dad, brother, or a first name.',
+                    },
+                    targetPhoneNumber: {
+                        anyOf: [
+                            { type: 'string', minLength: 1, maxLength: 40 },
+                            { type: 'null' },
+                        ],
+                        default: null,
+                        description: 'Phone number for a phone-bound invite when the user provided one.',
+                    },
+                    targetTelegramUsername: {
+                        anyOf: [
+                            { type: 'string', minLength: 5, maxLength: 32 },
+                            { type: 'null' },
+                        ],
+                        default: null,
+                        description: 'Telegram username without @ when the user provided one.',
+                    },
+                },
+                description: 'Invite target for create_invite. Optional context for start_checkout when the user mentions the person they want to invite; no invite token is created until Family billing is active.',
+            },
+        },
+        required: ['action'],
+    },
+};
+export const MURPH_PLAN_USAGE_TOOL = {
+    namespace: 'murph',
+    name: 'plan_usage',
+    description: `Read the current hosted member's cost-weighted included usage, reset or trial-end date, and any server-authorized plan action. Use only for an explicit plan/included-usage question, an explicit request to manage billing or an unsupported Family account change, or a manual 1:1 check. Never call it automatically during onboarding or as a watcher. Cost-weighted included usage is not a literal token count or cash balance. Communicate usage only through usedPercent and remainingPercent; never expose, infer, or format internal currency amounts as usage progress. Percentages, dates, and forecasts are approximate; if forecast is null, invent no estimate, precision, scarcity, or urgency. Never plead, imply Murph will die, use existential guilt, shame, or pressure. Mention server-authorized start or upgrade actions only when recommendedAction is non-null and relevant to the member's request; use its label and URL. For an explicit billing-management or unsupported Family-management request, direct the member to ${MURPH_PRODUCT_ORIGIN}/settings#subscription only after a private result whose status is active or exhausted, or whose reason is trial_conversion_pending; make clear that the tool only read status and made no billing or Family change. Describe this as a neutral Settings browser handoff, not a plan recommendation or billing action. Do not provide that private account-management link for group_not_supported or hosted_access_inactive. This read-only tool does not change billing. It is not a group balance or top-up surface. Never ask a group for money, claim a shared balance, or name a payer.`,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {},
+    },
+};
+export const MURPH_PERSONALIZATION_TOOL = {
+    namespace: 'murph',
+    name: 'personalization',
+    description: 'Read the current private hosted member\'s effective Murph tone, voice, and model context, or atomically update tone and voice. Use murph.assistant_configuration for model or reasoning changes.',
+    inputSchema: {
+        oneOf: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['read'],
+                    },
+                },
+                required: ['action'],
+            },
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['update'],
+                    },
+                    tone: {
+                        type: 'string',
+                        enum: assistantTonePreferenceValues,
+                    },
+                    voice: {
+                        type: 'string',
+                        enum: assistantVoiceOptionIdValues,
+                        description: assistantVoiceOptions
+                            .map((option) => `${option.label}=${option.id}`)
+                            .join(', '),
+                    },
+                },
+                required: ['action'],
+                anyOf: [
+                    { required: ['tone'] },
+                    { required: ['voice'] },
+                ],
+            },
+        ],
+    },
+};
+export const MURPH_ASSISTANT_CONFIGURATION_TOOL = {
+    namespace: 'murph',
+    name: 'assistant_configuration',
+    description: 'Read the current hosted turn model and reasoning effort plus the models and reasoning efforts available for the next turn, or directly save an explicit user-requested change. Luna is the most usage-efficient model, Terra is the default, and Sol requires an active paid Edge plan. The lowest supported reasoning effort is low; these hosted models do not support none. Use action="read" whenever configuration facts are needed. Use action="update" only when the current user-sourced turn explicitly asks for the exact change. Never switch models or reasoning automatically because usage is low. Do not claim a change is saved unless the result says updated or unchanged. A saved update does not change the running turn and takes effect on the next turn.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['read', 'update'],
+            },
+            model: {
+                type: 'string',
+                enum: [...HOSTED_ASSISTANT_PRODUCT_MODELS],
+                description: 'Optional next-turn model for action="update".',
+            },
+            reasoningEffort: {
+                type: 'string',
+                enum: [...HOSTED_ASSISTANT_REASONING_EFFORTS],
+                description: 'Optional next-turn reasoning effort for action="update".',
+            },
+        },
+        required: ['action'],
+    },
+};
+const GROUP_VAULT_SHARE_FIXED_PROJECTION_SCOPE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['projectionKind'],
+    properties: {
+        projectionKind: {
+            type: 'string',
+            enum: [...HOSTED_VAULT_SHARE_SELECTABLE_PROJECTION_KINDS],
+        },
+    },
+};
+const GROUP_VAULT_SHARE_ACTIVITY_MINUTES_PROJECTION_SCOPE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['projectionKind', 'selector'],
+    properties: {
+        projectionKind: {
+            type: 'string',
+            enum: [HOSTED_VAULT_SHARE_ACTIVITY_MINUTES_PROJECTION_KIND],
+        },
+        selector: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['activityKind'],
+            properties: {
+                activityKind: {
+                    type: 'string',
+                    enum: [...HOSTED_VAULT_SHARE_ACTIVITY_MINUTES_SELECTOR_ACTIVITY_KINDS],
+                },
+            },
+            description: 'Required for activity-minutes-days.v1.',
+        },
+    },
+};
+const GROUP_VAULT_SHARE_ACTIVITY_DISTANCE_PROJECTION_SCOPE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['projectionKind', 'selector'],
+    properties: {
+        projectionKind: {
+            type: 'string',
+            enum: [HOSTED_VAULT_SHARE_ACTIVITY_DISTANCE_PROJECTION_KIND],
+        },
+        selector: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['activityKind'],
+            properties: {
+                activityKind: {
+                    type: 'string',
+                    enum: [...HOSTED_VAULT_SHARE_ACTIVITY_DISTANCE_SELECTOR_ACTIVITY_KINDS],
+                },
+            },
+            description: 'Required for activity-distance-days.v1.',
+        },
+    },
+};
+const GROUP_VAULT_SHARE_ACTIVITY_SESSION_COUNT_PROJECTION_SCOPE_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['projectionKind', 'selector'],
+    properties: {
+        projectionKind: {
+            type: 'string',
+            enum: [HOSTED_VAULT_SHARE_ACTIVITY_SESSION_COUNT_PROJECTION_KIND],
+        },
+        selector: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['activityKind'],
+            properties: {
+                activityKind: {
+                    type: 'string',
+                    enum: [...HOSTED_VAULT_SHARE_ACTIVITY_SESSION_COUNT_SELECTOR_ACTIVITY_KINDS],
+                },
+            },
+            description: 'Required for activity-session-count-days.v1.',
+        },
+    },
+};
+const GROUP_VAULT_SHARE_PROJECTION_SCOPE_SCHEMA = {
+    oneOf: [
+        GROUP_VAULT_SHARE_FIXED_PROJECTION_SCOPE_SCHEMA,
+        GROUP_VAULT_SHARE_ACTIVITY_MINUTES_PROJECTION_SCOPE_SCHEMA,
+        GROUP_VAULT_SHARE_ACTIVITY_DISTANCE_PROJECTION_SCOPE_SCHEMA,
+        GROUP_VAULT_SHARE_ACTIVITY_SESSION_COUNT_PROJECTION_SCOPE_SCHEMA,
+    ],
+};
+export const MURPH_GROUP_TOOL = {
+    namespace: 'murph',
+    name: 'group',
+    description: 'Use action="ask" only from a personal direct conversation when the member wants an answer from one of their joined group Murphs. Supply the bounded natural-language question and, only when useful for choosing among multiple groups, the visible groupLabel the member would recognize. For this action, the runtime resolves membership and every internal target automatically; never supply or ask the member for membership, group, runtime, mailbox, session, callback, or route identifiers. The result is asynchronous, so an accepted request will return to the personal conversation later. ' +
+        'Use action="list_memberships" in a personal Murph conversation to list the current member\'s hosted groups, their opaque membershipId, role, each group\'s requested permissions, the member\'s active grants, and the first-party permissionsUrl when the member owns the group and an owner-authorized join link exists. profile-name.v0 means the group is allowed to receive the member\'s preferred name; group-email.v0 means it is allowed to resolve the member\'s verified email for group email; hrv-days.v0 and other health scopes are separate explicit grants. A grant proves control-plane permission only, not that fresh source data exists or has already reached the group runtime. In a personal Murph conversation, when the current member explicitly asks to leave one of their hosted groups, call list_memberships first and then call action="leave_membership" with the exact nonempty membershipId returned for the chosen group. Never guess a membershipId, accept one supplied by the user, target a group by name alone, or construct, use, or expose a join URL to leave. Do not use leave_membership in a group conversation or for another person. A successful leave ends that member\'s Murph group membership and future sharing; it does not remove them from the iMessage chat or erase historical messages, provider history, backups, or third-party copies. Owners cannot leave their own group. Read the current hosted group and its member roster (member ids, chat handles, and each member\'s granted share kinds) with action="read_current", request an update to both the current hosted group display name and current iMessage group chat title with action="update_display_name", request an update to the current iMessage group avatar with action="set_chat_avatar", mint the shareable group join link with action="create_join_link", or post a server-owned like-to-consent offer into the current group chat with action="post_join_offer". In a connected group-chat turn, if read_current returns status="none", no hosted group record exists yet. When the group asks to create the group, join, or approve sharing, continue with create_join_link or post_join_offer instead of claiming that an external workspace-linking step is required. When an existing group adds a permission, default to post_join_offer; do not tell members to join again or make the link the primary action. update_display_name sends a provider request for the upstream iMessage group chat title on the current route-authorized group chat and stores the same name in Murph after the provider accepts the request. set_chat_avatar sends a provider request for the upstream iMessage group icon on the current route-authorized group chat after the runtime preflights chat authority and prepares a hosted image URL; generated avatar images are saved as capture media under raw/captures/** when a vault is available. A join link grants membership and shares the joiner\'s memory-backed preferred display name with this group runtime; optional permissions stay individually selected on the join page. A group offer uses your short natural messageTemplate and {{share_scope}} to state exactly what liking the offer consents to share, then includes {{join_url}} only as the customize path. Pass displayName on create_join_link or post_join_offer only when it is the name the group chose. Liking grants membership when needed and adds only the posted permission snapshot; existing members keep their membership and other grants. Do not use a fixed script. When these actions are available for the current connected group-chat turn, use action="read_chat_participants" to see who is in the chat and whether each participant already uses Murph; use action="share_contact_card" to drop your contact card so participants can save you and text you directly. Use action="revoke_own_email_share" only when the current sender asks to stop receiving group newsletter email; the runtime identifies the current sender and revokes only that sender\'s group-email.v0 grant. This tool does not otherwise manage members, grant Family billing access, grant private chat access, grant raw vault access, or grant email sharing except through an explicit group-email.v0 join page or offer.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'ask',
+                    'read_current',
+                    'list_memberships',
+                    'leave_membership',
+                    'update_display_name',
+                    'create_join_link',
+                    'post_join_offer',
+                    'read_chat_participants',
+                    'set_chat_avatar',
+                    'share_contact_card',
+                    'revoke_own_email_share',
+                ],
+            },
+            question: {
+                type: 'string',
+                minLength: 1,
+                maxLength: HOSTED_EXECUTION_ASSISTANT_ASK_QUESTION_MAX_CODE_POINTS,
+                description: 'Required only for action="ask". Ask one self-contained natural-language question whose answer may use the joined group\'s read-only context.',
+            },
+            groupLabel: {
+                type: 'string',
+                minLength: 1,
+                maxLength: HOSTED_EXECUTION_ASSISTANT_ASK_TARGET_LABEL_MAX_CODE_POINTS,
+                description: 'Optional only for action="ask". A visible group name the member would recognize, used only to disambiguate among joined groups; never an internal identifier.',
+            },
+            displayName: {
+                type: 'string',
+                minLength: 1,
+                maxLength: HOSTED_RUNTIME_GROUP_DISPLAY_NAME_MAX_LENGTH,
+                description: 'Group display name. Required for action="update_display_name", which requests the iMessage group chat title update and stores the same hosted group label; optional for action="create_join_link" or action="post_join_offer" only when it is the name the group chose.',
+            },
+            membershipId: {
+                type: 'string',
+                minLength: 1,
+                description: 'Required only for action="leave_membership". Use the exact opaque membershipId from the immediately preceding list_memberships result; never guess it or take it from the user.',
+            },
+            avatarSource: {
+                type: 'string',
+                enum: ['generate', 'image_ref'],
+                description: 'Required for action="set_chat_avatar". Use "generate" to create a new square avatar from prompt, or "image_ref" to reuse one user-sent JPG, PNG, or WebP image ref.',
+            },
+            prompt: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 4000,
+                description: 'Required for action="set_chat_avatar" with avatarSource="generate". Prompt for one square group chat avatar image.',
+            },
+            imageRef: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 1024,
+                description: 'Required for action="set_chat_avatar" with avatarSource="image_ref". A user-sent JPG, PNG, or WebP ref under raw/inbox/** or raw/captures/**.',
+            },
+            size: {
+                type: 'string',
+                enum: ['1024x1024'],
+                default: '1024x1024',
+                description: 'For generated group avatars. Group avatars are square.',
+            },
+            quality: {
+                type: 'string',
+                enum: ['low', 'medium', 'high'],
+                default: 'medium',
+            },
+            outputFormat: {
+                type: 'string',
+                enum: ['webp', 'png', 'jpeg'],
+                default: 'webp',
+            },
+            alt: {
+                anyOf: [
+                    { type: 'string', minLength: 1, maxLength: 500 },
+                    { type: 'null' },
+                ],
+                default: null,
+                description: 'Optional alt text for the generated or reused avatar image.',
+            },
+            referenceImageRefs: {
+                type: 'array',
+                maxItems: 16,
+                default: [],
+                description: GROUP_GENERATED_AVATAR_REFERENCE_IMAGE_REFS_DESCRIPTION,
+                items: {
+                    type: 'string',
+                    minLength: 1,
+                    maxLength: 1024,
+                },
+            },
+            kind: {
+                type: 'string',
+                enum: [...HOSTED_RUNTIME_GROUP_KINDS],
+                description: 'Optional group kind when creating a join link.',
+            },
+            requestedVaultShareProjectionScopes: {
+                type: 'array',
+                maxItems: HOSTED_VAULT_SHARE_SELECTABLE_PROJECTION_SCOPES.length,
+                items: GROUP_VAULT_SHARE_PROJECTION_SCOPE_SCHEMA,
+                description: 'Optional bounded health projection scopes the join page may offer joining members. Joining never shares them automatically; each member approves their own selection. Use activity-minutes-days.v1 with a recognized activity alias, activity-distance-days.v1 with a distance-capable movement alias for daily distance plus session count, or activity-session-count-days.v1 with a recognized activity/intervention alias.',
+            },
+            projectionScopes: {
+                type: 'array',
+                maxItems: HOSTED_VAULT_SHARE_SELECTABLE_PROJECTION_SCOPES.length,
+                items: GROUP_VAULT_SHARE_PROJECTION_SCOPE_SCHEMA,
+                description: 'Optional bounded health projections that liking the server-owned offer message will add as a fixed permission snapshot. Existing membership and other grants remain unchanged. The server-filled {{share_scope}} placeholder always states that preferred display name is shared too.',
+            },
+            messageTemplate: {
+                type: 'string',
+                minLength: 1,
+                maxLength: HOSTED_RUNTIME_GROUP_JOIN_OFFER_MESSAGE_TEMPLATE_MAX_LENGTH,
+                description: 'Required for action="post_join_offer". Write one short natural group-chat message, not a fixed script. Lead with the exact words "Like this message" and immediately say what liking it consents to share. For an existing group, frame this as opting in to the new permission, never joining or rejoining. Include {{share_scope}} exactly once where the server inserts the exact shared-scope phrase. Include {{join_url}} exactly once as the secondary customize path so members can share more or less. Do not include any other URL.',
+            },
+        },
+        required: ['action'],
+    },
+};
+export const MURPH_NEWSLETTER_TOOL = {
+    namespace: 'murph',
+    name: 'newsletter',
+    description: 'Prepare or send the scheduled group health newsletter. `prepare` returns recipient eligibility, the occurrence reference, and current-week shared facts filtered to exact live email and health-share grants; compose only from its members. Each turn allows one prepare attempt and at most one send attempt. `send` durably queues recipient-scoped delivery and may return `accepted` while that outbox work is pending; stop after that result and do not claim provider completion. Start the subject with the exact name in the current scheduled automation instructions, never a generic label. Send the first edition only after the setup notice and opt-out window. This tool sends one shared email thread, never exposes addresses or grant metadata, and does not manage the automation.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['prepare', 'send'],
+            },
+            groupId: {
+                type: 'string',
+                minLength: 1,
+            },
+            subject: {
+                type: 'string',
+                minLength: 1,
+                maxLength: HOSTED_RUNTIME_NEWSLETTER_SUBJECT_MAX_LENGTH,
+            },
+            html: {
+                type: 'string',
+                minLength: 1,
+                maxLength: HOSTED_RUNTIME_NEWSLETTER_HTML_MAX_LENGTH,
+            },
+            text: {
+                anyOf: [
+                    {
+                        type: 'string',
+                        maxLength: HOSTED_RUNTIME_NEWSLETTER_TEXT_MAX_LENGTH,
+                    },
+                    { type: 'null' },
+                ],
+                default: null,
+            },
+        },
+        required: ['action', 'groupId'],
+    },
+};
 export const MURPH_SEND_VAULT_FILE_TOOL = {
     namespace: 'murph',
     name: 'send_vault_file',
-    description: "Securely prepare one existing file from the user's vault for the current iMessage conversation. Use a normalized vault-relative file path. When approval is pending, include the returned approval link in your normal reply. When approval is approved, this attaches the exact approved file to your normal reply. It does not reveal file bytes to the model, does not queue a separate delivery, and does not support arbitrary recipients.",
+    description: "Securely prepare one existing file from the user's vault for the current iMessage conversation. Use a normalized vault-relative file path. When approval is pending, explain that approval is required; the runtime adds the exact link outside model context. When approval is approved, attach the file through your normal reply path and write a natural acknowledgment instead of reciting internal queue or delivery-status wording. Do not claim final iMessage delivery unless later delivery evidence confirms it. It does not reveal file bytes to the model and does not support arbitrary recipients.",
     inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -277,7 +687,7 @@ export const MURPH_COMPUTER_ACT_TOOL = {
 export const MURPH_COMPUTER_OS_CONTROL_TOOL = {
     namespace: 'murph',
     name: 'computer_os_control',
-    description: 'Fallback only: run one bounded OS-level mouse or keyboard action against the current Kernel browser when computer_act cannot operate the page. Prefer computer_act for normal browser automation. Do not use for passwords, payment details, one-time codes, tokens, or any sensitive private input. After an OS-level action with an unknown outcome, use computer_open once to confirm the resulting page state.',
+    description: 'Fallback only: run one bounded OS-level mouse or keyboard action when computer_act cannot reliably operate the current Kernel page, including a visible enabled control that remains unresponsive after one safe Playwright alternative and a current-state check. Prefer computer_act for normal automation; obtain a fresh bounding box immediately before a coordinate action, and set numClicks to 1 for every fallback click. Never use OS control as a blind second click when a prior attempt may have caused a side effect: use computer_open to prove it did not happen first. After OS control, use computer_open to verify page state, and do not act again if a purchase, booking, submission, or other effect remains ambiguous. Do not use for passwords, payment details, one-time codes, tokens, or sensitive private input.',
     inputSchema: MURPH_COMPUTER_OS_CONTROL_INPUT_SCHEMA,
 };
 export const MURPH_COMPUTER_PAUSE_FOR_USER_TOOL = {
@@ -334,9 +744,16 @@ export const MURPH_COMPUTER_FINISH_RUN_TOOL = {
 };
 const MURPH_BASE_DYNAMIC_TOOLS = [
     MURPH_SEND_PROGRESS_UPDATE_TOOL,
+    MURPH_ASSISTANT_STYLE_TOOL,
     MURPH_ATTACH_RESPONSE_MEDIA_TOOL,
     MURPH_GENERATE_IMAGE_TOOL,
     MURPH_GENERATE_VOICE_MEMO_TOOL,
+    MURPH_ASSISTANT_CONFIGURATION_TOOL,
+    MURPH_PERSONALIZATION_TOOL,
+    MURPH_FAMILY_PLAN_TOOL,
+    MURPH_PLAN_USAGE_TOOL,
+    MURPH_GROUP_TOOL,
+    MURPH_NEWSLETTER_TOOL,
     MURPH_GENERATE_SONG_TOOL,
     MURPH_SUBMIT_PRODUCT_FEEDBACK_TOOL,
     MURPH_SEND_VAULT_FILE_TOOL,
@@ -364,15 +781,24 @@ const defaultOn = (read) => (a) => read(a) !== false;
 const defaultOff = (read) => (a) => read(a) === true;
 const TOOL_AVAILABILITY = new Map([
     [MURPH_SEND_PROGRESS_UPDATE_TOOL, defaultOn((a) => a.progressUpdatesAvailable)],
+    [MURPH_ASSISTANT_STYLE_TOOL, defaultOff((a) => a.assistantStyleSettingsAvailable)],
     [MURPH_FINISH_WITHOUT_REPLY_TOOL, defaultOn((a) => a.allowFinishWithoutReply)],
     [MURPH_REACT_TO_MESSAGE_TOOL, defaultOff((a) => a.allowMessageReactions)],
     [MURPH_SUBMIT_PRODUCT_FEEDBACK_TOOL, defaultOff((a) => a.productFeedbackAvailable)],
+    [MURPH_ASSISTANT_CONFIGURATION_TOOL, defaultOff((a) => a.assistantConfigurationAvailable)],
+    [MURPH_FAMILY_PLAN_TOOL, defaultOff((a) => a.familyPlanAvailable)],
+    [MURPH_PLAN_USAGE_TOOL, defaultOff((a) => a.planUsageAvailable)],
+    [MURPH_GROUP_TOOL, defaultOff((a) => a.groupAvailable)],
+    [MURPH_NEWSLETTER_TOOL, defaultOff((a) => a.newsletterAvailable)],
+    [MURPH_PERSONALIZATION_TOOL, defaultOff((a) => a.personalizationAvailable)],
     [MURPH_GENERATE_VOICE_MEMO_TOOL, defaultOff((a) => a.voiceMemoGenerationAvailable)],
     [MURPH_GENERATE_SONG_TOOL, defaultOff((a) => a.voiceMemoGenerationAvailable)],
     [MURPH_SEND_VAULT_FILE_TOOL, defaultOff((a) => a.vaultFileSendAvailable)],
     [MURPH_CREATE_PHONE_CALL_TOOL, defaultOff((a) => a.phoneCallsAvailable)],
     ...MURPH_COMPUTER_DYNAMIC_TOOLS.map((tool) => [tool, defaultOff((a) => a.computerToolsAvailable)]),
-    ...MURPH_CONNECTED_APPS_DYNAMIC_TOOLS.map((tool) => [tool, defaultOff((a) => a.connectedAppsAvailable)]),
+    [MURPH_CONNECTED_APPS_MANAGE_TOOL, defaultOff((a) => a.connectedAppsAvailable && a.connectedAppsManageAvailable !== false)],
+    [MURPH_CONNECTED_APPS_SEARCH_TOOL, defaultOff((a) => a.connectedAppsAvailable)],
+    [MURPH_CONNECTED_APPS_EXECUTE_TOOL, defaultOff((a) => a.connectedAppsAvailable)],
 ]);
 export function resolveMurphDynamicTools(availability) {
     return MURPH_DYNAMIC_TOOLS.filter((tool) => (TOOL_AVAILABILITY.get(tool) ?? ALWAYS_AVAILABLE)(availability));
@@ -400,16 +826,194 @@ const generateImageArgumentsSchema = z
     referenceImageRefs: z
         .array(z.string().trim().min(1).max(1024))
         .max(16)
+        .describe(GENERATE_IMAGE_REFERENCE_IMAGE_REFS_DESCRIPTION)
         .default([]),
     size: z.enum(['1024x1024', '1024x1536', '1536x1024']).default('1024x1024'),
 })
     .strict();
+const GROUP_JOIN_OFFER_JOIN_URL_PLACEHOLDER = '{{join_url}}';
+const GROUP_JOIN_OFFER_SHARE_SCOPE_PLACEHOLDER = '{{share_scope}}';
+function hasUsableGroupJoinOfferPlaceholders(messageTemplate) {
+    return hasPlaceholderExactlyOnce(messageTemplate, GROUP_JOIN_OFFER_SHARE_SCOPE_PLACEHOLDER) && hasPlaceholderExactlyOnce(messageTemplate, GROUP_JOIN_OFFER_JOIN_URL_PLACEHOLDER);
+}
+function hasPlaceholderExactlyOnce(messageTemplate, placeholder) {
+    return (messageTemplate.includes(placeholder)
+        && messageTemplate.indexOf(placeholder) === messageTemplate.lastIndexOf(placeholder));
+}
+const selectableVaultShareProjectionScopeByKey = new Map(HOSTED_VAULT_SHARE_SELECTABLE_PROJECTION_SCOPES.map((scope) => [
+    buildHostedVaultShareProjectionScopeKey(scope),
+    scope,
+]));
+const groupVaultShareProjectionScopeSchema = z.unknown().transform((value, context) => {
+    let parsedScope;
+    try {
+        parsedScope = parseHostedVaultShareProjectionScope(value, 'murph.group vault share projection scope');
+    }
+    catch (error) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: error instanceof Error
+                ? error.message
+                : 'Vault share projection scope is not supported.',
+        });
+        return z.NEVER;
+    }
+    const scope = selectableVaultShareProjectionScopeByKey.get(buildHostedVaultShareProjectionScopeKey(parsedScope));
+    if (!scope) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Vault share projection scope is not selectable.',
+        });
+        return z.NEVER;
+    }
+    return scope;
+});
+const groupArgumentsSchema = z.discriminatedUnion('action', [
+    z
+        .object({
+        action: z.literal('ask'),
+        groupLabel: z
+            .string()
+            .trim()
+            .min(1)
+            .refine((value) => Array.from(value).length
+            <= HOSTED_EXECUTION_ASSISTANT_ASK_TARGET_LABEL_MAX_CODE_POINTS, { message: 'groupLabel exceeds the Unicode code-point limit' })
+            .optional(),
+        question: z
+            .string()
+            .trim()
+            .min(1)
+            .refine((value) => Array.from(value).length
+            <= HOSTED_EXECUTION_ASSISTANT_ASK_QUESTION_MAX_CODE_POINTS, { message: 'question exceeds the Unicode code-point limit' }),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('read_current'),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('list_memberships'),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('leave_membership'),
+        membershipId: z.string().trim().min(1),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('update_display_name'),
+        displayName: z
+            .string()
+            .trim()
+            .min(1)
+            .max(HOSTED_RUNTIME_GROUP_DISPLAY_NAME_MAX_LENGTH),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('set_chat_avatar'),
+        alt: z.string().trim().min(1).max(500).nullable().default(null),
+        avatarSource: z.enum(['generate', 'image_ref']),
+        imageRef: z.string().trim().min(1).max(1024).optional(),
+        outputFormat: z.enum(['webp', 'png', 'jpeg']).default('webp'),
+        prompt: z.string().trim().min(1).max(4000).optional(),
+        quality: z.enum(['low', 'medium', 'high']).default('medium'),
+        referenceImageRefs: z
+            .array(z.string().trim().min(1).max(1024))
+            .max(16)
+            .describe(GROUP_GENERATED_AVATAR_REFERENCE_IMAGE_REFS_DESCRIPTION)
+            .default([]),
+        size: z.literal('1024x1024').default('1024x1024'),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('read_chat_participants'),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('share_contact_card'),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('post_join_offer'),
+        displayName: z
+            .string()
+            .trim()
+            .min(1)
+            .max(HOSTED_RUNTIME_GROUP_DISPLAY_NAME_MAX_LENGTH)
+            .optional(),
+        messageTemplate: z
+            .string()
+            .trim()
+            .min(1)
+            .max(HOSTED_RUNTIME_GROUP_JOIN_OFFER_MESSAGE_TEMPLATE_MAX_LENGTH)
+            .refine(hasUsableGroupJoinOfferPlaceholders, {
+            message: 'post_join_offer messageTemplate must contain {{share_scope}} exactly once and {{join_url}} exactly once',
+        }),
+        projectionScopes: z
+            .array(groupVaultShareProjectionScopeSchema)
+            .max(HOSTED_VAULT_SHARE_SELECTABLE_PROJECTION_SCOPES.length)
+            .optional(),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('revoke_own_email_share'),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('create_join_link'),
+        displayName: z
+            .string()
+            .trim()
+            .min(1)
+            .max(HOSTED_RUNTIME_GROUP_DISPLAY_NAME_MAX_LENGTH)
+            .optional(),
+        kind: z.enum(HOSTED_RUNTIME_GROUP_KINDS).optional(),
+        requestedVaultShareProjectionScopes: z
+            .array(groupVaultShareProjectionScopeSchema)
+            .max(HOSTED_VAULT_SHARE_SELECTABLE_PROJECTION_SCOPES.length)
+            .optional(),
+    })
+        .strict(),
+]);
+const newsletterArgumentsSchema = z.discriminatedUnion('action', [
+    z
+        .object({
+        action: z.literal('prepare'),
+        groupId: z.string().trim().min(1),
+    })
+        .strict(),
+    z
+        .object({
+        action: z.literal('send'),
+        groupId: z.string().trim().min(1),
+        html: z.string().trim().min(1).max(HOSTED_RUNTIME_NEWSLETTER_HTML_MAX_LENGTH),
+        subject: z.string().trim().min(1).max(HOSTED_RUNTIME_NEWSLETTER_SUBJECT_MAX_LENGTH),
+        text: z
+            .string()
+            .trim()
+            .max(HOSTED_RUNTIME_NEWSLETTER_TEXT_MAX_LENGTH)
+            .nullable()
+            .optional(),
+    })
+        .strict(),
+]);
 const sendVaultFileArgumentsSchema = z
     .object({
     ref: z.string().trim().min(1).max(1024),
 })
     .strict();
 const finishWithoutReplyArgumentsSchema = z.object({}).strict();
+const planUsageArgumentsSchema = z.object({}).strict();
 const submitProductFeedbackArgumentsSchema = z
     .object({
     kind: z.enum(HOSTED_PRODUCT_FEEDBACK_KINDS),
@@ -425,6 +1029,61 @@ const submitProductFeedbackArgumentsSchema = z
         .default([]),
 })
     .strict();
+const familyPlanArgumentsSchema = z
+    .discriminatedUnion('action', [
+    z.object({
+        action: z.literal('read_status'),
+    }).strict(),
+    z.object({
+        action: z.literal('start_checkout'),
+        invite: z.object({
+            planCode: z.enum(HOSTED_PLAN_CODES).optional(),
+            targetEmail: z.string().trim().email().max(320).nullable().default(null),
+            targetLabel: z.string().trim().min(1).max(80).nullable().default(null),
+            targetPhoneNumber: z.string().trim().min(1).max(40).nullable().default(null),
+            targetTelegramUsername: z.string().trim().min(5).max(32).nullable().default(null),
+        }).strict().nullable().default(null),
+    }).strict(),
+    z.object({
+        action: z.literal('create_invite'),
+        invite: z.object({
+            planCode: z.enum(HOSTED_PLAN_CODES).optional(),
+            targetEmail: z.string().trim().email().max(320).nullable().default(null),
+            targetLabel: z.string().trim().min(1).max(80).nullable().default(null),
+            targetPhoneNumber: z.string().trim().min(1).max(40).nullable().default(null),
+            targetTelegramUsername: z.string().trim().min(5).max(32).nullable().default(null),
+        }).strict(),
+    }).strict(),
+])
+    .superRefine((value, context) => {
+    const invite = value.action === 'create_invite'
+        ? value.invite
+        : value.action === 'start_checkout'
+            ? value.invite
+            : null;
+    if (invite && !invite.targetPhoneNumber && !invite.targetTelegramUsername && !invite.targetEmail) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Family invite requires a phone number, Telegram username, or email.',
+            path: ['invite'],
+        });
+    }
+});
+const assistantConfigurationArgumentsSchema = z
+    .union([
+    z.object({
+        action: z.literal('read'),
+    }).strict(),
+    z.object({
+        action: z.literal('update'),
+        model: z.enum(HOSTED_ASSISTANT_PRODUCT_MODELS),
+        reasoningEffort: z.enum(HOSTED_ASSISTANT_REASONING_EFFORTS).optional(),
+    }).strict(),
+    z.object({
+        action: z.literal('update'),
+        reasoningEffort: z.enum(HOSTED_ASSISTANT_REASONING_EFFORTS),
+    }).strict(),
+]);
 const computerRunIdSchema = z.string().trim().min(1);
 const COMPUTER_OPEN_ARGUMENT_ROOT_KEYS = [
     'startUrl',
@@ -574,6 +1233,13 @@ export function readMurphDynamicToolRequest(message) {
     if (connectedAppsRequest) {
         return connectedAppsRequest;
     }
+    const assistantStyleRequest = readAssistantStyleDynamicToolRequest({
+        arguments: request.arguments,
+        tool: request.tool,
+    });
+    if (assistantStyleRequest) {
+        return assistantStyleRequest;
+    }
     const phoneCallRequest = readPhoneCallDynamicToolRequest({
         arguments: request.arguments,
         tool: request.tool,
@@ -619,6 +1285,7 @@ export function readMurphDynamicToolRequest(message) {
             return {
                 kind: 'generate-image',
                 args: parsed.args,
+                ...(request.toolCallId ? { toolCallId: request.toolCallId } : {}),
             };
         }
         case MURPH_GENERATE_VOICE_MEMO_TOOL.name: {
@@ -673,8 +1340,86 @@ export function readMurphDynamicToolRequest(message) {
                 feedback: parsed.feedback,
             };
         }
-        case MURPH_FINISH_WITHOUT_REPLY_TOOL.name: {
-            const parsed = parseFinishWithoutReplyArguments(request.arguments);
+        case MURPH_FAMILY_PLAN_TOOL.name: {
+            const parsed = parseFamilyPlanArguments(request.arguments);
+            if (!parsed.ok) {
+                return {
+                    kind: 'invalid-family-plan-arguments',
+                    validationDigest: parsed.validationDigest,
+                };
+            }
+            return {
+                kind: 'family-plan',
+                request: parsed.request,
+            };
+        }
+        case MURPH_PLAN_USAGE_TOOL.name: {
+            const parsed = parsePlanUsageArguments(request.arguments);
+            if (!parsed.ok) {
+                return {
+                    kind: 'invalid-plan-usage-arguments',
+                    validationDigest: parsed.validationDigest,
+                };
+            }
+            return {
+                kind: 'plan-usage',
+            };
+        }
+        case MURPH_PERSONALIZATION_TOOL.name: {
+            const parsed = parsePersonalizationArguments(request.arguments);
+            if (!parsed.ok) {
+                return {
+                    kind: 'invalid-personalization-arguments',
+                    validationDigest: parsed.validationDigest,
+                };
+            }
+            return {
+                kind: 'personalization',
+                request: parsed.request,
+            };
+        }
+        case MURPH_ASSISTANT_CONFIGURATION_TOOL.name: {
+            const parsed = parseAssistantConfigurationArguments(request.arguments);
+            if (!parsed.ok) {
+                return {
+                    kind: 'invalid-assistant-configuration-arguments',
+                    validationDigest: parsed.validationDigest,
+                };
+            }
+            return {
+                kind: 'assistant-configuration',
+                request: parsed.request,
+            };
+        }
+        case MURPH_GROUP_TOOL.name: {
+            const parsed = parseGroupArguments(request.arguments);
+            if (!parsed.ok) {
+                return {
+                    kind: 'invalid-group-arguments',
+                    validationDigest: parsed.validationDigest,
+                };
+            }
+            return {
+                kind: 'group',
+                request: parsed.request,
+                ...(request.toolCallId ? { toolCallId: request.toolCallId } : {}),
+            };
+        }
+        case MURPH_NEWSLETTER_TOOL.name: {
+            const parsed = parseNewsletterArguments(request.arguments);
+            if (!parsed.ok) {
+                return {
+                    kind: 'invalid-newsletter-arguments',
+                    validationDigest: parsed.validationDigest,
+                };
+            }
+            return {
+                kind: 'newsletter',
+                request: parsed.request,
+            };
+        }
+        case MURPH_FINISH_WITHOUT_REPLY_TOOL.name: {
+            const parsed = parseFinishWithoutReplyArguments(request.arguments);
             if (!parsed.ok) {
                 return {
                     kind: 'invalid-finish-without-reply-arguments',
@@ -803,6 +1548,17 @@ function currentHostedMailboxItemId(hostedToolContext) {
     }
     return null;
 }
+function buildGeneratedImageCaptureIdempotencyKey(input) {
+    const toolCallId = normalizeNullableString(input.toolCallId);
+    return toolCallId
+        ? `murph.dynamic-tool.${input.scope}:${toolCallId}`
+        : null;
+}
+function readGeneratedImageToolCallId(request) {
+    return ('toolCallId' in request)
+        ? normalizeNullableString(request.toolCallId)
+        : null;
+}
 export async function executeMurphDynamicToolRequest(input) {
     if (isExecutableComputerDynamicToolRequest(input.request) &&
         !canExecuteComputerDynamicTools(input.hostedToolContext ?? null)) {
@@ -811,6 +1567,8 @@ export async function executeMurphDynamicToolRequest(input) {
     switch (input.request.kind) {
         case 'invalid-connected-apps-arguments':
             return toolTextResult(false, 'invalid connected-app arguments');
+        case 'invalid-assistant-style-arguments':
+            return toolTextResult(false, 'invalid assistant style arguments');
         case 'invalid-generate-image-arguments':
             return toolTextResult(false, 'invalid image generation arguments');
         case 'invalid-computer-arguments':
@@ -825,6 +1583,18 @@ export async function executeMurphDynamicToolRequest(input) {
             return toolTextResult(false, 'invalid reaction arguments');
         case 'invalid-product-feedback-arguments':
             return toolTextResult(false, 'invalid product feedback arguments');
+        case 'invalid-family-plan-arguments':
+            return toolTextResult(false, 'invalid family plan arguments');
+        case 'invalid-personalization-arguments':
+            return toolTextResult(false, 'invalid personalization arguments');
+        case 'invalid-plan-usage-arguments':
+            return toolTextResult(false, 'invalid plan usage arguments');
+        case 'invalid-assistant-configuration-arguments':
+            return toolTextResult(false, 'invalid assistant configuration arguments');
+        case 'invalid-group-arguments':
+            return toolTextResult(false, 'invalid group arguments');
+        case 'invalid-newsletter-arguments':
+            return toolTextResult(false, 'invalid newsletter arguments');
         case 'invalid-finish-without-reply-arguments':
             return toolTextResult(false, 'invalid no-reply arguments');
         case 'invalid-response-media-arguments':
@@ -854,6 +1624,18 @@ export async function executeMurphDynamicToolRequest(input) {
                 progressDelivery: input.progressDelivery,
                 text: input.request.text,
             });
+        case 'assistant-style': {
+            const hostedToolContext = input.hostedToolContext ?? null;
+            return await executeAssistantStyleDynamicTool({
+                assistantInputId: hostedToolContext?.currentAssistantPreferenceInputId?.() ?? null,
+                available: input.assistantStyleSettingsAvailable === true,
+                hosted: hostedToolContext != null,
+                hostedPersonalizationTool: hostedToolContext?.personalizationTool ?? null,
+                hostedSettingsOverlay: input.assistantStyleSettingsOverlay ?? null,
+                request: input.request,
+                vaultRoot: input.vaultRoot ?? null,
+            });
+        }
         case 'send-vault-file': {
             const hostedToolContext = input.hostedToolContext ?? null;
             const sendVaultFile = hostedToolContext?.sendVaultFile;
@@ -870,15 +1652,17 @@ export async function executeMurphDynamicToolRequest(input) {
                     case 'pending':
                         return {
                             ...toolTextResult(true, JSON.stringify({
-                                approvalUrl: result.approvalUrl,
                                 filename: result.filename,
                                 status: result.status,
                             })),
+                            requiredVaultFileApprovalUrl: result.approvalUrl,
                         };
                     case 'approved':
                         return {
                             ...toolTextResult(true, JSON.stringify({
+                                deliveryStatus: 'queued_with_reply',
                                 filename: result.filename,
+                                note: 'Approval succeeded. Attach this file through your normal reply path. Do not quote this note or claim final iMessage delivery unless later delivery evidence confirms it.',
                                 status: result.status,
                             })),
                             responseMediaPatch: {
@@ -902,9 +1686,9 @@ export async function executeMurphDynamicToolRequest(input) {
             if (!hostedToolContext || !phoneCalls) {
                 return toolTextResult(false, 'phone calling is unavailable without hosted phone-call transport');
             }
-            const requestKeyScope = hostedToolContext.currentPhoneCallToolRequestKeyScope?.() ?? null;
+            const requestKeyScope = hostedToolContext.currentUserActionScope?.() ?? null;
             if (!requestKeyScope) {
-                return toolTextResult(false, 'phone calling requires user-approved manual input for this turn');
+                return toolTextResult(false, 'phone calling requires user-sourced input for this turn');
             }
             try {
                 const result = await phoneCalls.start({
@@ -916,7 +1700,12 @@ export async function executeMurphDynamicToolRequest(input) {
                 }, {
                     signal: input.abortSignal ?? null,
                 });
-                return toolTextResult(true, `phone call ${result.status}: ${result.phoneCallId}`);
+                if (result.status === "calling") {
+                    return toolTextResult(true, `phone call accepted or placed: ${result.phoneCallId}`);
+                }
+                return toolTextResult(false, result.status === "starting"
+                    ? `phone call start is still being reconciled: ${result.phoneCallId}`
+                    : `phone call attempt was unsuccessful: ${result.phoneCallId}`);
             }
             catch {
                 return toolTextResult(false, 'phone call could not be started');
@@ -927,6 +1716,44 @@ export async function executeMurphDynamicToolRequest(input) {
                 feedback: input.request.feedback,
                 productFeedbackRecorder: input.productFeedbackRecorder ?? null,
             });
+        case 'family-plan':
+            return await executeFamilyPlanTool({
+                hostedToolContext: input.hostedToolContext ?? null,
+                request: input.request.request,
+            });
+        case 'plan-usage':
+            return await executePlanUsageTool({
+                hostedToolContext: input.hostedToolContext ?? null,
+            });
+        case 'personalization':
+            return await executePersonalizationTool({
+                hostedToolContext: input.hostedToolContext ?? null,
+                request: input.request.request,
+            });
+        case 'assistant-configuration':
+            return await executeAssistantConfigurationTool({
+                hostedToolContext: input.hostedToolContext ?? null,
+                request: input.request.request,
+            });
+        case 'group':
+            return await executeGroupTool({
+                abortSignal: input.abortSignal ?? null,
+                env: input.env,
+                fetchImpl: input.fetchImpl,
+                hostedToolContext: input.hostedToolContext ?? null,
+                hostedGeneratedImageUploader: input.hostedGeneratedImageUploader ?? null,
+                materializeWorkspaceArtifacts: input.materializeWorkspaceArtifacts ?? null,
+                nextUsageOrdinal: input.nextUsageOrdinal,
+                request: input.request.request,
+                toolCallId: readGeneratedImageToolCallId(input.request),
+                vaultRoot: input.vaultRoot ?? null,
+            });
+        case 'newsletter':
+            return await executeNewsletterTool({
+                hostedToolContext: input.hostedToolContext ?? null,
+                request: input.request.request,
+                vaultRoot: input.vaultRoot ?? null,
+            });
         case 'finish-without-reply':
             return {
                 ...toolTextResult(true, 'finished without reply'),
@@ -948,19 +1775,13 @@ export async function executeMurphDynamicToolRequest(input) {
             if (hasVoiceMemoResponseMedia(input.currentResponseMedia ?? [])) {
                 return toolTextResult(false, 'image generation cannot be combined with a voice memo');
             }
-            // Only resolve the per-turn authority allowlist when the model is
-            // actually requesting reference images. A plain no-refs generate_image
-            // call must keep working even if the accepted-input journal is
-            // transiently unreadable; gating the loader keeps the existing
-            // /v1/images/generations path independent of attachment-runtime state.
-            const requestedRefs = input.request.args.referenceImageRefs ?? [];
-            const authorizedRefs = requestedRefs.length > 0 && input.loadAuthorizedReferenceImageRefs
-                ? await input.loadAuthorizedReferenceImageRefs()
-                : null;
             const result = await executeGenerateImageTool({
                 abortSignal: input.abortSignal ?? null,
                 args: input.request.args,
-                authorizedReferenceImageRefs: authorizedRefs,
+                captureIdempotencyKey: buildGeneratedImageCaptureIdempotencyKey({
+                    toolCallId: readGeneratedImageToolCallId(input.request),
+                    scope: 'generate-image',
+                }),
                 codexHome: input.codexHome ?? null,
                 env: input.env,
                 fetchImpl: input.fetchImpl,
@@ -1065,6 +1886,10 @@ export async function executeMurphDynamicToolRequest(input) {
                     pauseDeliveryContext: currentHostedDeliveryContext(input.hostedToolContext ?? null),
                 },
                 fetchImpl: input.fetchImpl,
+                finishPath: buildHostedComputerRunOperationPath({
+                    operation: 'finish',
+                    runId,
+                }),
                 path: buildHostedComputerRunOperationPath({
                     operation: 'pause-for-user',
                     runId,
@@ -1108,6 +1933,561 @@ async function executeSubmitProductFeedbackTool(input) {
         return toolTextResult(false, 'product feedback recording failed');
     }
 }
+async function executeFamilyPlanTool(input) {
+    const familyPlanTool = input.hostedToolContext?.familyPlanTool ?? null;
+    if (!familyPlanTool) {
+        return toolTextResult(false, 'family plan tools are unavailable for this turn');
+    }
+    try {
+        const result = await familyPlanTool.request(input.request);
+        return toolTextResult(true, safeToolPayloadText(result));
+    }
+    catch {
+        return toolTextResult(false, 'family plan tool request failed');
+    }
+}
+async function executePlanUsageTool(input) {
+    const planUsageTool = input.hostedToolContext?.planUsageTool ?? null;
+    if (!planUsageTool) {
+        return toolTextResult(false, 'plan usage is unavailable for this turn');
+    }
+    try {
+        return toolTextResult(true, safeToolPayloadText(await planUsageTool.read()));
+    }
+    catch {
+        return toolTextResult(false, 'plan usage could not be read');
+    }
+}
+async function executePersonalizationTool(input) {
+    const personalizationTool = input.hostedToolContext?.personalizationTool ?? null;
+    if (!personalizationTool) {
+        return toolTextResult(false, 'personalization is unavailable for this turn');
+    }
+    const assistantInputId = input.request.action === 'update'
+        ? input.hostedToolContext?.currentAssistantPreferenceInputId?.() ?? null
+        : null;
+    if (input.request.action === 'update' && assistantInputId === null) {
+        return toolTextResult(false, 'personalization is unavailable for this turn');
+    }
+    try {
+        const result = await personalizationTool.request(input.request, assistantInputId === null ? undefined : { assistantInputId });
+        return toolTextResult(true, safeToolPayloadText(result));
+    }
+    catch {
+        return toolTextResult(false, 'personalization request failed');
+    }
+}
+async function executeAssistantConfigurationTool(input) {
+    const assistantConfigurationTool = input.hostedToolContext?.assistantConfigurationTool ?? null;
+    if (!assistantConfigurationTool) {
+        return toolTextResult(false, 'assistant configuration tools are unavailable for this turn');
+    }
+    try {
+        const currentTurn = input.hostedToolContext?.currentAssistantTarget?.() ?? {
+            model: null,
+            reasoningEffort: null,
+        };
+        if (input.request.action === 'read') {
+            const result = await assistantConfigurationTool.request(input.request);
+            if (result.action !== 'read') {
+                throw new TypeError('Assistant configuration read returned an update response.');
+            }
+            return toolTextResult(true, safeToolPayloadText({
+                currentTurn,
+                savedForNextTurn: result.result,
+            }));
+        }
+        const assistantInputId = input.hostedToolContext?.currentAssistantPreferenceInputId?.() ?? null;
+        if (!assistantInputId) {
+            return toolTextResult(false, 'assistant configuration updates require user-sourced input');
+        }
+        const readResult = await assistantConfigurationTool.request({ action: 'read' });
+        if (readResult.action !== 'read') {
+            throw new TypeError('Assistant configuration read returned an update response.');
+        }
+        const savedForNextTurn = readResult.result;
+        const requestedForNextTurn = {
+            model: input.request.model ?? savedForNextTurn.model,
+            reasoningEffort: input.request.reasoningEffort ?? savedForNextTurn.reasoningEffort,
+        };
+        if (!savedForNextTurn.configurationAvailable) {
+            return toolTextResult(true, safeToolPayloadText({
+                currentTurn,
+                savedForNextTurn: {
+                    ...savedForNextTurn,
+                    appliesAt: 'next_turn',
+                    requiredPlan: null,
+                    status: 'unavailable',
+                },
+            }));
+        }
+        if (requestedForNextTurn.model === HOSTED_ASSISTANT_SOL_MODEL &&
+            !savedForNextTurn.solAvailable) {
+            return toolTextResult(true, safeToolPayloadText({
+                currentTurn,
+                savedForNextTurn: {
+                    ...savedForNextTurn,
+                    appliesAt: 'next_turn',
+                    requiredPlan: 'edge',
+                    status: 'upgrade_required',
+                },
+            }));
+        }
+        const result = input.request.model === undefined
+            ? await assistantConfigurationTool.request({
+                action: 'update',
+                assistantInputId,
+                reasoningEffort: requestedForNextTurn.reasoningEffort,
+            })
+            : input.request.reasoningEffort === undefined
+                ? await assistantConfigurationTool.request({
+                    action: 'update',
+                    assistantInputId,
+                    model: requestedForNextTurn.model,
+                })
+                : await assistantConfigurationTool.request({
+                    action: 'update',
+                    assistantInputId,
+                    model: requestedForNextTurn.model,
+                    reasoningEffort: requestedForNextTurn.reasoningEffort,
+                });
+        if (result.action !== 'update') {
+            throw new TypeError('Assistant configuration update returned a read response.');
+        }
+        return toolTextResult(true, safeToolPayloadText({
+            currentTurn,
+            savedForNextTurn: result.result,
+        }));
+    }
+    catch {
+        return toolTextResult(false, 'assistant configuration tool request failed');
+    }
+}
+function groupAvatarUnavailableToolResult(unavailableReason) {
+    return toolTextResult(true, safeToolPayloadText({
+        action: 'set_chat_avatar',
+        result: {
+            status: 'unavailable',
+            unavailableReason,
+        },
+    }));
+}
+async function executeGroupTool(input) {
+    const groupTool = input.hostedToolContext?.groupTool ?? null;
+    if (!groupTool) {
+        return toolTextResult(false, 'group tools are unavailable for this turn');
+    }
+    let request;
+    let usageDraft = null;
+    let generatedAvatarCapture = null;
+    if (isPreparedGroupAvatarRequest(input.request)) {
+        let preflight;
+        try {
+            const preflightResult = await groupTool.request({ action: 'preflight_set_chat_avatar' });
+            if (preflightResult.action !== 'preflight_set_chat_avatar') {
+                return groupAvatarUnavailableToolResult('group_avatar_preflight_unavailable');
+            }
+            preflight = preflightResult;
+        }
+        catch {
+            return groupAvatarUnavailableToolResult('group_avatar_preflight_unavailable');
+        }
+        if (preflight.result.status !== 'ok') {
+            return toolTextResult(true, safeToolPayloadText({
+                action: 'set_chat_avatar',
+                result: preflight.result,
+            }));
+        }
+        const prepared = await prepareGroupAvatarRuntimeRequest({
+            abortSignal: input.abortSignal,
+            toolCallId: input.toolCallId,
+            env: input.env,
+            fetchImpl: input.fetchImpl,
+            hostedGeneratedImageUploader: input.hostedGeneratedImageUploader,
+            materializeWorkspaceArtifacts: input.materializeWorkspaceArtifacts,
+            nextUsageOrdinal: input.nextUsageOrdinal,
+            request: input.request,
+            vaultRoot: input.vaultRoot,
+        });
+        if (!prepared.rpcSuccess) {
+            return {
+                rpcResult: {
+                    success: false,
+                    contentItems: [{ type: 'inputText', text: prepared.rpcText }],
+                },
+                usageDraft: prepared.usageDraft ?? null,
+            };
+        }
+        request = prepared.request;
+        usageDraft = prepared.usageDraft ?? null;
+        generatedAvatarCapture = prepared.savedImageRef
+            ? {
+                savedCaptureId: prepared.savedCaptureId ?? null,
+                savedImageRef: prepared.savedImageRef,
+            }
+            : null;
+    }
+    else if (input.request.action === 'ask') {
+        const userActionScope = input.hostedToolContext?.currentUserActionScope?.() ?? null;
+        if (userActionScope?.conversationScope !== 'direct') {
+            return toolTextResult(false, 'group ask requires a fresh user request in a personal direct conversation');
+        }
+        const originAssistantInputId = userActionScope.acceptedInputIds[userActionScope.acceptedInputIds.length - 1] ?? null;
+        if (!originAssistantInputId) {
+            return toolTextResult(false, 'group ask requires fresh user-sourced input for this turn');
+        }
+        request = {
+            action: 'ask',
+            ...(input.request.groupLabel !== undefined
+                ? { groupLabel: input.request.groupLabel }
+                : {}),
+            originAssistantInputId,
+            originSessionId: userActionScope.originSessionId,
+            question: input.request.question,
+        };
+    }
+    else {
+        request = input.request;
+    }
+    try {
+        const result = await groupTool.request(request);
+        const payload = generatedAvatarCapture
+            ? { ...result, generatedImage: generatedAvatarCapture }
+            : result;
+        return {
+            ...toolTextResult(true, safeToolPayloadText(payload)),
+            ...(usageDraft ? { usageDraft } : {}),
+        };
+    }
+    catch {
+        return {
+            ...toolTextResult(false, 'group tool request failed'),
+            ...(usageDraft ? { usageDraft } : {}),
+        };
+    }
+}
+function isPreparedGroupAvatarRequest(request) {
+    return request.action === 'set_chat_avatar' && 'avatar' in request;
+}
+async function prepareGroupAvatarRuntimeRequest(input) {
+    const avatar = input.request.avatar;
+    if (avatar.source === 'generate') {
+        const generated = await executeGenerateImageTool({
+            abortSignal: input.abortSignal,
+            args: avatar.args,
+            captureIdempotencyKey: buildGeneratedImageCaptureIdempotencyKey({
+                toolCallId: input.toolCallId,
+                scope: 'group-avatar',
+            }),
+            env: input.env,
+            fetchImpl: input.fetchImpl,
+            hostedGeneratedImageUploader: input.hostedGeneratedImageUploader,
+            materializeWorkspaceArtifacts: input.materializeWorkspaceArtifacts,
+            providerRequestOrdinal: input.nextUsageOrdinal(),
+            requireHostedGeneratedImageUploader: true,
+            vaultRoot: input.vaultRoot,
+        });
+        if (!generated.rpcSuccess) {
+            return {
+                rpcSuccess: false,
+                rpcText: generated.rpcText,
+                usageDraft: generated.usageDraft ?? null,
+            };
+        }
+        const media = generated.responseMedia?.[0] ?? null;
+        if (media?.kind !== 'image') {
+            return {
+                rpcSuccess: false,
+                rpcText: 'generated group avatar did not produce a hosted image URL',
+                usageDraft: generated.usageDraft ?? null,
+            };
+        }
+        return {
+            request: { action: 'set_chat_avatar', groupChatIconUrl: media.url },
+            rpcSuccess: true,
+            savedCaptureId: generated.savedCaptureId ?? null,
+            savedImageRef: generated.savedImageRef ?? null,
+            usageDraft: generated.usageDraft ?? null,
+        };
+    }
+    const uploaded = await uploadGroupAvatarImageReference({
+        alt: avatar.alt,
+        hostedGeneratedImageUploader: input.hostedGeneratedImageUploader,
+        imageRef: avatar.imageRef,
+        materializeWorkspaceArtifacts: input.materializeWorkspaceArtifacts,
+        vaultRoot: input.vaultRoot,
+    });
+    if (!uploaded.rpcSuccess) {
+        return uploaded;
+    }
+    return {
+        request: { action: 'set_chat_avatar', groupChatIconUrl: uploaded.url },
+        rpcSuccess: true,
+    };
+}
+async function uploadGroupAvatarImageReference(input) {
+    if (!input.hostedGeneratedImageUploader) {
+        return {
+            rpcSuccess: false,
+            rpcText: 'hosted image upload is not available for this turn',
+        };
+    }
+    if (!normalizeNullableString(input.vaultRoot)) {
+        return {
+            rpcSuccess: false,
+            rpcText: 'image references are unavailable for this turn',
+        };
+    }
+    let references;
+    try {
+        references = await resolveGenerateImageReferences({
+            materializeWorkspaceArtifacts: input.materializeWorkspaceArtifacts,
+            refs: [input.imageRef],
+            vaultRoot: input.vaultRoot ?? '',
+        });
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
+        return {
+            rpcSuccess: false,
+            rpcText: 'group avatar image reference could not be loaded',
+        };
+    }
+    const reference = references[0] ?? null;
+    if (!reference) {
+        return {
+            rpcSuccess: false,
+            rpcText: 'group avatar image reference could not be loaded',
+        };
+    }
+    try {
+        const media = await input.hostedGeneratedImageUploader.uploadGeneratedImage({
+            alt: input.alt ?? 'Group chat avatar',
+            bytes: reference.bytes,
+            contentType: groupAvatarReferenceContentType(reference.mediaType),
+            filename: groupAvatarReferenceFilename(reference.mediaType),
+            metadata: {
+                imageSha256: reference.sha256,
+                schema: 'murph.group-avatar.v1',
+                sourceRefSha256: reference.sourceRefSha256,
+            },
+            source: 'murph.group-avatar',
+        });
+        if (media.kind !== 'image') {
+            return {
+                rpcSuccess: false,
+                rpcText: 'group avatar upload did not produce a hosted image URL',
+            };
+        }
+        return { rpcSuccess: true, url: media.url };
+    }
+    catch {
+        return {
+            rpcSuccess: false,
+            rpcText: 'group avatar image upload failed',
+        };
+    }
+}
+function groupAvatarReferenceContentType(mediaType) {
+    return mediaType;
+}
+function groupAvatarReferenceFilename(mediaType) {
+    switch (mediaType) {
+        case 'image/jpeg':
+            return 'group-avatar.jpg';
+        case 'image/png':
+            return 'group-avatar.png';
+        case 'image/webp':
+            return 'group-avatar.webp';
+    }
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+async function executeNewsletterTool(input) {
+    const newsletterTool = input.hostedToolContext?.newsletterTool ?? null;
+    if (!newsletterTool) {
+        recordNewsletterUnavailable(input.hostedToolContext, 'newsletter_tool_unavailable');
+        return toolTextResult(false, 'newsletter tools are unavailable for this turn');
+    }
+    try {
+        if (input.request.action === 'send'
+            && input.vaultRoot
+            && !await isGroupSharedProjectionAvailable(input.vaultRoot)) {
+            recordNewsletterUnavailable(input.hostedToolContext, 'newsletter_preparation_unavailable');
+            return groupSharedProjectionUnavailableResult(input.request.action);
+        }
+        const scheduledAutomationAuthority = input.hostedToolContext?.currentScheduledAutomationAuthority?.() ??
+            null;
+        let newsletterWeeklySource = null;
+        if (input.request.action === 'prepare') {
+            newsletterWeeklySource = await readNewsletterWeeklySource({
+                referenceAt: scheduledAutomationAuthority?.occurrenceAt ?? null,
+                vaultRoot: input.vaultRoot,
+            });
+            if (newsletterWeeklySource === null) {
+                recordNewsletterUnavailable(input.hostedToolContext, 'newsletter_preparation_unavailable');
+                return groupSharedProjectionUnavailableResult(input.request.action);
+            }
+        }
+        const request = {
+            ...input.request,
+            scheduledAutomationAuthority,
+        };
+        const result = await newsletterTool.request(request);
+        if (result.action === 'send') {
+            input.hostedToolContext?.recordNewsletterSendResult?.(result);
+        }
+        else if (result.action === 'prepare' && result.result.status === 'unavailable') {
+            recordNewsletterUnavailable(input.hostedToolContext, result.result.unavailableReason);
+        }
+        const toolSucceeded = !isNewsletterAllRecipientSendFailure(result);
+        if (result.action !== 'prepare' || result.result.status !== 'ok') {
+            return toolTextResult(toolSucceeded, safeToolPayloadText(result));
+        }
+        const skippedNoEmailMemberIds = result.result.participants
+            .filter((participant) => !participant.hasEmail)
+            .map((participant) => participant.memberId);
+        if (skippedNoEmailMemberIds.length === result.result.participants.length) {
+            input.hostedToolContext?.closeNewsletterCapability?.();
+            input.hostedToolContext?.recordNewsletterSendResult?.({
+                action: 'send',
+                result: {
+                    participantCount: 0,
+                    skippedNoEmailMemberIds,
+                    status: 'no_recipients',
+                },
+            });
+        }
+        const referenceAt = scheduledAutomationAuthority?.occurrenceAt ?? null;
+        if (newsletterWeeklySource === null) {
+            recordNewsletterUnavailable(input.hostedToolContext, 'newsletter_preparation_unavailable');
+            return groupSharedProjectionUnavailableResult(input.request.action);
+        }
+        const members = buildEligibleNewsletterWeeklyMembers({
+            participants: result.result.participants,
+            referenceAt,
+            source: newsletterWeeklySource,
+        });
+        return toolTextResult(true, safeToolPayloadText({
+            action: 'prepare',
+            result: {
+                groupId: result.result.groupId,
+                missingEmailParticipants: stripNewsletterAuthorizationSnapshot(result.result.missingEmailParticipants),
+                members,
+                participants: stripNewsletterAuthorizationSnapshot(result.result.participants),
+                referenceAt,
+                status: 'ok',
+            },
+        }));
+    }
+    catch {
+        recordNewsletterUnavailable(input.hostedToolContext, 'newsletter_tool_failed');
+        return toolTextResult(false, 'newsletter tool request failed');
+    }
+}
+function recordNewsletterUnavailable(hostedToolContext, unavailableReason) {
+    hostedToolContext?.closeNewsletterCapability?.();
+    hostedToolContext?.recordNewsletterSendResult?.({
+        action: 'send',
+        result: { status: 'unavailable', unavailableReason },
+    });
+}
+function isNewsletterAllRecipientSendFailure(result) {
+    return (result.action === 'send' &&
+        (result.result.status === 'unavailable'
+            || (result.result.status === 'partial_failure'
+                && result.result.sentRecipientCount === 0)));
+}
+async function isGroupSharedProjectionAvailable(vaultRoot) {
+    const read = await readSharedVaultShareProjectionStore(vaultRoot);
+    return read.status === 'loaded' || read.status === 'empty';
+}
+async function readNewsletterWeeklySource(input) {
+    if (!input.referenceAt || !input.vaultRoot) {
+        return { status: 'empty' };
+    }
+    const read = await readSharedVaultShareProjectionStore(input.vaultRoot);
+    if (read.status === 'corrupt' || read.status === 'read_failed') {
+        return null;
+    }
+    if (read.status === 'empty') {
+        return { status: 'empty' };
+    }
+    let timeZone;
+    try {
+        const { loadVault } = await import('@murphai/core');
+        timeZone = (await loadVault({ vaultRoot: input.vaultRoot })).metadata.timezone;
+    }
+    catch {
+        return null;
+    }
+    return { status: 'loaded', store: read.store, timeZone };
+}
+function buildEligibleNewsletterWeeklyMembers(input) {
+    if (!input.referenceAt || input.source.status === 'empty') {
+        return [];
+    }
+    const authorizedStore = filterNewsletterAuthorizedProjectionStore({
+        participants: input.participants,
+        store: input.source.store,
+    });
+    return buildSharedGroupWeeklyMembers({
+        members: flattenSharedVaultShareProjectionStore(authorizedStore),
+        referenceAt: input.referenceAt,
+        timeZone: input.source.timeZone,
+    });
+}
+function filterNewsletterAuthorizedProjectionStore(input) {
+    const authorizedShares = new Set();
+    for (const participant of input.participants) {
+        if (!participant.hasEmail) {
+            continue;
+        }
+        for (const share of participant.authorizedShares) {
+            authorizedShares.add(JSON.stringify([
+                participant.memberId,
+                share.projectionScopeKey,
+                share.shareId,
+            ]));
+        }
+    }
+    const projections = {};
+    for (const [projectionScopeKey, projection] of Object.entries(input.store.projections)) {
+        const grantors = {};
+        for (const [memberId, grantor] of Object.entries(projection.grantors)) {
+            if (!authorizedShares.has(JSON.stringify([
+                memberId,
+                projectionScopeKey,
+                grantor.shareId,
+            ]))) {
+                continue;
+            }
+            const records = grantor.records.filter((record) => record.shareId === grantor.shareId);
+            if (records.length > 0) {
+                grantors[memberId] = { ...grantor, records };
+            }
+        }
+        if (Object.keys(grantors).length > 0) {
+            projections[projectionScopeKey] = { ...projection, grantors };
+        }
+    }
+    return { ...input.store, projections };
+}
+function stripNewsletterAuthorizationSnapshot(participants) {
+    return participants.map(({ hasEmail, memberId }) => ({ hasEmail, memberId }));
+}
+function groupSharedProjectionUnavailableResult(action) {
+    return toolTextResult(true, safeToolPayloadText({
+        action,
+        result: {
+            status: 'unavailable',
+            unavailableReason: 'shared_projection_unavailable',
+        },
+    }));
+}
 async function executeProgressUpdateTool(input) {
     if (!input.progressDelivery) {
         return toolTextResult(false, 'progress updates are not available for this turn');
@@ -1123,9 +2503,6 @@ async function executeProgressUpdateTool(input) {
         if (result.reason === 'limit') {
             return toolTextResult(false, 'progress update skipped: progress update limit reached');
         }
-        if (result.reason === 'too-soon') {
-            return toolTextResult(false, 'progress update skipped: progress update sent too recently');
-        }
         if (result.reason === 'duplicate') {
             return toolTextResult(false, 'progress update skipped: duplicate progress update');
         }
@@ -1145,13 +2522,12 @@ async function executeHostedComputerPauseForUserTool(input) {
     });
     if (!apiResult.ok) {
         if (apiResult.unknownOutcome) {
-            return toolTextResult(false, apiResult.errorText, {
-                computerRunPausedForUser: true,
-            });
+            return toolTextResult(false, apiResult.errorText);
         }
         return toolTextResult(false, apiResult.errorText);
     }
-    return toolTextResult(true, safeToolPayloadText(readSanitizedComputerPausePayload(apiResult.payload)), { computerRunPausedForUser: true });
+    const payload = readSanitizedComputerPausePayload(apiResult.payload);
+    return toolTextResult(true, safeToolPayloadText(payload));
 }
 async function executeHostedComputerOpenTool(input) {
     return await executeHostedComputerApiTool({
@@ -1442,9 +2818,8 @@ function safeToolPayloadText(payload) {
     }
     return `${text.slice(0, 60_000)}...`;
 }
-function toolTextResult(success, text, extra) {
+function toolTextResult(success, text) {
     return {
-        ...extra,
         rpcResult: {
             success,
             contentItems: [{ type: 'inputText', text }],
@@ -1461,12 +2836,19 @@ function parseDynamicToolCallRequest(message) {
             arguments: null,
             namespace: null,
             tool: null,
+            toolCallId: null,
         };
     }
     return {
         arguments: params.arguments,
         namespace: normalizeNullableStringValue(params.namespace),
         tool: normalizeNullableStringValue(params.tool),
+        toolCallId: normalizeNullableStringValue(params.callId) ??
+            normalizeNullableStringValue(params.call_id) ??
+            normalizeNullableStringValue(params.toolCallId) ??
+            normalizeNullableStringValue(params.tool_call_id) ??
+            normalizeNullableStringValue(params.itemId) ??
+            normalizeNullableStringValue(params.item_id),
     };
 }
 function parseSendVaultFileArguments(value) {
@@ -1545,6 +2927,314 @@ function parseSubmitProductFeedbackArguments(value) {
         ok: true,
     };
 }
+function parseFamilyPlanArguments(value) {
+    const parsed = familyPlanArgumentsSchema.safeParse(value);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            validationDigest: buildDynamicToolValidationDigest({
+                error: parsed.error,
+                rawInput: value,
+                schemaName: 'murph.family_plan.input',
+                schemaRootKeys: ['action', 'invite'],
+                toolName: 'murph.family_plan',
+            }),
+        };
+    }
+    if (parsed.data.action === 'read_status') {
+        return {
+            ok: true,
+            request: {
+                action: 'read_status',
+            },
+        };
+    }
+    if (parsed.data.action === 'start_checkout') {
+        return {
+            ok: true,
+            request: parsed.data.invite
+                ? {
+                    action: 'start_checkout',
+                    invite: {
+                        ...(parsed.data.invite.planCode
+                            ? { planCode: parsed.data.invite.planCode }
+                            : {}),
+                        ...(parsed.data.invite.targetEmail
+                            ? { targetEmail: parsed.data.invite.targetEmail }
+                            : {}),
+                        targetLabel: parsed.data.invite.targetLabel,
+                        targetPhoneNumber: parsed.data.invite.targetPhoneNumber,
+                        targetTelegramUsername: parsed.data.invite.targetTelegramUsername,
+                    },
+                }
+                : {
+                    action: 'start_checkout',
+                },
+        };
+    }
+    return {
+        ok: true,
+        request: {
+            action: 'create_invite',
+            invite: {
+                ...(parsed.data.invite.planCode
+                    ? { planCode: parsed.data.invite.planCode }
+                    : {}),
+                ...(parsed.data.invite.targetEmail
+                    ? { targetEmail: parsed.data.invite.targetEmail }
+                    : {}),
+                targetLabel: parsed.data.invite.targetLabel,
+                targetPhoneNumber: parsed.data.invite.targetPhoneNumber,
+                targetTelegramUsername: parsed.data.invite.targetTelegramUsername,
+            },
+        },
+    };
+}
+function parsePlanUsageArguments(value) {
+    const parsed = planUsageArgumentsSchema.safeParse(value);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            validationDigest: buildDynamicToolValidationDigest({
+                error: parsed.error,
+                rawInput: value,
+                schemaName: 'murph.plan_usage.input',
+                schemaRootKeys: [],
+                toolName: 'murph.plan_usage',
+            }),
+        };
+    }
+    return { ok: true };
+}
+function parsePersonalizationArguments(value) {
+    const parsed = hostedRuntimeAssistantPersonalizationModelToolRequestSchema
+        .safeParse(value);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            validationDigest: buildDynamicToolValidationDigest({
+                error: parsed.error,
+                rawInput: value,
+                schemaName: 'murph.personalization.input',
+                schemaRootKeys: ['action', 'tone', 'voice'],
+                toolName: 'murph.personalization',
+            }),
+        };
+    }
+    return {
+        ok: true,
+        request: parsed.data,
+    };
+}
+function parseAssistantConfigurationArguments(value) {
+    const parsed = assistantConfigurationArgumentsSchema.safeParse(value);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            validationDigest: buildDynamicToolValidationDigest({
+                error: parsed.error,
+                rawInput: value,
+                schemaName: 'murph.assistant_configuration.input',
+                schemaRootKeys: ['action', 'model', 'reasoningEffort'],
+                toolName: 'murph.assistant_configuration',
+            }),
+        };
+    }
+    return {
+        ok: true,
+        request: parsed.data,
+    };
+}
+function parseGroupArguments(value) {
+    const parsed = groupArgumentsSchema.safeParse(value);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            validationDigest: buildDynamicToolValidationDigest({
+                error: parsed.error,
+                rawInput: value,
+                schemaName: 'murph.group.input',
+                schemaRootKeys: ['action'],
+                toolName: 'murph.group',
+            }),
+        };
+    }
+    if (parsed.data.action === 'ask') {
+        return {
+            ok: true,
+            request: {
+                action: 'ask',
+                ...(parsed.data.groupLabel !== undefined
+                    ? { groupLabel: parsed.data.groupLabel }
+                    : {}),
+                question: parsed.data.question,
+            },
+        };
+    }
+    if (parsed.data.action === 'create_join_link') {
+        const joinLink = {
+            ...(parsed.data.displayName !== undefined
+                ? { displayName: parsed.data.displayName }
+                : {}),
+            ...(parsed.data.kind !== undefined ? { kind: parsed.data.kind } : {}),
+            ...(parsed.data.requestedVaultShareProjectionScopes !== undefined
+                ? {
+                    requestedVaultShareProjectionScopes: parsed.data.requestedVaultShareProjectionScopes,
+                }
+                : {}),
+        };
+        return {
+            ok: true,
+            request: Object.keys(joinLink).length > 0
+                ? { action: 'create_join_link', joinLink }
+                : { action: 'create_join_link' },
+        };
+    }
+    if (parsed.data.action === 'update_display_name') {
+        return {
+            ok: true,
+            request: {
+                action: 'update_display_name',
+                updateDisplayName: {
+                    displayName: parsed.data.displayName,
+                },
+            },
+        };
+    }
+    if (parsed.data.action === 'leave_membership') {
+        return {
+            ok: true,
+            request: {
+                action: 'leave_membership',
+                membershipId: parsed.data.membershipId,
+            },
+        };
+    }
+    if (parsed.data.action === 'set_chat_avatar') {
+        if (parsed.data.avatarSource === 'generate') {
+            if (!parsed.data.prompt) {
+                return {
+                    ok: false,
+                    validationDigest: buildDynamicToolValidationDigest({
+                        error: new z.ZodError([
+                            {
+                                code: z.ZodIssueCode.custom,
+                                message: 'set_chat_avatar with avatarSource="generate" requires prompt',
+                                path: ['prompt'],
+                            },
+                        ]),
+                        rawInput: value,
+                        schemaName: 'murph.group.input',
+                        schemaRootKeys: ['action'],
+                        toolName: 'murph.group',
+                    }),
+                };
+            }
+            return {
+                ok: true,
+                request: {
+                    action: 'set_chat_avatar',
+                    avatar: {
+                        source: 'generate',
+                        args: {
+                            alt: parsed.data.alt,
+                            outputFormat: parsed.data.outputFormat,
+                            prompt: parsed.data.prompt,
+                            quality: parsed.data.quality,
+                            referenceImageRefs: parsed.data.referenceImageRefs,
+                            size: parsed.data.size,
+                        },
+                    },
+                },
+            };
+        }
+        if (!parsed.data.imageRef) {
+            return {
+                ok: false,
+                validationDigest: buildDynamicToolValidationDigest({
+                    error: new z.ZodError([
+                        {
+                            code: z.ZodIssueCode.custom,
+                            message: 'set_chat_avatar with avatarSource="image_ref" requires imageRef',
+                            path: ['imageRef'],
+                        },
+                    ]),
+                    rawInput: value,
+                    schemaName: 'murph.group.input',
+                    schemaRootKeys: ['action'],
+                    toolName: 'murph.group',
+                }),
+            };
+        }
+        return {
+            ok: true,
+            request: {
+                action: 'set_chat_avatar',
+                avatar: {
+                    alt: parsed.data.alt,
+                    imageRef: parsed.data.imageRef,
+                    source: 'image_ref',
+                },
+            },
+        };
+    }
+    if (parsed.data.action === 'post_join_offer') {
+        const joinOffer = {
+            ...(parsed.data.displayName !== undefined
+                ? { displayName: parsed.data.displayName }
+                : {}),
+            messageTemplate: parsed.data.messageTemplate,
+            ...(parsed.data.projectionScopes !== undefined
+                ? { projectionScopes: parsed.data.projectionScopes }
+                : {}),
+        };
+        return {
+            ok: true,
+            request: { action: 'post_join_offer', joinOffer },
+        };
+    }
+    if (parsed.data.action === 'list_memberships'
+        || parsed.data.action === 'read_chat_participants'
+        || parsed.data.action === 'share_contact_card'
+        || parsed.data.action === 'revoke_own_email_share') {
+        return { ok: true, request: { action: parsed.data.action } };
+    }
+    return { ok: true, request: { action: 'read_current' } };
+}
+function parseNewsletterArguments(value) {
+    const parsed = newsletterArgumentsSchema.safeParse(value);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            validationDigest: buildDynamicToolValidationDigest({
+                error: parsed.error,
+                rawInput: value,
+                schemaName: 'murph.newsletter.input',
+                schemaRootKeys: ['action', 'groupId'],
+                toolName: 'murph.newsletter',
+            }),
+        };
+    }
+    if (parsed.data.action === 'prepare') {
+        return {
+            ok: true,
+            request: {
+                action: 'prepare',
+                groupId: parsed.data.groupId,
+            },
+        };
+    }
+    return {
+        ok: true,
+        request: {
+            action: 'send',
+            groupId: parsed.data.groupId,
+            html: parsed.data.html,
+            subject: parsed.data.subject,
+            ...(parsed.data.text === undefined ? {} : { text: parsed.data.text }),
+        },
+    };
+}
 function parseFinishWithoutReplyArguments(value) {
     const parsed = finishWithoutReplyArgumentsSchema.safeParse(value);
     if (!parsed.success) {