@vellumai/assistant 0.12.2 → 0.12.3-staging.1

package/src/persistence/migrations/378-create-conversation-tool-surfaces.test.ts

@@ -0,0 +1,78 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateCreateConversationToolSurfaces } from "./378-create-conversation-tool-surfaces.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.run("PRAGMA foreign_keys = ON");
+  // Only the parent table the FK points at.
+  sqlite.run(/*sql*/ `CREATE TABLE conversations (id TEXT PRIMARY KEY)`);
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function tableDdl(sqlite: Database): string | undefined {
+  const row = sqlite
+    .query(
+      `SELECT sql FROM sqlite_master WHERE type='table' AND name='conversation_tool_surfaces'`,
+    )
+    .get() as { sql: string } | null;
+  return row?.sql;
+}
+
+function insertSurface(sqlite: Database, conversationId: string): void {
+  sqlite
+    .query(
+      /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
+    )
+    .run(conversationId, "[]", "hash", 1);
+}
+
+function surfaceCount(sqlite: Database): number {
+  const row = sqlite
+    .query(`SELECT COUNT(*) AS n FROM conversation_tool_surfaces`)
+    .get() as { n: number };
+  return row.n;
+}
+
+describe("migration 378: conversation_tool_surfaces", () => {
+  test("creates the table keyed by conversation with a cascading FK", () => {
+    const { sqlite, db } = createTestDb();
+    expect(tableDdl(sqlite)).toBeUndefined();
+
+    migrateCreateConversationToolSurfaces(db);
+
+    const ddl = tableDdl(sqlite);
+    expect(ddl).toContain("conversation_id TEXT PRIMARY KEY");
+    expect(ddl).toContain("REFERENCES conversations(id) ON DELETE CASCADE");
+    expect(ddl).toContain("tools_json TEXT NOT NULL");
+    expect(ddl).toContain("tools_hash TEXT NOT NULL");
+    expect(ddl).toContain("updated_at INTEGER NOT NULL");
+  });
+
+  test("deleting a conversation cascades to its surface row", () => {
+    const { sqlite, db } = createTestDb();
+    migrateCreateConversationToolSurfaces(db);
+    sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
+    insertSurface(sqlite, "conv-1");
+    expect(surfaceCount(sqlite)).toBe(1);
+
+    sqlite.query(`DELETE FROM conversations WHERE id = ?`).run("conv-1");
+
+    expect(surfaceCount(sqlite)).toBe(0);
+  });
+
+  test("is idempotent: a second run keeps the table and its rows", () => {
+    const { sqlite, db } = createTestDb();
+    migrateCreateConversationToolSurfaces(db);
+    sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
+    insertSurface(sqlite, "conv-1");
+
+    expect(() => migrateCreateConversationToolSurfaces(db)).not.toThrow();
+
+    expect(surfaceCount(sqlite)).toBe(1);
+  });
+});

package/src/persistence/migrations/378-create-conversation-tool-surfaces.ts

@@ -0,0 +1,29 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+const TABLE = "conversation_tool_surfaces";
+
+/**
+ * Create `conversation_tool_surfaces`: one row per conversation holding the
+ * tool definitions its most recent live turn sent to the provider, keyed by
+ * conversation with a content hash so an unchanged surface is never rewritten.
+ *
+ * Its own table rather than a column on `conversations` because the payload
+ * is a JSON array of every tool definition (tens of kilobytes) that only fork
+ * wakes read, while `conversations` rows are read whole on every hot path.
+ * The row cascades with its conversation, so a deleted conversation leaves
+ * no surface behind.
+ *
+ * Idempotent via IF NOT EXISTS.
+ */
+export function migrateCreateConversationToolSurfaces(
+  database: DrizzleDb,
+): void {
+  database.run(
+    `CREATE TABLE IF NOT EXISTS ${TABLE} (
+       conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
+       tools_json TEXT NOT NULL,
+       tools_hash TEXT NOT NULL,
+       updated_at INTEGER NOT NULL
+     )`,
+  );
+}

package/src/persistence/migrations/379-oauth-providers-response-ok-field.test.ts

@@ -0,0 +1,92 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateOAuthProvidersResponseOkField } from "./379-oauth-providers-response-ok-field.js";
+
+function createTestDb(options: { withTable?: boolean } = {}) {
+  const sqlite = new Database(":memory:");
+  if (options.withTable !== false) {
+    // Pre-379 shape: only the columns the migration and tests touch.
+    sqlite.exec(/*sql*/ `
+      CREATE TABLE oauth_providers (
+        provider_key TEXT PRIMARY KEY,
+        identity_ok_field TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+    `);
+  }
+  return { sqlite, db: drizzle(sqlite, { schema }) };
+}
+
+function columnNames(sqlite: Database): string[] {
+  return (
+    sqlite.query("PRAGMA table_info(oauth_providers)").all() as Array<{
+      name: string;
+    }>
+  ).map((c) => c.name);
+}
+
+describe("migration 379: oauth_providers.response_ok_field", () => {
+  test("adds the nullable column beside the identity one", () => {
+    const { sqlite, db } = createTestDb();
+    expect(columnNames(sqlite)).not.toContain("response_ok_field");
+
+    migrateOAuthProvidersResponseOkField(db);
+
+    const column = (
+      sqlite.query("PRAGMA table_info(oauth_providers)").all() as Array<{
+        name: string;
+        notnull: number;
+      }>
+    ).find((c) => c.name === "response_ok_field");
+    expect(column).toBeDefined();
+    expect(column?.notnull).toBe(0);
+    expect(columnNames(sqlite)).toContain("identity_ok_field");
+  });
+
+  test("rows written before the column existed read back null", () => {
+    // A provider that declared nothing is judged by status alone, which is
+    // what it was before the column existed.
+    const { sqlite, db } = createTestDb();
+    sqlite.exec(/*sql*/ `
+      INSERT INTO oauth_providers (provider_key, identity_ok_field, created_at, updated_at)
+      VALUES ('slack', 'ok', 1000, 1000)
+    `);
+
+    migrateOAuthProvidersResponseOkField(db);
+
+    const row = sqlite
+      .query(
+        "SELECT response_ok_field FROM oauth_providers WHERE provider_key = 'slack'",
+      )
+      .get() as { response_ok_field: unknown };
+    expect(row.response_ok_field).toBeNull();
+  });
+
+  test("is idempotent: re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateOAuthProvidersResponseOkField(db);
+    expect(() => migrateOAuthProvidersResponseOkField(db)).not.toThrow();
+
+    expect(
+      columnNames(sqlite).filter((n) => n === "response_ok_field"),
+    ).toHaveLength(1);
+  });
+
+  test("a missing table is a failure, never a silent success", () => {
+    // The runner checkpoints a throwing step as failed and retries it, and
+    // the registry defers this step behind the table's own. Swallowing the
+    // error here would checkpoint the step as done against no table, and the
+    // column would never be added.
+    // The driver wraps SQLite's "no such table" in its own message, so the
+    // assertion is that the step throws at all.
+    const { db } = createTestDb({ withTable: false });
+
+    expect(() => migrateOAuthProvidersResponseOkField(db)).toThrow();
+  });
+});

package/src/persistence/migrations/379-oauth-providers-response-ok-field.ts

@@ -0,0 +1,32 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+const TABLE_NAME = "oauth_providers";
+const COLUMN_NAME = "response_ok_field";
+const COLUMN_DEFINITION = "response_ok_field TEXT";
+
+/**
+ * Add `response_ok_field` to `oauth_providers` (migration 149): the dot path
+ * of the boolean a provider's API puts in every response body to report
+ * success (Slack: `ok`). Its own column, distinct from `identity_ok_field`,
+ * because the two declare different facts: the identity field governs the
+ * one call the provider row names, this one governs any request made with
+ * the credential.
+ *
+ * Nullable with no backfill: seeding upserts the value for the built-in rows
+ * on the next start, and a custom provider that declares nothing is judged by
+ * status alone, which is what it was before the column existed.
+ *
+ * Idempotent: guarded with `tableHasColumn` so a crash between the `ALTER
+ * TABLE` and the checkpoint write doesn't cause a duplicate-column error on
+ * the next boot. A missing table is not swallowed: the registry declares the
+ * dependency on the table's own step, so this one is deferred rather than
+ * checkpointed as done against no table.
+ */
+export function migrateOAuthProvidersResponseOkField(
+  database: DrizzleDb,
+): void {
+  if (!tableHasColumn(database, TABLE_NAME, COLUMN_NAME)) {
+    database.run(`ALTER TABLE ${TABLE_NAME} ADD COLUMN ${COLUMN_DEFINITION}`);
+  }
+}

package/src/persistence/migrations/380-conversation-tool-surfaces-delegate-independent-tasks.test.ts

@@ -0,0 +1,90 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import * as schema from "../schema.js";
+import { migrateCreateConversationToolSurfaces } from "./378-create-conversation-tool-surfaces.js";
+import { migrateConversationToolSurfacesDelegateIndependentTasks } from "./380-conversation-tool-surfaces-delegate-independent-tasks.js";
+
+function createTestDb(options: { withTable?: boolean } = {}) {
+  const sqlite = new Database(":memory:");
+  sqlite.run("PRAGMA foreign_keys = ON");
+  // Only the parent table the FK points at.
+  sqlite.run(/*sql*/ `CREATE TABLE conversations (id TEXT PRIMARY KEY)`);
+  const db = drizzle(sqlite, { schema });
+  if (options.withTable !== false) {
+    // Pre-380 shape: the table as migration 378 creates it.
+    migrateCreateConversationToolSurfaces(db);
+  }
+  return { sqlite, db };
+}
+
+function columns(sqlite: Database): Array<{ name: string; notnull: number }> {
+  return sqlite
+    .query("PRAGMA table_info(conversation_tool_surfaces)")
+    .all() as Array<{ name: string; notnull: number }>;
+}
+
+describe("migration 380: conversation_tool_surfaces.delegate_independent_tasks", () => {
+  test("adds the nullable column", () => {
+    const { sqlite, db } = createTestDb();
+    expect(columns(sqlite).map((c) => c.name)).not.toContain(
+      "delegate_independent_tasks",
+    );
+
+    migrateConversationToolSurfacesDelegateIndependentTasks(db);
+
+    const column = columns(sqlite).find(
+      (c) => c.name === "delegate_independent_tasks",
+    );
+    expect(column).toBeDefined();
+    expect(column?.notnull).toBe(0);
+  });
+
+  test("rows written before the column existed read back null", () => {
+    // A fork replaying such a row derives the section for itself, which is
+    // what it did before the column existed.
+    const { sqlite, db } = createTestDb();
+    sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
+    sqlite
+      .query(
+        /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
+      )
+      .run("conv-1", "[]", "hash", 1);
+
+    migrateConversationToolSurfacesDelegateIndependentTasks(db);
+
+    const row = sqlite
+      .query(
+        "SELECT delegate_independent_tasks FROM conversation_tool_surfaces WHERE conversation_id = 'conv-1'",
+      )
+      .get() as { delegate_independent_tasks: unknown };
+    expect(row.delegate_independent_tasks).toBeNull();
+  });
+
+  test("is idempotent: re-run is a no-op", () => {
+    const { sqlite, db } = createTestDb();
+
+    migrateConversationToolSurfacesDelegateIndependentTasks(db);
+    expect(() =>
+      migrateConversationToolSurfacesDelegateIndependentTasks(db),
+    ).not.toThrow();
+
+    expect(
+      columns(sqlite).filter((c) => c.name === "delegate_independent_tasks"),
+    ).toHaveLength(1);
+  });
+
+  test("a missing table is a failure, never a silent success", () => {
+    // The runner checkpoints a throwing step as failed and retries it, and
+    // the registry defers this step behind the table's own. Swallowing the
+    // error here would checkpoint the step as done against no table, and the
+    // column would never be added.
+    const { db } = createTestDb({ withTable: false });
+
+    expect(() =>
+      migrateConversationToolSurfacesDelegateIndependentTasks(db),
+    ).toThrow();
+  });
+});

package/src/persistence/migrations/380-conversation-tool-surfaces-delegate-independent-tasks.ts

@@ -0,0 +1,34 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+const TABLE_NAME = "conversation_tool_surfaces";
+const COLUMN_NAME = "delegate_independent_tasks";
+const COLUMN_DEFINITION = "delegate_independent_tasks INTEGER";
+
+/**
+ * Add `delegate_independent_tasks` to `conversation_tool_surfaces`: whether
+ * the system prompt of the turn that recorded the surface rendered the
+ * parallel-delegation section (`01-parallel-tasks`). The prompt derives that
+ * section from the same resolved tool surface, so a fork wake replaying the
+ * surface needs the rendered state too: the section sits in the system
+ * prompt, the second tier of the provider cache prefix, and a fork that
+ * derives it from its own restricted scope renders it off where the source
+ * rendered it on, missing the source's cached prefix from that byte on.
+ *
+ * Nullable with no backfill: a row written before the column existed reads
+ * null and the fork derives the section for itself, exactly as it did before
+ * the column; the next live turn records the state.
+ *
+ * Idempotent: guarded with `tableHasColumn` so a crash between the `ALTER
+ * TABLE` and the checkpoint write doesn't cause a duplicate-column error on
+ * the next boot. A missing table is not swallowed: the registry declares the
+ * dependency on the table's own step, so this one is deferred rather than
+ * checkpointed as done against no table.
+ */
+export function migrateConversationToolSurfacesDelegateIndependentTasks(
+  database: DrizzleDb,
+): void {
+  if (!tableHasColumn(database, TABLE_NAME, COLUMN_NAME)) {
+    database.run(`ALTER TABLE ${TABLE_NAME} ADD COLUMN ${COLUMN_DEFINITION}`);
+  }
+}

package/src/persistence/schema/conversation-tool-surfaces.ts

@@ -0,0 +1,32 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+import { conversations } from "./conversations.js";
+
+/**
+ * The tool definitions a conversation's most recent live turn sent to the
+ * provider, serialized exactly as resolved, plus whether that turn's system
+ * prompt rendered the parallel-delegation section (which the prompt derives
+ * from the same resolved surface and the turn's channel). Written at the
+ * agent loop's send boundary when either changes; read by fork wakes that
+ * replay both so their provider prompt-cache prefix matches the source's live
+ * turns. Cascades with its conversation.
+ */
+export const conversationToolSurfaces = sqliteTable(
+  "conversation_tool_surfaces",
+  {
+    conversationId: text("conversation_id")
+      .primaryKey()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    toolsJson: text("tools_json").notNull(),
+    toolsHash: text("tools_hash").notNull(),
+    /**
+     * Whether the turn's system prompt rendered the `01-parallel-tasks`
+     * section. Null when unknown: the turn ran on a system-prompt override,
+     * or the row predates the column.
+     */
+    delegateIndependentTasks: integer("delegate_independent_tasks", {
+      mode: "boolean",
+    }),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);

package/src/persistence/schema/index.ts

@@ -5,6 +5,7 @@ export * from "./calls.js";
 export * from "./contacts.js";
 export * from "./conversation-groups.js";
 export * from "./conversation-starters.js";
+export * from "./conversation-tool-surfaces.js";
 export * from "./conversations.js";
 export * from "./documents.js";
 export * from "./guardian.js";

package/src/persistence/schema/oauth.ts

@@ -50,6 +50,7 @@ export const oauthProviders = sqliteTable("oauth_providers", {
   identityResponsePaths: text("identity_response_paths"),
   identityFormat: text("identity_format"),
   identityOkField: text("identity_ok_field"),
+  responseOkField: text("response_ok_field"),
   featureFlag: text("feature_flag"),
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),

package/src/persistence/steps.ts

@@ -485,6 +485,9 @@ import { migrateChannelInboundMessageIdIndex } from "./migrations/374-channel-in
 import { migrateCreateChannelOutboundPosts } from "./migrations/375-create-channel-outbound-posts.js";
 import { migrateNotificationDeliveriesCanonicalMessageId } from "./migrations/376-notification-deliveries-canonical-message-id.js";
 import { migrateAddSubagentBudgetStopReason } from "./migrations/377-add-subagent-budget-stop-reason.js";
+import { migrateCreateConversationToolSurfaces } from "./migrations/378-create-conversation-tool-surfaces.js";
+import { migrateOAuthProvidersResponseOkField } from "./migrations/379-oauth-providers-response-ok-field.js";
+import { migrateConversationToolSurfacesDelegateIndependentTasks } from "./migrations/380-conversation-tool-surfaces-delegate-independent-tasks.js";
 import type { MigrationStep } from "./migrations/run-migrations.js";
 
 export const migrationSteps: MigrationStep[] = [
@@ -1606,9 +1609,27 @@ export const migrationSteps: MigrationStep[] = [
   {
     name: "migrateAddSubagentBudgetStopReason",
     run: migrateAddSubagentBudgetStopReason,
-    // The column guard treats a missing table as nothing-to-do, so the table
-    // must be checkpointed first or a repair flow could permanently checkpoint
-    // this as a no-op.
+    // The column guard reads the table's columns and the ALTER throws on a
+    // missing table, so the table must be checkpointed first or a repair flow
+    // that failed to create it would fail this step needlessly.
     dependsOn: ["migrateCreateSubagentsTable"],
   },
+  migrateCreateConversationToolSurfaces,
+  {
+    name: "migrateOAuthProvidersResponseOkField",
+    run: migrateOAuthProvidersResponseOkField,
+    // The column guard reads the table's columns, and an `ALTER` on a missing
+    // table throws, so the table must be checkpointed first or a repair flow
+    // that failed to create it would either fail this step needlessly or, if
+    // the error were swallowed, checkpoint it as done against no table.
+    dependsOn: ["createOAuthTables"],
+  },
+  {
+    name: "migrateConversationToolSurfacesDelegateIndependentTasks",
+    run: migrateConversationToolSurfacesDelegateIndependentTasks,
+    // Same column-guard shape as the step above: the guard reads the table's
+    // columns and the `ALTER` throws on a missing table, so the table's own
+    // step must be checkpointed first.
+    dependsOn: ["migrateCreateConversationToolSurfaces"],
+  },
 ];

package/src/plugin-api/conversation-turn.ts

@@ -284,13 +284,20 @@ export async function runConversationTurn(
   const { resolveChannelCapabilities } =
     await import("../daemon/conversation-runtime-assembly.js");
 
-  // Plugin-driven turns run as the guardian: plugins are installed by the
-  // guardian, so their conversations inherit guardian trust. This lets the
-  // existing non-interactive auto-approve machinery handle tool permissions
-  // (the conversation is already non-interactive via `isInteractive: false`
-  // below) without requiring a client to approve prompts.
+  // Channel-addressed turns are inbound: the gateway classifies the sender
+  // and the turn runs only if that actor clears the channel admission floor.
+  // Internal plugin jobs (no channel address) use guardian trust because they
+  // are assistant-owned work, not an external sender.
   const { INTERNAL_GUARDIAN_TRUST_CONTEXT } =
     await import("../daemon/trust-context.js");
+  const { resolvePluginChannelTurnTrust } =
+    await import("./plugin-channel-turn-trust.js");
+  const { prepareChannelInboundContent } =
+    await import("../runtime/routes/inbound-stages/inbound-content-prep.js");
+
+  const trustContext = options.channel
+    ? await resolvePluginChannelTurnTrust(options.channel)
+    : INTERNAL_GUARDIAN_TRUST_CONTEXT;
 
   // A channel address resolves through the same binding an inbound message
   // uses, so a turn addressed by chat lands in that chat's conversation
@@ -311,7 +318,7 @@ export async function runConversationTurn(
     ? !channelConversation.created
     : getConversation(conversationId) != null;
   const conversation = await getOrCreateConversation(conversationId, {
-    trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
+    trustContext,
     ...(options.conversationType
       ? { conversationType: options.conversationType }
       : {}),
@@ -336,10 +343,23 @@ export async function runConversationTurn(
 
   // Convert ContentBlock[] input to the text + attachments shape the
   // conversation's processMessage path expects.
-  const { text, attachments } = extractContentAndAttachments(
+  const { text: rawText, attachments } = extractContentAndAttachments(
     options.content,
     resolveMediaSourceData,
   );
+  const inboundContent = options.channel
+    ? prepareChannelInboundContent({
+        trimmedContent: rawText,
+        trustClass: trustContext.trustClass,
+        sourceChannel: options.channel.sourceChannel,
+        requesterIdentifier:
+          options.channel.username ??
+          options.channel.externalUserId ??
+          undefined,
+      })
+    : { content: rawText, displayContent: undefined };
+  const text = inboundContent.content;
+  const displayContent = inboundContent.displayContent;
 
   // The channel this turn speaks on. Runtime assembly reads the per-turn
   // context first and falls back to the conversation's `originChannel`, then
@@ -409,6 +429,8 @@ export async function runConversationTurn(
       requestId,
       isInteractive: false,
       metadata,
+      trustContext,
+      ...(displayContent ? { displayContent } : {}),
     });
     if (enqueueResult.rejected) {
       throw new Error(
@@ -432,6 +454,8 @@ export async function runConversationTurn(
     onEvent,
     isInteractive: false,
     metadata,
+    trustContext,
+    ...(displayContent ? { displayContent } : {}),
     ...(options.callSite ? { callSite: options.callSite } : {}),
   });
 

package/src/plugin-api/index.ts

@@ -286,6 +286,11 @@ export {
 // writes files under the workspace (e.g. its own `plugins/<name>/data/`
 // directory) resolves them against this instead of hardcoding a base path.
 export { getWorkspaceDir } from "../util/platform.js";
+// `String.prototype.slice` that never cuts a UTF-16 surrogate pair in half.
+// Any text a plugin truncates by character budget and hands to a model must
+// go through this: an orphaned half is invalid UTF-16 that strict provider
+// parsers reject.
+export { safeStringSlice } from "../util/unicode.js";
 // Declarative help for the top-level `assistant` CLI commands that have adopted
 // the static-help split. Plugins (e.g. the memory capability indexer) read this
 // to embed CLI command capabilities without importing the CLI action graph.
@@ -359,7 +364,8 @@ export {
   stringifyMessageContent,
 } from "../persistence/message-content.js";
 // Conversation history — reads and writes on the host conversation store
-// (rows, message history, processing state, disk-view paths) plus the lexical
+// (rows, message history, processing state, the recorded wire tool surface,
+// disk-view paths) plus the lexical
 // message-search surface. Every operation takes explicit parameters; nothing
 // is resolved from config. Async because the facade loads the DB store graph
 // lazily on first call.
@@ -371,7 +377,9 @@ export {
   getConversation,
   getConversationDirPath,
   getConversationProcessingStartedAt,
+  getConversationToolSurface,
   getMessages,
+  getRecordedConversationToolSurface,
   hasLexicalTokens,
   isConversationProcessing,
   listConversations,
@@ -380,6 +388,7 @@ export {
   syncMessageToDisk,
   updateMessageMetadata,
 } from "../persistence/conversation-plugin-facade.js";
+export type { ConversationToolSurface } from "../persistence/conversation-tool-surface.js";
 // System cards: a transcript notice authored by the daemon rather than the
 // assistant persona, for telling the user something a turn did to their input
 // that the model's reply cannot explain (e.g. an attachment that could not be
@@ -438,6 +447,7 @@ export type {
   RunConversationTurnResult,
 } from "./conversation-turn.js";
 export { runConversationTurn } from "./conversation-turn.js";
+export { PluginTurnNotAdmittedError } from "./plugin-channel-turn-trust.js";
 // Live voice — drive a single client's real-time voice session (STT → agent
 // turn → TTS, with server-VAD turn-taking, pauses, and barge-in) over a
 // transport the plugin owns. The plugin brings only a `send` callback (e.g.