@vellumai/assistant 0.4.26 → 0.4.30

package/src/daemon/session-queue-manager.ts

@@ -5,11 +5,14 @@
  * agent loop is in flight.
  */
 
-import type { TurnChannelContext, TurnInterfaceContext } from '../channels/types.js';
-import { getLogger } from '../util/logger.js';
-import type { ServerMessage, UserMessageAttachment } from './ipc-protocol.js';
+import type {
+  TurnChannelContext,
+  TurnInterfaceContext,
+} from "../channels/types.js";
+import { getLogger } from "../util/logger.js";
+import type { ServerMessage, UserMessageAttachment } from "./ipc-protocol.js";
 
-const log = getLogger('session-queue');
+const log = getLogger("session-queue");
 
 export interface QueuedMessage {
   content: string;
@@ -39,7 +42,7 @@ const CAPACITY_WARNING_THRESHOLD = 0.8;
  * - `loop_complete`: the agent loop finished normally and the next message was drained.
  * - `checkpoint_handoff`: a turn-boundary checkpoint decided to yield to the queued message.
  */
-export type QueueDrainReason = 'loop_complete' | 'checkpoint_handoff';
+export type QueueDrainReason = "loop_complete" | "checkpoint_handoff";
 
 /**
  * Configuration for how/when checkpoint handoff is allowed.
@@ -92,7 +95,10 @@ export class MessageQueue {
     const ratio = this.items.length / MAX_QUEUE_DEPTH;
     if (ratio >= CAPACITY_WARNING_THRESHOLD && !this.capacityWarned) {
       this.capacityWarned = true;
-      log.warn({ depth: this.items.length, max: MAX_QUEUE_DEPTH }, 'Queue nearing capacity');
+      log.warn(
+        { depth: this.items.length, max: MAX_QUEUE_DEPTH },
+        "Queue nearing capacity",
+      );
     } else if (ratio < CAPACITY_WARNING_THRESHOLD) {
       this.capacityWarned = false;
     }
@@ -141,7 +147,8 @@ export class MessageQueue {
       currentDepth: this.items.length,
       totalDropped: this.droppedCount,
       totalExpired: this.expiredCount,
-      averageWaitMs: this.dequeuedCount > 0 ? this.totalWaitMs / this.dequeuedCount : 0,
+      averageWaitMs:
+        this.dequeuedCount > 0 ? this.totalWaitMs / this.dequeuedCount : 0,
     };
   }
 
@@ -159,18 +166,28 @@ export class MessageQueue {
       return true;
     });
     for (const item of expired) {
-      log.warn({ requestId: item.requestId, waitMs: now - item.queuedAt }, 'Expiring stale queued message');
+      log.warn(
+        { requestId: item.requestId, waitMs: now - item.queuedAt },
+        "Expiring stale queued message",
+      );
       try {
         item.onEvent({
-          type: 'error',
-          message: 'Your queued message was dropped because it waited too long in the queue.',
-          category: 'queue_expired',
+          type: "error",
+          message:
+            "Your queued message was dropped because it waited too long in the queue.",
+          category: "queue_expired",
         });
       } catch (e) {
-        log.debug({ err: e, requestId: item.requestId }, 'Failed to notify client of expired message');
+        log.debug(
+          { err: e, requestId: item.requestId },
+          "Failed to notify client of expired message",
+        );
       }
     }
-    if (expired.length > 0 && this.items.length / MAX_QUEUE_DEPTH < CAPACITY_WARNING_THRESHOLD) {
+    if (
+      expired.length > 0 &&
+      this.items.length / MAX_QUEUE_DEPTH < CAPACITY_WARNING_THRESHOLD
+    ) {
       this.capacityWarned = false;
     }
   }

package/src/daemon/session-runtime-assembly.ts

@@ -18,6 +18,7 @@ import {
 import { getAppsDir, listAppFiles } from "../memory/app-store.js";
 import type { Message } from "../providers/types.js";
 import type { ActorTrustContext } from "../runtime/actor-trust-resolver.js";
+import { channelStatusToMemberStatus } from "../runtime/routes/inbound-stages/acl-enforcement.js";
 
 /**
  * Describes the capabilities of the channel through which the user is
@@ -38,20 +39,49 @@ export interface ChannelCapabilities {
   microphonePermissionGranted?: boolean;
 }
 
-/** Guardian identity/trust context for external chat channels. */
-export interface GuardianRuntimeContext {
+/**
+ * Runtime trust context for an inbound actor session.
+ *
+ * Carries the resolved trust classification, guardian binding metadata, and
+ * requester identity for the current session. This is the canonical trust
+ * shape used by sessions, tool execution, memory gating, and channel routing.
+ *
+ * Produced by {@link resolveActorTrust} -> {@link toTrustContext}, or by
+ * the convenience wrapper {@link resolveTrustContext}.
+ *
+ * The `trustClass` field determines the actor's permission level:
+ * - `'guardian'`: full access, self-approves tool invocations
+ * - `'trusted_contact'`: can invoke tools, sensitive ops require guardian approval
+ * - `'unknown'`: fail-closed, no escalation
+ *
+ * Guardian-specific fields (`guardianChatId`, `guardianExternalUserId`,
+ * `guardianPrincipalId`) describe the guardian binding for this channel,
+ * NOT the current actor (unless the actor IS the guardian).
+ */
+export interface TrustContext {
+  /** Channel through which the inbound message arrived. */
   sourceChannel: ChannelId;
+  /** Trust classification -- see {@link TrustClass} for semantics. */
   trustClass: "guardian" | "trusted_contact" | "unknown";
+  /** Chat/conversation ID for delivering guardian notifications. */
   guardianChatId?: string;
+  /** Canonical external user ID of the guardian for this (assistant, channel) binding. */
   guardianExternalUserId?: string;
-  /** Canonical principal ID for the guardian binding. */
+  /** Internal principal ID of the guardian. */
   guardianPrincipalId?: string;
+  /** Human-readable identifier for the requester (e.g. @username or phone number). */
   requesterIdentifier?: string;
+  /** Preferred display name for the requester (member name or sender name). */
   requesterDisplayName?: string;
+  /** Raw sender display name as provided by the channel transport. */
   requesterSenderDisplayName?: string;
+  /** Guardian-managed display name from the contact record. */
   requesterMemberDisplayName?: string;
+  /** Canonical external user ID of the requester (the current actor). */
   requesterExternalUserId?: string;
+  /** Chat/conversation ID the requester is interacting through. */
   requesterChatId?: string;
+  /** Access denial reason, if applicable. See {@link DenialReason}. */
   denialReason?: "no_binding" | "no_identity";
 }
 
@@ -73,27 +103,27 @@ export interface InboundActorContext {
   actorDisplayName?: string;
   /** Raw sender display name as provided by the channel transport. */
   actorSenderDisplayName?: string;
-  /** Guardian-managed member display name from ingress membership. */
+  /** Guardian-managed display name from the contact record. */
   actorMemberDisplayName?: string;
   /** Trust classification: guardian, trusted_contact, or unknown. */
   trustClass: "guardian" | "trusted_contact" | "unknown";
   /** Guardian identity for this (assistant, channel) binding. */
   guardianIdentity?: string;
-  /** Member status when the actor has an ingress member record. */
+  /** Member status when the actor has a contact record. */
   memberStatus?: string;
-  /** Member policy when the actor has an ingress member record. */
+  /** Member policy when the actor has a contact record. */
   memberPolicy?: string;
   /** Denial reason when access is blocked. */
   denialReason?: string;
 }
 
 /**
- * Construct an InboundActorContext from a legacy GuardianRuntimeContext.
+ * Construct an InboundActorContext from a TrustContext.
  *
  * Maps the runtime trust class into the model-facing inbound actor context.
  */
-export function inboundActorContextFromGuardian(
-  ctx: GuardianRuntimeContext,
+export function inboundActorContextFromTrustContext(
+  ctx: TrustContext,
 ): InboundActorContext {
   return {
     sourceChannel: ctx.sourceChannel,
@@ -124,8 +154,10 @@ export function inboundActorContextFromTrust(
     actorMemberDisplayName: ctx.actorMetadata.memberDisplayName,
     trustClass: ctx.trustClass,
     guardianIdentity: ctx.guardianBindingMatch?.guardianExternalUserId,
-    memberStatus: ctx.memberRecord?.status ?? undefined,
-    memberPolicy: ctx.memberRecord?.policy ?? undefined,
+    memberStatus: ctx.memberRecord
+      ? channelStatusToMemberStatus(ctx.memberRecord.channel.status)
+      : undefined,
+    memberPolicy: ctx.memberRecord?.channel.policy ?? undefined,
     denialReason: ctx.denialReason,
   };
 }
@@ -1012,6 +1044,18 @@ export function stripInjectedContext(
   return stripUserTextBlocksByPrefix(afterProfile, RUNTIME_INJECTION_PREFIXES);
 }
 
+/**
+ * Controls which runtime injections are applied.
+ *
+ * - `'full'` (default): all injections are applied.
+ * - `'minimal'`: only safety-critical context is injected (channel turn,
+ *   interface turn, inbound actor, non-interactive marker, voice call
+ *   control, channel capabilities, soft conflict). High-token optional
+ *   blocks (workspace top-level, temporal, channel command, active surface)
+ *   are skipped to reduce context pressure.
+ */
+export type InjectionMode = "full" | "minimal";
+
 /**
  * Apply a chain of user-message injections to `runMessages`.
  *
@@ -1032,8 +1076,10 @@ export function applyRuntimeInjections(
     temporalContext?: string | null;
     voiceCallControlPrompt?: string | null;
     isNonInteractive?: boolean;
+    mode?: InjectionMode;
   },
 ): Message[] {
+  const mode = options.mode ?? "full";
   let result = runMessages;
 
   // For non-interactive sessions (scheduled jobs, work items), instruct the
@@ -1080,7 +1126,7 @@ export function applyRuntimeInjections(
     }
   }
 
-  if (options.activeSurface) {
+  if (mode === "full" && options.activeSurface) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
@@ -1100,7 +1146,7 @@ export function applyRuntimeInjections(
     }
   }
 
-  if (options.channelCommandContext) {
+  if (mode === "full" && options.channelCommandContext) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
@@ -1143,7 +1189,7 @@ export function applyRuntimeInjections(
   // Temporal context is injected before workspace top-level so it
   // appears after workspace context in the final message content
   // (both are prepended, so later injections appear first).
-  if (options.temporalContext) {
+  if (mode === "full" && options.temporalContext) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [
@@ -1156,7 +1202,7 @@ export function applyRuntimeInjections(
   // Workspace top-level context is injected last so it appears first
   // (prepended) in the user message content, keeping cache breakpoints
   // anchored to the trailing blocks.
-  if (options.workspaceTopLevelContext) {
+  if (mode === "full" && options.workspaceTopLevelContext) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {
       result = [

package/src/daemon/session-skill-tools.ts

@@ -8,28 +8,28 @@
  * tool definitions so the agent loop can include them in the next request.
  */
 
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { isAssistantFeatureFlagEnabled } from '../config/assistant-feature-flags.js';
-import { getConfig } from '../config/loader.js';
-import { skillFlagKey } from '../config/skill-state.js';
-import type { SkillSummary, SkillToolManifest } from '../config/skills.js';
-import { loadSkillCatalog } from '../config/skills.js';
-import type { Message, ToolDefinition } from '../providers/types.js';
-import type { ActiveSkillEntry } from '../skills/active-skill-tools.js';
-import { deriveActiveSkills } from '../skills/active-skill-tools.js';
-import { parseToolManifestFile } from '../skills/tool-manifest.js';
-import { computeSkillVersionHash } from '../skills/version-hash.js';
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { getConfig } from "../config/loader.js";
+import { skillFlagKey } from "../config/skill-state.js";
+import type { SkillSummary, SkillToolManifest } from "../config/skills.js";
+import { loadSkillCatalog } from "../config/skills.js";
+import type { Message, ToolDefinition } from "../providers/types.js";
+import type { ActiveSkillEntry } from "../skills/active-skill-tools.js";
+import { deriveActiveSkills } from "../skills/active-skill-tools.js";
+import { parseToolManifestFile } from "../skills/tool-manifest.js";
+import { computeSkillVersionHash } from "../skills/version-hash.js";
 import {
   getTool,
   registerSkillTools,
   unregisterSkillTools,
-} from '../tools/registry.js';
-import { createSkillToolsFromManifest } from '../tools/skills/skill-tool-factory.js';
-import { getLogger } from '../util/logger.js';
+} from "../tools/registry.js";
+import { createSkillToolsFromManifest } from "../tools/skills/skill-tool-factory.js";
+import { getLogger } from "../util/logger.js";
 
-const log = getLogger('session-skill-tools');
+const log = getLogger("session-skill-tools");
 
 // ---------------------------------------------------------------------------
 // Public types
@@ -95,16 +95,22 @@ export interface ProjectSkillToolsOptions {
  * Load and parse a skill's TOOLS.json manifest, returning null on any failure.
  */
 function loadManifestForSkill(skill: SkillSummary): SkillToolManifest | null {
-  const manifestPath = join(skill.directoryPath, 'TOOLS.json');
+  const manifestPath = join(skill.directoryPath, "TOOLS.json");
   if (!existsSync(manifestPath)) {
-    log.debug({ skillId: skill.id, manifestPath }, 'No TOOLS.json found for skill');
+    log.debug(
+      { skillId: skill.id, manifestPath },
+      "No TOOLS.json found for skill",
+    );
     return null;
   }
 
   try {
     return parseToolManifestFile(manifestPath);
   } catch (err) {
-    log.warn({ err, skillId: skill.id, manifestPath }, 'Failed to parse TOOLS.json for skill');
+    log.warn(
+      { err, skillId: skill.id, manifestPath },
+      "Failed to parse TOOLS.json for skill",
+    );
     return null;
   }
 }
@@ -134,12 +140,20 @@ function getCachedActiveSkills(
   // Fast path: history unchanged since last scan. Both the count and the
   // first message reference must match — compaction can rewrite history
   // without changing the total count.
-  if (cached && cached.messageCount === history.length && cached.firstMessage === history[0]) {
+  if (
+    cached &&
+    cached.messageCount === history.length &&
+    cached.firstMessage === history[0]
+  ) {
     return cached.entries;
   }
 
   // History grew (and first message is unchanged) — scan only the new messages.
-  if (cached && cached.messageCount < history.length && cached.firstMessage === history[0]) {
+  if (
+    cached &&
+    cached.messageCount < history.length &&
+    cached.firstMessage === history[0]
+  ) {
     const delta = history.slice(cached.messageCount);
     const newEntries = deriveActiveSkills(delta);
 
@@ -157,7 +171,7 @@ function getCachedActiveSkills(
     if (changed) {
       log.debug(
         { newEntries: newEntries.length, total: cached.entries.length },
-        'Incremental skill derivation found new entries',
+        "Incremental skill derivation found new entries",
       );
     }
     return cached.entries;
@@ -166,7 +180,12 @@ function getCachedActiveSkills(
   // History shrank, compaction rewrote it, or no cache yet — full rescan.
   const entries = deriveActiveSkills(history);
   const seenIds = new Set(entries.map((e) => e.id));
-  cache.derived = { messageCount: history.length, firstMessage: history[0], seenIds, entries };
+  cache.derived = {
+    messageCount: history.length,
+    firstMessage: history[0],
+    seenIds,
+    entries,
+  };
   return entries;
 }
 
@@ -204,7 +223,8 @@ export function projectSkillTools(
 ): SkillToolProjection {
   const contextEntries = getCachedActiveSkills(history, options?.cache);
   const preactivated = options?.preactivatedSkillIds ?? [];
-  const prevActive = options?.previouslyActiveSkillIds ?? new Map<string, string>();
+  const prevActive =
+    options?.previouslyActiveSkillIds ?? new Map<string, string>();
 
   // Index marker versions by skill ID so we can use them during registration.
   // When a marker carries a version, it records the hash that was active at
@@ -240,7 +260,7 @@ export function projectSkillTools(
 
   // Unregister tools for skills that are no longer active
   for (const id of removedIds) {
-    log.info({ skillId: id }, 'Unregistering tools for deactivated skill');
+    log.info({ skillId: id }, "Unregistering tools for deactivated skill");
     unregisterSkillTools(id);
   }
 
@@ -267,7 +287,7 @@ export function projectSkillTools(
   for (const skillId of activeIds) {
     const skill = catalogById.get(skillId);
     if (!skill) {
-      log.warn({ skillId }, 'Active skill ID not found in catalog');
+      log.warn({ skillId }, "Active skill ID not found in catalog");
       continue;
     }
 
@@ -281,7 +301,10 @@ export function projectSkillTools(
     try {
       currentHash = computeSkillVersionHash(skill.directoryPath);
     } catch (err) {
-      log.warn({ err, skillId }, 'Failed to compute skill version hash, treating as changed');
+      log.warn(
+        { err, skillId },
+        "Failed to compute skill version hash, treating as changed",
+      );
       currentHash = `unknown-${Date.now()}`;
     }
 
@@ -302,13 +325,19 @@ export function projectSkillTools(
         accepted = registerSkillTools(tools);
       } else if (prevHash !== currentHash) {
         // Hash changed — unregister stale tools, then re-register with new definitions
-        log.info({ skillId, prevHash, currentHash }, 'Skill version changed, re-registering tools');
+        log.info(
+          { skillId, prevHash, currentHash },
+          "Skill version changed, re-registering tools",
+        );
         unregisterSkillTools(skillId);
         alreadyUnregistered.add(skillId);
         try {
           accepted = registerSkillTools(tools);
         } catch (err) {
-          log.error({ err, skillId }, 'Failed to re-register skill tools after version change');
+          log.error(
+            { err, skillId },
+            "Failed to re-register skill tools after version change",
+          );
           // Don't add to successfulEntries — will be cleaned up as transiently-failed
           continue;
         }
@@ -317,8 +346,14 @@ export function projectSkillTools(
         // managed skill override was added/removed with identical content).
         // Re-register so the ownerSkillBundled flag stays accurate.
         const existing = getTool(tools[0].name);
-        if (existing && existing.ownerSkillBundled !== (skill.bundled ?? undefined)) {
-          log.info({ skillId, bundled: skill.bundled }, 'Skill bundled status changed, re-registering tools');
+        if (
+          existing &&
+          existing.ownerSkillBundled !== (skill.bundled ?? undefined)
+        ) {
+          log.info(
+            { skillId, bundled: skill.bundled },
+            "Skill bundled status changed, re-registering tools",
+          );
           unregisterSkillTools(skillId);
           accepted = registerSkillTools(tools);
         } else {
@@ -327,7 +362,11 @@ export function projectSkillTools(
           // to core-name collisions — don't let them leak back in.
           accepted = tools.filter((t) => {
             const reg = getTool(t.name);
-            return reg !== undefined && reg.origin === 'skill' && reg.ownerSkillId === skillId;
+            return (
+              reg !== undefined &&
+              reg.origin === "skill" &&
+              reg.ownerSkillId === skillId
+            );
           });
         }
       }
@@ -345,8 +384,15 @@ export function projectSkillTools(
   // skill would be re-registered when it recovers next turn, inflating the
   // refcount since the prior registration was never decremented.
   for (const id of prevActive.keys()) {
-    if (activeIds.has(id) && !successfulEntries.has(id) && !alreadyUnregistered.has(id)) {
-      log.info({ skillId: id }, 'Unregistering tools for transiently-failed skill');
+    if (
+      activeIds.has(id) &&
+      !successfulEntries.has(id) &&
+      !alreadyUnregistered.has(id)
+    ) {
+      log.info(
+        { skillId: id },
+        "Unregistering tools for transiently-failed skill",
+      );
       unregisterSkillTools(id);
     }
   }
@@ -368,7 +414,9 @@ export function projectSkillTools(
  * Reset the projection state and unregister all skill tools tracked in the
  * given map. Used for session teardown and tests.
  */
-export function resetSkillToolProjection(trackedIds?: Map<string, string>): void {
+export function resetSkillToolProjection(
+  trackedIds?: Map<string, string>,
+): void {
   if (trackedIds) {
     for (const id of trackedIds.keys()) {
       unregisterSkillTools(id);