@happier-dev/stack 0.1.0 → 0.2.0

package/node_modules/@happier-dev/protocol/dist/actions/actionSpecs.js

@@ -4,6 +4,13 @@ import { ActionUiPlacementSchema } from './actionUiPlacements.js';
 import { ReviewStartInputSchema } from '../reviews/reviewStart.js';
 import { ActionInputPredicateSchema } from './actionInputPredicates.js';
 import { MemorySearchQueryV1Schema } from '../memory/memorySearch.js';
+import { ApprovalRequestCreatedBySchema } from '../approvals/approvalRequestV1.js';
+import { PromptRegistryConfiguredSourceV1Schema } from '../promptLibrary/promptRegistriesV1.js';
+import { PromptAssetInstallModeV1Schema, PromptAssetScopeV1Schema } from '../promptLibrary/promptAssetsV1.js';
+import { BackendTargetKeySchema, BackendTargetRefSchema, parseBackendTargetKey } from '../backendTargets/backendTargetRef.js';
+import { ExecutionRunListRequestSchema } from '../executionRunListRequest.js';
+import { SessionRollbackTargetSchema } from '../sessionRollback.js';
+import { SessionHandoffWorkspaceTransferSchema } from '../sessionControl/handoff/handoffSchemas.js';
 const ZodSchemaLike = z.custom((value) => {
     if (!value || typeof value !== 'object')
         return false;
@@ -15,8 +22,9 @@ export const ActionSurfaceSchema = z.object({
     ui_slash_command: z.boolean(),
     voice_tool: z.boolean(),
     voice_action_block: z.boolean(),
+    session_agent: z.boolean(),
     mcp: z.boolean(),
-    session_control_cli: z.boolean(),
+    cli: z.boolean(),
 }).strict();
 export const ActionSafetySchema = z.enum(['safe', 'danger']);
 export const ActionInputWidgetSchema = z.enum(['text', 'textarea', 'text_list', 'select', 'multiselect', 'toggle', 'checkbox']);
@@ -25,6 +33,7 @@ export const ActionInputOptionSchema = z
     value: z.string().min(1),
     label: z.string().min(1),
     description: z.string().min(1).optional(),
+    disabled: z.boolean().optional(),
 })
     .strict();
 export const ActionInputFieldHintSchema = z
@@ -45,6 +54,11 @@ export const ActionInputFieldHintSchema = z
      */
     listSeparator: z.enum(['comma', 'newline']).optional(),
     required: z.boolean().optional(),
+    /**
+     * When true, draft/launcher UIs should keep this field empty until the user
+     * explicitly picks a value instead of auto-seeding or auto-selecting one.
+     */
+    requireExplicitSelection: z.boolean().optional(),
     options: z.array(ActionInputOptionSchema).optional(),
     optionsSourceId: z.string().min(1).optional(),
     visibleWhen: ActionInputPredicateSchema.optional(),
@@ -85,11 +99,17 @@ export const ActionInputHintsSchema = z
     fields: z.array(ActionInputFieldHintSchema).default([]),
 })
     .strict();
+export const ActionPromptingSchema = z
+    .object({
+    voiceHotPath: z.boolean().optional(),
+})
+    .strict();
 export const ActionSpecSchema = z.object({
     id: ActionIdSchema,
     title: z.string().min(1),
     description: z.string().min(1).optional(),
     safety: ActionSafetySchema,
+    // UI placements where the action can appear when the relevant surface is enabled.
     placements: z.array(ActionUiPlacementSchema).default([]),
     // Optional stable slash command token for ui_slash_command.
     slash: z.object({
@@ -118,14 +138,48 @@ export const ActionSpecSchema = z.object({
     })
         .passthrough()
         .optional(),
+    prompting: ActionPromptingSchema.optional(),
     surfaces: ActionSurfaceSchema,
     inputSchema: ZodSchemaLike,
     inputHints: ActionInputHintsSchema.optional(),
 }).passthrough();
 const EmptyObjectSchema = z.object({}).strict();
+const OptionalSessionIdInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+}).passthrough();
+const SessionIdRequiredInputSchema = z.object({
+    sessionId: z.string().min(1),
+}).passthrough();
+const SessionTitleSetInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+    title: z.string().trim().min(1),
+}).passthrough();
+const SessionPermissionModeSetInputSchema = z.object({
+    sessionId: z.string().min(1),
+    permissionMode: z.string().trim().min(1),
+}).passthrough();
+const SessionModelSetInputSchema = z.object({
+    sessionId: z.string().min(1),
+    modelId: z.string().trim().min(1),
+}).passthrough();
+const SessionStatusGetInputSchema = z.object({
+    sessionId: z.string().min(1),
+    live: z.boolean().optional(),
+}).passthrough();
+const SessionHistoryGetInputSchema = z.object({
+    sessionId: z.string().min(1),
+    limit: z.number().int().min(1).max(250).optional(),
+    format: z.enum(['compact', 'raw']).optional(),
+    includeMeta: z.boolean().optional(),
+    includeStructuredPayload: z.boolean().optional(),
+}).passthrough();
+const SessionWaitIdleInputSchema = z.object({
+    sessionId: z.string().min(1),
+    timeoutSeconds: z.number().int().min(1).max(3600).optional(),
+}).passthrough();
 const IntentStartCommonSchema = z.object({
     sessionId: z.string().min(1).optional(),
-    backendIds: z.array(z.string().min(1)).min(1),
+    backendTargetKeys: z.array(BackendTargetKeySchema).min(1),
     instructions: z.string().trim().min(1),
     permissionMode: z.string().min(1).optional(),
     retentionPolicy: z.enum(['ephemeral', 'resumable']).optional(),
@@ -154,6 +208,20 @@ const ExecutionRunIdInputSchema = z.object({
     sessionId: z.string().min(1).optional(),
     runId: z.string().min(1),
 }).passthrough();
+const ExecutionRunStartInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+    intent: z.enum(['review', 'plan', 'delegate', 'voice_agent', 'memory_hints']),
+    backendTarget: BackendTargetRefSchema,
+    instructions: z.string().optional(),
+    display: z.unknown().optional(),
+    permissionMode: z.string().min(1),
+    retentionPolicy: z.enum(['ephemeral', 'resumable']),
+    runClass: z.enum(['bounded', 'long_lived']),
+    ioMode: z.enum(['request_response', 'streaming']),
+    initialContextMode: z.enum(['bootstrap', 'first_turn']).optional(),
+    resumeHandle: z.unknown().nullable().optional(),
+    replay: z.unknown().optional(),
+}).passthrough();
 const ExecutionRunGetInputSchema = ExecutionRunIdInputSchema.extend({
     includeStructured: z.boolean().optional(),
 }).passthrough();
@@ -165,14 +233,41 @@ const ExecutionRunActionInputSchema = ExecutionRunIdInputSchema.extend({
     actionId: z.string().min(1),
     input: z.unknown().optional(),
 }).passthrough();
+const ExecutionRunWaitInputSchema = ExecutionRunIdInputSchema.extend({
+    timeoutSeconds: z.number().int().min(1).max(3600).optional(),
+    pollIntervalMs: z.number().int().min(100).max(60_000).optional(),
+}).passthrough();
 const SessionOpenInputSchema = z.object({
-    sessionId: z.string().min(1),
+    sessionId: z.string().min(1).optional(),
+    sessionTitle: z.string().trim().min(1).optional(),
+}).passthrough().superRefine((value, ctx) => {
+    if (!(typeof value.sessionId === 'string' && value.sessionId.trim().length > 0) && !(typeof value.sessionTitle === 'string' && value.sessionTitle.trim().length > 0)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'sessionId or sessionTitle is required',
+            path: ['sessionId'],
+        });
+    }
+});
+const SessionForkInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+}).passthrough();
+const SessionRollbackInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+    target: SessionRollbackTargetSchema.optional(),
+}).passthrough();
+const SessionHandoffInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+    targetMachineId: z.string().min(1).optional(),
+    targetSessionStorageMode: z.enum(['direct', 'persisted']).optional(),
+    workspaceTransfer: SessionHandoffWorkspaceTransferSchema.optional(),
 }).passthrough();
 const SessionSpawnNewInputSchema = z.object({
     tag: z.string().min(1).optional(),
-    workspaceId: z.string().min(1).optional(),
     agentId: z.string().min(1).optional(),
     modelId: z.string().min(1).optional(),
+    backendTargetKey: z.string().min(1).optional(),
+    title: z.string().min(1).optional(),
     path: z.string().min(1).optional(),
     host: z.string().min(1).optional(),
     initialMessage: z.string().min(1).optional(),
@@ -183,9 +278,6 @@ const SessionSpawnPickerInputSchema = z.object({
     modelId: z.string().min(1).optional(),
     initialMessage: z.string().min(1).optional(),
 }).passthrough();
-const WorkspacesListRecentInputSchema = z.object({
-    limit: z.number().int().min(1).max(50).optional(),
-}).passthrough();
 const PathsListRecentInputSchema = z.object({
     machineId: z.string().min(1).optional(),
     limit: z.number().int().min(1).max(50).optional(),
@@ -196,32 +288,143 @@ const MachinesListInputSchema = z.object({
 const ServersListInputSchema = z.object({
     limit: z.number().int().min(1).max(200).optional(),
 }).passthrough();
+const ReviewEnginesListInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+    includeDisabled: z.boolean().optional(),
+}).passthrough();
 const AgentsBackendsListInputSchema = z.object({
     includeDisabled: z.boolean().optional(),
+    limit: z.number().int().min(1).max(200).optional(),
 }).passthrough();
 const AgentsModelsListInputSchema = z.object({
-    agentId: z.string().min(1),
+    agentId: z.string().min(1).optional(),
+    backendTargetKey: BackendTargetKeySchema.optional(),
     machineId: z.string().min(1).optional(),
+    limit: z.number().int().min(1).max(200).optional(),
+}).passthrough().superRefine((value, ctx) => {
+    if (!value.agentId && !value.backendTargetKey) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'agentId or backendTargetKey is required',
+            path: ['agentId'],
+        });
+    }
+    if (value.agentId === 'customAcp' && !value.backendTargetKey) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'backendTargetKey is required for customAcp',
+            path: ['backendTargetKey'],
+        });
+    }
+    if (value.agentId && value.backendTargetKey) {
+        const parsedTarget = parseBackendTargetKey(value.backendTargetKey);
+        const derivedAgentId = parsedTarget.kind === 'builtInAgent' ? parsedTarget.agentId : 'customAcp';
+        if (value.agentId !== derivedAgentId) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'agentId must match backendTargetKey when both are provided',
+                path: ['agentId'],
+            });
+        }
+    }
+});
+const ActionSpecSearchInputSchema = z.object({
+    query: z.string().trim().optional(),
+    limit: z.number().int().min(1).max(100).optional(),
 }).passthrough();
+const ActionSpecGetInputSchema = z.object({
+    id: z.string().min(1),
+}).passthrough();
+const ActionOptionsResolveInputSchema = z.object({
+    actionId: z.string().min(1).optional(),
+    fieldPath: z.string().min(1).optional(),
+    optionsSourceId: z.string().min(1).optional(),
+    sessionId: z.string().min(1).optional(),
+    limit: z.number().int().min(1).max(200).optional(),
+    query: z.string().trim().optional(),
+}).passthrough().superRefine((value, ctx) => {
+    const actionId = typeof value.actionId === 'string' ? value.actionId.trim() : '';
+    const fieldPath = typeof value.fieldPath === 'string' ? value.fieldPath.trim() : '';
+    const optionsSourceId = typeof value.optionsSourceId === 'string' ? value.optionsSourceId.trim() : '';
+    if (!optionsSourceId && !(actionId && fieldPath)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'actionId + fieldPath or optionsSourceId is required',
+            path: ['actionId'],
+        });
+    }
+});
 const SessionSendMessageInputSchema = z.object({
     sessionId: z.string().min(1).optional(),
     message: z.string().min(1),
+    permissionModeOverride: z.string().trim().min(1).optional(),
+    modelOverride: z.union([z.string().trim().min(1), z.null()]).optional(),
+    wait: z.boolean().optional(),
+    timeoutSeconds: z.number().int().min(1).max(3600).optional(),
 }).passthrough();
 const SessionPermissionRespondInputSchema = z.object({
     sessionId: z.string().min(1).optional(),
     decision: z.enum(['allow', 'deny']),
     requestId: z.string().min(1).optional(),
 }).passthrough();
-const SessionPrimaryTargetInputSchema = z.object({
-    sessionId: z.string().min(1).nullable(),
+const SessionUserActionAnswerItemSchema = z.object({
+    question: z.string().trim().min(1),
+    answer: z.string().trim().min(1),
+}).strict();
+const SessionUserActionAnswerInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+    requestId: z.string().min(1).optional(),
+    decision: z.enum(['approve', 'reject', 'request_changes']).optional(),
+    reason: z.string().trim().min(1).optional(),
+    answers: z.array(SessionUserActionAnswerItemSchema).min(1).optional(),
+    updatedPermissions: z.unknown().optional(),
+}).passthrough().superRefine((value, ctx) => {
+    const hasAnswers = Array.isArray(value.answers) && value.answers.length > 0;
+    const decision = typeof value.decision === 'string' ? value.decision : null;
+    if (!hasAnswers && !decision) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'decision or answers is required',
+            path: ['decision'],
+        });
+    }
+    if (decision === 'request_changes' && !(typeof value.reason === 'string' && value.reason.trim().length > 0)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'reason is required when decision=request_changes',
+            path: ['reason'],
+        });
+    }
+});
+const SessionModeSetInputSchema = z.object({
+    sessionId: z.string().min(1).optional(),
+    modeId: z.string().min(1),
 }).passthrough();
+const SessionPrimaryTargetInputSchema = z.object({
+    sessionId: z.string().min(1).nullable().optional(),
+    sessionTitle: z.string().trim().min(1).optional(),
+}).passthrough().superRefine((value, ctx) => {
+    const hasSessionId = value.sessionId === null || (typeof value.sessionId === 'string' && value.sessionId.trim().length > 0);
+    const hasSessionTitle = typeof value.sessionTitle === 'string' && value.sessionTitle.trim().length > 0;
+    if (!hasSessionId && !hasSessionTitle) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'sessionId or sessionTitle is required',
+            path: ['sessionId'],
+        });
+    }
+});
 const SessionTrackedTargetsInputSchema = z.object({
     sessionIds: z.array(z.string().min(1)).max(50),
 }).passthrough();
 const SessionListInputSchema = z.object({
-    limit: z.number().int().min(1).max(50).optional(),
+    limit: z.number().int().min(1).max(200).optional(),
     cursor: z.string().min(1).nullable().optional(),
     includeLastMessagePreview: z.boolean().optional(),
+    activeOnly: z.boolean().optional(),
+    archivedOnly: z.boolean().optional(),
+    includeSystem: z.boolean().optional(),
+    resumableOnly: z.boolean().optional(),
 }).passthrough();
 const SessionActivityInputSchema = z.object({
     sessionId: z.string().min(1),
@@ -253,13 +456,164 @@ const MemoryEnsureUpToDateInputSchema = z.object({
     machineId: z.string().min(1),
     sessionId: z.string().min(1).optional(),
 }).passthrough();
+const ApprovalRequestCreateInputSchema = z.object({
+    actionId: ActionIdSchema,
+    actionArgs: z.unknown(),
+    summary: z.string().min(1),
+    createdBy: ApprovalRequestCreatedBySchema,
+    preview: z.unknown().optional(),
+}).passthrough();
+const ApprovalRequestDecideInputSchema = z.object({
+    artifactId: z.string().min(1),
+    decision: z.enum(['approve', 'reject']),
+}).passthrough();
+const PromptDocUpdateInputSchema = z.object({
+    artifactId: z.string().min(1),
+    title: z.string().min(1),
+    markdown: z.string(),
+    folderId: z.string().min(1).nullable().optional(),
+    tags: z.array(z.string().min(1)).optional(),
+}).passthrough();
+const PromptBundleUpdateInputSchema = z.object({
+    artifactId: z.string().min(1),
+    title: z.string().min(1),
+    skillMarkdown: z.string(),
+    folderId: z.string().min(1).nullable().optional(),
+    tags: z.array(z.string().min(1)).optional(),
+}).passthrough();
+const PromptAssetExportInputSchema = z.object({
+    artifactId: z.string().min(1),
+    machineId: z.string().min(1),
+    assetTypeId: z.string().min(1),
+    scope: PromptAssetScopeV1Schema,
+    directory: z.string().min(1).optional(),
+    targetPath: z.string().min(1).optional(),
+    targetName: z.string().min(1).optional(),
+    installMode: PromptAssetInstallModeV1Schema.optional(),
+}).passthrough().superRefine((value, ctx) => {
+    const hasDocTarget = typeof value.targetPath === 'string' && value.targetPath.trim().length > 0;
+    const hasBundleTarget = typeof value.targetName === 'string' && value.targetName.trim().length > 0;
+    if (!hasDocTarget && !hasBundleTarget) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'targetPath or targetName is required',
+            path: ['targetPath'],
+        });
+    }
+});
+const PromptRegistryInstallInputSchema = z.object({
+    machineId: z.string().min(1),
+    sourceId: z.string().min(1),
+    itemId: z.string().min(1),
+    configuredSources: z.array(PromptRegistryConfiguredSourceV1Schema).default([]),
+    installTarget: z.object({
+        assetTypeId: z.string().min(1),
+        scope: PromptAssetScopeV1Schema,
+        directory: z.string().min(1).optional(),
+        targetName: z.string().min(1),
+        installMode: PromptAssetInstallModeV1Schema.optional(),
+    }).optional(),
+}).passthrough();
 export const ACTION_SPECS = Object.freeze([
+    {
+        id: 'action.spec.search',
+        title: 'Search action specs',
+        description: 'Search available Happier action specs by name, description, bindings, and field hints.',
+        safety: 'safe',
+        placements: ['voice_panel'],
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'searchActionSpecs', mcpToolName: 'action_spec_search' },
+        examples: {
+            voice: { argsExample: '{"query":"plan mode","limit":5}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: true,
+            voice_action_block: true,
+            session_agent: true,
+            mcp: true,
+            cli: false,
+        },
+        inputHints: {
+            title: 'Search action specs',
+            description: 'Use this before guessing action ids or tool names.',
+            fields: [
+                { path: 'query', title: 'Query', description: 'Natural-language search text.', widget: 'text' },
+                { path: 'limit', title: 'Limit', description: 'Maximum number of action specs to return.', widget: 'text' },
+            ],
+        },
+        inputSchema: ActionSpecSearchInputSchema,
+    },
+    {
+        id: 'action.spec.get',
+        title: 'Get action spec',
+        description: 'Get one Happier action spec with input hints and examples.',
+        safety: 'safe',
+        placements: ['voice_panel'],
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'getActionSpec', mcpToolName: 'action_spec_get' },
+        examples: {
+            voice: { argsExample: '{"id":"subagents.plan.start"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: true,
+            voice_action_block: true,
+            session_agent: true,
+            mcp: true,
+            cli: false,
+        },
+        inputHints: {
+            title: 'Get action spec',
+            fields: [
+                { path: 'id', title: 'Action id', description: 'The exact Happier action id.', widget: 'text', required: true },
+            ],
+        },
+        inputSchema: ActionSpecGetInputSchema,
+    },
+    {
+        id: 'action.options.resolve',
+        title: 'Resolve action options',
+        description: 'Resolve valid options for an action field, including dynamic options sources.',
+        safety: 'safe',
+        placements: ['voice_panel'],
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'resolveActionOptions', mcpToolName: 'action_options_resolve' },
+        examples: {
+            voice: { argsExample: '{"actionId":"subagents.plan.start","fieldPath":"backendTargetKeys","sessionId":"{{sessionId}}"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: true,
+            voice_action_block: true,
+            session_agent: true,
+            mcp: true,
+            cli: false,
+        },
+        inputHints: {
+            title: 'Resolve action options',
+            description: 'Use this when an action field has static options or an optionsSourceId.',
+            fields: [
+                { path: 'actionId', title: 'Action id', description: 'Optional when optionsSourceId is provided directly.', widget: 'text' },
+                { path: 'fieldPath', title: 'Field path', description: 'Dot-path for the action input field.', widget: 'text' },
+                { path: 'optionsSourceId', title: 'Options source id', description: 'Direct options source lookup when known.', widget: 'text' },
+                { path: 'sessionId', title: 'Session id', description: 'Needed for session-scoped option sources.', widget: 'text' },
+                { path: 'query', title: 'Query filter', description: 'Optional search text to filter the returned options.', widget: 'text' },
+                { path: 'limit', title: 'Limit', description: 'Maximum number of options to return.', widget: 'text' },
+            ],
+        },
+        inputSchema: ActionOptionsResolveInputSchema,
+    },
     {
         id: 'review.start',
         title: 'Start review',
         safety: 'safe',
         placements: ['agent_input_chips', 'session_action_menu', 'command_palette', 'slash_command', 'voice_panel'],
-        slash: { tokens: ['/h.review'] },
+        prompting: { voiceHotPath: true },
+        slash: { tokens: ['/review', '/h.review'] },
         bindings: { voiceClientToolName: 'startReview', mcpToolName: 'review_start' },
         inputHints: {
             title: 'Start a code review',
@@ -271,6 +625,7 @@ export const ACTION_SPECS = Object.freeze([
                     description: 'Select one or more engines. Each engine runs as its own execution run.',
                     widget: 'multiselect',
                     required: true,
+                    requireExplicitSelection: true,
                     optionsSourceId: 'review.engines.available',
                 },
                 {
@@ -331,31 +686,33 @@ export const ACTION_SPECS = Object.freeze([
             ],
         },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","engineIds":["codex"],"instructions":"Review this.","changeType":"committed","base":{"kind":"none"}}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","engineIds":["codex"],"instructions":"Review this.","changeType":"uncommitted","base":{"kind":"none"}}' },
         },
         surfaces: {
             ui_button: true,
             ui_slash_command: true,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
         inputSchema: ReviewStartInputSchema,
     },
     {
-        id: 'plan.start',
+        id: 'subagents.plan.start',
         title: 'Start plan run',
         safety: 'safe',
         placements: ['agent_input_chips', 'session_action_menu', 'command_palette', 'slash_command', 'voice_panel'],
+        prompting: { voiceHotPath: true },
         slash: { tokens: ['/h.plan'] },
-        bindings: { voiceClientToolName: 'startPlan', mcpToolName: 'plan_start' },
+        bindings: { voiceClientToolName: 'startPlan', mcpToolName: 'subagents_plan_start' },
         inputHints: {
             title: 'Start a planning run',
             description: 'Start one or more parallel planning runs using selected backends.',
             fields: [
                 {
-                    path: 'backendIds',
+                    path: 'backendTargetKeys',
                     title: 'Backends',
                     description: 'Select one or more backends. Each backend runs as its own execution run.',
                     widget: 'multiselect',
@@ -372,31 +729,33 @@ export const ACTION_SPECS = Object.freeze([
             ],
         },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","backendIds":["codex"],"instructions":"Plan the changes."}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","backendTargetKeys":["agent:codex"],"instructions":"Plan the changes."}' },
         },
         surfaces: {
             ui_button: true,
             ui_slash_command: true,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
         inputSchema: PlanStartInputSchema,
     },
     {
-        id: 'delegate.start',
+        id: 'subagents.delegate.start',
         title: 'Start delegate run',
         safety: 'safe',
         placements: ['agent_input_chips', 'session_action_menu', 'command_palette', 'slash_command', 'voice_panel'],
+        prompting: { voiceHotPath: true },
         slash: { tokens: ['/h.delegate'] },
-        bindings: { voiceClientToolName: 'startDelegate', mcpToolName: 'delegate_start' },
+        bindings: { voiceClientToolName: 'startDelegate', mcpToolName: 'subagents_delegate_start' },
         inputHints: {
             title: 'Start a delegation run',
             description: 'Start one or more parallel delegation runs using selected backends.',
             fields: [
                 {
-                    path: 'backendIds',
+                    path: 'backendTargetKeys',
                     title: 'Backends',
                     description: 'Select one or more backends. Each backend runs as its own execution run.',
                     widget: 'multiselect',
@@ -413,15 +772,16 @@ export const ACTION_SPECS = Object.freeze([
             ],
         },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","backendIds":["codex"],"instructions":"Delegate the task."}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","backendTargetKeys":["agent:codex"],"instructions":"Delegate the task."}' },
         },
         surfaces: {
             ui_button: true,
             ui_slash_command: true,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
         inputSchema: DelegateStartInputSchema,
     },
@@ -437,7 +797,7 @@ export const ACTION_SPECS = Object.freeze([
             description: 'Start a voice agent execution run (typically used by the voice control plane).',
             fields: [
                 {
-                    path: 'backendIds',
+                    path: 'backendTargetKeys',
                     title: 'Backends',
                     description: 'Select one or more backends.',
                     widget: 'multiselect',
@@ -454,58 +814,118 @@ export const ACTION_SPECS = Object.freeze([
             ],
         },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","backendIds":["codex"],"instructions":"..."}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","backendTargetKeys":["agent:codex"],"instructions":"Start the voice assistant for this workspace."}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
         inputSchema: VoiceAgentStartInputSchema,
     },
+    {
+        id: 'execution.run.start',
+        title: 'Start execution run',
+        description: 'Start a new execution run within a session.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'execution_run_start' },
+        examples: {
+            mcp: {
+                argsExample: '{"sessionId":"{{sessionId}}","intent":"voice_agent","backendTarget":{"kind":"builtInAgent","agentId":"codex"},"instructions":"Summarize recent changes.","permissionMode":"read_only","retentionPolicy":"ephemeral","runClass":"bounded","ioMode":"request_response"}',
+            },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Start a run',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text' },
+                { path: 'intent', title: 'Intent', widget: 'text', required: true },
+                { path: 'backendTarget', title: 'Backend target (json)', widget: 'textarea', required: true },
+                { path: 'instructions', title: 'Instructions', widget: 'textarea' },
+                { path: 'permissionMode', title: 'Permission mode', widget: 'text', required: true },
+                { path: 'retentionPolicy', title: 'Retention policy', widget: 'text', required: true },
+                { path: 'runClass', title: 'Run class', widget: 'text', required: true },
+                { path: 'ioMode', title: 'IO mode', widget: 'text', required: true },
+                { path: 'initialContextMode', title: 'Initial context mode', widget: 'text' },
+            ],
+        },
+        inputSchema: ExecutionRunStartInputSchema,
+    },
     {
         id: 'execution.run.list',
         title: 'List execution runs',
         safety: 'safe',
         placements: ['run_list', 'command_palette', 'slash_command', 'voice_panel'],
+        prompting: { voiceHotPath: true },
         slash: { tokens: ['/h.runs'] },
         bindings: { voiceClientToolName: 'listExecutionRuns', mcpToolName: 'execution_run_list' },
         inputHints: {
             title: 'List execution runs',
-            fields: [{ path: 'sessionId', title: 'Session id', widget: 'text' }],
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text' },
+                { path: 'backendTarget', title: 'Backend target', widget: 'text' },
+                {
+                    path: 'status',
+                    title: 'Status',
+                    widget: 'select',
+                    options: [
+                        { value: 'running', label: 'Running' },
+                        { value: 'succeeded', label: 'Succeeded' },
+                        { value: 'failed', label: 'Failed' },
+                        { value: 'cancelled', label: 'Cancelled' },
+                        { value: 'timeout', label: 'Timeout' },
+                    ],
+                },
+                { path: 'limit', title: 'Max runs', widget: 'text' },
+            ],
         },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}"}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","status":"running","limit":10}' },
         },
         surfaces: {
             ui_button: true,
             ui_slash_command: true,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
-        inputSchema: z.object({ sessionId: z.string().min(1).optional() }).passthrough(),
+        inputSchema: ExecutionRunListRequestSchema.extend({
+            sessionId: z.string().min(1).optional(),
+        }),
     },
     {
         id: 'execution.run.get',
         title: 'Get execution run',
         safety: 'safe',
         placements: ['run_list', 'run_card', 'command_palette'],
+        prompting: { voiceHotPath: true },
         bindings: { voiceClientToolName: 'getExecutionRun', mcpToolName: 'execution_run_get' },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","runId":"...","includeStructured":false}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","runId":"run_123","includeStructured":false}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
         inputHints: {
             title: 'Get a run',
@@ -523,15 +943,16 @@ export const ACTION_SPECS = Object.freeze([
         placements: ['run_card'],
         bindings: { voiceClientToolName: 'sendExecutionRunMessage', mcpToolName: 'execution_run_send' },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","runId":"...","message":"...","resume":false}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","runId":"run_123","message":"Continue and summarize what changed.","resume":false}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
         inputHints: {
             title: 'Send to run',
@@ -550,15 +971,16 @@ export const ACTION_SPECS = Object.freeze([
         placements: ['run_card', 'run_list'],
         bindings: { voiceClientToolName: 'stopExecutionRun', mcpToolName: 'execution_run_stop' },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","runId":"..."}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","runId":"run_123"}' },
         },
         surfaces: {
             ui_button: true,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
         inputHints: {
             title: 'Stop a run',
@@ -573,15 +995,16 @@ export const ACTION_SPECS = Object.freeze([
         placements: ['run_card'],
         bindings: { voiceClientToolName: 'actionExecutionRun', mcpToolName: 'execution_run_action' },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","runId":"...","actionId":"...","input":{}}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","runId":"run_123","actionId":"voice_agent.commit","input":{"maxChars":1200}}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: true,
             mcp: true,
-            session_control_cli: true,
+            cli: true,
         },
         inputHints: {
             title: 'Run action',
@@ -593,6 +1016,36 @@ export const ACTION_SPECS = Object.freeze([
         },
         inputSchema: ExecutionRunActionInputSchema,
     },
+    {
+        id: 'execution.run.wait',
+        title: 'Wait for execution run',
+        description: 'Wait until an execution run reaches a terminal status (succeeded/failed/cancelled/timeout).',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'execution_run_wait' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}","runId":"run_123","timeoutSeconds":300}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Wait for a run',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text' },
+                { path: 'runId', title: 'Run id', widget: 'text', required: true },
+                { path: 'timeoutSeconds', title: 'Timeout seconds', widget: 'text' },
+                { path: 'pollIntervalMs', title: 'Poll interval (ms)', widget: 'text' },
+            ],
+        },
+        inputSchema: ExecutionRunWaitInputSchema,
+    },
     {
         id: 'session.open',
         title: 'Open session',
@@ -600,46 +1053,130 @@ export const ACTION_SPECS = Object.freeze([
         placements: ['command_palette', 'session_info', 'voice_panel'],
         bindings: { voiceClientToolName: 'openSession' },
         examples: {
-            voice: { argsExample: '{"sessionId":"..."}' },
+            voice: { argsExample: '{"sessionTitle":"Session Setup"}' },
         },
         surfaces: {
             ui_button: true,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: false,
             mcp: false,
-            session_control_cli: false,
+            cli: false,
         },
         inputHints: {
             title: 'Open a session',
-            fields: [{ path: 'sessionId', title: 'Session id', widget: 'text', required: true }],
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text' },
+                { path: 'sessionTitle', title: 'Session title', widget: 'text' },
+            ],
         },
         inputSchema: SessionOpenInputSchema,
     },
+    {
+        id: 'session.fork',
+        title: 'Fork session',
+        description: 'Create a new session from the latest state of the selected session.',
+        safety: 'safe',
+        placements: ['session_action_menu', 'session_info', 'command_palette', 'slash_command', 'voice_panel', 'agent_input_chips'],
+        slash: { tokens: ['fork'] },
+        bindings: { voiceClientToolName: 'forkSession' },
+        examples: {
+            voice: { argsExample: '{"sessionId":"{{sessionId}}"}' },
+        },
+        surfaces: {
+            ui_button: true,
+            ui_slash_command: true,
+            voice_tool: true,
+            voice_action_block: true,
+            session_agent: false,
+            mcp: false,
+            cli: false,
+        },
+        inputHints: {
+            title: 'Fork a session',
+            description: 'Forks from the latest message in the session.',
+            fields: [{ path: 'sessionId', title: 'Session id', widget: 'text' }],
+        },
+        inputSchema: SessionForkInputSchema,
+    },
+    {
+        id: 'session.rollback',
+        title: 'Rollback conversation',
+        description: 'Roll back conversation state in the selected session.',
+        safety: 'danger',
+        placements: ['session_action_menu', 'session_info'],
+        surfaces: {
+            ui_button: true,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: false,
+            mcp: false,
+            cli: false,
+        },
+        inputHints: {
+            title: 'Rollback a session conversation',
+            description: 'Rewinds conversation state for the selected session.',
+            fields: [{ path: 'sessionId', title: 'Session id', widget: 'text' }],
+        },
+        inputSchema: SessionRollbackInputSchema,
+    },
+    {
+        id: 'session.handoff',
+        title: 'Hand off session',
+        description: 'Move the current session to another machine while keeping the same session id.',
+        safety: 'safe',
+        placements: ['session_action_menu', 'session_info'],
+        examples: {
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","targetMachineId":"{{machineId}}"}' },
+        },
+        surfaces: {
+            ui_button: true,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: false,
+            mcp: false,
+            cli: false,
+        },
+        inputHints: {
+            title: 'Hand off a session',
+            description: 'Moves the current session to another machine.',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text' },
+                { path: 'targetMachineId', title: 'Target machine id', widget: 'text' },
+            ],
+        },
+        inputSchema: SessionHandoffInputSchema,
+    },
     {
         id: 'session.spawn_new',
         title: 'Create session',
         safety: 'safe',
         placements: ['command_palette', 'session_info', 'voice_panel'],
-        bindings: { voiceClientToolName: 'spawnSession' },
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'spawnSession', mcpToolName: 'session_spawn_new' },
         examples: {
-            voice: { argsExample: '{"tag":"...optional...","workspaceId":"...optional...","agentId":"...optional...","modelId":"...optional...","path":"...optional...","host":"...optional...","initialMessage":"...optional..."}' },
+            voice: { argsExample: '{"tag":"voice-qa","agentId":"claude","modelId":"default","initialMessage":"Help me inspect this workspace."}' },
         },
         surfaces: {
             ui_button: true,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: true,
+            session_agent: false,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'Create a new session',
             fields: [
                 { path: 'tag', title: 'Tag', widget: 'text' },
-                { path: 'workspaceId', title: 'Workspace id', widget: 'text' },
                 { path: 'agentId', title: 'Agent id', widget: 'text' },
                 { path: 'modelId', title: 'Model id', widget: 'text' },
+                { path: 'backendTargetKey', title: 'Backend target key', widget: 'text' },
+                { path: 'title', title: 'Title', widget: 'text' },
                 { path: 'path', title: 'Path', widget: 'text' },
                 { path: 'host', title: 'Host', widget: 'text' },
                 { path: 'initialMessage', title: 'Initial message', widget: 'textarea' },
@@ -653,17 +1190,19 @@ export const ACTION_SPECS = Object.freeze([
         description: 'Open the in-app machine + directory picker and create a new session from the user selection.',
         safety: 'safe',
         placements: ['voice_panel'],
+        prompting: { voiceHotPath: true },
         bindings: { voiceClientToolName: 'spawnSessionPicker' },
         examples: {
-            voice: { argsExample: '{"tag":"...optional...","agentId":"...optional...","modelId":"...optional...","initialMessage":"...optional..."}' },
+            voice: { argsExample: '{"tag":"voice-qa","agentId":"claude","modelId":"default","initialMessage":"Help me inspect this workspace."}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: false,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'Create a new session (picker)',
@@ -676,30 +1215,6 @@ export const ACTION_SPECS = Object.freeze([
         },
         inputSchema: SessionSpawnPickerInputSchema,
     },
-    {
-        id: 'workspaces.list_recent',
-        title: 'List recent workspaces',
-        description: 'List recent workspace handles for discovery without exposing raw paths to remote providers.',
-        safety: 'safe',
-        placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'listRecentWorkspaces' },
-        examples: {
-            voice: { argsExample: '{"limit":10}' },
-        },
-        surfaces: {
-            ui_button: false,
-            ui_slash_command: false,
-            voice_tool: true,
-            voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
-        },
-        inputHints: {
-            title: 'List recent workspaces',
-            fields: [{ path: 'limit', title: 'Limit', widget: 'text' }],
-        },
-        inputSchema: WorkspacesListRecentInputSchema,
-    },
     {
         id: 'paths.list_recent',
         title: 'List recent paths',
@@ -708,15 +1223,16 @@ export const ACTION_SPECS = Object.freeze([
         placements: ['voice_panel'],
         bindings: { voiceClientToolName: 'listRecentPaths' },
         examples: {
-            voice: { argsExample: '{"machineId":"...optional...","limit":10}' },
+            voice: { argsExample: '{"limit":10}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: false,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'List recent paths',
@@ -742,8 +1258,9 @@ export const ACTION_SPECS = Object.freeze([
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: false,
             mcp: false,
-            session_control_cli: false,
+            cli: false,
         },
         inputHints: {
             title: 'List machines',
@@ -766,8 +1283,9 @@ export const ACTION_SPECS = Object.freeze([
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: false,
             mcp: false,
-            session_control_cli: false,
+            cli: false,
         },
         inputHints: {
             title: 'List servers',
@@ -776,28 +1294,61 @@ export const ACTION_SPECS = Object.freeze([
         inputSchema: ServersListInputSchema,
     },
     {
-        id: 'agents.backends.list',
-        title: 'List agent backends',
-        description: 'List available agent backends (providers) for spawning sessions.',
+        id: 'review.engines.list',
+        title: 'List review engines',
+        description: 'List review engines currently available for the active session.',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'listAgentBackends' },
+        bindings: { voiceClientToolName: 'listReviewEngines' },
         examples: {
-            voice: { argsExample: '{"includeDisabled":false}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","includeDisabled":false}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: false,
             mcp: false,
-            session_control_cli: false,
+            cli: false,
         },
         inputHints: {
-            title: 'List agent backends',
-            fields: [{ path: 'includeDisabled', title: 'Include disabled', widget: 'toggle' }],
+            title: 'List review engines',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text' },
+                { path: 'includeDisabled', title: 'Include disabled', widget: 'toggle' },
+            ],
         },
-        inputSchema: AgentsBackendsListInputSchema,
+        inputSchema: ReviewEnginesListInputSchema,
+    },
+    {
+        id: 'agents.backends.list',
+        title: 'List agent backends',
+        description: 'List available agent backends (providers) for spawning sessions.',
+        safety: 'safe',
+        placements: ['voice_panel'],
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'listAgentBackends', mcpToolName: 'agents_backends_list' },
+        examples: {
+            voice: { argsExample: '{"includeDisabled":false,"limit":10}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: true,
+            voice_action_block: true,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'List agent backends',
+            fields: [
+                { path: 'includeDisabled', title: 'Include disabled', widget: 'toggle' },
+                { path: 'limit', title: 'Max results', widget: 'text' },
+            ],
+        },
+        inputSchema: AgentsBackendsListInputSchema,
     },
     {
         id: 'agents.models.list',
@@ -805,23 +1356,27 @@ export const ACTION_SPECS = Object.freeze([
         description: 'List available models for an agent backend.',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'listAgentModels' },
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'listAgentModels', mcpToolName: 'agents_models_list' },
         examples: {
-            voice: { argsExample: '{"agentId":"claude","machineId":"...optional..."}' },
+            voice: { argsExample: '{"backendTargetKey":"agent:claude","limit":10}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'List agent models',
             fields: [
-                { path: 'agentId', title: 'Agent id', widget: 'text', required: true },
+                { path: 'agentId', title: 'Agent id', widget: 'text' },
+                { path: 'backendTargetKey', title: 'Backend target key', widget: 'text' },
                 { path: 'machineId', title: 'Machine id (optional)', widget: 'text' },
+                { path: 'limit', title: 'Max results', widget: 'text' },
             ],
         },
         inputSchema: AgentsModelsListInputSchema,
@@ -832,44 +1387,306 @@ export const ACTION_SPECS = Object.freeze([
         description: 'Send a user message to the AI coding assistant inside the specified session.',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'sendSessionMessage' },
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'sendSessionMessage', mcpToolName: 'session_message_send' },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","message":"..."}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","message":"Please inspect the latest changes."}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'Send a message',
             fields: [
                 { path: 'sessionId', title: 'Session id', widget: 'text' },
                 { path: 'message', title: 'Message', widget: 'textarea', required: true },
+                { path: 'permissionModeOverride', title: 'Permission mode override (optional)', widget: 'text' },
+                { path: 'modelOverride', title: 'Model override (optional)', widget: 'text' },
+                { path: 'wait', title: 'Wait for idle (optional)', widget: 'toggle' },
+                { path: 'timeoutSeconds', title: 'Timeout seconds (optional)', widget: 'text' },
             ],
         },
         inputSchema: SessionSendMessageInputSchema,
     },
+    {
+        id: 'session.stop',
+        title: 'Stop session',
+        description: 'Request that the local daemon stops the specified session.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_stop' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Stop a session',
+            fields: [{ path: 'sessionId', title: 'Session id', widget: 'text', required: true }],
+        },
+        inputSchema: SessionIdRequiredInputSchema,
+    },
+    {
+        id: 'session.title.set',
+        title: 'Set session title',
+        description: 'Set the title (summary text) shown for a session.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_title_set' },
+        examples: {
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","title":"Fix flaky tests"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Set title',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text' },
+                { path: 'title', title: 'Title', widget: 'text', required: true },
+            ],
+        },
+        inputSchema: SessionTitleSetInputSchema,
+    },
+    {
+        id: 'session.permission_mode.set',
+        title: 'Set session permission mode',
+        description: 'Update the permission intent (read_only/workspace_write/etc) for the specified session.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_permission_mode_set' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}","permissionMode":"read_only"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Set permission mode',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text', required: true },
+                { path: 'permissionMode', title: 'Permission mode', widget: 'text', required: true },
+            ],
+        },
+        inputSchema: SessionPermissionModeSetInputSchema,
+    },
+    {
+        id: 'session.model.set',
+        title: 'Set session model',
+        description: 'Set the model override for the specified session.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_model_set' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}","modelId":"default"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Set session model',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text', required: true },
+                { path: 'modelId', title: 'Model id', widget: 'text', required: true },
+            ],
+        },
+        inputSchema: SessionModelSetInputSchema,
+    },
+    {
+        id: 'session.archive',
+        title: 'Archive session',
+        description: 'Archive the specified session.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_archive' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Archive a session',
+            fields: [{ path: 'sessionId', title: 'Session id', widget: 'text', required: true }],
+        },
+        inputSchema: SessionIdRequiredInputSchema,
+    },
+    {
+        id: 'session.unarchive',
+        title: 'Unarchive session',
+        description: 'Unarchive the specified session.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_unarchive' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Unarchive a session',
+            fields: [{ path: 'sessionId', title: 'Session id', widget: 'text', required: true }],
+        },
+        inputSchema: SessionIdRequiredInputSchema,
+    },
+    {
+        id: 'session.status.get',
+        title: 'Get session status',
+        description: 'Get summary status for a session, optionally refreshing live agent state.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_status_get' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}","live":true}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Get session status',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text', required: true },
+                { path: 'live', title: 'Live', widget: 'toggle' },
+            ],
+        },
+        inputSchema: SessionStatusGetInputSchema,
+    },
+    {
+        id: 'session.history.get',
+        title: 'Get session history',
+        description: 'Fetch a slice of session history/transcript records.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_history_get' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}","limit":50,"format":"compact"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Get session history',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text', required: true },
+                { path: 'limit', title: 'Limit', widget: 'text' },
+                {
+                    path: 'format',
+                    title: 'Format',
+                    widget: 'select',
+                    options: [
+                        { value: 'compact', label: 'Compact' },
+                        { value: 'raw', label: 'Raw' },
+                    ],
+                },
+                { path: 'includeMeta', title: 'Include meta', widget: 'toggle' },
+                { path: 'includeStructuredPayload', title: 'Include structured payload', widget: 'toggle' },
+            ],
+        },
+        inputSchema: SessionHistoryGetInputSchema,
+    },
+    {
+        id: 'session.wait.idle',
+        title: 'Wait for session idle',
+        description: 'Wait until the session becomes idle or the timeout elapses.',
+        safety: 'safe',
+        placements: [],
+        bindings: { mcpToolName: 'session_wait_idle' },
+        examples: {
+            mcp: { argsExample: '{"sessionId":"{{sessionId}}","timeoutSeconds":300}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Wait for idle',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text', required: true },
+                { path: 'timeoutSeconds', title: 'Timeout seconds', widget: 'text' },
+            ],
+        },
+        inputSchema: SessionWaitIdleInputSchema,
+    },
     {
         id: 'session.permission.respond',
         title: 'Respond to permission request',
         description: 'Approve or deny an active permission request in a session.',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'processPermissionRequest' },
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'processPermissionRequest', mcpToolName: 'session_permission_respond' },
         examples: {
-            voice: { argsExample: '{"sessionId":"{{sessionId}}","decision":"allow|deny","requestId":"...optional..."}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","decision":"allow"}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'Respond to permission request',
@@ -890,27 +1707,142 @@ export const ACTION_SPECS = Object.freeze([
         },
         inputSchema: SessionPermissionRespondInputSchema,
     },
+    {
+        id: 'session.user_action.answer',
+        title: 'Respond to user-action request',
+        description: 'Approve, reject, request changes, or provide structured answers for an active user-action request.',
+        safety: 'safe',
+        placements: ['voice_panel'],
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'answerUserActionRequest', mcpToolName: 'session_user_action_answer' },
+        examples: {
+            voice: {
+                argsExample: '{"sessionId":"{{sessionId}}","answers":[{"question":"Continue?","answer":"Yes"}]}',
+            },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: true,
+            voice_action_block: true,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Respond to user-action request',
+            fields: [
+                { path: 'sessionId', title: 'Session id', widget: 'text' },
+                { path: 'requestId', title: 'Request id', widget: 'text' },
+                {
+                    path: 'decision',
+                    title: 'Decision',
+                    description: 'Use approve or reject for general user actions, or request_changes when you need the coding assistant to revise something first.',
+                    widget: 'select',
+                    options: [
+                        { value: 'approve', label: 'Approve' },
+                        { value: 'reject', label: 'Reject' },
+                        { value: 'request_changes', label: 'Request changes' },
+                    ],
+                },
+                {
+                    path: 'reason',
+                    title: 'Reason',
+                    description: 'Required when requesting changes. Optional extra context for a rejection.',
+                    widget: 'textarea',
+                },
+                {
+                    path: 'answers',
+                    title: 'Answers',
+                    description: 'Structured answers for question-style user-action requests such as AskUserQuestion.',
+                    widget: 'textarea',
+                },
+                {
+                    path: 'answers.[]',
+                    title: 'Answer entry',
+                    description: 'One question/answer pair for the pending request.',
+                    widget: 'textarea',
+                },
+                {
+                    path: 'answers.[].question',
+                    title: 'Question',
+                    description: 'The exact question text to answer.',
+                    widget: 'text',
+                    required: true,
+                },
+                {
+                    path: 'answers.[].answer',
+                    title: 'Answer',
+                    description: 'The answer text to send back for that question.',
+                    widget: 'text',
+                    required: true,
+                },
+            ],
+        },
+        inputSchema: SessionUserActionAnswerInputSchema,
+    },
+    {
+        id: 'session.mode.set',
+        title: 'Set session mode',
+        description: 'Request a new ACP session mode for the current session when the active provider supports session modes.',
+        safety: 'safe',
+        placements: ['voice_panel'],
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'setSessionMode' },
+        examples: {
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","modeId":"plan"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: true,
+            voice_action_block: true,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputHints: {
+            title: 'Set session mode',
+            fields: [
+                { path: 'sessionId', title: 'Session id', description: 'Optional when the active target session is already correct.', widget: 'text' },
+                {
+                    path: 'modeId',
+                    title: 'Mode id',
+                    description: 'Use default to clear the override and return to the provider default mode.',
+                    widget: 'select',
+                    required: true,
+                    optionsSourceId: 'session.modes.available',
+                },
+            ],
+        },
+        inputSchema: SessionModeSetInputSchema,
+    },
     {
         id: 'session.target.primary.set',
         title: 'Set primary action session',
         description: 'Set which session the voice assistant should target by default.',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'setPrimaryActionSession' },
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'setPrimaryActionSession', mcpToolName: 'session_target_primary_set' },
         examples: {
-            voice: { argsExample: '{"sessionId":"...|null"}' },
+            voice: { argsExample: '{"sessionTitle":"Session Setup"}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: false,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'Set primary action session',
-            fields: [{ path: 'sessionId', title: 'Session id (or null)', widget: 'text' }],
+            fields: [
+                { path: 'sessionId', title: 'Session id (or null)', widget: 'text' },
+                { path: 'sessionTitle', title: 'Session title', widget: 'text' },
+            ],
         },
         inputSchema: SessionPrimaryTargetInputSchema,
     },
@@ -920,17 +1852,18 @@ export const ACTION_SPECS = Object.freeze([
         description: 'Set which sessions should be treated as tracked for updates/snippets.',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'setTrackedSessions' },
+        bindings: { voiceClientToolName: 'setTrackedSessions', mcpToolName: 'session_target_tracked_set' },
         examples: {
-            voice: { argsExample: '{"sessionIds":["..."]}' },
+            voice: { argsExample: '{"sessionIds":["{{sessionId}}"]}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: false,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'Set tracked sessions',
@@ -944,7 +1877,8 @@ export const ACTION_SPECS = Object.freeze([
         description: 'List recent sessions the user can target.',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'listSessions' },
+        prompting: { voiceHotPath: true },
+        bindings: { voiceClientToolName: 'listSessions', mcpToolName: 'session_list' },
         examples: {
             voice: { argsExample: '{"limit":20,"cursor":null,"includeLastMessagePreview":true}' },
         },
@@ -953,8 +1887,9 @@ export const ACTION_SPECS = Object.freeze([
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'List sessions',
@@ -972,17 +1907,18 @@ export const ACTION_SPECS = Object.freeze([
         description: 'Get a short activity digest for a session without transcript content.',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'getSessionActivity' },
+        bindings: { voiceClientToolName: 'getSessionActivity', mcpToolName: 'session_activity_get' },
         examples: {
-            voice: { argsExample: '{"sessionId":"..."}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}"}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'Get session activity',
@@ -999,17 +1935,18 @@ export const ACTION_SPECS = Object.freeze([
         description: 'Get a small slice of recent messages for a session (privacy guarded).',
         safety: 'safe',
         placements: ['voice_panel'],
-        bindings: { voiceClientToolName: 'getSessionRecentMessages' },
+        bindings: { voiceClientToolName: 'getSessionRecentMessages', mcpToolName: 'session_messages_recent_get' },
         examples: {
-            voice: { argsExample: '{"sessionId":"...","limit":3,"cursor":null}' },
+            voice: { argsExample: '{"sessionId":"{{sessionId}}","limit":3,"cursor":null}' },
         },
         surfaces: {
             ui_button: false,
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: false,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
         },
         inputHints: {
             title: 'Get recent messages',
@@ -1043,17 +1980,45 @@ export const ACTION_SPECS = Object.freeze([
             ui_slash_command: true,
             voice_tool: true,
             voice_action_block: true,
+            session_agent: false,
             mcp: false,
-            session_control_cli: false,
+            cli: false,
         },
         inputSchema: EmptyObjectSchema,
     },
+    {
+        id: 'ui.voice_agent.teleport',
+        title: 'Teleport voice agent to session root',
+        description: 'Move the daemon-backed voice agent into the current or specified session root.',
+        safety: 'safe',
+        placements: ['voice_panel'],
+        bindings: { voiceClientToolName: 'teleportVoiceAgentToSessionRoot' },
+        inputHints: {
+            title: 'Teleport voice agent',
+            description: 'Teleport the active voice agent into a session root. Defaults to the current action session when omitted.',
+            fields: [{ path: 'sessionId', title: 'Session id', widget: 'text' }],
+        },
+        examples: {
+            voice: { argsExample: '{"sessionId":"{{sessionId}}"}' },
+        },
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: true,
+            voice_action_block: true,
+            session_agent: false,
+            mcp: false,
+            cli: false,
+        },
+        inputSchema: OptionalSessionIdInputSchema,
+    },
     {
         id: 'memory.search',
         title: 'Search memory',
         description: 'Search the local daemon memory index (opt-in).',
         safety: 'safe',
         placements: ['voice_panel', 'command_palette'],
+        prompting: { voiceHotPath: true },
         bindings: { voiceClientToolName: 'memorySearch', mcpToolName: 'memory_search' },
         inputHints: {
             title: 'Search memory',
@@ -1096,8 +2061,9 @@ export const ACTION_SPECS = Object.freeze([
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: true,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: false,
+            cli: false,
         },
         inputSchema: MemorySearchInputSchema,
     },
@@ -1123,8 +2089,13 @@ export const ACTION_SPECS = Object.freeze([
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: true,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: false,
+            cli: false,
+        },
+        examples: {
+            voice: { argsExample: '{"machineId":"{{machineId}}","sessionId":"{{sessionId}}","seqFrom":120,"seqTo":124}' },
+            mcp: { argsExample: '{"machineId":"{{machineId}}","sessionId":"{{sessionId}}","seqFrom":120,"seqTo":124}' },
         },
         inputSchema: MemoryGetWindowInputSchema,
     },
@@ -1148,11 +2119,223 @@ export const ACTION_SPECS = Object.freeze([
             ui_slash_command: false,
             voice_tool: true,
             voice_action_block: true,
-            mcp: true,
-            session_control_cli: false,
+            session_agent: true,
+            mcp: false,
+            cli: false,
+        },
+        examples: {
+            voice: { argsExample: '{"machineId":"{{machineId}}","sessionId":"{{sessionId}}"}' },
+            mcp: { argsExample: '{"machineId":"{{machineId}}","sessionId":"{{sessionId}}"}' },
         },
         inputSchema: MemoryEnsureUpToDateInputSchema,
     },
+    {
+        id: 'prompt_doc.update',
+        title: 'Update prompt document',
+        description: 'Update a prompt document stored in the Happier prompt library.',
+        safety: 'danger',
+        placements: [],
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputSchema: PromptDocUpdateInputSchema,
+        inputHints: {
+            title: 'Update prompt document',
+            fields: [
+                { path: 'artifactId', title: 'Prompt artifact id', widget: 'text', required: true },
+                { path: 'title', title: 'Title', widget: 'text', required: true },
+                { path: 'markdown', title: 'Markdown', widget: 'textarea', required: true },
+                { path: 'folderId', title: 'Folder id', widget: 'text' },
+                { path: 'tags', title: 'Tags', widget: 'text_list', listSeparator: 'comma' },
+            ],
+        },
+    },
+    {
+        id: 'prompt_bundle.update',
+        title: 'Update prompt bundle',
+        description: 'Update a skill bundle stored in the Happier prompt library.',
+        safety: 'danger',
+        placements: [],
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: false,
+            mcp: false,
+            cli: false,
+        },
+        inputSchema: PromptBundleUpdateInputSchema,
+        inputHints: {
+            title: 'Update prompt bundle',
+            fields: [
+                { path: 'artifactId', title: 'Bundle artifact id', widget: 'text', required: true },
+                { path: 'title', title: 'Title', widget: 'text', required: true },
+                { path: 'skillMarkdown', title: 'SKILL.md markdown', widget: 'textarea', required: true },
+                { path: 'folderId', title: 'Folder id', widget: 'text' },
+                { path: 'tags', title: 'Tags', widget: 'text_list', listSeparator: 'comma' },
+            ],
+        },
+    },
+    {
+        id: 'prompt_asset.export',
+        title: 'Export prompt asset',
+        description: 'Export a prompt doc or skill bundle from the Happier library to a provider-native asset.',
+        safety: 'danger',
+        placements: [],
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: false,
+            mcp: false,
+            cli: false,
+        },
+        inputSchema: PromptAssetExportInputSchema,
+        inputHints: {
+            title: 'Export prompt asset',
+            fields: [
+                { path: 'artifactId', title: 'Artifact id', widget: 'text', required: true },
+                { path: 'machineId', title: 'Machine id', widget: 'text', required: true },
+                { path: 'assetTypeId', title: 'Asset type id', widget: 'text', required: true },
+                {
+                    path: 'scope',
+                    title: 'Scope',
+                    widget: 'select',
+                    required: true,
+                    options: [
+                        { value: 'project', label: 'Project' },
+                        { value: 'user', label: 'User' },
+                    ],
+                },
+                { path: 'directory', title: 'Project directory', widget: 'text' },
+                { path: 'targetPath', title: 'Document path', widget: 'text' },
+                { path: 'targetName', title: 'Skill name', widget: 'text' },
+                {
+                    path: 'installMode',
+                    title: 'Install mode',
+                    widget: 'select',
+                    options: [
+                        { value: 'copy', label: 'Copy' },
+                        { value: 'symlink', label: 'Symlink' },
+                    ],
+                },
+            ],
+        },
+    },
+    {
+        id: 'prompt_registry.install',
+        title: 'Install prompt registry skill',
+        description: 'Import a skill bundle from a registry and optionally export it to an external skills location.',
+        safety: 'danger',
+        placements: [],
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: false,
+            mcp: false,
+            cli: false,
+        },
+        inputSchema: PromptRegistryInstallInputSchema,
+        inputHints: {
+            title: 'Install prompt registry skill',
+            fields: [
+                { path: 'machineId', title: 'Machine id', widget: 'text', required: true },
+                { path: 'sourceId', title: 'Source id', widget: 'text', required: true },
+                { path: 'itemId', title: 'Item id', widget: 'text', required: true },
+                { path: 'configuredSources', title: 'Configured sources (json)', widget: 'textarea' },
+                { path: 'installTarget.assetTypeId', title: 'Target asset type', widget: 'text' },
+                {
+                    path: 'installTarget.scope',
+                    title: 'Target scope',
+                    widget: 'select',
+                    options: [
+                        { value: 'project', label: 'Project' },
+                        { value: 'user', label: 'User' },
+                    ],
+                },
+                { path: 'installTarget.directory', title: 'Project directory', widget: 'text' },
+                { path: 'installTarget.targetName', title: 'Target skill name', widget: 'text' },
+                {
+                    path: 'installTarget.installMode',
+                    title: 'Install mode',
+                    widget: 'select',
+                    options: [
+                        { value: 'copy', label: 'Copy' },
+                        { value: 'symlink', label: 'Symlink' },
+                    ],
+                },
+            ],
+        },
+    },
+    {
+        id: 'approval.request.create',
+        title: 'Create approval request',
+        description: 'Create an approval request for another action to run.',
+        safety: 'danger',
+        placements: [],
+        surfaces: {
+            ui_button: false,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: true,
+            mcp: true,
+            cli: true,
+        },
+        inputSchema: ApprovalRequestCreateInputSchema,
+        inputHints: {
+            title: 'Request approval',
+            description: 'Create an approval request in the global inbox.',
+            fields: [
+                { path: 'summary', title: 'Summary', widget: 'textarea', required: true },
+                { path: 'actionId', title: 'Action id', widget: 'text', required: true },
+                { path: 'actionArgs', title: 'Action args (json)', widget: 'textarea', required: true },
+            ],
+        },
+    },
+    {
+        id: 'approval.request.decide',
+        title: 'Decide approval request',
+        description: 'Approve or reject an approval request.',
+        safety: 'danger',
+        placements: [],
+        surfaces: {
+            ui_button: true,
+            ui_slash_command: false,
+            voice_tool: false,
+            voice_action_block: false,
+            session_agent: false,
+            mcp: true,
+            cli: true,
+        },
+        inputSchema: ApprovalRequestDecideInputSchema,
+        inputHints: {
+            title: 'Approve or reject',
+            fields: [
+                { path: 'artifactId', title: 'Approval artifact id', widget: 'text', required: true },
+                {
+                    path: 'decision',
+                    title: 'Decision',
+                    widget: 'select',
+                    required: true,
+                    options: [
+                        { value: 'approve', label: 'Approve' },
+                        { value: 'reject', label: 'Reject' },
+                    ],
+                },
+            ],
+        },
+    },
 ]);
 export function listActionSpecs() {
     return ACTION_SPECS;
@@ -1165,11 +2348,25 @@ export function getActionSpec(id) {
     }
     return spec;
 }
+export function isActionSpecSurfacedOn(spec, surface) {
+    if (!surface)
+        return true;
+    return spec.surfaces[surface] === true;
+}
+export function listActionSpecsForSurface(surface) {
+    return ACTION_SPECS.filter((spec) => isActionSpecSurfacedOn(spec, surface));
+}
 export function listVoiceToolActionSpecs() {
-    return ACTION_SPECS.filter((spec) => spec.surfaces.voice_tool === true && Boolean(spec.bindings?.voiceClientToolName));
+    return listActionSpecsForSurface('voice_tool').filter((spec) => Boolean(spec.bindings?.voiceClientToolName));
+}
+export function isVoicePromptHotPathSpec(spec) {
+    return spec.prompting?.voiceHotPath === true;
+}
+export function listVoicePromptHotPathSpecs() {
+    return listVoiceToolActionSpecs().filter(isVoicePromptHotPathSpec);
 }
 export function listVoiceActionBlockSpecs() {
-    return ACTION_SPECS.filter((spec) => spec.surfaces.voice_action_block === true && Boolean(spec.bindings?.voiceClientToolName));
+    return listActionSpecsForSurface('voice_action_block').filter((spec) => Boolean(spec.bindings?.voiceClientToolName));
 }
 export function listVoiceClientToolNames() {
     const names = listVoiceToolActionSpecs()
@@ -1178,4 +2375,17 @@ export function listVoiceClientToolNames() {
     names.sort();
     return names;
 }
+export function resolveVoiceClientToolNameAlias(value) {
+    const normalized = String(value ?? '').trim();
+    if (!normalized)
+        return null;
+    for (const spec of listVoiceToolActionSpecs()) {
+        const toolName = String(spec.bindings?.voiceClientToolName ?? '').trim();
+        if (!toolName)
+            continue;
+        if (toolName === normalized || spec.id === normalized)
+            return toolName;
+    }
+    return null;
+}
 //# sourceMappingURL=actionSpecs.js.map