@vellumai/assistant 0.4.54 → 0.4.56

package/src/runtime/auth/__tests__/middleware.test.ts

@@ -213,8 +213,8 @@ describe("authenticateRequest", () => {
   });
 
   test("rejects token with wrong audience", () => {
-    // Mint a token with audience vellum-gateway instead of vellum-daemon
-    const token = mintValidToken({ aud: "vellum-gateway" });
+    // Mint a token with an unrecognized audience (neither vellum-daemon nor vellum-gateway)
+    const token = mintValidToken({ aud: "vellum-other" as TokenAudience });
 
     const req = new Request("http://localhost/v1/messages", {
       method: "POST",

package/src/runtime/auth/__tests__/subject.test.ts

@@ -14,7 +14,7 @@ describe("parseSub", () => {
       expect(result.principalType).toBe("actor");
       expect(result.assistantId).toBe("self");
       expect(result.actorPrincipalId).toBe("principal-abc");
-      expect(result.sessionId).toBeUndefined();
+      expect(result.conversationId).toBeUndefined();
     }
   });
 
@@ -39,7 +39,7 @@ describe("parseSub", () => {
       expect(result.principalType).toBe("svc_gateway");
       expect(result.assistantId).toBe("self");
       expect(result.actorPrincipalId).toBeUndefined();
-      expect(result.sessionId).toBeUndefined();
+      expect(result.conversationId).toBeUndefined();
     }
   });
 
@@ -54,7 +54,7 @@ describe("parseSub", () => {
       expect(result.principalType).toBe("svc_daemon");
       expect(result.assistantId).toBe("self");
       expect(result.actorPrincipalId).toBeUndefined();
-      expect(result.sessionId).toBeUndefined();
+      expect(result.conversationId).toBeUndefined();
     }
   });
 
@@ -79,13 +79,13 @@ describe("parseSub", () => {
   // local pattern
   // -------------------------------------------------------------------------
 
-  test("parses local:<assistantId>:<sessionId>", () => {
+  test("parses local:<assistantId>:<conversationId>", () => {
     const result = parseSub("local:self:session-xyz");
     expect(result.ok).toBe(true);
     if (result.ok) {
       expect(result.principalType).toBe("local");
       expect(result.assistantId).toBe("self");
-      expect(result.sessionId).toBe("session-xyz");
+      expect(result.conversationId).toBe("session-xyz");
       expect(result.actorPrincipalId).toBeUndefined();
     }
   });
@@ -158,7 +158,7 @@ describe("parseSub", () => {
     }
   });
 
-  test("fails on local with empty sessionId", () => {
+  test("fails on local with empty conversationId", () => {
     const result = parseSub("local:self:");
     expect(result.ok).toBe(false);
     if (!result.ok) {

package/src/runtime/auth/context.ts

@@ -53,7 +53,7 @@ export function buildAuthContext(claims: TokenClaims): BuildAuthContextResult {
     principalType: subResult.principalType,
     assistantId,
     actorPrincipalId: subResult.actorPrincipalId,
-    sessionId: subResult.sessionId,
+    conversationId: subResult.conversationId,
     scopeProfile: claims.scope_profile,
     scopes,
     policyEpoch: claims.policy_epoch,

package/src/runtime/auth/credential-service.ts

@@ -107,7 +107,7 @@ function mintAccessToken(guardianPrincipalId: string): {
   expiresAt: number;
   issuedAt: number;
 } {
-  const externalAssistantId = getExternalAssistantId();
+  const externalAssistantId = getExternalAssistantId() ?? "self";
   const sub = `actor:${externalAssistantId}:${guardianPrincipalId}`;
 
   const token = mintToken({

package/src/runtime/auth/external-assistant-id.ts

@@ -1,35 +1,42 @@
 /**
  * External assistant ID resolver.
  *
- * Reads the external assistant ID from the lockfile for use in
- * edge-facing JWT tokens (aud=vellum-gateway). The external ID is
- * needed because the gateway must identify which assistant the token
- * belongs to, while the daemon internally uses 'self'.
+ * Resolves the external assistant ID for use in edge-facing JWT tokens
+ * (aud=vellum-gateway). The external ID is needed because the gateway
+ * must identify which assistant the token belongs to, while the daemon
+ * internally uses 'self'.
+ *
+ * Resolution order:
+ *   1. Cached in-memory value (populated on first call)
+ *   2. Most recently hatched entry in lockfile assistants array
+ *      (sorted by `hatchedAt` descending) → assistantId
+ *   3. BASE_DATA_DIR path matching `/assistants/<name>` or `/instances/<name>` suffix
+ *   4. `undefined` — callers must handle the missing value
  *
  * The value is cached in memory after the first successful read.
- * Falls back to 'self' if the lockfile is unreadable or has no
- * assistant entries.
  */
 
+import { getBaseDataDir } from "../../config/env-registry.js";
 import { getLogger } from "../../util/logger.js";
 import { readLockfile } from "../../util/platform.js";
 
 const log = getLogger("external-assistant-id");
 
-let cached: string | undefined;
+let cached: string | null | undefined;
 
 /**
- * Get the external assistant ID from the lockfile.
+ * Get the external assistant ID.
  *
  * Resolution order:
  *   1. Cached in-memory value (populated on first call)
  *   2. Most recently hatched entry in lockfile assistants array
  *      (sorted by `hatchedAt` descending) → assistantId
- *   3. Fallback: 'self'
+ *   3. BASE_DATA_DIR path matching `/assistants/<name>` or `/instances/<name>` suffix
+ *   4. `undefined` when resolution fails entirely
  */
-export function getExternalAssistantId(): string {
+export function getExternalAssistantId(): string | undefined {
   if (cached !== undefined) {
-    return cached;
+    return cached ?? undefined;
   }
 
   try {
@@ -58,14 +65,26 @@ export function getExternalAssistantId(): string {
       }
     }
   } catch (err) {
-    log.warn(
-      { err },
-      "Failed to read lockfile for external assistant ID — falling back to self",
-    );
+    log.warn({ err }, "Failed to read lockfile for external assistant ID");
+  }
+
+  // Fallback: derive from BASE_DATA_DIR path
+  const base = getBaseDataDir();
+  if (base && typeof base === "string") {
+    const normalized = base.replace(/\\/g, "/").replace(/\/+$/, "");
+    const match = normalized.match(/\/(?:assistants|instances)\/([^/]+)$/);
+    if (match) {
+      cached = match[1];
+      log.info(
+        { externalAssistantId: cached },
+        "Resolved external assistant ID from BASE_DATA_DIR",
+      );
+      return cached;
+    }
   }
 
-  cached = "self";
-  return cached;
+  cached = null;
+  return undefined;
 }
 
 /**

package/src/runtime/auth/route-policy.ts

@@ -146,6 +146,8 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "secret", scopes: ["approval.write"] },
   { endpoint: "trust-rules", scopes: ["approval.write"] },
   { endpoint: "host-bash-result", scopes: ["approval.write"] },
+  { endpoint: "host-cu-result", scopes: ["approval.write"] },
+  { endpoint: "host-file-result", scopes: ["approval.write"] },
   { endpoint: "pending-interactions", scopes: ["approval.read"] },
 
   // Guardian actions
@@ -282,6 +284,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "apps/gallery/install", scopes: ["settings.write"] },
   { endpoint: "apps/sign-bundle", scopes: ["settings.write"] },
   { endpoint: "apps/signing-identity", scopes: ["settings.read"] },
+  { endpoint: "apps/dist", scopes: ["settings.read"] },
 
   // Usage / cost telemetry
   { endpoint: "usage/totals", scopes: ["settings.read"] },
@@ -320,11 +323,22 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "subagents/abort", scopes: ["chat.write"] },
   { endpoint: "subagents/message", scopes: ["chat.write"] },
 
+  // ACP (Agent Communication Protocol)
+  { endpoint: "acp/spawn", scopes: ["chat.write"] },
+  { endpoint: "acp/steer", scopes: ["chat.write"] },
+  { endpoint: "acp/cancel", scopes: ["chat.write"] },
+  { endpoint: "acp/close", scopes: ["chat.write"] },
+  { endpoint: "acp", scopes: ["chat.read"] },
+  { endpoint: "acp/permission", scopes: ["approval.write"] },
+
   // Model config
   { endpoint: "model:GET", scopes: ["settings.read"] },
   { endpoint: "model:PUT", scopes: ["settings.write"] },
   { endpoint: "model/image-gen", scopes: ["settings.write"] },
 
+  // Conversation management
+  { endpoint: "conversations/reorder", scopes: ["chat.write"] },
+
   // Conversation search
   { endpoint: "conversations/search", scopes: ["chat.read"] },
 
@@ -377,6 +391,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Surface actions
   { endpoint: "surface-actions", scopes: ["chat.write"] },
   { endpoint: "surfaces/undo", scopes: ["chat.write"] },
+  { endpoint: "surfaces", scopes: ["chat.read"] },
 
   // Conversation deletion (channel-facing)
   { endpoint: "channels/conversation:DELETE", scopes: ["chat.write"] },
@@ -393,6 +408,8 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Settings (voice, avatar, client settings)
   { endpoint: "settings/voice", scopes: ["settings.write"] },
   { endpoint: "settings/avatar/generate", scopes: ["settings.write"] },
+  { endpoint: "avatar/character-components", scopes: ["settings.read"] },
+  { endpoint: "avatar/render-from-traits", scopes: ["settings.write"] },
   { endpoint: "settings/client", scopes: ["settings.write"] },
 
   // Schedules

package/src/runtime/auth/subject.ts

@@ -2,7 +2,7 @@
  * Sub (subject) pattern parser for JWT tokens.
  *
  * The sub claim encodes principal type, assistant scope, and optional
- * actor/session identifiers in a colon-delimited string.
+ * actor/conversation identifiers in a colon-delimited string.
  */
 
 import type { PrincipalType } from "./types.js";
@@ -17,7 +17,7 @@ export type ParseSubResult =
       principalType: PrincipalType;
       assistantId: string;
       actorPrincipalId?: string;
-      sessionId?: string;
+      conversationId?: string;
     }
   | { ok: false; reason: string };
 
@@ -32,7 +32,7 @@ export type ParseSubResult =
  *   actor:<assistantId>:<actorPrincipalId>
  *   svc:gateway:<assistantId>
  *   svc:daemon:<identifier>
- *   local:<assistantId>:<sessionId>
+ *   local:<assistantId>:<conversationId>
  */
 export function parseSub(sub: string): ParseSubResult {
   if (!sub || typeof sub !== "string") {
@@ -69,14 +69,14 @@ export function parseSub(sub: string): ParseSubResult {
   }
 
   if (parts[0] === "local" && parts.length === 3) {
-    const [, assistantId, sessionId] = parts;
-    if (!assistantId || !sessionId) {
+    const [, assistantId, conversationId] = parts;
+    if (!assistantId || !conversationId) {
       return {
         ok: false,
-        reason: "local sub has empty assistantId or sessionId",
+        reason: "local sub has empty assistantId or conversationId",
       };
     }
-    return { ok: true, principalType: "local", assistantId, sessionId };
+    return { ok: true, principalType: "local", assistantId, conversationId };
   }
 
   return { ok: false, reason: `unrecognized sub pattern: ${sub}` };

package/src/runtime/auth/types.ts

@@ -73,7 +73,7 @@ export interface AuthContext {
   principalType: PrincipalType;
   assistantId: string;
   actorPrincipalId?: string;
-  sessionId?: string;
+  conversationId?: string;
   scopeProfile: ScopeProfile;
   scopes: ReadonlySet<Scope>;
   policyEpoch: number;

package/src/runtime/channel-approval-types.ts

@@ -17,7 +17,7 @@ import type { GuardianDecisionAction } from "./guardian-decision-types.js";
 export type ApprovalAction =
   | "approve_once"
   | "approve_10m"
-  | "approve_thread"
+  | "approve_conversation"
   | "approve_always"
   | "reject";
 

package/src/runtime/channel-approvals.ts

@@ -134,7 +134,7 @@ export function buildApprovalUIMetadata(
 /**
  * Map a channel-level `ApprovalAction` to the permission system's
  * `UserDecision` type. Temporary approval modes (`approve_10m`,
- * `approve_thread`) map directly to their `allow_*` counterparts so
+ * `approve_conversation`) map directly to their `allow_*` counterparts so
  * the permission pipeline can activate the appropriate override.
  */
 function mapApprovalActionToUserDecision(action: ApprovalAction): UserDecision {
@@ -143,8 +143,8 @@ function mapApprovalActionToUserDecision(action: ApprovalAction): UserDecision {
       return "deny";
     case "approve_10m":
       return "allow_10m";
-    case "approve_thread":
-      return "allow_thread";
+    case "approve_conversation":
+      return "allow_conversation";
     default:
       return "allow";
   }
@@ -214,16 +214,19 @@ export function handleChannelDecision(
     // still proceeds as a one-time approval (falls through to session call).
   }
 
-  // Resolve the interaction to get the session and remove from tracker
+  // Resolve the interaction to get the conversation and remove from tracker
   const resolved = pendingInteractions.resolve(info.requestId);
   if (!resolved) return { applied: false };
 
   // Map channel-level action to the permission system's UserDecision type.
   const userDecision = mapApprovalActionToUserDecision(decision.action);
   if (decisionContext === undefined) {
-    resolved.session.handleConfirmationResponse(info.requestId, userDecision);
+    resolved.conversation.handleConfirmationResponse(
+      info.requestId,
+      userDecision,
+    );
   } else {
-    resolved.session.handleConfirmationResponse(
+    resolved.conversation.handleConfirmationResponse(
       info.requestId,
       userDecision,
       undefined,

package/src/runtime/channel-invite-transport.ts

@@ -13,6 +13,13 @@
  */
 
 import type { ChannelId } from "../channels/types.js";
+import { getConfig } from "../config/loader.js";
+import { isEmailEnabled } from "../email/feature-gate.js";
+import { emailInviteAdapter } from "./channel-invite-transports/email.js";
+import { slackInviteAdapter } from "./channel-invite-transports/slack.js";
+import { telegramInviteAdapter } from "./channel-invite-transports/telegram.js";
+import { voiceInviteAdapter } from "./channel-invite-transports/voice.js";
+import { whatsappInviteAdapter } from "./channel-invite-transports/whatsapp.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -131,16 +138,12 @@ export async function resolveAdapterHandle(
 // Singleton registry
 // ---------------------------------------------------------------------------
 
-import { emailInviteAdapter } from "./channel-invite-transports/email.js";
-import { slackInviteAdapter } from "./channel-invite-transports/slack.js";
-import { telegramInviteAdapter } from "./channel-invite-transports/telegram.js";
-import { voiceInviteAdapter } from "./channel-invite-transports/voice.js";
-import { whatsappInviteAdapter } from "./channel-invite-transports/whatsapp.js";
-
 /** Create a registry instance with built-in adapters registered. */
 export function createInviteAdapterRegistry(): InviteAdapterRegistry {
   const registry = new InviteAdapterRegistry();
-  registry.register(emailInviteAdapter);
+  if (isEmailEnabled(getConfig())) {
+    registry.register(emailInviteAdapter);
+  }
   registry.register(slackInviteAdapter);
   registry.register(telegramInviteAdapter);
   registry.register(voiceInviteAdapter);

package/src/runtime/channel-readiness-service.ts

@@ -1,7 +1,8 @@
 import { resolveTwilioPhoneNumber } from "../calls/twilio-config.js";
 import { hasTwilioCredentials } from "../calls/twilio-rest.js";
 import { getChannelInvitePolicy } from "../channels/config.js";
-import { loadRawConfig } from "../config/loader.js";
+import { getConfig, loadRawConfig } from "../config/loader.js";
+import { isEmailEnabled } from "../email/feature-gate.js";
 import { getEmailService } from "../email/service.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -427,7 +428,9 @@ export function createReadinessService(): ChannelReadinessService {
   const service = new ChannelReadinessService();
   service.registerProbe(voiceProbe);
   service.registerProbe(telegramProbe);
-  service.registerProbe(emailProbe);
+  if (isEmailEnabled(getConfig())) {
+    service.registerProbe(emailProbe);
+  }
   service.registerProbe(whatsappProbe);
   service.registerProbe(slackProbe);
   return service;

package/src/runtime/channel-retry-sweep.ts

@@ -7,7 +7,7 @@ import {
   parseChannelId,
   parseInterfaceId,
 } from "../channels/types.js";
-import type { TrustContext } from "../daemon/session-runtime-assembly.js";
+import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 import * as deliveryChannels from "../memory/delivery-channels.js";
 import * as deliveryCrud from "../memory/delivery-crud.js";
 import * as deliveryStatus from "../memory/delivery-status.js";

package/src/runtime/channel-verification-service.ts

@@ -114,7 +114,7 @@ function generateNumericSecret(digits: number = 6): string {
  */
 export function createInboundVerificationSession(
   channel: string,
-  sessionId?: string,
+  conversationId?: string,
 ): CreateVerificationSessionResult {
   // High-entropy hex for unbound inbound challenges — 6-digit numeric
   // codes are only safe when identity binding provides a second factor.
@@ -128,7 +128,7 @@ export function createInboundVerificationSession(
     channel,
     challengeHash,
     expiresAt,
-    createdBySessionId: sessionId,
+    createdByConversationId: conversationId,
   });
 
   const ttlSeconds = CHALLENGE_TTL_MS / 1000;

package/src/runtime/confirmation-request-guardian-bridge.ts

@@ -12,7 +12,7 @@
  * canonical records.
  */
 
-import type { TrustContext } from "../daemon/session-runtime-assembly.js";
+import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
 import {
   type CanonicalGuardianRequest,
   createCanonicalGuardianDelivery,
@@ -167,7 +167,7 @@ export function bridgeConfirmationRequestToGuardian(
       questionText,
     },
     dedupeKey: `tc-confirmation-request:${canonicalRequest.id}`,
-    onThreadCreated: (info) => {
+    onConversationCreated: (info) => {
       createCanonicalGuardianDelivery({
         requestId: canonicalRequest.id,
         destinationChannel: "vellum",
@@ -180,7 +180,7 @@ export function bridgeConfirmationRequestToGuardian(
   void signalPromise
     .then((signalResult) => {
       for (const result of signalResult.deliveryResults) {
-        if (result.channel === "vellum") continue; // handled in onThreadCreated
+        if (result.channel === "vellum") continue; // handled in onConversationCreated
         createCanonicalGuardianDelivery({
           requestId: canonicalRequest.id,
           destinationChannel: result.channel,

package/src/runtime/{session-approval-overrides.ts → conversation-approval-overrides.ts}

@@ -1,19 +1,19 @@
 /**
  * Per-conversation temporary approval overrides.
  *
- * When a user chooses `allow_thread` or `allow_10m`, the session records a
+ * When a user chooses `allow_conversation` or `allow_10m`, the conversation records a
  * temporary approval mode scoped to the conversation. Subsequent tool-use
  * confirmations within the same conversation can check this state to
  * auto-approve without prompting.
  *
  * State is in-memory only -- it does not survive daemon restarts, which is
- * the desired behavior for temporary approvals. Thread-scoped overrides
+ * the desired behavior for temporary approvals. Conversation-scoped overrides
  * persist until the session ends or the mode is explicitly cleared. Timed
  * overrides expire after their TTL (checked at read time, no background sweep).
  */
 
 export type TemporaryApprovalMode =
-  | { kind: "thread" }
+  | { kind: "conversation" }
   | { kind: "timed"; expiresAt: number };
 
 const DEFAULT_TIMED_DURATION_MS = 10 * 60 * 1000; // 10 minutes
@@ -21,12 +21,12 @@ const DEFAULT_TIMED_DURATION_MS = 10 * 60 * 1000; // 10 minutes
 const store = new Map<string, TemporaryApprovalMode>();
 
 /**
- * Set thread-scoped temporary approval for a conversation.
+ * Set conversation-scoped temporary approval for a conversation.
  * Remains active until explicitly cleared or session ends.
  * Replaces any existing mode for the conversation.
  */
-export function setThreadMode(conversationId: string): void {
-  store.set(conversationId, { kind: "thread" });
+export function setConversationMode(conversationId: string): void {
+  store.set(conversationId, { kind: "conversation" });
 }
 
 /**

package/src/runtime/guardian-action-grant-minter.ts

@@ -3,7 +3,7 @@
  * request is resolved with tool metadata.
  *
  * Used by both the channel inbound path (inbound-message-handler.ts) and
- * the desktop path (session-process.ts) to ensure grants are minted
+ * the desktop path (conversation-process.ts) to ensure grants are minted
  * consistently regardless of which channel the guardian answers on.
  */
 
@@ -124,9 +124,7 @@ export async function tryMintGuardianActionGrant(params: {
     conversationId: request.sourceConversationId,
     callSessionId: request.callSessionId,
     guardianExternalUserId: guardianExternalUserId ?? null,
-    expiresAt: new Date(
-      Date.now() + GUARDIAN_ACTION_GRANT_TTL_MS,
-    ).toISOString(),
+    expiresAt: Date.now() + GUARDIAN_ACTION_GRANT_TTL_MS,
   });
 
   if (result.ok) {

package/src/runtime/guardian-action-service.ts

@@ -21,7 +21,7 @@ import type { ApprovalAction } from "./channel-approval-types.js";
 export const VALID_GUARDIAN_ACTIONS: ReadonlySet<string> = new Set<string>([
   "approve_once",
   "approve_10m",
-  "approve_thread",
+  "approve_conversation",
   "approve_always",
   "reject",
 ]);
@@ -73,7 +73,7 @@ export async function processGuardianDecision(
     return {
       ok: false,
       error: "invalid_action",
-      message: `Invalid action: ${action}. Must be one of: approve_once, approve_10m, approve_thread, approve_always, reject`,
+      message: `Invalid action: ${action}. Must be one of: approve_once, approve_10m, approve_conversation, approve_always, reject`,
     };
   }
 

package/src/runtime/guardian-decision-types.ts

@@ -48,7 +48,10 @@ export interface GuardianDecisionAction {
 export const GUARDIAN_DECISION_ACTIONS = {
   approve_once: { action: "approve_once", label: "Approve once" },
   approve_10m: { action: "approve_10m", label: "Allow 10 min" },
-  approve_thread: { action: "approve_thread", label: "Allow thread" },
+  approve_conversation: {
+    action: "approve_conversation",
+    label: "Allow conversation",
+  },
   approve_always: { action: "approve_always", label: "Approve always" },
   reject: { action: "reject", label: "Reject" },
 } as const satisfies Record<string, GuardianDecisionAction>;
@@ -62,7 +65,7 @@ export const GUARDIAN_DECISION_ACTIONS = {
  * of a requester), both `approve_always` and the temporary modes are excluded
  * since guardians cannot grant broad delegated allow modes on behalf of others.
  *
- * Temporary modes (`approve_10m`, `approve_thread`) are included for
+ * Temporary modes (`approve_10m`, `approve_conversation`) are included for
  * requester-side standard approval flows when persistent decisions are allowed.
  */
 export function buildDecisionActions(opts?: {
@@ -78,7 +81,7 @@ export function buildDecisionActions(opts?: {
     ...(showTemporary
       ? [
           GUARDIAN_DECISION_ACTIONS.approve_10m,
-          GUARDIAN_DECISION_ACTIONS.approve_thread,
+          GUARDIAN_DECISION_ACTIONS.approve_conversation,
         ]
       : []),
     ...(showAlways ? [GUARDIAN_DECISION_ACTIONS.approve_always] : []),
@@ -97,16 +100,18 @@ export function buildPlainTextFallback(
 ): string {
   const hasAlways = actions.some((a) => a.action === "approve_always");
   const has10m = actions.some((a) => a.action === "approve_10m");
-  const hasThread = actions.some((a) => a.action === "approve_thread");
+  const hasConversation = actions.some(
+    (a) => a.action === "approve_conversation",
+  );
 
-  if (hasAlways && has10m && hasThread) {
-    return `${promptText}\n\nReply "yes" to approve once, "approve for 10 minutes", "approve for thread", "always" to approve always, or "no" to reject.`;
+  if (hasAlways && has10m && hasConversation) {
+    return `${promptText}\n\nReply "yes" to approve once, "approve for 10 minutes", "approve for conversation", "always" to approve always, or "no" to reject.`;
   }
   if (hasAlways) {
     return `${promptText}\n\nReply "yes" to approve once, "always" to approve always, or "no" to reject.`;
   }
-  if (has10m && hasThread) {
-    return `${promptText}\n\nReply "yes" to approve once, "approve for 10 minutes", "approve for thread", or "no" to reject.`;
+  if (has10m && hasConversation) {
+    return `${promptText}\n\nReply "yes" to approve once, "approve for 10 minutes", "approve for conversation", or "no" to reject.`;
   }
   return `${promptText}\n\nReply "yes" to approve or "no" to reject.`;
 }

package/src/runtime/guardian-reply-router.ts

@@ -114,7 +114,7 @@ export interface GuardianReplyResult {
 const VALID_ACTIONS: ReadonlySet<string> = new Set([
   "approve_once",
   "approve_10m",
-  "approve_thread",
+  "approve_conversation",
   "approve_always",
   "reject",
 ]);
@@ -165,7 +165,7 @@ function parseRequestCode(
   if (!request) return null;
 
   // Scope to the current conversation when requested, so a code belonging
-  // to a different session/conversation is not consumed here. Requests with
+  // to a different conversation is not consumed here. Requests with
   // null conversationId are global/unscoped and match any conversation.
   if (
     scopeConversationId &&
@@ -496,7 +496,7 @@ export async function routeGuardianReply(
 
     // Use all pending requests for the guardian without conversation scoping.
     // Guardian requests for channel/voice flows are created on the requester's
-    // conversation, not the guardian's reply thread, so filtering by
+    // conversation, not the guardian's reply conversation, so filtering by
     // conversationId would incorrectly drop valid pending requests. Identity-
     // based filtering in findPendingCanonicalRequests already constrains
     // results to the correct guardian.
@@ -560,7 +560,7 @@ export async function routeGuardianReply(
     if (
       decisionAction === "approve_always" ||
       decisionAction === "approve_10m" ||
-      decisionAction === "approve_thread"
+      decisionAction === "approve_conversation"
     ) {
       decisionAction = "approve_once";
     }