@company-semantics/contracts 81.0.0 → 83.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@company-semantics/contracts",
-  "version": "81.0.0",
+  "version": "83.0.0",
   "private": false,
   "repository": {
     "type": "git",

package/src/api/generated-spec-hash.ts

@@ -1,3 +1,3 @@
 // AUTO-GENERATED — do not edit. Run pnpm generate:spec-hash to regenerate.
-export const SPEC_HASH = '7e0656a03459' as const;
-export const SPEC_HASH_FULL = '7e0656a03459e90e26051fe9aea403e95f0de11fea465f6a0f00ae5caf8b0aa7' as const;
+export const SPEC_HASH = '9286d0cf0c7c' as const;
+export const SPEC_HASH_FULL = '9286d0cf0c7c1457a11e830402e9e860ee80e5b0b263b79d4ec15308d7ecb271' as const;

package/src/api/generated.ts

@@ -4889,6 +4889,21 @@ export interface components {
                     /** Format: date-time */
                     addedAt: string;
                 }[];
+                continuity: {
+                    subjectId: string;
+                    /** @enum {string} */
+                    subjectKind: "source-sync-candidate-review" | "source-sync-synthesis-review" | "org-structure-review";
+                    subjectTitle: string;
+                    generation: number;
+                    isActiveGeneration: boolean;
+                    activeChatId: string | null;
+                    continuationOf: {
+                        chatId: string;
+                        /** Format: date-time */
+                        createdAt: string;
+                    } | null;
+                    continuationReason: "user-started-fresh" | null;
+                } | null;
             };
             messages: {
                 id: string;
@@ -7614,9 +7629,13 @@ export interface components {
                     href: string | null;
                     createdAt: string;
                     readAt: string | null;
+                    activityAt: string;
+                    occurrenceCount: number;
+                    resolvedAt: string | null;
                 };
             })[];
             nextCursor: string | null;
+            viewCount: number;
             unreadCount: number;
             truncated: boolean;
         };

package/src/chat/README.md

@@ -38,24 +38,44 @@ Shared types for chat persistence, sharing, real-time events, and runtime profil
 - The summary carries a participant COUNT, never the roster. A 50-row sidebar page must not carry 50 rosters, and a chat's membership is not disclosed by the chat merely appearing in a list. `ChatDetail.participants` is where the names are, and it is optional — a missing roster is simply not drawn, whereas a guessed role is drawn wrong
 - A `ChatParticipant` is a USER, never a `PrincipalRef` — the deliberate asymmetry with a mention TARGET, which is a ref precisely so the agent can be named. The agent takes part in every chat by construction and has no participant row: it is mentionable, not a member, and cannot be added, removed or left
 - `ChatParticipantRole` has EXACTLY two members. A third would be an access band, and this is participation rather than an ACL: a participant sees the whole conversation, `owner` names the one person who additionally deletes, renames, pins and shares it, and a chat you can read half of is not a thing this surface models
-- The chat schemas are THREE files with a one-way load order: `enums.ts` (the closed vocabularies plus the `proactiveChatFields` / `multiPartyChatFields` groups) imports nothing from the domain, `event-schemas.ts` imports only from it, and `schemas.ts` imports from both and RE-EXPORTS them so `index.ts`, `types.ts` and the tests keep one import site. An import from either of the first two back into `schemas.ts` is a load cycle: the re-export edge is evaluated before `schemas.ts`'s body, so the shared declarations are reached in the temporal dead zone and every consumer throws a `ReferenceError` at import time
+- The chat schemas are THREE files with a one-way load order: `enums.ts` (the closed vocabularies plus the `proactiveChatFields` / `multiPartyChatFields` groups) imports nothing from the domain, `event-schemas.ts` imports only from it, and `schemas.ts` imports from both and RE-EXPORTS them so `index.ts`, `types.ts` and the tests keep one import site. An import from either of the first two back into `schemas.ts` is a load cycle: the re-export edge is evaluated before `schemas.ts`'s body, so the shared declarations are reached in the temporal dead zone and every consumer throws a `ReferenceError` at import time. `continuity.ts` sits outside that set on the same terms: `schemas.ts` imports it, it never imports `schemas.ts`, and `index.ts` re-exports it directly (its types are declared beside its schemas, as `runtime-profile.ts` does)
 - `CHAT_PAGE_VIEWS` and `CHAT_PAGE_SCOPES` are a projection of the app's `Route` union (`company-semantics-app/src/platform/route-parser.ts`), not a parallel vocabulary. A view the parser can emit but the schema rejects fails the send outright rather than degrading
 
+## Continuity
+
+A chat can belong to a SUBJECT — the durable case a hand-off to chat is about — and a subject is worked in numbered GENERATIONS, each a chat linked back to its predecessor (`src/chat/continuity.ts`, ADR slug `chat-continuity-wire-vocabulary`).
+
+- `ChatDetail.continuity` is REQUIRED and NULLABLE: null means the chat belongs to no subject; a missing key is a backend that has not adopted the release
+- Three identities, never conflated: `subjectId` (the case), `generation` (1-based position in the lineage), and the chat id carrying it. `activeChatId` is where the case continues now — this chat's own id when it is active, null when the subject has no active generation
+- `continuationOf` and `continuationReason` are null together: generation 1, a generation started after its predecessor was deleted, and a predecessor row that no longer exists all send null, never a dangling link
+- Compaction NEVER changes subject or generation identity. Compacting a chat (`compactedThroughSequence`) summarizes the older turns of the SAME chat — it keeps the same `subjectId`, the same `generation` and the same chat id, and it is not a continuation. A new generation starts only through a `continuationReason`, and compaction is deliberately not one
+- `CONVERSATION_SUBJECT_KINDS` and `CHAT_CONTINUATION_REASONS` are CLOSED. A reason is added only when a real trigger exists; the launch-kind → subject-kind mapping and subject titles are server policy and do not live here
+- Launch resolution is READ-ONLY and never creates a chat. `LAUNCH_DISPOSITIONS` is CLOSED; `created-and-launch` carries a null `chatId` AND a null `generation` (its `subjectId` is still reported when the subject row exists), and both `resume-*` dispositions carry `subjectId`, `chatId` and `generation`. `ResolveLaunchResponseSchema` refuses every other combination
+- `StartFreshChatResponse` is the NEW active generation and always links its predecessor (`continuationOf.chatId`)
+- A launch posted into a chat that is not — or can no longer become — the subject's active generation is a 409 whose body is `LaunchTargetSuperseded` (`code: "launch_target_superseded"`); its `activeChatId` names where to go, and null means start a new chat
+- Request bodies for resolve-launch and start-fresh are deliberately NOT here: the resolve body embeds the backend-local launch schema, and start-fresh has no body
+
 <!-- BEGIN GENERATED: readme-public-api — derived from code by `pnpm readme-api`. Do not edit. -->
 
 ## Public API
 
 - `BaseEvent` _(type)_ — Base envelope for all SSE events.
 - `BaseEventSchema`
+- `CHAT_CONTINUATION_REASONS` — Why a generation continues its predecessor.
 - `CHAT_DISCUSSION_REQUEST_TYPES` — The kinds of durable input request a turn can be scoped to.
 - `CHAT_PAGE_ENTITY_TYPES` — What kind of thing the reader has open, when they have one open.
 - `CHAT_PAGE_SCOPES` — The route parser's four URL scopes: unscoped, `/me/*`, `/team/*`, `/@:org/*`.
 - `CHAT_PAGE_VIEWS` — The app route parser's seventeen `type` values, projected onto the wire.
 - `CHAT_RUNTIME_PROFILES` — Ordered list of available profiles for UI rendering.
+- `CONVERSATION_SUBJECT_KINDS` — The kinds of subject a chat can continue.
 - `ChatByInteractionResponse` _(type)_ — Response for GET /api/chats/by-interaction/:interactionId
 - `ChatByInteractionResponseSchema` — Response for GET /api/chats/by-interaction/:interactionId
 - `ChatChangedField` _(type)_ — Fields that can change on a chat, used in changed array.
 - `ChatChangedFieldSchema`
+- `ChatContinuationReason` _(type)_
+- `ChatContinuationReasonSchema`
+- `ChatContinuity` _(type)_
+- `ChatContinuitySchema` — Where a chat sits in its subject's lineage — carried on the chat detail.
 - `ChatCreatedEvent` _(type)_ — Emitted exactly once after a chat is successfully persisted.
 - `ChatCreatedEventSchema` — Emitted exactly once after a chat is persisted; a pushed proactive chat is announced over this event too.
 - `ChatDeletedEvent` _(type)_ — Emitted when a chat is deleted.
@@ -103,6 +123,8 @@ Shared types for chat persistence, sharing, real-time events, and runtime profil
 - `ChatUpdatedEventSchema`
 - `ChatVisibility` _(type)_ — Chat share visibility. - private: Token exists but access requires authentication as chat owner - public…
 - `ChatVisibilitySchema`
+- `ConversationSubjectKind` _(type)_
+- `ConversationSubjectKindSchema`
 - `CreateChatResponse` _(type)_ — Response for POST /api/chats
 - `CreateChatResponseSchema` — Response for POST /api/chats
 - `CreateShareRequest` _(type)_ — Request to create a new share for a chat.
@@ -117,15 +139,25 @@ Shared types for chat persistence, sharing, real-time events, and runtime profil
 - `InvalidateChatListEventSchema`
 - `InvalidationReason` _(type)_ — Reason for cache invalidation.
 - `InvalidationReasonSchema`
+- `LAUNCH_DISPOSITIONS` — What the read-only launch resolution found for a hand-off.
+- `LAUNCH_TARGET_SUPERSEDED_CODE` — The 409 code for a launch posted into a chat that is not the subject's active generation.
+- `LaunchDisposition` _(type)_
+- `LaunchDispositionSchema`
+- `LaunchTargetSuperseded` _(type)_
+- `LaunchTargetSupersededSchema` — The 409 body the authoritative launch write returns when the posted chat is not — or can no longer become —…
 - `ListSharesResponse` _(type)_ — Response for GET /api/chats/:chatId/shares
 - `ListSharesResponseSchema` — Response for GET /api/chats/:chatId/shares
 - `ProactiveChatResolution` _(type)_ — Resolving an occurrence id to the CURRENT reader's chat — one of the four bounded states `ready` (with…
 - `ProactiveChatResolutionSchema` — Resolving an occurrence id to THIS reader's chat (INV-PROACTIVE-LINK).
 - `RecognizedProactiveKind` _(type)_ — A wire `proactiveKind` after recognition: a kind this contracts version knows, or the raw string it did not —…
+- `ResolveLaunchResponse` _(type)_
+- `ResolveLaunchResponseSchema` — Response of the read-only launch resolution.
 - `SharedChatMessage` _(type)_ — Individual message in a shared chat view.
 - `SharedChatMessageSchema`
 - `SharedChatView` _(type)_ — Shared chat view returned to viewers.
 - `SharedChatViewSchema`
+- `StartFreshChatResponse` _(type)_
+- `StartFreshChatResponseSchema` — Response of the start-fresh write: the NEW active generation of the subject, linked back to the chat it…
 - `TitleGenerationRequest` _(type)_ — Request to generate a title for a chat.
 - `TitleGenerationResponse` _(type)_ — Response from title generation.
 - `TitleGenerationResponseSchema`

package/src/chat/__tests__/compaction-boundary.test.ts

@@ -34,6 +34,7 @@ const BASE_DETAIL = {
   interactionId: "int_1",
   createdAt: "2026-08-31T00:00:00.000Z",
   updatedAt: "2026-08-31T01:00:00.000Z",
+  continuity: null,
 };
 
 describe("ChatDetail compaction boundary", () => {

package/src/chat/__tests__/continuity.test.ts

@@ -0,0 +1,402 @@
+/**
+ * Chat continuity wire vocabulary (chat-continuity-wire-vocabulary).
+ *
+ * INVARIANTS TESTED:
+ * - The subject-kind and continuation-reason vocabularies are CLOSED and
+ *   pinned member-for-member; the only continuation reason is
+ *   `user-started-fresh`.
+ * - `generation` is a positive integer — generation 1 is the first.
+ * - `continuationOf` and `continuationReason` are null TOGETHER: a reason
+ *   without a predecessor, or a predecessor without a reason, is refused.
+ * - `activeChatId` is nullable (the subject has no active generation).
+ * - `ChatDetail.continuity` is REQUIRED and NULLABLE: null parses (a chat
+ *   with no subject), a missing key does not.
+ * - The launch dispositions are CLOSED. `created-and-launch` carries a null
+ *   chatId AND generation (resolve never creates a chat); both `resume-*`
+ *   dispositions carry subjectId, chatId and generation — the refinement
+ *   rejects either direction of violation.
+ * - The start-fresh response always links its predecessor; the 409 body's
+ *   code is the literal `launch_target_superseded`, activeChatId nullable.
+ * - Every export is reachable from both the chat barrel and the root barrel.
+ */
+import { describe, expect, it } from "vitest";
+import * as root from "../../index";
+import {
+  CHAT_CONTINUATION_REASONS,
+  ChatContinuationReasonSchema,
+  ChatContinuitySchema,
+  CONVERSATION_SUBJECT_KINDS,
+  ConversationSubjectKindSchema,
+  LAUNCH_DISPOSITIONS,
+  LAUNCH_TARGET_SUPERSEDED_CODE,
+  LaunchDispositionSchema,
+  LaunchTargetSupersededSchema,
+  ResolveLaunchResponseSchema,
+  StartFreshChatResponseSchema,
+} from "../continuity";
+import * as chat from "../index";
+import { ChatDetailSchema, GetChatResponseSchema } from "../schemas";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+/** Generation 1 of a subject, and the active one. */
+const FIRST_GENERATION = {
+  subjectId: "subj_1",
+  subjectKind: "source-sync-candidate-review",
+  subjectTitle: "Review candidate files",
+  generation: 1,
+  isActiveGeneration: true,
+  activeChatId: "chat_1",
+  continuationOf: null,
+  continuationReason: null,
+} as const;
+
+/** Generation 2, continuing chat_1 because the reader started fresh. */
+const SECOND_GENERATION = {
+  ...FIRST_GENERATION,
+  generation: 2,
+  activeChatId: "chat_2",
+  continuationOf: { chatId: "chat_1", createdAt: "2026-09-01T00:00:00.000Z" },
+  continuationReason: "user-started-fresh",
+} as const;
+
+/** A chat detail with every REQUIRED field except `continuity`. */
+const BASE_DETAIL = {
+  id: "chat_1",
+  title: "Candidate review",
+  interactionId: "int_1",
+  createdAt: "2026-09-01T00:00:00.000Z",
+  updatedAt: "2026-09-01T01:00:00.000Z",
+};
+
+describe("continuity vocabularies", () => {
+  it("pins the closed subject kinds", () => {
+    expect([...CONVERSATION_SUBJECT_KINDS]).toEqual([
+      "source-sync-candidate-review",
+      "source-sync-synthesis-review",
+      "org-structure-review",
+    ]);
+    expect(new Set(CONVERSATION_SUBJECT_KINDS).size).toBe(
+      CONVERSATION_SUBJECT_KINDS.length,
+    );
+    expect(ConversationSubjectKindSchema.safeParse("chat").success).toBe(false);
+  });
+
+  it("has exactly one continuation reason: user-started-fresh", () => {
+    expect([...CHAT_CONTINUATION_REASONS]).toEqual(["user-started-fresh"]);
+    expect(ChatContinuationReasonSchema.safeParse("inactivity").success).toBe(
+      false,
+    );
+    expect(
+      ChatContinuationReasonSchema.safeParse("semantic-divergence").success,
+    ).toBe(false);
+  });
+});
+
+describe("ChatContinuitySchema", () => {
+  it("a first generation has no continuation", () => {
+    const parsed = ChatContinuitySchema.parse(FIRST_GENERATION);
+    expect(parsed).toEqual(FIRST_GENERATION);
+    expect(parsed.generation).toBe(1);
+    expect(parsed.continuationOf).toBeNull();
+    expect(parsed.continuationReason).toBeNull();
+  });
+
+  it("parses a continuing generation with its predecessor and reason", () => {
+    expect(ChatContinuitySchema.parse(SECOND_GENERATION)).toEqual(
+      SECOND_GENERATION,
+    );
+  });
+
+  it("parses a superseded generation pointing at the active chat", () => {
+    const parsed = ChatContinuitySchema.parse({
+      ...FIRST_GENERATION,
+      isActiveGeneration: false,
+      activeChatId: "chat_2",
+    });
+    expect(parsed.activeChatId).toBe("chat_2");
+  });
+
+  it("accepts a null activeChatId when the subject has no active generation", () => {
+    const parsed = ChatContinuitySchema.parse({
+      ...FIRST_GENERATION,
+      isActiveGeneration: false,
+      activeChatId: null,
+    });
+    expect(parsed.activeChatId).toBeNull();
+  });
+
+  it("refuses a reason without a predecessor", () => {
+    expect(
+      ChatContinuitySchema.safeParse({
+        ...FIRST_GENERATION,
+        continuationReason: "user-started-fresh",
+      }).success,
+    ).toBe(false);
+  });
+
+  it("refuses a predecessor without a reason", () => {
+    expect(
+      ChatContinuitySchema.safeParse({
+        ...SECOND_GENERATION,
+        continuationReason: null,
+      }).success,
+    ).toBe(false);
+  });
+
+  it("requires a positive integer generation", () => {
+    for (const generation of [0, -1, 1.5]) {
+      expect(
+        ChatContinuitySchema.safeParse({ ...FIRST_GENERATION, generation })
+          .success,
+      ).toBe(false);
+    }
+  });
+
+  it("requires an ISO timestamp on the predecessor", () => {
+    expect(
+      ChatContinuitySchema.safeParse({
+        ...SECOND_GENERATION,
+        continuationOf: { chatId: "chat_1", createdAt: "yesterday" },
+      }).success,
+    ).toBe(false);
+  });
+
+  it("an unknown subject kind is rejected", () => {
+    expect(
+      ChatContinuitySchema.safeParse({
+        ...FIRST_GENERATION,
+        subjectKind: "org-structure/review",
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe("ChatDetail.continuity", () => {
+  it("is null for a chat that belongs to no subject", () => {
+    const parsed = ChatDetailSchema.parse({ ...BASE_DETAIL, continuity: null });
+    expect(parsed.continuity).toBeNull();
+  });
+
+  it("carries the lineage for a chat that belongs to a subject", () => {
+    const parsed = ChatDetailSchema.parse({
+      ...BASE_DETAIL,
+      continuity: SECOND_GENERATION,
+    });
+    expect(parsed.continuity?.generation).toBe(2);
+  });
+
+  it("a chat detail without continuity fails to parse", () => {
+    expect(ChatDetailSchema.safeParse(BASE_DETAIL).success).toBe(false);
+  });
+
+  it("rides the chat detail in GET /api/chats/:id", () => {
+    const parsed = GetChatResponseSchema.parse({
+      chat: { ...BASE_DETAIL, continuity: FIRST_GENERATION },
+      messages: [],
+    });
+    expect(parsed.chat.continuity?.subjectId).toBe("subj_1");
+  });
+});
+
+describe("barrel exports", () => {
+  it("every continuity value is reachable from both barrels", () => {
+    for (const barrel of [chat, root]) {
+      expect(barrel.CONVERSATION_SUBJECT_KINDS).toBe(
+        CONVERSATION_SUBJECT_KINDS,
+      );
+      expect(barrel.ConversationSubjectKindSchema).toBe(
+        ConversationSubjectKindSchema,
+      );
+      expect(barrel.CHAT_CONTINUATION_REASONS).toBe(CHAT_CONTINUATION_REASONS);
+      expect(barrel.ChatContinuationReasonSchema).toBe(
+        ChatContinuationReasonSchema,
+      );
+      expect(barrel.ChatContinuitySchema).toBe(ChatContinuitySchema);
+      expect(barrel.LAUNCH_DISPOSITIONS).toBe(LAUNCH_DISPOSITIONS);
+      expect(barrel.LaunchDispositionSchema).toBe(LaunchDispositionSchema);
+      expect(barrel.ResolveLaunchResponseSchema).toBe(
+        ResolveLaunchResponseSchema,
+      );
+      expect(barrel.StartFreshChatResponseSchema).toBe(
+        StartFreshChatResponseSchema,
+      );
+      expect(barrel.LAUNCH_TARGET_SUPERSEDED_CODE).toBe(
+        LAUNCH_TARGET_SUPERSEDED_CODE,
+      );
+      expect(barrel.LaunchTargetSupersededSchema).toBe(
+        LaunchTargetSupersededSchema,
+      );
+    }
+  });
+});
+
+describe("launch dispositions", () => {
+  it("pins the closed disposition vocabulary", () => {
+    expect([...LAUNCH_DISPOSITIONS]).toEqual([
+      "resume-existing-anchor",
+      "resume-and-launch",
+      "created-and-launch",
+    ]);
+    expect(new Set(LAUNCH_DISPOSITIONS).size).toBe(LAUNCH_DISPOSITIONS.length);
+    expect(LaunchDispositionSchema.safeParse("created").success).toBe(false);
+  });
+});
+
+describe("ResolveLaunchResponseSchema", () => {
+  const RESUME = {
+    subjectId: "subj_1",
+    chatId: "chat_1",
+    generation: 1,
+  } as const;
+
+  it("parses both resume dispositions with subject, chat and generation", () => {
+    for (const disposition of [
+      "resume-existing-anchor",
+      "resume-and-launch",
+    ] as const) {
+      expect(
+        ResolveLaunchResponseSchema.parse({ ...RESUME, disposition }),
+      ).toEqual({ ...RESUME, disposition });
+    }
+  });
+
+  it("parses created-and-launch with no chat and no generation", () => {
+    const parsed = ResolveLaunchResponseSchema.parse({
+      subjectId: null,
+      chatId: null,
+      generation: null,
+      disposition: "created-and-launch",
+    });
+    expect(parsed.chatId).toBeNull();
+  });
+
+  it("created-and-launch still reports an existing subject with no active generation", () => {
+    const parsed = ResolveLaunchResponseSchema.parse({
+      subjectId: "subj_1",
+      chatId: null,
+      generation: null,
+      disposition: "created-and-launch",
+    });
+    expect(parsed.subjectId).toBe("subj_1");
+  });
+
+  // Resolve never creates a chat, so a created-and-launch cannot name one.
+  it("created-and-launch with a chat id is rejected", () => {
+    expect(
+      ResolveLaunchResponseSchema.safeParse({
+        subjectId: "subj_1",
+        chatId: "chat_1",
+        generation: null,
+        disposition: "created-and-launch",
+      }).success,
+    ).toBe(false);
+  });
+
+  it("rejects created-and-launch carrying a generation", () => {
+    expect(
+      ResolveLaunchResponseSchema.safeParse({
+        subjectId: "subj_1",
+        chatId: null,
+        generation: 1,
+        disposition: "created-and-launch",
+      }).success,
+    ).toBe(false);
+  });
+
+  it("resume-and-launch without a chat id is rejected", () => {
+    const result = ResolveLaunchResponseSchema.safeParse({
+      ...RESUME,
+      chatId: null,
+      disposition: "resume-and-launch",
+    });
+    expect(result.success).toBe(false);
+    expect(result.error?.issues[0]?.path).toEqual(["chatId"]);
+  });
+
+  it("rejects a resume disposition missing chatId, subjectId or generation", () => {
+    for (const disposition of [
+      "resume-existing-anchor",
+      "resume-and-launch",
+    ] as const) {
+      for (const field of ["chatId", "subjectId", "generation"] as const) {
+        const result = ResolveLaunchResponseSchema.safeParse({
+          ...RESUME,
+          disposition,
+          [field]: null,
+        });
+        expect(result.success).toBe(false);
+        expect(result.error?.issues[0]?.path).toEqual([field]);
+      }
+    }
+  });
+
+  it("requires a positive integer generation", () => {
+    expect(
+      ResolveLaunchResponseSchema.safeParse({
+        ...RESUME,
+        generation: 0,
+        disposition: "resume-and-launch",
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe("StartFreshChatResponseSchema", () => {
+  const FRESH = {
+    chatId: "chat_2",
+    interactionId: "int_2",
+    subjectId: "subj_1",
+    generation: 2,
+    continuationOf: { chatId: "chat_1" },
+  };
+
+  it("parses the new active generation linked to its predecessor", () => {
+    expect(StartFreshChatResponseSchema.parse(FRESH)).toEqual(FRESH);
+  });
+
+  it("requires the predecessor link", () => {
+    expect(
+      StartFreshChatResponseSchema.safeParse({ ...FRESH, continuationOf: null })
+        .success,
+    ).toBe(false);
+  });
+
+  it("requires a positive integer generation", () => {
+    expect(
+      StartFreshChatResponseSchema.safeParse({ ...FRESH, generation: 0 })
+        .success,
+    ).toBe(false);
+  });
+});
+
+describe("LaunchTargetSupersededSchema", () => {
+  it("pins the 409 code", () => {
+    expect(LAUNCH_TARGET_SUPERSEDED_CODE).toBe("launch_target_superseded");
+  });
+
+  it("a superseded target names the active chat", () => {
+    const body = { code: "launch_target_superseded", activeChatId: "chat_2" };
+    expect(LaunchTargetSupersededSchema.parse(body)).toEqual(body);
+  });
+
+  it("a null activeChatId means start a new chat", () => {
+    expect(
+      LaunchTargetSupersededSchema.parse({
+        code: LAUNCH_TARGET_SUPERSEDED_CODE,
+        activeChatId: null,
+      }).activeChatId,
+    ).toBeNull();
+  });
+
+  it("rejects any other code", () => {
+    expect(
+      LaunchTargetSupersededSchema.safeParse({
+        code: "conflict",
+        activeChatId: null,
+      }).success,
+    ).toBe(false);
+  });
+});

package/src/chat/__tests__/message-mentions.test.ts

@@ -95,6 +95,7 @@ describe("ChatMessageSchema mentions", () => {
         interactionId: "int_1",
         createdAt: "2026-09-02T00:00:00.000Z",
         updatedAt: "2026-09-02T01:00:00.000Z",
+        continuity: null,
       },
       messages: [makeMessage({ mentions: [makeMention()] })],
     });

package/src/chat/__tests__/multi-party.test.ts

@@ -124,6 +124,7 @@ const BASE_DETAIL = {
   interactionId: "int_1",
   createdAt: ISO,
   updatedAt: ISO,
+  continuity: null,
 };
 
 describe("ChatMessageSchema author", () => {