@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/schedule/__tests__/worker-control.test.ts

@@ -206,19 +206,26 @@ describe("spawnScheduleWorkerProcess", () => {
     }
   });
 
-  test("reuses an already-running worker without spawning", async () => {
+  test("spawns when the PID file names an unrelated live process", async () => {
     writeFileSync(pidPath, String(process.pid));
     let spawned = false;
     const restore = stubBunSpawn(() => {
       spawned = true;
-      return { unref: () => {}, kill: () => {}, pid: 1, exited: neverExits() };
+      writeFileSync(pidPath, "4242");
+      return {
+        unref: () => {},
+        kill: () => {},
+        pid: 4242,
+        exited: neverExits(),
+      };
     });
     try {
       const result = await spawnScheduleWorkerProcess({
-        pidWaitTimeoutMs: 100,
+        pidWaitTimeoutMs: 1_000,
+        pidPollIntervalMs: 10,
       });
-      expect(result).toEqual({ pid: process.pid, alreadyRunning: true });
-      expect(spawned).toBe(false);
+      expect(result).toEqual({ pid: 4242, alreadyRunning: false });
+      expect(spawned).toBe(true);
     } finally {
       restore();
     }
@@ -240,6 +247,11 @@ describe("probeScheduleWorker", () => {
     }
   });
 
+  test("reports not_running when the PID file names a live process that is not this worker", () => {
+    writeFileSync(pidPath, String(process.pid));
+    expect(probeScheduleWorker()).toEqual({ status: "not_running" });
+  });
+
   test("reports running (not throws) when the process exists but is not signalable (EPERM)", () => {
     writeFileSync(pidPath, "4321");
     const restore = stubProcessKill(new Set(), new Set([4321]));
@@ -256,6 +268,25 @@ describe("stopScheduleWorkerProcess", () => {
     expect(stopScheduleWorkerProcess()).toEqual({ status: "not_running" });
   });
 
+  test("does not signal a recycled PID that is not this worker", () => {
+    writeFileSync(pidPath, String(process.pid));
+    const signalled: Array<[number, string | number | undefined]> = [];
+    const original = process.kill.bind(process);
+    process.kill = ((pid: number, signal?: string | number) => {
+      if ((signal ?? 0) === 0) {
+        return original(pid, signal);
+      }
+      signalled.push([pid, signal]);
+      return true;
+    }) as typeof process.kill;
+    try {
+      expect(stopScheduleWorkerProcess()).toEqual({ status: "not_running" });
+      expect(signalled).toEqual([]);
+    } finally {
+      process.kill = original;
+    }
+  });
+
   test("signals a running worker and reports its prior state", () => {
     writeFileSync(pidPath, "4321");
     const signalled: Array<[number, string | number | undefined]> = [];

package/src/schedule/worker-control.ts

@@ -19,6 +19,8 @@ import {
   type WorkerProcessStatus,
 } from "../util/worker-process.js";
 
+const SCHEDULE_WORKER_ENTRY = new URL("./worker.ts", import.meta.url);
+
 const log = getLogger("schedule-worker-control");
 
 /**
@@ -42,11 +44,15 @@ export function setScheduleWorkerAdministrativelyStopped(value: boolean): void {
 
 /**
  * Inspect the PID file to determine whether the schedule worker process is
- * alive. A stale PID file (pointing at a dead process) is cleaned up and
- * reported as not_running.
+ * alive. A stale PID file (pointing at a dead process, or at a live process
+ * that is not this worker) is cleaned up and reported as not_running.
  */
 export function probeScheduleWorker(): WorkerProcessStatus {
-  return probeWorkerPidFile(getScheduleWorkerPidPath());
+  return probeWorkerPidFile(
+    getScheduleWorkerPidPath(),
+    SCHEDULE_WORKER_ENTRY,
+    "schedule",
+  );
 }
 
 export class ScheduleWorkerSpawnError extends WorkerProcessSpawnError {}
@@ -95,7 +101,7 @@ async function spawnScheduleWorkerProcessUncoalesced(
   try {
     return await spawnWorkerProcess({
       pidPath: getScheduleWorkerPidPath(),
-      entry: new URL("./worker.ts", import.meta.url),
+      entry: SCHEDULE_WORKER_ENTRY,
       packagedEntry: "schedule",
       workerLabel: "Schedule worker",
       options: opts,
@@ -114,7 +120,11 @@ async function spawnScheduleWorkerProcessUncoalesced(
  * `process.kill` itself fails (e.g. EPERM) — a not-running worker is a no-op.
  */
 export function stopScheduleWorkerProcess(): WorkerProcessStatus {
-  return stopWorkerProcess(getScheduleWorkerPidPath());
+  return stopWorkerProcess(
+    getScheduleWorkerPidPath(),
+    SCHEDULE_WORKER_ENTRY,
+    "schedule",
+  );
 }
 
 /**

package/src/security/secure-keys.ts

@@ -1,22 +1,18 @@
 /**
- * Unified secure key storage — single-backend routing through CredentialBackend
+ * Unified secure key storage: single-backend routing through CredentialBackend
  * adapters.
  *
  * Backend selection (`resolveBackendAsync`) is the single async decision point:
- *   1. CES RPC (primary) - injected via `setCesClient()`: delegates credential
- *      operations to the CES process over Unix socket RPC. This is the default
- *      path for the assistant (which calls startCes() at boot) and for
- *      child processes that lazily connect to the CES socket (see below).
- *   2. Lazy CES RPC connect - non-assistant processes (workers, CLI
- *      subprocesses) that never call startCes(). On first credential
- *      resolution they discover the CES bootstrap socket
- *      (`CES_BOOTSTRAP_SOCKET_DIR`) and cache
- *      the connection.
- *   3. CES HTTP - containerized failover when IPC is unavailable
+ *   1. CES RPC (primary) - connect to the CES bootstrap socket and talk RPC.
+ *      `openCesRpcSession` is the one client constructor. The assistant
+ *      claims session ownership at boot (`startCes`) and hands CES the
+ *      assistant API key. Child processes open a session on first credential
+ *      read only when this process has no client and no reconnect owner.
+ *   2. CES HTTP - containerized failover when IPC is unavailable
  *      (`IS_CONTAINERIZED` + `CES_CREDENTIAL_URL`). Used if the assistant's
  *      bootstrap RPC transport is down, or if a process with HTTP env could
  *      not open the socket.
- *   4. Encrypted file store (fallback) - used when CES is unavailable locally.
+ *   3. Encrypted file store (fallback) - used when CES is unavailable locally.
  *
  * All operations (reads, writes, lists, deletes) go to exactly one backend.
  * There are no cross-store fallbacks or merges. The only transport failover is
@@ -35,14 +31,11 @@ import type {
 
 import { getIsContainerized } from "../config/env-registry.js";
 import {
-  type CesClient,
-  createCesClient,
-} from "../credential-execution/client.js";
+  openCesRpcSession,
+  reconnectCesRpcSession,
+} from "../credential-execution/ces-connect.js";
+import { type CesClient } from "../credential-execution/client.js";
 import { discoverCes } from "../credential-execution/executable-discovery.js";
-import {
-  CesUnavailableError,
-  createCesProcessManager,
-} from "../credential-execution/process-manager.js";
 import { getAnyProviderEnvVar } from "../providers/provider-env-vars.js";
 import { getLogger } from "../util/logger.js";
 import { getProtectedDir } from "../util/platform.js";
@@ -85,11 +78,11 @@ let _resolvedBackend: CredentialBackend | undefined;
 let _resolvePromise: Promise<CredentialBackend> | undefined;
 
 /**
- * In-flight lazy CES connection promise for non-daemon processes.
+ * In-flight CES RPC session promise for processes that did not call startCes().
  *
  * Workers and CLI subprocesses never call startCes(). When they hit
  * resolveBackendAsync() with no _cesClient and no _cesReconnect
- * (daemon-only), this promise memoizes a direct CES connection attempt so
+ * (assistant-boot only), this promise memoizes `openCesRpcSession` so
  * concurrent credential reads in the same process share a single
  * connect+handshake rather than racing.
  */
@@ -206,10 +199,9 @@ function getEncryptedStoreBackend(): CredentialBackend {
  * Resolve the primary credential backend for this process (async).
  *
  * Priority:
- *   1. CES RPC client: primary path in every environment.
- *   2. Lazy CES RPC connect: child processes discover the CES socket.
- *   3. Containerized + CES_CREDENTIAL_URL: CES HTTP, only if IPC is down.
- *   4. Encrypted file store: local fallback when CES is unavailable.
+ *   1. CES RPC: live client, or open one via `openCesRpcSession`.
+ *   2. Containerized + CES_CREDENTIAL_URL: CES HTTP, only if IPC is down.
+ *   3. Encrypted file store: local fallback when CES is unavailable.
  *
  * Once resolved, the backend is cached. If it becomes unavailable (e.g. the
  * CES transport dies), we attempt to reconnect via `_cesReconnect` rather
@@ -415,19 +407,19 @@ export async function attemptCesReconnection(
 }
 
 /**
- * Lazily connect to a CES sibling socket from a non-daemon process.
+ * Open a CES RPC session from a process that did not call startCes().
  *
  * Workers and CLI subprocesses never call startCes(). This function
- * establishes a direct CES connection on first credential resolution,
+ * opens the same `openCesRpcSession` path the assistant uses at boot,
  * memoizing the in-flight promise so concurrent callers share a single
  * connect+handshake. Discovery uses the shared CES bootstrap socket; a
  * missing socket fails immediately so callers can fall through without
  * polling.
  *
  * On success, the client is injected via setCesClient() so subsequent
- * resolveBackendAsync() calls take the fast CES RPC path (step 1). A
- * reconnect callback is also registered so the lazy connection can heal
- * if the transport drops mid-process.
+ * resolveBackendAsync() calls take the live CES RPC path. A reconnect
+ * callback is also registered so the session can heal if the transport
+ * drops mid-process.
  *
  * Returns undefined on any failure (socket not found, handshake rejected,
  * timeout) so the caller falls through to the encrypted file store.
@@ -438,70 +430,30 @@ async function tryLazyCesConnect(): Promise<CesClient | undefined> {
   }
 
   _lazyConnectPromise = (async () => {
-    try {
-      const discovery = discoverCes();
-      if (discovery.mode === "unavailable") {
-        log.info(
-          { reason: discovery.reason },
-          "CES socket not reachable for lazy connect, falling back to encrypted file store",
-        );
-        return undefined;
-      }
-      const pm = createCesProcessManager({});
-      const transport = await pm.start();
-      const client = createCesClient(transport);
-      const { accepted, reason } = await client.handshake();
-      if (!accepted) {
-        log.warn(
-          { reason },
-          "Lazy CES connection handshake rejected — falling back to encrypted file store",
-        );
-        client.close();
-        await pm.stop().catch(() => {});
-        return undefined;
-      }
+    const discovery = discoverCes();
+    if (discovery.mode === "unavailable") {
       log.info(
-        "Lazy CES connection established — credential operations routed through CES RPC",
+        { reason: discovery.reason },
+        "CES socket not reachable for lazy connect, falling back to encrypted file store",
       );
-      setCesClient(client);
-      // Register a reconnect callback so the lazy connection self-heals
-      // if the transport drops, mirroring the daemon's proactive reconnect.
-      setCesReconnect(async () => {
-        try {
-          await pm.stop();
-          const newTransport = await pm.start();
-          const newClient = createCesClient(newTransport);
-          const { accepted: ok } = await newClient.handshake();
-          if (ok) {
-            log.info("Lazy CES reconnection successful");
-            return newClient;
-          }
-          newClient.close();
-          await pm.stop().catch(() => {});
-          return undefined;
-        } catch (err) {
-          log.warn(
-            { error: err instanceof Error ? err.message : String(err) },
-            "Lazy CES reconnection failed",
-          );
-          return undefined;
-        }
-      });
-      return client;
-    } catch (err) {
-      if (err instanceof CesUnavailableError) {
-        log.info(
-          { reason: err.message },
-          "CES socket not reachable for lazy connect — falling back to encrypted file store",
-        );
-      } else {
-        log.warn(
-          { error: err instanceof Error ? err.message : String(err) },
-          "Lazy CES connection failed — falling back to encrypted file store",
-        );
-      }
       return undefined;
     }
+    const session = await openCesRpcSession();
+    if (!session) {
+      return undefined;
+    }
+    log.info(
+      "CES RPC session established; credential operations route through CES RPC",
+    );
+    setCesClient(session.client);
+    setCesReconnect(async () => {
+      const client = await reconnectCesRpcSession(session.processManager);
+      if (client) {
+        log.info("CES RPC reconnection successful");
+      }
+      return client;
+    });
+    return session.client;
   })();
 
   try {
@@ -512,7 +464,10 @@ async function tryLazyCesConnect(): Promise<CesClient | undefined> {
 }
 
 async function doResolveBackend(): Promise<CredentialBackend> {
-  // 1. CES RPC. Primary credential backend in every environment.
+  // 1. CES RPC. Primary credential backend in every environment. Boot
+  //    claims reconnect ownership before it reads handshake identity, so
+  //    that read cannot open a second session. Children open here only
+  //    when this process has no client and no reconnect owner.
   if (_cesClient) {
     const cesRpc = new CesRpcCredentialBackend(_cesClient);
     if (cesRpc.isAvailable()) {
@@ -525,24 +480,19 @@ async function doResolveBackend(): Promise<CredentialBackend> {
     );
   }
 
-  // 2. Lazy CES RPC connect. Child processes never call startCes(). When
-  //    the assistant's setCesReconnect() is NOT registered, attempt a
-  //    direct connection to the CES bootstrap socket. On success, inject
-  //    the client via setCesClient()
-  //    and re-resolve through the CES RPC path. On failure, fall through.
   if (!_cesClient && !_cesReconnect) {
-    const lazyClient = await tryLazyCesConnect();
-    if (lazyClient) {
-      const cesRpc = new CesRpcCredentialBackend(lazyClient);
+    const client = await tryLazyCesConnect();
+    if (client) {
+      const cesRpc = new CesRpcCredentialBackend(client);
       if (cesRpc.isAvailable()) {
         _resolvedBackend = cesRpc;
-        log.info("Resolved credential backend: ces-rpc (lazy connect)");
+        log.info("Resolved credential backend: ces-rpc");
         return cesRpc;
       }
     }
   }
 
-  // 3. CES HTTP. Managed failover when IPC is unavailable.
+  // 2. CES HTTP. Managed failover when IPC is unavailable.
   if (getIsContainerized() && process.env.CES_CREDENTIAL_URL) {
     const ces = createCesCredentialBackend();
     if (ces.isAvailable()) {
@@ -556,7 +506,7 @@ async function doResolveBackend(): Promise<CredentialBackend> {
     );
   }
 
-  // 4. On a containerized pod the local encrypted store does not exist and CES
+  // 3. On a containerized pod the local encrypted store does not exist and CES
   //    owns credentials. Never resolve to the encrypted store here; it would
   //    report a provisioned credential as absent. Return an unreachable backend
   //    (presence indeterminate, which callers retry) WITHOUT caching it, so the
@@ -568,7 +518,7 @@ async function doResolveBackend(): Promise<CredentialBackend> {
     return createUnavailableBackend();
   }
 
-  // 5. Encrypted file store: the legitimate backend for local / self-hosted
+  // 4. Encrypted file store: the legitimate backend for local / self-hosted
   //    mode when CES is unavailable.
   _resolvedBackend = getEncryptedStoreBackend();
   log.info("Resolved credential backend: encrypted-store (local mode)");

package/src/skills/clawhub.ts

@@ -11,11 +11,6 @@ import {
 
 const log = getLogger("clawhub");
 
-// Managed skills directory — where installed skill folders live
-function getManagedSkillsDir(): string {
-  return getWorkspaceSkillsDir();
-}
-
 // ClaWHub project root — clawhub creates a `skills/` subdir inside its cwd,
 // so we use the parent of the managed skills dir as the project root.
 function getClawhubProjectRoot(): string {
@@ -39,7 +34,7 @@ interface IntegrityRecord {
 type IntegrityManifest = Record<string, IntegrityRecord>;
 
 function getIntegrityPath(): string {
-  return join(getManagedSkillsDir(), ".integrity.json");
+  return join(getWorkspaceSkillsDir(), ".integrity.json");
 }
 
 function loadIntegrityManifest(): IntegrityManifest {
@@ -66,7 +61,7 @@ function loadIntegrityManifest(): IntegrityManifest {
  * from skills that haven't been migrated yet.
  */
 export function verifyAndRecordSkillHash(slug: string): void {
-  const skillDir = join(getManagedSkillsDir(), slug);
+  const skillDir = join(getWorkspaceSkillsDir(), slug);
   const hash = computeSkillHash(skillDir);
   if (!hash) {
     log.warn({ slug }, "Could not compute content hash for installed skill");
@@ -232,7 +227,7 @@ function getSkillNameFromSlug(slug: string): string {
 }
 
 function getClawhubSkillsDir(projectRoot?: string): string {
-  return projectRoot ? join(projectRoot, "skills") : getManagedSkillsDir();
+  return projectRoot ? join(projectRoot, "skills") : getWorkspaceSkillsDir();
 }
 
 function hasRootSkillFile(skillDir: string): boolean {

package/src/skills/managed-store.ts

@@ -44,13 +44,9 @@ export function validateManagedSkillId(id: string): string | null {
 
 // ─── Path helpers ────────────────────────────────────────────────────────────
 
-function getManagedSkillsDir(): string {
-  return getWorkspaceSkillsDir();
-}
-
 /** Absolute path of a managed skill's directory (whether or not it exists). */
 export function getManagedSkillDir(id: string): string {
-  return join(getManagedSkillsDir(), id);
+  return join(getWorkspaceSkillsDir(), id);
 }
 
 interface ResolvedCompanionPath {

package/src/stt/types.ts

@@ -436,6 +436,10 @@ export interface SttStreamServerTurnEndEvent {
    * provider does not surface a score.
    */
   readonly confidence?: number;
+  /** Provider-reported cause of the turn boundary, when available. */
+  readonly trigger?: "model" | "manual" | "timeout";
+  /** End of the decoded audio window, in seconds from stream start. */
+  readonly audioWindowEndSeconds?: number;
   /**
    * Provider's index for the turn being closed, matching the
    * {@link SttStreamServerTurnStartEvent} that opened it. A consumer can

package/src/subagent/notify.ts

@@ -8,16 +8,20 @@
  * manager out of the import graph lets tool modules import these helpers without
  * pulling in the conversation/agent-loop core.
  *
- * Delivery targets the parent's in-process `Conversation` via the conversation
- * registry: a notification is injected only when the parent is live here. A
- * stale idle parent is rebuilt through `getOrCreateConversation` first so the
- * injected turn uses the current provider, prompt, and credentials.
+ * An active live-voice session owns delivery for its conversation. Otherwise,
+ * delivery targets the parent's in-process `Conversation` via the registry.
+ * A stale idle parent is rebuilt through `getOrCreateConversation` first so
+ * the injected turn uses the current provider, prompt, and credentials.
  */
 
+import { getConfig } from "../config/loader.js";
+import { resolveTurnCommitWaitMs } from "../daemon/abort-watchdog.js";
 import {
   findConversation,
   findConversationOrSubagent,
 } from "../daemon/conversation-registry.js";
+import { startAfterTurnFinalization } from "../daemon/turn-finalization.js";
+import { deliverSubagentNotificationToLiveVoice } from "../live-voice/live-voice-manager.js";
 import { getSubagentRecordByConversationId } from "../persistence/subagent-store.js";
 import { getLogger } from "../util/logger.js";
 import { type SubagentStatus, TERMINAL_STATUSES } from "./types.js";
@@ -25,9 +29,9 @@ import { type SubagentStatus, TERMINAL_STATUSES } from "./types.js";
 const log = getLogger("subagent-notify");
 
 /**
- * Enqueue (or persist + run) `message` as a user-role turn in the parent
- * conversation. No-op with a warning when the parent conversation is not live
- * in this process.
+ * Deliver task updates through the parent's live voice session when present,
+ * otherwise enqueue a parent turn. No-op with a warning
+ * when neither the session nor the parent conversation is live here.
  *
  * Shared by the child-triggered {@link notifyParentFromChild} and the
  * manager's terminal/abort injections so every subagent → parent turn lands
@@ -37,8 +41,30 @@ export function injectMessageIntoParent(
   parentConversationId: string,
   message: string,
   metadata?: Record<string, unknown>,
-  opts?: { cronRunId?: string | null },
+  opts?: { cronRunId?: string | null; bypassLiveVoice?: boolean },
 ): void {
+  const notification = metadata?.subagentNotification;
+  // The live child's conversation ID is stable even if its cosmetic record changes.
+  if (
+    !opts?.bypassLiveVoice &&
+    notification !== null &&
+    typeof notification === "object" &&
+    "subagentId" in notification &&
+    typeof notification.subagentId === "string" &&
+    metadata !== undefined &&
+    deliverSubagentNotificationToLiveVoice(parentConversationId, {
+      taskId:
+        "conversationId" in notification &&
+        typeof notification.conversationId === "string"
+          ? notification.conversationId
+          : notification.subagentId,
+      message,
+      metadata,
+      cronRunId: opts?.cronRunId,
+    })
+  ) {
+    return;
+  }
   const existing = findConversation(parentConversationId);
   if (!existing) {
     log.warn(
@@ -76,17 +102,10 @@ function deliverToParent(
       content: string;
       metadata?: Record<string, unknown>;
       isInteractive: boolean;
+      queueWhenIdle: boolean;
       cronRunId?: string | null;
     }) => { queued: boolean; rejected?: boolean };
-    persistUserMessage: (options: {
-      content: string;
-      metadata?: Record<string, unknown>;
-    }) => Promise<{ id: string }>;
-    runAgentLoop: (
-      message: string,
-      messageId: string,
-      options: { isInteractive: boolean; cronRunId?: string | null },
-    ) => Promise<unknown>;
+    kickDrainQueue: (reason: "loop_complete", origin: string) => Promise<void>;
   },
   parentConversationId: string,
   message: string,
@@ -95,33 +114,34 @@ function deliverToParent(
 ): void {
   // The continuation this notification starts is still the scheduled firing's
   // work, so it carries the same run id as the child whose result triggered it.
-  // Both delivery paths need it: the queued one drains after the enqueuing turn
-  // has ended, so the id has to travel on the message.
+  // The queue drains after the enqueuing turn, so the id travels on the message.
   const cronRunId = opts?.cronRunId ?? null;
   // Machine-injected with no human asserted present, so the notification
   // turn runs non-interactive; it still streams to whoever is watching
   // through the parent's sink.
   const enqueueResult = parentConversation.enqueueMessage({
     content: message,
-    metadata,
+    metadata: { ...metadata, scripted: true },
     isInteractive: false,
+    queueWhenIdle: true,
     ...(cronRunId ? { cronRunId } : {}),
   });
-  if (!enqueueResult.queued && !enqueueResult.rejected) {
-    parentConversation
-      .persistUserMessage({ content: message, metadata })
-      .then(({ id: messageId }) =>
-        parentConversation.runAgentLoop(message, messageId, {
-          isInteractive: false,
-          ...(cronRunId ? { cronRunId } : {}),
-        }),
-      )
-      .catch((err) => {
-        log.error(
-          { parentConversationId, err },
-          "Failed to process subagent notification in parent",
+  if (enqueueResult.queued) {
+    startAfterTurnFinalization(
+      parentConversationId,
+      resolveTurnCommitWaitMs(getConfig().workspaceGit?.turnCommitMaxWaitMs),
+      () => {
+        void parentConversation.kickDrainQueue(
+          "loop_complete",
+          "subagent_notification",
         );
-      });
+      },
+    );
+  } else {
+    log.error(
+      { parentConversationId },
+      "Parent queue rejected subagent notification",
+    );
   }
 }
 

package/src/subagent/parent-notification.ts

@@ -0,0 +1,6 @@
+export interface SubagentParentNotification {
+  taskId: string;
+  message: string;
+  metadata: Record<string, unknown>;
+  cronRunId?: string | null;
+}

package/src/telemetry/__tests__/phone-call-funnel.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  PHONE_CALL_STEPS,
+  phoneCallEndScreen,
+  phoneCallSilenceReason,
+  phoneCallStartScreen,
+} from "../phone-call-funnel.js";
+
+describe("phoneCallStartScreen", () => {
+  it("stamps the direction and the call mode", () => {
+    expect(phoneCallStartScreen("inbound", "normal")).toBe(
+      "started_inbound:normal",
+    );
+    expect(phoneCallStartScreen("outbound", "verification")).toBe(
+      "started_outbound:verification",
+    );
+  });
+
+  it("reads an unwritten mode as the ordinary call it is", () => {
+    // Only verification and invite calls write a mode, so a null there is a
+    // normal conversation rather than a dimension nobody filled in.
+    expect(phoneCallStartScreen("inbound", null)).toBe(
+      "started_inbound:normal",
+    );
+    expect(phoneCallStartScreen("inbound")).toBe("started_inbound:normal");
+  });
+
+  it("keeps the longest stamp inside the wire field's 64-char bound", () => {
+    const longest = phoneCallStartScreen("outbound", "verification");
+    expect(longest.length).toBeLessThanOrEqual(64);
+  });
+});
+
+describe("phoneCallSilenceReason", () => {
+  it("blames the connection when the call never reached the caller", () => {
+    // Nothing that happens on a live call can be held against one that never
+    // connected: nobody was there to speak.
+    expect(phoneCallSilenceReason({ connected: false })).toBe("no_connect");
+  });
+
+  it("reports a connected call that took no turn as silence on the line", () => {
+    expect(phoneCallSilenceReason({ connected: true })).toBe("no_turn");
+  });
+});
+
+describe("phoneCallEndScreen", () => {
+  it("stamps the terminal status on a call that took a turn", () => {
+    expect(phoneCallEndScreen("completed")).toBe("ended_completed");
+    expect(phoneCallEndScreen("failed", null)).toBe("ended_failed");
+  });
+
+  it("carries the silence classification when no turn was taken", () => {
+    expect(phoneCallEndScreen("failed", "no_connect")).toBe(
+      "ended_failed:silent_no_connect",
+    );
+    expect(phoneCallEndScreen("completed", "no_turn")).toBe(
+      "ended_completed:silent_no_turn",
+    );
+  });
+});
+
+describe("PHONE_CALL_STEPS", () => {
+  it("orders the pair the warehouse subtracts", () => {
+    // Duration is the gap between these two rows, so their order is part of
+    // the contract rather than a label.
+    expect(PHONE_CALL_STEPS.callStarted.stepIndex).toBe(0);
+    expect(PHONE_CALL_STEPS.callEnded.stepIndex).toBe(1);
+    expect(PHONE_CALL_STEPS.callStarted.stepName).toBe("phone_call_started");
+    expect(PHONE_CALL_STEPS.callEnded.stepName).toBe("phone_call_ended");
+  });
+});