@pikku/core 0.12.74 → 0.12.78

package/src/services/secret-service.ts

@@ -1,6 +1,11 @@
+import type { SecretValue } from '../secret-value.js'
+
+/** A record of secrets, each still wrapped. */
+export type SecretValues<T> = { [K in keyof T]: SecretValue<T[K]> }
+
 export interface SecretService {
-  /** Throws if the secret is not found. */
-  getSecret<T = string>(key: string): Promise<T>
+  /** Throws if the secret is not found. Unwrap the result with `.reveal()`. */
+  getSecret<T = string>(key: string): Promise<SecretValue<T>>
   /** Answers for any key, including a disallowed one — it must not throw. */
   hasSecret(key: string): Promise<boolean>
   setSecret(key: string, value: unknown): Promise<void>
@@ -12,5 +17,5 @@ export interface SecretService {
    */
   getSecrets<T extends Record<string, unknown> = Record<string, unknown>>(
     keys: (keyof T & string)[]
-  ): Promise<Partial<T>>
+  ): Promise<Partial<SecretValues<T>>>
 }

package/src/services/typed-secret-service.ts

@@ -1,4 +1,5 @@
-import type { SecretService } from './secret-service.js'
+import type { SecretValue } from '../secret-value.js'
+import type { SecretService, SecretValues } from './secret-service.js'
 
 export interface CredentialStatus {
   secretId: string
@@ -25,8 +26,10 @@ export class TypedSecretService<
     private credentialsMeta: Record<string, CredentialMeta>
   ) {}
 
-  async getSecret<K extends keyof TMap & string>(key: K): Promise<TMap[K]>
-  async getSecret<T = string>(key: string): Promise<T>
+  async getSecret<K extends keyof TMap & string>(
+    key: K
+  ): Promise<SecretValue<TMap[K]>>
+  async getSecret<T = string>(key: string): Promise<SecretValue<T>>
   async getSecret(key: string): Promise<unknown> {
     if (this.cache.has(key)) {
       return this.cache.get(key)
@@ -58,12 +61,12 @@ export class TypedSecretService<
 
   async getSecrets<T extends Record<string, unknown> = Record<string, unknown>>(
     keys: (keyof T & string)[]
-  ): Promise<Partial<T>> {
-    const result: Partial<T> = {}
+  ): Promise<Partial<SecretValues<T>>> {
+    const result: Partial<SecretValues<T>> = {}
     const missing: (keyof T & string)[] = []
     for (const key of keys) {
       if (this.cache.has(key)) {
-        result[key] = this.cache.get(key) as T[keyof T & string]
+        result[key] = this.cache.get(key) as SecretValues<T>[keyof T & string]
       } else {
         missing.push(key)
       }
@@ -72,7 +75,8 @@ export class TypedSecretService<
       const fetched = await this.secrets.getSecrets<T>(missing)
       for (const [key, value] of Object.entries(fetched)) {
         this.cache.set(key, value)
-        result[key as keyof T & string] = value as T[keyof T & string]
+        result[key as keyof T & string] = value as SecretValues<T>[keyof T &
+          string]
       }
     }
     return result

package/src/services/webhook-service.ts

@@ -1,5 +1,6 @@
 import { NotImplementedError } from '../errors/errors.js'
 import { hmacSha256Hex, timingSafeStringEqual } from '../utils/hmac.js'
+import type { Safe } from '../secret-value.js'
 
 export interface SendWebhookInput {
   url: string
@@ -90,7 +91,9 @@ export const DEFAULT_WEBHOOK_SIGNATURE_HEADER = 'X-Pikku-Signature'
 export const DEFAULT_WEBHOOK_RETRIES = 3
 
 export abstract class WebhookService {
-  abstract send(input: SendWebhookInput): Promise<SendWebhookResult>
+  abstract send<T extends SendWebhookInput>(
+    input: Safe<T>
+  ): Promise<SendWebhookResult>
 
   /** Produces the header value, `sha256=<hex>`, not the bare digest. */
   protected sign(secret: string, body: string): string {

package/src/testing/service-tests.ts

@@ -831,17 +831,17 @@ export function defineServiceTests(config: ServiceTestConfig): void {
           token: string
           endpoint: string
         }>('api-key')
-        assert.deepEqual(result, {
+        assert.deepEqual(result.reveal(), {
           token: 'sk-123',
           endpoint: 'https://api.example.com',
         })
       })
 
-      test('getSecret returns raw string', async () => {
+      test('getSecret wraps the raw string rather than returning it', async () => {
         const service = await factory({ key: kek })
         await service.setSecret('string-secret', 'plain-value')
         const result = await service.getSecret('string-secret')
-        assert.strictEqual(result, 'plain-value')
+        assert.strictEqual(result.reveal(), 'plain-value')
       })
 
       test('hasSecret returns true/false', async () => {
@@ -862,7 +862,7 @@ export function defineServiceTests(config: ServiceTestConfig): void {
         await service.setSecret('upsert-key', { v: 1 })
         await service.setSecret('upsert-key', { v: 2 })
         const result = await service.getSecret<{ v: number }>('upsert-key')
-        assert.deepEqual(result, { v: 2 })
+        assert.deepEqual(result.reveal(), { v: 2 })
       })
 
       test('deleteSecret removes the key', async () => {
@@ -887,7 +887,7 @@ export function defineServiceTests(config: ServiceTestConfig): void {
         const before = await rotatedService.getSecret<{
           important: string
         }>('rotate-test')
-        assert.deepEqual(before, { important: 'data' })
+        assert.deepEqual(before.reveal(), { important: 'data' })
 
         assert.ok(rotatedService.rotateKEK)
         const count = await rotatedService.rotateKEK!()
@@ -900,7 +900,7 @@ export function defineServiceTests(config: ServiceTestConfig): void {
         const after = await newOnlyService.getSecret<{
           important: string
         }>('rotate-test')
-        assert.deepEqual(after, { important: 'data' })
+        assert.deepEqual(after.reveal(), { important: 'data' })
       })
 
       test('rotateKEK throws without previousKey', async () => {

package/src/types/core.types.ts

@@ -44,6 +44,7 @@ import type { AIAgentRunnerService } from '../services/ai-agent-runner-service.j
 import type { AIEmbeddingService } from '../services/ai-embedding-service.js'
 import type { AIRunStateService } from '../services/ai-run-state-service.js'
 import type { AgentRunService } from '../wirings/ai-agent/ai-agent.types.js'
+import type { VirtualUserRunStore } from '../wirings/virtual-user/virtual-user-run-store.js'
 import type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.js'
 import type { WorkflowRunService } from '../wirings/workflow/workflow.types.js'
 import type { CredentialService } from '../services/credential-service.js'
@@ -125,11 +126,12 @@ export type FunctionRuntimeMeta = {
    */
   auth?: boolean
   /**
-   * The author's declaration that this function authorizes callers in its own
-   * body. Carries no runtime effect — it records a gate codegen cannot see, so
-   * an audit is not left to guess whether a sessionless function is open.
+   * The author's declaration that this function's permission check lives in its
+   * own body. Carries no runtime effect — it records a gate codegen cannot see,
+   * so an audit is not left to guess whether a sessionless function is open.
+   * Refused unless `allow.permissionsInBody` is set in `pikku.config.json`.
    */
-  selfAuthenticated?: boolean
+  permissionsInBody?: boolean
   remote?: boolean
   /**
    * A step RPC: invoked by name only from a scenario run and refused
@@ -173,6 +175,19 @@ export type FunctionRuntimeMeta = {
   scenarioStepAddon?: string
   /** Scenario steps only: the prose a reporter renders, with `{placeholders}` filled from the step's recorded input. */
   scenarioStepTemplate?: string
+  /**
+   * The function's `audit` config, resolved — `audit: true` reads as
+   * `{ durability: 'best-effort' }`. Absent means the function records nothing:
+   * `auditLog.write()` from an unmarked function is dropped with a warning, so
+   * this is the only place a reader can see which functions have a trail at all
+   * without running them.
+   *
+   * Informational. The runner resolves audit from the live function config, not
+   * from here, so meta and runtime cannot disagree about whether audit is on.
+   */
+  audit?: {
+    durability: AuditDurability
+  }
   /** Keeps the full `SecretService`. Set by the inspector, read by the runner. */
   secretBroker?: boolean
   version?: number
@@ -323,6 +338,12 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
    */
   webhookService?: WebhookService
   metaService?: MetaService
+  /**
+   * Where virtual-user runs are recorded. A run is dispatched and answered for
+   * later, so this store is the only trace it leaves — see
+   * {@link VirtualUserRunStore}.
+   */
+  virtualUserRunStore?: VirtualUserRunStore
   /** V8 precise-coverage collector (`pikku dev --coverage` only) */
   coverageService?: CoverageService
   audit?: AuditService

package/src/wirings/ai-agent/ai-agent-agui.test.ts

@@ -590,6 +590,22 @@ describe('wrapChannelWithAGUI — speech', () => {
     assert.ok(find(events, 'CUSTOM', 'pikku:audio-done'))
   })
 
+  it('forwards the transcript as a CUSTOM event', () => {
+    const { channel, events } = makeChannel()
+    const wrapped = wrapChannelWithAGUI(channel)
+
+    wrapped.send({
+      type: 'transcript',
+      text: 'what the user said',
+    } as AIStreamEvent)
+
+    // The client sent audio, so this is the only way it learns what its own
+    // turn was. Dropped, the user's message renders as an empty bubble.
+    const custom = find(events, 'CUSTOM', 'pikku:transcript')
+    assert.ok(custom)
+    assert.deepEqual(custom.value, { text: 'what the user said' })
+  })
+
   it('leaves an open text message open, so speech cannot split a reply', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)

package/src/wirings/ai-agent/ai-agent-agui.ts

@@ -381,7 +381,11 @@ export function wrapChannelWithAGUI(
           send({
             type: 'CUSTOM',
             name: 'pikku:audio-delta',
-            value: { data: event.data, format: event.format },
+            value: {
+              data: event.data,
+              format: event.format,
+              ...(event.text === undefined ? {} : { text: event.text }),
+            },
           })
           break
         }
@@ -390,6 +394,15 @@ export function wrapChannelWithAGUI(
           send({ type: 'CUSTOM', name: 'pikku:audio-done', value: {} })
           break
         }
+
+        case 'transcript': {
+          send({
+            type: 'CUSTOM',
+            name: 'pikku:transcript',
+            value: { text: event.text },
+          })
+          break
+        }
       }
     },
   }

package/src/wirings/ai-agent/ai-agent-prepare.ts

@@ -959,7 +959,13 @@ export async function prepareAgentRun(
 
   const userContent: AIMessage['content'] = input.attachments?.length
     ? [
-        { type: 'text' as const, text: input.message },
+        // Omitted when there is nothing to say. An attachment on its own is a
+        // real turn — a spoken one carries audio and no text at all — and an
+        // empty text part alongside it is a part providers are entitled to
+        // reject, for a caller who never wrote one.
+        ...(input.message
+          ? [{ type: 'text' as const, text: input.message }]
+          : []),
         ...input.attachments.map(
           (a) =>
             ({

package/src/wirings/ai-agent/ai-agent-runner.ts

@@ -144,6 +144,9 @@ export async function runAIAgent(
     ...(agent.aiMiddleware ?? []),
   ]
 
+  // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
+  const sharedNotes: Record<string, unknown> = {}
+
   let modifiedMessages = runnerParams.messages
   let modifiedInstructions = runnerParams.instructions
   for (const mw of aiMiddlewares) {
@@ -151,6 +154,7 @@ export async function runAIAgent(
       const result = await mw.modifyInput(singletonServices, {
         messages: modifiedMessages,
         instructions: modifiedInstructions,
+        shared: sharedNotes,
       })
       modifiedMessages = result.messages
       modifiedInstructions = result.instructions
@@ -159,6 +163,14 @@ export async function runAIAgent(
   runnerParams.messages = modifiedMessages
   runnerParams.instructions = modifiedInstructions
 
+  // History records what the model was asked, which for a spoken turn is the
+  // transcript rather than the base64 audio that arrived — see the same note on
+  // the streaming path. Identity-checked, because a middleware may legitimately
+  // replace the message list with something unrelated to this turn.
+  const lastModified = modifiedMessages[modifiedMessages.length - 1]
+  const persistedUserMessage =
+    lastModified?.id === userMessage.id ? lastModified : userMessage
+
   const runId = await aiRunState.createRun({
     agentName,
     threadId,
@@ -275,7 +287,7 @@ export async function runAIAgent(
           threadId,
           input.resourceId,
           memoryConfig,
-          userMessage,
+          persistedUserMessage,
           { text: '', steps: completedStepsForSave }
         )
 
@@ -351,7 +363,7 @@ export async function runAIAgent(
       threadId,
       input.resourceId,
       memoryConfig,
-      userMessage,
+      persistedUserMessage,
       {
         ...result,
         text: outputText,
@@ -608,6 +620,9 @@ async function continueAfterToolResultSync(
     }),
     ...(agent.aiMiddleware ?? []),
   ]
+  // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
+  const sharedNotes: Record<string, unknown> = {}
+
   let modifiedMessages = trimmedMessages
   let modifiedInstructions = instructions
   for (const mw of aiMiddlewares) {
@@ -615,6 +630,7 @@ async function continueAfterToolResultSync(
       const result = await mw.modifyInput(singletonServices, {
         messages: modifiedMessages,
         instructions: modifiedInstructions,
+        shared: sharedNotes,
       })
       modifiedMessages = result.messages
       modifiedInstructions = result.instructions

package/src/wirings/ai-agent/ai-agent-stream.ts

@@ -12,6 +12,7 @@ import type {
 import { pikkuState, getSingletonServices } from '../../pikku-state.js'
 import { AIProviderNotConfiguredError } from '../../errors/errors.js'
 import { randomUUID } from './ai-agent-utils.js'
+import { SPOKEN_TRANSCRIPT } from './voice-input.js'
 import {
   combineChannelMiddleware,
   wrapChannelWithMiddleware,
@@ -672,6 +673,9 @@ export async function streamAIAgent(
     ...(agent.aiMiddleware ?? []),
   ]
 
+  // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
+  const sharedNotes: Record<string, unknown> = {}
+
   let modifiedMessages = runnerParams.messages
   let modifiedInstructions = runnerParams.instructions
   for (const mw of aiMiddlewares) {
@@ -679,6 +683,7 @@ export async function streamAIAgent(
       const result = await mw.modifyInput(singletonServices, {
         messages: modifiedMessages,
         instructions: modifiedInstructions,
+        shared: sharedNotes,
       })
       modifiedMessages = result.messages
       modifiedInstructions = result.instructions
@@ -687,6 +692,26 @@ export async function streamAIAgent(
   runnerParams.messages = modifiedMessages
   runnerParams.instructions = modifiedInstructions
 
+  // Sent on the raw channel, ahead of the run. A voice client sent audio and so
+  // has no idea what it said; until this arrives its own message is a blank
+  // bubble. Ahead of the run rather than alongside it because the answer starts
+  // streaming within a few hundred milliseconds, and a question that appears
+  // after its answer reads as the wrong question.
+  const transcript = sharedNotes[SPOKEN_TRANSCRIPT]
+  if (typeof transcript === 'string') {
+    channel.send({ type: 'transcript', text: transcript })
+  }
+
+  // What goes into thread history is what the model was actually asked. For a
+  // spoken turn that is not what arrived over the wire: the wire carried a
+  // base64 audio blob, and persisting it would write megabytes of unreadable
+  // data into the history while losing the only readable record of the turn.
+  // Identity-checked rather than assumed — a middleware is free to rewrite the
+  // message list into something with no relation to the turn.
+  const lastModified = modifiedMessages[modifiedMessages.length - 1]
+  const persistedUserMessage =
+    lastModified?.id === userMessage.id ? lastModified : userMessage
+
   const runId = await aiRunState.createRun({
     agentName,
     threadId,
@@ -706,7 +731,7 @@ export async function streamAIAgent(
   runnerParams.tools = trackToolExecution(runnerParams.tools, interruptHandle)
 
   if (storage) {
-    await storage.saveMessages(threadId, [userMessage])
+    await storage.saveMessages(threadId, [persistedUserMessage])
   }
 
   const streamMiddleware = aiMiddlewares
@@ -720,6 +745,7 @@ export async function streamAIAgent(
           event,
           allEvents,
           state,
+          shared: sharedNotes,
           // Sends downstream directly, so a hook can hand back the fast event
           // now and push the slow one when it is ready.
           emit: next,
@@ -1288,6 +1314,9 @@ async function continueAfterToolResult(
     }),
     ...(agent.aiMiddleware ?? []),
   ]
+  // One bag per run, shared by every middleware — see PikkuAIMiddlewareHooks.
+  const sharedNotes: Record<string, unknown> = {}
+
   let modifiedMessages = trimmedMessages
   let modifiedInstructions = instructions
   for (const mw of aiMiddlewares) {
@@ -1295,6 +1324,7 @@ async function continueAfterToolResult(
       const result = await mw.modifyInput(singletonServices, {
         messages: modifiedMessages,
         instructions: modifiedInstructions,
+        shared: sharedNotes,
       })
       modifiedMessages = result.messages
       modifiedInstructions = result.instructions
@@ -1318,6 +1348,7 @@ async function continueAfterToolResult(
           event,
           allEvents,
           state,
+          shared: sharedNotes,
           // Sends downstream directly, so a hook can hand back the fast event
           // now and push the slow one when it is ready.
           emit: next,

package/src/wirings/ai-agent/ai-agent.types.ts

@@ -171,7 +171,27 @@ export interface PikkuAIMiddlewareHooks<
 > {
   modifyInput?: (
     services: Services,
-    ctx: { messages: AIMessage[]; instructions: string }
+    ctx: {
+      messages: AIMessage[]
+      instructions: string
+      /**
+       * Notes about this run that every middleware can read and write, as
+       * opposed to {@link modifyOutputStream}'s `state`, which is private to
+       * one middleware.
+       *
+       * It exists because middlewares transform the turn for each other, and
+       * the transformation can destroy what a later one needed to know. Voice
+       * is the case in point: `voiceInput` replaces the user's audio with its
+       * transcript, so by the time anything downstream looks, the turn is
+       * indistinguishable from one that was typed — and whether it was typed is
+       * exactly what `voiceOutput` needs in order to decide whether to answer
+       * aloud. Only the middleware that consumed the audio can still say so.
+       *
+       * Namespace what you put here (`voice:spokenTurn`); it is one bag for
+       * everybody. Cleared between runs.
+       */
+      shared: Record<string, unknown>
+    }
   ) =>
     | Promise<{ messages: AIMessage[]; instructions: string }>
     | { messages: AIMessage[]; instructions: string }
@@ -181,7 +201,10 @@ export interface PikkuAIMiddlewareHooks<
     ctx: {
       event: AIStreamEvent
       allEvents: readonly AIStreamEvent[]
+      /** Private to this middleware, for this run. Cross-middleware facts go in `shared`. */
       state: State
+      /** Per-run notes shared with every middleware — see {@link modifyInput}. */
+      shared: Record<string, unknown>
       /**
        * Push an event into the stream *after* this call has returned.
        *
@@ -418,10 +441,31 @@ export type AIStreamEvent =
       type: 'audio-delta'
       data: string
       format: string
+      /**
+       * The sentence this audio says.
+       *
+       * Carried alongside the bytes because a client that gets talked over has
+       * to tell the model what the user actually heard, and playback position
+       * is the only place that is knowable. Without it a barge-in can stop the
+       * sound but not report it, and the next turn is answered as though the
+       * whole reply had landed.
+       */
+      text?: string
       agent?: string
       session?: string
     }
   | { type: 'audio-done'; agent?: string; session?: string }
+  | {
+      /**
+       * What the user was heard to say, sent once at the start of a spoken
+       * turn. Only the server knows this — the client sent audio — and a chat
+       * surface needs it to show the user's own message.
+       */
+      type: 'transcript'
+      text: string
+      agent?: string
+      session?: string
+    }
   | {
       type: 'data'
       name: string

package/src/wirings/ai-agent/index.ts

@@ -16,6 +16,8 @@ export {
   voiceInput,
   readsAsNonSpeech,
   NoSpeechDetectedError,
+  SPOKEN_TURN,
+  SPOKEN_TRANSCRIPT,
 } from './voice-input.js'
 export {
   voiceOutput,

package/src/wirings/ai-agent/voice-input.test.ts

@@ -5,6 +5,8 @@ import {
   voiceInput,
   readsAsNonSpeech,
   NoSpeechDetectedError,
+  SPOKEN_TURN,
+  SPOKEN_TRANSCRIPT,
 } from './voice-input.js'
 import type { AIContentPart, AIMessage } from './ai-agent.types.js'
 
@@ -39,6 +41,7 @@ describe('voiceInput', () => {
     const result = await mw.modifyInput!(services as any, {
       messages: [audioMessage()],
       instructions: 'sys',
+      shared: {},
     })
 
     const last = result.messages[result.messages.length - 1]!
@@ -67,6 +70,7 @@ describe('voiceInput', () => {
     const result = await mw.modifyInput!(services as any, {
       messages,
       instructions: 'sys',
+      shared: {},
     })
 
     assert.equal(result.messages[0]!.content, 'just text')
@@ -81,6 +85,7 @@ describe('voiceInput', () => {
         mw.modifyInput!(services as any, {
           messages: [audioMessage()],
           instructions: 'sys',
+          shared: {},
         }),
       /voiceInput requires a transcription model/
     )
@@ -105,6 +110,7 @@ describe('voiceInput', () => {
         mw.modifyInput!({ aiAgentRunner: silent } as any, {
           messages: [audioMessage()],
           instructions: 'sys',
+          shared: {},
         }),
       NoSpeechDetectedError
     )
@@ -127,6 +133,7 @@ describe('voiceInput', () => {
     const result = await mw.modifyInput!({ aiAgentRunner: spaced } as any, {
       messages: [audioMessage()],
       instructions: 'sys',
+      shared: {},
     })
 
     const parts = result.messages.at(-1)!.content as AIContentPart[]
@@ -152,4 +159,62 @@ describe('readsAsNonSpeech', () => {
     assert.equal(readsAsNonSpeech({ text: 'yes' }), false)
     assert.equal(readsAsNonSpeech({ text: 'Thank you.' }), false)
   })
+  test('records that the turn was spoken, for voiceOutput to read', async () => {
+    // The note has to be written here: the transcript this middleware puts in
+    // the message's place is indistinguishable from something typed, so no
+    // later middleware can tell what it started as.
+    const mw = voiceInput({ model: 'mock/whisper' })
+    const shared: Record<string, unknown> = {}
+
+    await mw.modifyInput!({ aiAgentRunner: new ThisDependentRunner() } as any, {
+      messages: [audioMessage()],
+      instructions: 'sys',
+      shared,
+    })
+
+    assert.equal(shared[SPOKEN_TURN], true)
+  })
+
+  test('records a typed turn as not spoken, rather than leaving it unsaid', async () => {
+    const mw = voiceInput({ model: 'mock/whisper' })
+    const shared: Record<string, unknown> = {}
+
+    await mw.modifyInput!({ aiAgentRunner: new ThisDependentRunner() } as any, {
+      messages: [{ role: 'user', content: 'typed' } as any],
+      instructions: 'sys',
+      shared,
+    })
+
+    // Explicitly false, not absent: absent is what a caller with no voice input
+    // at all looks like, and that one should still be spoken to.
+    assert.equal(shared[SPOKEN_TURN], false)
+  })
+
+  test('records what was heard, so the client can show the user their own turn', async () => {
+    const mw = voiceInput({ model: 'mock/whisper' })
+    const shared: Record<string, unknown> = {}
+
+    await mw.modifyInput!({ aiAgentRunner: new ThisDependentRunner() } as any, {
+      messages: [audioMessage()],
+      instructions: 'sys',
+      shared,
+    })
+
+    assert.equal(shared[SPOKEN_TRANSCRIPT], 'the transcribed spoken words')
+  })
+
+  test('a typed turn leaves no transcript behind', async () => {
+    // Absence is the signal: the stream only announces a transcript when there
+    // was one, and a typed message is already on the client's screen.
+    const mw = voiceInput({ model: 'mock/whisper' })
+    const shared: Record<string, unknown> = {}
+
+    await mw.modifyInput!({ aiAgentRunner: new ThisDependentRunner() } as any, {
+      messages: [{ role: 'user', content: 'typed' } as any],
+      instructions: 'sys',
+      shared,
+    })
+
+    assert.equal(SPOKEN_TRANSCRIPT in shared, false)
+  })
 })