@vellumai/assistant 0.4.3 → 0.4.4

package/src/daemon/call-pointer-generators.ts

@@ -0,0 +1,59 @@
+import {
+  buildPointerGenerationPrompt,
+  getPointerFallbackMessage,
+  includesRequiredFacts,
+  POINTER_COPY_MAX_TOKENS,
+  POINTER_COPY_SYSTEM_PROMPT,
+  POINTER_COPY_TIMEOUT_MS,
+} from '../calls/call-pointer-message-composer.js';
+import { loadConfig } from '../config/loader.js';
+import { getFailoverProvider } from '../providers/registry.js';
+import type { PointerCopyGenerator } from '../runtime/http-types.js';
+
+/**
+ * Create the daemon-owned pointer copy generator that resolves providers
+ * and calls `provider.sendMessage` to generate pointer message text.
+ * This keeps all provider awareness in the daemon lifecycle, away from
+ * the runtime composer.
+ */
+export function createPointerCopyGenerator(): PointerCopyGenerator {
+  return async (context, options = {}) => {
+    const config = loadConfig();
+    let provider;
+    try {
+      provider = getFailoverProvider(config.provider, config.providerOrder);
+    } catch {
+      return null;
+    }
+
+    const fallbackText = options.fallbackText?.trim() || getPointerFallbackMessage(context);
+    const requiredFacts = options.requiredFacts
+      ?.map((f) => f.trim())
+      .filter((f) => f.length > 0);
+    const prompt = buildPointerGenerationPrompt(context, fallbackText, requiredFacts);
+
+    const response = await provider.sendMessage(
+      [{ role: 'user', content: [{ type: 'text', text: prompt }] }],
+      [],
+      POINTER_COPY_SYSTEM_PROMPT,
+      {
+        config: {
+          max_tokens: options.maxTokens ?? POINTER_COPY_MAX_TOKENS,
+          modelIntent: 'latency-optimized',
+        },
+        signal: AbortSignal.timeout(options.timeoutMs ?? POINTER_COPY_TIMEOUT_MS),
+      },
+    );
+
+    const block = response.content.find((entry) => entry.type === 'text');
+    const text = block && 'text' in block ? block.text.trim() : '';
+    if (!text) return null;
+    const cleaned = text
+      .replace(/^["'`]+/, '')
+      .replace(/["'`]+$/, '')
+      .trim();
+    if (!cleaned) return null;
+    if (!includesRequiredFacts(cleaned, requiredFacts)) return null;
+    return cleaned;
+  };
+}

package/src/daemon/computer-use-session.ts

@@ -79,7 +79,7 @@ export class ComputerUseSession {
   private pendingSurfaceActions = new Map<string, {
     resolve: (result: ToolExecutionResult) => void;
   }>();
-  private surfaceState = new Map<string, { surfaceType: SurfaceType; data: SurfaceData }>();
+  private surfaceState = new Map<string, { surfaceType: SurfaceType; data: SurfaceData; title?: string }>();
   private terminalNotified = false;
   private prompter: PermissionPrompter | null = null;
 
@@ -337,7 +337,7 @@ export class ComputerUseSession {
         const awaitAction = (input.await_action as boolean) ?? isInteractive;
 
         // Track surface state for ui_update merging
-        this.surfaceState.set(surfaceId, { surfaceType, data });
+        this.surfaceState.set(surfaceId, { surfaceType, data, title });
 
         this.sendToClient({
           type: 'ui_surface_show',
@@ -532,9 +532,6 @@ export class ComputerUseSession {
         maxTokens: 4096,
         maxInputTokens: cuConfig.contextWindow.maxInputTokens,
         toolChoice: { type: 'any' },
-        // Allow MAX_STEPS non-terminal actions plus one terminal turn
-        // (computer_use_done/computer_use_respond), since AgentLoop caps tool turns globally.
-        maxToolUseTurns: MAX_STEPS + 1,
       },
       toolDefs,
       toolExecutor,

package/src/daemon/handlers/apps.ts

@@ -7,6 +7,8 @@ import { v4 as uuid } from 'uuid';
 
 import { packageApp } from '../../bundler/app-bundler.js';
 import { defaultGallery } from '../../gallery/default-gallery.js';
+import { resolveHomeBaseAppId } from '../../home-base/bootstrap.js';
+import { isPrebuiltHomeBaseApp } from '../../home-base/prebuilt-home-base-updater.js';
 import { getAppDiff, getAppFileAtVersion, getAppHistory, restoreAppVersion } from '../../memory/app-git-service.js';
 import { createApp, createAppRecord, deleteAppRecord, getApp, getAppPreview, listApps, queryAppRecords, updateApp,updateAppRecord } from '../../memory/app-store.js';
 import { createSharedAppLink } from '../../memory/shared-app-links-store.js';
@@ -77,28 +79,54 @@ export function handleAppDataRequest(
 }
 
 export function handleAppOpenRequest(msg: { appId: string }, socket: net.Socket, ctx: HandlerContext): void {
-  const appId = msg.appId;
-  if (!appId) {
-    ctx.send(socket, { type: 'error', message: 'app_open_request requires appId' });
-    return;
-  }
+  try {
+    const appId = msg.appId;
+    if (!appId) {
+      ctx.send(socket, { type: 'error', message: 'app_open_request requires appId' });
+      return;
+    }
+
+    const app = getApp(appId);
+    if (app) {
+      const surfaceId = `app-open-${uuid()}`;
+      ctx.send(socket, {
+        type: 'ui_surface_show',
+        sessionId: 'app-panel',
+        surfaceId,
+        surfaceType: 'dynamic_page',
+        title: app.name,
+        data: { html: app.htmlDefinition, appId: app.id, appType: app.appType },
+        display: 'panel',
+      } as UiSurfaceShow);
+      return;
+    }
+
+    // Fallback: the ID might be a surfaceId from an ephemeral ui_show surface
+    // (not a persistent app). Search active sessions for cached surface data.
+    for (const session of ctx.sessions.values()) {
+      const cached = session.surfaceState.get(appId);
+      if (cached && cached.surfaceType === 'dynamic_page') {
+        const newSurfaceId = `app-open-${uuid()}`;
+        ctx.send(socket, {
+          type: 'ui_surface_show',
+          sessionId: 'app-panel',
+          surfaceId: newSurfaceId,
+          surfaceType: 'dynamic_page',
+          title: cached.title ?? (cached.data as { preview?: { title?: string } }).preview?.title,
+          data: cached.data,
+          display: 'panel',
+        } as UiSurfaceShow);
+        return;
+      }
+    }
 
-  const app = getApp(appId);
-  if (!app) {
+    log.warn({ appId }, 'App not found in store or session surfaces');
     ctx.send(socket, { type: 'error', message: `App not found: ${appId}` });
-    return;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log.error({ err, appId: msg.appId }, 'Failed to handle app open request');
+    ctx.send(socket, { type: 'error', message: `Failed to open app: ${message}` });
   }
-
-  const surfaceId = `app-open-${uuid()}`;
-  ctx.send(socket, {
-    type: 'ui_surface_show',
-    sessionId: 'app-panel',
-    surfaceId,
-    surfaceType: 'dynamic_page',
-    title: app.name,
-    data: { html: app.htmlDefinition, appId: app.id, appType: app.appType },
-    display: 'panel',
-  } as UiSurfaceShow);
 }
 
 export function handleAppUpdatePreview(msg: AppUpdatePreviewRequest, socket: net.Socket, ctx: HandlerContext): void {
@@ -114,7 +142,35 @@ export function handleAppUpdatePreview(msg: AppUpdatePreviewRequest, socket: net
 
 export function handleAppsList(socket: net.Socket, ctx: HandlerContext): void {
   try {
-    const apps = listApps();
+    const allApps = listApps();
+    const homeBaseId = resolveHomeBaseAppId();
+
+    // When no home base was found by ID, do a single targeted search for an app
+    // matching the HTML marker. listApps() returns metadata-only (no htmlDefinition),
+    // so the HTML marker check requires loading the full app from disk. We limit
+    // this expensive operation to the case where homeBaseId is null.
+    const excludeIds = new Set<string>();
+    if (homeBaseId) {
+      excludeIds.add(homeBaseId);
+    } else {
+      for (const a of allApps) {
+        if (isPrebuiltHomeBaseApp(a)) {
+          excludeIds.add(a.id);
+          continue;
+        }
+        const fullApp = getApp(a.id);
+        if (fullApp && isPrebuiltHomeBaseApp(fullApp)) {
+          excludeIds.add(a.id);
+          continue;
+        }
+      }
+    }
+
+    const apps = allApps.filter((a) => {
+      if (excludeIds.has(a.id)) return false;
+      if (isPrebuiltHomeBaseApp(a)) return false;
+      return true;
+    });
     ctx.send(socket, {
       type: 'apps_list_response',
       apps: apps.map((a) => {

package/src/daemon/handlers/config-channels.ts

@@ -19,7 +19,6 @@ import {
   startOutbound,
 } from '../../runtime/guardian-outbound-actions.js';
 import type {
-  ChannelReadinessRequest,
   GuardianVerificationRequest,
   GuardianVerificationResponse,
 } from '../ipc-protocol.js';
@@ -60,7 +59,6 @@ export function getReadinessService(): ChannelReadinessService {
 
 export function createGuardianChallenge(
   channel?: ChannelId,
-  assistantId?: string,
   rebind?: boolean,
   sessionId?: string,
 ): GuardianVerificationResult {
@@ -89,7 +87,6 @@ export function createGuardianChallenge(
 
 export function getGuardianStatus(
   channel?: ChannelId,
-  _assistantId?: string,
 ): GuardianVerificationResult {
   const resolvedAssistantId = DAEMON_INTERNAL_ASSISTANT_ID;
   const resolvedChannel = channel ?? 'telegram';
@@ -166,10 +163,10 @@ export function handleGuardianVerification(
 
   try {
     if (msg.action === 'create_challenge') {
-      const result = createGuardianChallenge(channel, assistantId, msg.rebind, msg.sessionId);
+      const result = createGuardianChallenge(channel, msg.rebind, msg.sessionId);
       ctx.send(socket, { type: 'guardian_verification_response', ...result });
     } else if (msg.action === 'status') {
-      const result = getGuardianStatus(channel, assistantId);
+      const result = getGuardianStatus(channel);
       ctx.send(socket, { type: 'guardian_verification_response', ...result });
     } else if (msg.action === 'revoke') {
       // Capture binding before revoking so we can revoke the guardian's
@@ -198,13 +195,13 @@ export function handleGuardianVerification(
         channel,
       });
     } else if (msg.action === 'start_outbound') {
-      const result = startOutbound({ channel, assistantId, destination: msg.destination, rebind: msg.rebind, originConversationId: msg.originConversationId });
+      const result = startOutbound({ channel, destination: msg.destination, rebind: msg.rebind, originConversationId: msg.originConversationId });
       ctx.send(socket, { type: 'guardian_verification_response', ...result });
     } else if (msg.action === 'resend_outbound') {
-      const result = resendOutbound({ channel, assistantId, originConversationId: msg.originConversationId });
+      const result = resendOutbound({ channel, originConversationId: msg.originConversationId });
       ctx.send(socket, { type: 'guardian_verification_response', ...result });
     } else if (msg.action === 'cancel_outbound') {
-      const result = cancelOutbound({ channel, assistantId });
+      const result = cancelOutbound({ channel });
       ctx.send(socket, { type: 'guardian_verification_response', ...result });
     } else {
       ctx.send(socket, {
@@ -227,53 +224,6 @@ export function handleGuardianVerification(
 }
 
 
-// ---------------------------------------------------------------------------
-// Channel readiness handler
-// ---------------------------------------------------------------------------
-
-export async function handleChannelReadiness(
-  msg: ChannelReadinessRequest,
-  socket: net.Socket,
-  ctx: HandlerContext,
-): Promise<void> {
-  try {
-    const service = getReadinessService();
-
-    if (msg.action === 'refresh') {
-      if (msg.channel) {
-        service.invalidateChannel(msg.channel, msg.assistantId);
-      } else {
-        service.invalidateAll();
-      }
-    }
-
-    const snapshots = await service.getReadiness(msg.channel, msg.includeRemote, msg.assistantId);
-
-    ctx.send(socket, {
-      type: 'channel_readiness_response',
-      success: true,
-      snapshots: snapshots.map((s) => ({
-        channel: s.channel,
-        ready: s.ready,
-        checkedAt: s.checkedAt,
-        stale: s.stale,
-        reasons: s.reasons,
-        localChecks: s.localChecks,
-        remoteChecks: s.remoteChecks,
-      })),
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to handle channel readiness');
-    ctx.send(socket, {
-      type: 'channel_readiness_response',
-      success: false,
-      error: message,
-    });
-  }
-}
-
 export const channelHandlers = defineHandlers({
-  channel_readiness: handleChannelReadiness,
   guardian_verification: handleGuardianVerification,
 });

package/src/daemon/handlers/config-inbox.ts

@@ -305,9 +305,15 @@ async function executeApprove(
     }
   }
   session.setAssistantId(assistantId);
-  // The guardian approved this escalation, so tag as guardian trust to avoid
-  // unknown-provenance memory gating.
-  session.setGuardianContext({ trustClass: 'guardian', sourceChannel: sourceChannel ?? 'vellum' });
+  // The guardian already approved this escalation via the inbox, so we
+  // directly set guardian trust. Going through resolveLocalIpcGuardianContext
+  // would look up the vellum binding's guardian ID and compare it against
+  // a different channel's binding (e.g. telegram/sms), misclassifying the
+  // actor as 'unknown'.
+  session.setGuardianContext({
+    sourceChannel: sourceChannel ?? 'vellum',
+    trustClass: 'guardian',
+  });
   session.setCommandIntent(null);
 
   // Process the message through the agent loop (no IPC event callback

package/src/daemon/handlers/config-ingress.ts

@@ -10,6 +10,7 @@ import {
   setIngressPublicBaseUrl,
 } from '../../config/env.js';
 import { loadRawConfig, saveRawConfig } from '../../config/loader.js';
+import { registerCallbackRoute, resolveCallbackUrl, shouldUsePlatformCallbacks } from '../../inbound/platform-callback-registration.js';
 import {
   getTwilioSmsWebhookUrl,
   getTwilioStatusCallbackUrl,
@@ -92,9 +93,21 @@ export async function syncTwilioWebhooks(
   ingressConfig: IngressConfig,
 ): Promise<{ success: boolean; warning?: string }> {
   try {
-    const voiceUrl = getTwilioVoiceWebhookUrl(ingressConfig);
-    const statusCallbackUrl = getTwilioStatusCallbackUrl(ingressConfig);
-    const smsUrl = getTwilioSmsWebhookUrl(ingressConfig);
+    const voiceUrl = await resolveCallbackUrl(
+      () => getTwilioVoiceWebhookUrl(ingressConfig),
+      'webhooks/twilio/voice',
+      'twilio_voice',
+    );
+    const statusCallbackUrl = await resolveCallbackUrl(
+      () => getTwilioStatusCallbackUrl(ingressConfig),
+      'webhooks/twilio/status',
+      'twilio_status',
+    );
+    const smsUrl = await resolveCallbackUrl(
+      () => getTwilioSmsWebhookUrl(ingressConfig),
+      'webhooks/twilio/sms',
+      'twilio_sms',
+    );
     await updatePhoneNumberWebhooks(accountSid, authToken, phoneNumber, {
       voiceUrl,
       statusCallbackUrl,
@@ -183,6 +196,18 @@ export async function handleIngressConfig(
       // Use the effective URL from process.env (which accounts for the
       // fallback branch above) rather than the raw `value` from the UI.
       const effectiveUrl = isEnabled ? getIngressPublicBaseUrl() : undefined;
+
+      // When containerized with a platform, register the Telegram callback
+      // route so the platform knows how to forward Telegram webhooks.
+      // This must happen independently of effectiveUrl — in containerized
+      // deployments without ingress.publicBaseUrl, platform callbacks are the
+      // only way to receive Telegram webhooks.
+      if (shouldUsePlatformCallbacks()) {
+        registerCallbackRoute('webhooks/telegram', 'telegram').catch((err) => {
+          log.warn({ err }, 'Failed to register Telegram platform callback route');
+        });
+      }
+
       triggerGatewayReconcile(effectiveUrl);
 
       // Best-effort Twilio webhook reconciliation: when ingress is being

package/src/daemon/handlers/config-telegram.ts

@@ -1,6 +1,7 @@
 import * as net from 'node:net';
 
 import { getIngressPublicBaseUrl } from '../../config/env.js';
+import { registerCallbackRoute, shouldUsePlatformCallbacks } from '../../inbound/platform-callback-registration.js';
 import { deleteSecureKey,getSecureKey, setSecureKey } from '../../security/secure-keys.js';
 import { deleteCredentialMetadata, getCredentialMetadata,upsertCredentialMetadata } from '../../tools/credentials/metadata-store.js';
 import type { TelegramConfigRequest, TelegramConfigResponse } from '../ipc-protocol.js';
@@ -161,6 +162,17 @@ export async function setTelegramConfig(botToken?: string): Promise<TelegramConf
     hasWebhookSecret,
   };
 
+  // When containerized with a platform, register the Telegram callback
+  // route so the platform knows how to forward Telegram webhooks.
+  // This must happen independently of effectiveUrl — in containerized
+  // deployments without ingress.publicBaseUrl, platform callbacks are the
+  // only way to receive Telegram webhooks.
+  if (shouldUsePlatformCallbacks()) {
+    registerCallbackRoute('webhooks/telegram', 'telegram').catch((err) => {
+      log.warn({ err }, 'Failed to register Telegram platform callback route');
+    });
+  }
+
   // Trigger gateway reconcile so the webhook registration updates immediately
   const effectiveUrl = getIngressPublicBaseUrl();
   if (effectiveUrl) {

package/src/daemon/handlers/config.ts

@@ -11,13 +11,12 @@
  *   config-platform.ts    — Platform base URL configuration
  *   config-integrations.ts — Vercel API & Twitter integration
  *   config-telegram.ts    — Telegram bot configuration
- *   config-twilio.ts      — Twilio SMS/voice configuration
- *   config-channels.ts    — Channel guardian & readiness
+ *   config-channels.ts    — Channel guardian verification
  *   config-tools.ts       — Env vars, tool permission simulation, tool names
  */
 
 // Re-export individual handlers for direct import by tests and other modules
-export { getReadinessService,handleChannelReadiness, handleGuardianVerification } from './config-channels.js';
+export { getReadinessService, handleGuardianVerification } from './config-channels.js';
 export { handleHeartbeatChecklistRead, handleHeartbeatChecklistWrite,handleHeartbeatConfig, handleHeartbeatRunNow, handleHeartbeatRunsList } from './config-heartbeat.js';
 export { computeGatewayTarget, handleIngressConfig, syncTwilioWebhooks,triggerGatewayReconcile } from './config-ingress.js';
 export { handleTwitterIntegrationConfig,handleVercelApiConfig } from './config-integrations.js';
@@ -28,7 +27,6 @@ export { handleShareToSlack, handleSlackWebhookConfig } from './config-slack.js'
 export { handleTelegramConfig, summarizeTelegramError } from './config-telegram.js';
 export { handleEnvVarsRequest, handleToolNamesList,handleToolPermissionSimulate } from './config-tools.js';
 export { handleAcceptStarterBundle,handleAddTrustRule, handleRemoveTrustRule, handleTrustRulesList, handleUpdateTrustRule } from './config-trust.js';
-export { handleTwilioConfig } from './config-twilio.js';
 export { broadcastClientSettingsUpdate, handleVoiceConfigUpdate, normalizeActivationKey } from './config-voice.js';
 
 // Assemble the combined dispatch map from domain-specific handler groups
@@ -43,7 +41,6 @@ import { slackHandlers } from './config-slack.js';
 import { telegramHandlers } from './config-telegram.js';
 import { toolHandlers } from './config-tools.js';
 import { trustHandlers } from './config-trust.js';
-import { twilioHandlers } from './config-twilio.js';
 import { voiceHandlers } from './config-voice.js';
 
 export const configHandlers = {
@@ -55,7 +52,6 @@ export const configHandlers = {
   ...platformHandlers,
   ...integrationHandlers,
   ...telegramHandlers,
-  ...twilioHandlers,
   ...channelHandlers,
   ...toolHandlers,
   ...heartbeatHandlers,

package/src/daemon/handlers/pairing.ts

@@ -1,5 +1,6 @@
 import * as net from 'node:net';
 
+import { cleanupPairingState } from '../../runtime/routes/pairing-routes.js';
 import {
   approveDevice,
   clearAllDevices,
@@ -46,6 +47,7 @@ function handlePairingApprovalResponse(
 
   if (msg.decision === 'deny') {
     pairingStoreRef.deny(msg.pairingRequestId);
+    cleanupPairingState(msg.pairingRequestId);
     log.info({ pairingRequestId: msg.pairingRequestId }, 'Pairing request denied');
     return;
   }

package/src/daemon/handlers/sessions.ts

@@ -19,6 +19,7 @@ import { GENERATING_TITLE, queueGenerateConversationTitle, UNTITLED_FALLBACK } f
 import * as externalConversationStore from '../../memory/external-conversation-store.js';
 import { DAEMON_INTERNAL_ASSISTANT_ID } from '../../runtime/assistant-scope.js';
 import { routeGuardianReply } from '../../runtime/guardian-reply-router.js';
+import { resolveLocalIpcGuardianContext } from '../../runtime/local-actor-identity.js';
 import * as pendingInteractions from '../../runtime/pending-interactions.js';
 import { checkIngressForSecrets } from '../../security/secret-ingress.js';
 import { compileCustomPatterns, redactSecrets } from '../../security/secret-scanner.js';
@@ -176,6 +177,10 @@ export async function handleUserMessage(
       conversationId: msg.sessionId,
       sourceChannel: ipcChannel,
     });
+    // Route prompter-originated events (confirmation_request/secret_request)
+    // through the IPC wrapper so pending-interactions + canonical tracking
+    // are updated before the message is sent to the client.
+    session.updateClient(sendEvent, false);
     const ipcInterface = parseInterfaceId(msg.interface);
     if (!ipcInterface) {
       ctx.send(socket, {
@@ -264,6 +269,7 @@ export async function handleUserMessage(
       }
 
       rlog.info({ source }, 'Processing user message');
+      session.emitActivityState('thinking', 'message_dequeued', 'assistant_turn', dispatchRequestId);
       session.setTurnChannelContext({
         userMessageChannel: ipcChannel,
         assistantMessageChannel: ipcChannel,
@@ -273,9 +279,11 @@ export async function handleUserMessage(
         assistantMessageInterface: ipcInterface,
       });
       session.setAssistantId(DAEMON_INTERNAL_ASSISTANT_ID);
-      // IPC/desktop user IS the guardian — default to guardian trust so
-      // messages are not tagged as unknown provenance.
-      session.setGuardianContext({ trustClass: 'guardian', sourceChannel: ipcChannel });
+      // Resolve local IPC actor identity through the same trust pipeline
+      // used by HTTP channel ingress. The vellum guardian binding provides
+      // the guardianPrincipalId, and resolveGuardianContext classifies the
+      // local user as 'guardian' via binding match.
+      session.setGuardianContext(resolveLocalIpcGuardianContext(ipcChannel));
       session.setCommandIntent(null);
       // Fire-and-forget: don't block the IPC handler so the connection can
       // continue receiving messages (e.g. cancel, confirmations, or
@@ -600,9 +608,29 @@ export async function handleUserMessage(
             conversationId: msg.sessionId,
             pendingRequestIds: pendingRequestIdsForConversation,
             approvalConversationGenerator: desktopApprovalConversationGenerator,
+            emissionContext: {
+              source: 'inline_nl',
+              causedByRequestId: requestId,
+              decisionText: messageText.trim(),
+            },
           });
 
           if (routerResult.consumed && routerResult.type !== 'nl_keep_pending') {
+            // Success-path emissions (approved/denied) are handled centrally
+            // by handleConfirmationResponse (called via the resolver chain).
+            // However, stale/failed paths never reach handleConfirmationResponse,
+            // so we emit resolved_stale here for those cases.
+            if (routerResult.requestId && !routerResult.decisionApplied) {
+              session.emitConfirmationStateChanged({
+                sessionId: msg.sessionId,
+                requestId: routerResult.requestId,
+                state: 'resolved_stale',
+                source: 'inline_nl',
+                causedByRequestId: requestId,
+                decisionText: messageText.trim(),
+              });
+            }
+
             const consumedChannelMeta = {
               userMessageChannel: ipcChannel,
               assistantMessageChannel: ipcChannel,
@@ -686,6 +714,19 @@ export async function handleUserMessage(
     // will see the denial and can re-request the tool if still needed.
     if (session.hasAnyPendingConfirmation()) {
       rlog.info('Auto-denying pending confirmation(s) due to new user message');
+      // Emit authoritative confirmation state for each auto-denied request
+      // before the prompter clears them.
+      for (const interaction of pendingInteractions.getByConversation(msg.sessionId)) {
+        if (interaction.session === session && interaction.kind === 'confirmation') {
+          session.emitConfirmationStateChanged({
+            sessionId: msg.sessionId,
+            requestId: interaction.requestId,
+            state: 'denied',
+            source: 'auto_deny',
+            causedByRequestId: requestId,
+          });
+        }
+      }
       session.denyAllPendingConfirmations();
       // Keep the pending-interaction tracker aligned with the prompter so
       // stale request IDs are not reused as routing candidates.
@@ -731,6 +772,8 @@ export function handleConfirmationResponse(
         msg.decision,
         msg.selectedPattern,
         msg.selectedScope,
+        undefined,
+        { source: 'button' },
       );
       syncCanonicalStatusFromIpcConfirmationDecision(msg.requestId, msg.decision);
       pendingInteractions.resolve(msg.requestId);
@@ -910,6 +953,7 @@ export async function handleSessionCreate(
       conversationId: conversation.id,
       sourceChannel: transportChannel,
     });
+    session.updateClient(sendEvent, false);
     session.setTurnChannelContext({
       userMessageChannel: transportChannel,
       assistantMessageChannel: transportChannel,
@@ -1260,6 +1304,7 @@ export async function handleRegenerate(
     conversationId: msg.sessionId,
     sourceChannel: regenerateChannel,
   });
+  session.updateClient(sendEvent, false);
   const requestId = uuid();
   session.traceEmitter.emit('request_received', 'Regenerate requested', {
     requestId,

package/src/daemon/handlers/shared.ts

@@ -338,9 +338,24 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
   let currentSegmentParts: string[] = [];
   let hasOpenSegment = false;
 
+  function joinWithSpacing(parts: string[]): string {
+    let result = parts[0] ?? '';
+    for (let i = 1; i < parts.length; i++) {
+      const prev = result[result.length - 1];
+      const next = parts[i][0];
+      // Only insert a space when neither side already has whitespace
+      if (prev && next && prev !== ' ' && prev !== '\n' && prev !== '\t' &&
+          next !== ' ' && next !== '\n' && next !== '\t') {
+        result += ' ';
+      }
+      result += parts[i];
+    }
+    return result;
+  }
+
   function finalizeSegment(): void {
     if (hasOpenSegment) {
-      textSegments[textSegments.length - 1] = currentSegmentParts.join('');
+      textSegments[textSegments.length - 1] = joinWithSpacing(currentSegmentParts);
       currentSegmentParts = [];
       hasOpenSegment = false;
     }
@@ -445,7 +460,7 @@ export function renderHistoryContent(content: unknown): RenderedHistoryContent {
 
   finalizeSegment();
 
-  const text = textParts.join('');
+  const text = joinWithSpacing(textParts);
   let rendered: string;
   if (attachmentParts.length === 0) {
     rendered = text;