@namzu/sdk 0.2.0 → 0.3.0

package/src/session/handoff/__tests__/single.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { ThreadManager } from '../../../manager/thread/lifecycle.js'
 import { TenantIsolationError } from '../../../session/errors.js'
 import type { ActorRef } from '../../../session/hierarchy/actor.js'
 import {
@@ -8,6 +9,7 @@ import {
 } from '../../../session/workspace/git-worktree.js'
 import { WorkspaceBackendRegistry } from '../../../session/workspace/registry.js'
 import { InMemorySessionStore } from '../../../store/session/memory.js'
+import { InMemoryThreadStore } from '../../../store/thread/memory.js'
 import type { AgentId, SessionId, TenantId, UserId } from '../../../types/ids/index.js'
 import { generateHandoffId } from '../../../utils/id.js'
 import type { HandoffAssignment } from '../assignment.js'
@@ -59,6 +61,7 @@ interface MockedHandoffEventSink extends HandoffEventSink {
 
 function buildDeps(
 	store: InMemorySessionStore,
+	threadStore: InMemoryThreadStore,
 	execOverride?: ExecFile,
 	runResolver?: RunStatusResolver,
 ): { deps: SingleHandoffDeps; events: MockedHandoffEventSink; execCalls: string[] } {
@@ -84,29 +87,36 @@ function buildDeps(
 		onBroadcastRollback: vi.fn<(ev: HandoffBroadcastRollbackEvent) => void>(),
 	}
 
+	const threadManager = new ThreadManager({ threadStore, sessionStore: store })
 	const deps: SingleHandoffDeps = {
 		store,
 		workspaceRegistry: registry,
 		capacity: new DefaultCapacityValidator(store),
 		events,
+		threadManager,
 		...(runResolver !== undefined && { runStatus: runResolver }),
 	}
 
 	return { deps, events, execCalls }
 }
 
-async function seedIdle(store: InMemorySessionStore) {
+async function seedIdle(store: InMemorySessionStore, threadStore: InMemoryThreadStore) {
 	const project = await store.createProject({ tenantId: tenant, name: 'p' }, tenant)
+	const thread = await threadStore.createThread(
+		{ projectId: project.id, title: 'handoff-single-test' },
+		tenant,
+	)
 	const session = await store.createSession(
-		{ projectId: project.id, currentActor: user('usr_source') },
+		{ threadId: thread.id, projectId: project.id, currentActor: user('usr_source') },
 		tenant,
 	)
-	return { project, session }
+	return { project, thread, session }
 }
 
 function buildAssignment(
 	sourceSessionId: SessionId,
 	projectId: Awaited<ReturnType<InMemorySessionStore['createProject']>>['id'],
+	threadId: Awaited<ReturnType<InMemoryThreadStore['createThread']>>['id'],
 	expectedOwnerVersion: number,
 	recipient: ActorRef = user('usr_target'),
 ): HandoffAssignment {
@@ -115,6 +125,7 @@ function buildAssignment(
 		mode: 'single',
 		sourceSessionId,
 		tenantId: tenant,
+		threadId,
 		projectId,
 		sourceActor: user('usr_source'),
 		recipientActor: recipient,
@@ -125,16 +136,18 @@ function buildAssignment(
 
 describe('executeSingleHandoff', () => {
 	let store: InMemorySessionStore
+	let threadStore: InMemoryThreadStore
 
 	beforeEach(() => {
 		store = new InMemorySessionStore()
+		threadStore = new InMemoryThreadStore()
 	})
 
 	it('happy path: idle source → lock → commit → outcome populated + source mutated', async () => {
-		const { project, session } = await seedIdle(store)
-		const { deps, events } = buildDeps(store)
+		const { project, thread, session } = await seedIdle(store, threadStore)
+		const { deps, events } = buildDeps(store, threadStore)
 
-		const assignment = buildAssignment(session.id, project.id, 0)
+		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
 		const outcome = await executeSingleHandoff(deps, assignment, tenant)
 
 		expect(outcome.assignmentId).toBe(assignment.id)
@@ -155,11 +168,11 @@ describe('executeSingleHandoff', () => {
 	})
 
 	it('rejects when source session is non-idle (active → HandoffLockRejected with active_run)', async () => {
-		const { project, session } = await seedIdle(store)
+		const { project, thread, session } = await seedIdle(store, threadStore)
 		await store.updateSession({ ...session, status: 'active' }, tenant)
 
-		const { deps } = buildDeps(store)
-		const assignment = buildAssignment(session.id, project.id, 0)
+		const { deps } = buildDeps(store, threadStore)
+		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
 
 		try {
 			await executeSingleHandoff(deps, assignment, tenant)
@@ -171,14 +184,14 @@ describe('executeSingleHandoff', () => {
 	})
 
 	it('rejects when Run resolver reports pending_hitl', async () => {
-		const { project, session } = await seedIdle(store)
+		const { project, thread, session } = await seedIdle(store, threadStore)
 		const resolver: RunStatusResolver = {
 			async blockingRun() {
 				return { reason: 'pending_hitl' }
 			},
 		}
-		const { deps } = buildDeps(store, undefined, resolver)
-		const assignment = buildAssignment(session.id, project.id, 0)
+		const { deps } = buildDeps(store, threadStore, undefined, resolver)
+		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
 
 		try {
 			await executeSingleHandoff(deps, assignment, tenant)
@@ -190,11 +203,11 @@ describe('executeSingleHandoff', () => {
 	})
 
 	it('rejects on tenant mismatch (TenantIsolationError)', async () => {
-		const { project, session } = await seedIdle(store)
-		const { deps } = buildDeps(store)
+		const { project, thread, session } = await seedIdle(store, threadStore)
+		const { deps } = buildDeps(store, threadStore)
 		// Assignment tenant differs from the call-site tenant.
 		const assignment: HandoffAssignment = {
-			...buildAssignment(session.id, project.id, 0),
+			...buildAssignment(session.id, project.id, thread.id, 0),
 			tenantId: otherTenant,
 		}
 		await expect(executeSingleHandoff(deps, assignment, otherTenant)).rejects.toBeInstanceOf(
@@ -203,13 +216,13 @@ describe('executeSingleHandoff', () => {
 	})
 
 	it('rejects on CAS mismatch (HandoffVersionConflict)', async () => {
-		const { project, session } = await seedIdle(store)
-		const { deps } = buildDeps(store)
+		const { project, thread, session } = await seedIdle(store, threadStore)
+		const { deps } = buildDeps(store, threadStore)
 
 		// Simulate a concurrent bump: move ownerVersion to 1 before the assignment
 		// with expectedOwnerVersion=0 is executed.
 		await store.updateSession({ ...session, ownerVersion: 1 }, tenant)
-		const assignment = buildAssignment(session.id, project.id, 0)
+		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
 
 		try {
 			await executeSingleHandoff(deps, assignment, tenant)
@@ -224,18 +237,22 @@ describe('executeSingleHandoff', () => {
 	it('depth cap enforcement rejects with DelegationCapacityExceeded (dimension=depth)', async () => {
 		// Build a chain so the handoff source already sits at max depth.
 		const project = await store.createProject({ tenantId: tenant, name: 'p' }, tenant)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'depth-cap' },
+			tenant,
+		)
 		// Set a tight limit on the project via a second createProject? — no, the
 		// store hardcodes defaults {4,8,10}. Build a depth-4 chain then attempt
 		// handoff on depth-4 node (ancestry length 5 > 4).
 		const root = await store.createSession(
-			{ projectId: project.id, currentActor: user('usr_source') },
+			{ threadId: thread.id, projectId: project.id, currentActor: user('usr_source') },
 			tenant,
 		)
 		let parent = root.id
 		let tail: SessionId = root.id
 		for (let i = 0; i < 4; i++) {
 			const child = await store.createSession(
-				{ projectId: project.id, currentActor: user(`usr_${i}`) },
+				{ threadId: thread.id, projectId: project.id, currentActor: user(`usr_${i}`) },
 				tenant,
 			)
 			await store.createSubSession(
@@ -252,15 +269,15 @@ describe('executeSingleHandoff', () => {
 		}
 
 		// Source is `tail` at ancestry length 5 → depth-capacity with limit 4 rejects.
-		const { deps } = buildDeps(store)
-		const assignment = buildAssignment(tail, project.id, 0)
+		const { deps } = buildDeps(store, threadStore)
+		const assignment = buildAssignment(tail, project.id, thread.id, 0)
 		await expect(executeSingleHandoff(deps, assignment, tenant)).rejects.toBeInstanceOf(
 			DelegationCapacityExceeded,
 		)
 	})
 
 	it('compensating revert: workspace provisioning failure reverts source to idle, version unchanged, onUnlocked fires', async () => {
-		const { project, session } = await seedIdle(store)
+		const { project, thread, session } = await seedIdle(store, threadStore)
 
 		// Fail only on `worktree add` but pass for everything else. Here we fail
 		// the single worktree add.
@@ -270,8 +287,8 @@ describe('executeSingleHandoff', () => {
 			}
 			return okExec()
 		}
-		const { deps, events } = buildDeps(store, exec)
-		const assignment = buildAssignment(session.id, project.id, 0)
+		const { deps, events } = buildDeps(store, threadStore, exec)
+		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
 
 		await expect(executeSingleHandoff(deps, assignment, tenant)).rejects.toThrow(
 			/Workspace backend git-worktree failed on create/,
@@ -290,7 +307,7 @@ describe('executeSingleHandoff', () => {
 	})
 
 	it('compensating revert: store.createSubSession failure still reverts + archives partial recipient', async () => {
-		const { project, session } = await seedIdle(store)
+		const { project, thread, session } = await seedIdle(store, threadStore)
 
 		// Monkey-patch createSubSession on the store to throw.
 		const original = store.createSubSession.bind(store)
@@ -298,8 +315,8 @@ describe('executeSingleHandoff', () => {
 			throw new Error('simulated createSubSession failure')
 		}
 
-		const { deps, events } = buildDeps(store)
-		const assignment = buildAssignment(session.id, project.id, 0)
+		const { deps, events } = buildDeps(store, threadStore)
+		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
 
 		await expect(executeSingleHandoff(deps, assignment, tenant)).rejects.toThrow(
 			/createSubSession failure/,

package/src/session/handoff/assignment.ts

@@ -9,7 +9,7 @@
  */
 
 import type { SessionId, TenantId } from '../../types/ids/index.js'
-import type { HandoffId, ProjectId, WorkspaceId } from '../../types/session/ids.js'
+import type { HandoffId, ProjectId, ThreadId, WorkspaceId } from '../../types/session/ids.js'
 import type { ActorRef } from '../hierarchy/actor.js'
 
 /**
@@ -32,6 +32,18 @@ export interface HandoffAssignment {
 	mode: HandoffMode
 	sourceSessionId: SessionId
 	tenantId: TenantId
+	/**
+	 * Topic-layer scope the source session belongs to. Handoff recipients
+	 * always land on the same Thread (cross-thread handoff is forbidden —
+	 * a new actor taking over a conversation stays on the same topic).
+	 * Validated against `source.threadId` at execute time.
+	 */
+	threadId: ThreadId
+	/**
+	 * Denormalized from the owning Thread. Kept alongside `threadId` as the
+	 * Session record itself carries both (see `Session` JSDoc). Consistency
+	 * validated against `source.projectId` at execute time.
+	 */
 	projectId: ProjectId
 	/** The actor initiating the handoff (must be the source's current owner). */
 	sourceActor: ActorRef

package/src/session/handoff/broadcast.ts

@@ -21,6 +21,7 @@
  * ```
  */
 
+import type { ThreadManager } from '../../manager/thread/lifecycle.js'
 import type { SessionId, TenantId } from '../../types/ids/index.js'
 import type { SubSessionId } from '../../types/session/ids.js'
 import type { SessionStore } from '../../types/session/store.js'
@@ -41,6 +42,12 @@ export interface BroadcastHandoffDeps {
 	capacity: CapacityValidator
 	events: HandoffEventSink
 	runStatus?: RunStatusResolver
+	/**
+	 * Gate every recipient-session creation on the Thread being `'open'`.
+	 * Added in Phase 2.6; checked once per broadcast (all recipients share
+	 * a threadId by the fan-out invariant validated above).
+	 */
+	threadManager: ThreadManager
 }
 
 /**
@@ -108,6 +115,9 @@ export async function executeBroadcastHandoff(
 		if (a.expectedOwnerVersion !== first.expectedOwnerVersion) {
 			throw new Error('executeBroadcastHandoff: all assignments must share expectedOwnerVersion')
 		}
+		if (a.threadId !== first.threadId) {
+			throw new Error('executeBroadcastHandoff: all assignments must share threadId')
+		}
 		if (a.projectId !== first.projectId) {
 			throw new Error('executeBroadcastHandoff: all assignments must share projectId')
 		}
@@ -130,6 +140,12 @@ export async function executeBroadcastHandoff(
 		seen.add(key)
 	}
 
+	// Thread archive gate (Phase 2.6) — runs BEFORE source load/capacity so an
+	// archived thread fails fastest with `ThreadClosedError`. All assignments
+	// share `threadId` by the shape validation above. Runs BEFORE the CAS
+	// lock so a denied fan-out leaves the source session untouched.
+	await deps.threadManager.requireOpen(first.threadId, tenantId)
+
 	// 3. Load source + tenant check.
 	const source = await deps.store.getSession(first.sourceSessionId, tenantId)
 	if (!source) {
@@ -141,6 +157,11 @@ export async function executeBroadcastHandoff(
 			resource: `session(${source.id})`,
 		})
 	}
+	if (source.threadId !== first.threadId) {
+		throw new Error(
+			`Assignment threadId ${first.threadId} does not match source threadId ${source.threadId}`,
+		)
+	}
 	if (source.projectId !== first.projectId) {
 		throw new Error(
 			`Assignment projectId ${first.projectId} does not match source projectId ${source.projectId}`,
@@ -220,7 +241,11 @@ export async function executeBroadcastHandoff(
 			worktreesProvisioned += 1
 
 			const childSession = await deps.store.createSession(
-				{ projectId: source.projectId, currentActor: assignment.recipientActor },
+				{
+					threadId: source.threadId,
+					projectId: source.projectId,
+					currentActor: assignment.recipientActor,
+				},
 				tenantId,
 			)
 			partial.createdSessionId = childSession.id

package/src/session/handoff/single.ts

@@ -20,6 +20,7 @@
  *   9. Emit `onCommitted` with the new version.
  */
 
+import type { ThreadManager } from '../../manager/thread/lifecycle.js'
 import type { SessionId, TenantId } from '../../types/ids/index.js'
 import type { SessionStore } from '../../types/session/store.js'
 import { TenantIsolationError } from '../errors.js'
@@ -64,6 +65,12 @@ export interface SingleHandoffDeps {
 	capacity: CapacityValidator
 	events: HandoffEventSink
 	runStatus?: RunStatusResolver
+	/**
+	 * Gate the recipient-session creation on the Thread being `'open'`.
+	 * Added in Phase 2.6 to mirror spawn — a handoff into an archived
+	 * Thread would otherwise undermine `ThreadManager.archive`.
+	 */
+	threadManager: ThreadManager
 }
 
 /**
@@ -85,6 +92,12 @@ export async function executeSingleHandoff(
 		})
 	}
 
+	// Thread archive gate (Phase 2.6) — runs FIRST so an archived thread
+	// fails fastest with `ThreadClosedError` rather than a lock rejection or
+	// capacity error. Checked BEFORE the CAS lock so a denied handoff leaves
+	// the source session untouched.
+	await deps.threadManager.requireOpen(assignment.threadId, tenantId)
+
 	// 1. Load source session + tenant check.
 	const source = await deps.store.getSession(assignment.sourceSessionId, tenantId)
 	if (!source) {
@@ -96,6 +109,11 @@ export async function executeSingleHandoff(
 			resource: `session(${source.id})`,
 		})
 	}
+	if (source.threadId !== assignment.threadId) {
+		throw new Error(
+			`Assignment threadId ${assignment.threadId} does not match source session threadId ${source.threadId}`,
+		)
+	}
 	if (source.projectId !== assignment.projectId) {
 		throw new Error(
 			`Assignment projectId ${assignment.projectId} does not match source session projectId ${source.projectId}`,
@@ -157,7 +175,11 @@ export async function executeSingleHandoff(
 		provisionedWorkspace = await driver.create({ label: `handoff-${assignment.id}` })
 
 		const recipientSession = await deps.store.createSession(
-			{ projectId: source.projectId, currentActor: assignment.recipientActor },
+			{
+				threadId: source.threadId,
+				projectId: source.projectId,
+				currentActor: assignment.recipientActor,
+			},
 			tenantId,
 		)
 		createdSessionId = recipientSession.id

package/src/session/hierarchy/__tests__/session.test.ts

@@ -1,11 +1,18 @@
 import { describe, expect, it } from 'vitest'
 import type { RunStatus } from '../../../types/run/status.js'
-import type { ProjectId, SessionId, TenantId, UserId } from '../../../types/session/ids.js'
+import type {
+	ProjectId,
+	SessionId,
+	TenantId,
+	ThreadId,
+	UserId,
+} from '../../../types/session/ids.js'
 import type { ActorRef } from '../actor.js'
 import { type Session, type SessionStatus, deriveStatus } from '../session.js'
 
 const tenant = 'tnt_a' as TenantId
 const project = 'prj_a' as ProjectId
+const thread = 'thd_a' as ThreadId
 
 function user(): ActorRef {
 	return { kind: 'user', userId: 'usr_a' as UserId, tenantId: tenant }
@@ -14,6 +21,7 @@ function user(): ActorRef {
 function makeSession(status: SessionStatus): Session {
 	return {
 		id: 'ses_a' as SessionId,
+		threadId: thread,
 		projectId: project,
 		tenantId: tenant,
 		status,

package/src/session/hierarchy/index.ts

@@ -5,6 +5,7 @@ export type { ActorRef, SystemRoleId } from './actor.js'
 export type { Lineage } from './lineage.js'
 export type { Tenant } from './tenant.js'
 export type { Project, ProjectConfig } from './project.js'
+export type { Thread, ThreadStatus } from './thread.js'
 export type { Session, SessionStatus } from './session.js'
 export { deriveStatus } from './session.js'
 export type {

package/src/session/hierarchy/session.ts

@@ -1,6 +1,6 @@
 import type { SessionId, TenantId } from '../../types/ids/index.js'
 import type { RunStatus } from '../../types/run/status.js'
-import type { ProjectId, WorkspaceId } from '../../types/session/ids.js'
+import type { ProjectId, ThreadId, WorkspaceId } from '../../types/session/ids.js'
 import type { ActorRef } from './actor.js'
 
 /**
@@ -21,15 +21,27 @@ export type SessionStatus =
 /**
  * Multi-turn work unit owned by exactly one {@link ActorRef} at a time.
  *
- * Fields derived from session-hierarchy.md §4.3:
+ * Scope identifiers:
+ *   - `threadId` — the topic-level {@link Thread} this Session lives under.
+ *     Set at creation, immutable; Sessions never move threads.
+ *   - `projectId` — the {@link Project} the owning Thread belongs to.
+ *     **Denormalized** from `thread.projectId` at creation time; immutable.
+ *     Kept on the Session record for ergonomic access (Project-scoped
+ *     consumers — handoff validators, archival, retention — would otherwise
+ *     need a second round-trip to ThreadStore on every read). This is NOT
+ *     a deprecated mirror of a fading field; it is a deliberate
+ *     denormalization of structurally-immutable derived data.
+ *
+ * Other invariants (session-hierarchy.md §4.3):
  *   - `previousActors` is append-only and publicly read-only; previous
- *     owners cannot write to the session again (Decision #3).
+ *     owners cannot write to the session again.
  *   - `ownerVersion` is the CAS counter for handoff (§6.1 / §6.2 / §6.4).
  *   - `workspaceId` is nullable for sessions whose workspace has not yet
  *     been provisioned (or has been torn down during archival).
  */
 export interface Session {
 	id: SessionId
+	threadId: ThreadId
 	projectId: ProjectId
 	tenantId: TenantId
 	status: SessionStatus

package/src/session/hierarchy/thread.ts

@@ -0,0 +1,55 @@
+import type { TenantId } from '../../types/ids/index.js'
+import type { ProjectId, ThreadId } from '../../types/session/ids.js'
+
+/**
+ * Lifecycle state of a Thread.
+ *
+ * - `open` — accepts new Sessions and new Runs under existing Sessions.
+ * - `archived` — read-only tombstone. No new Sessions may be created; existing
+ *   Sessions remain navigable. Transitioning `open → archived` requires that
+ *   no Session under the Thread is in a non-terminal state (guarded at the
+ *   store level by listing + status fan-in).
+ *
+ * There is no `active` variant — Thread does NOT derive status from its child
+ * Sessions the way a Session does from its Runs. Thread is a pure container
+ * (Phase 0 decision B.1: Thread is container-only, no message stream, no
+ * fan-in). Its status is an explicit owner action.
+ */
+export type ThreadStatus = 'open' | 'archived'
+
+/**
+ * Topic-level container sitting between {@link ProjectId Project} and
+ * {@link import('../../types/session/ids.js').SessionId Session} in the
+ * five-layer hierarchy (Project → Thread → Session → SubSession → Run).
+ *
+ * A Thread groups together many Sessions that address the same coherent
+ * topic or line-of-work within a Project (e.g. "auth refactor", "billing
+ * incident"). Sessions under the same Thread share Project-level shared
+ * resources (memory, vaults, knowledge bases) but have independent actor
+ * state, handoff history, and Run streams.
+ *
+ * Design §4 (`docs.local/sessions/ses_001-hierarchy-redesign/design.md`):
+ *   - Container only. No own message stream, no own Run stream. Messages
+ *     live in Sessions (Phase 0 decision B.1).
+ *   - `title` is a user-facing label. **Titles are NOT unique within a
+ *     Project.** Callers disambiguate by {@link ThreadId}; the title is
+ *     freeform display text. If a product surface needs uniqueness (e.g.
+ *     a human-typed slug), that constraint lives at the API layer, not in
+ *     the kernel.
+ *   - `ownerVersion` is the CAS counter for mutations — `updateThread` and
+ *     archival transitions require a matching version and reject
+ *     {@link StaleThreadError} on mismatch. Mirrors the
+ *     {@link import('./session.js').Session} handoff CAS pattern (§6.1).
+ *   - No fan-in `deriveStatus()` helper — status is owner-managed, not
+ *     Run-derived. This is the Thread-vs-Session contract boundary.
+ */
+export interface Thread {
+	id: ThreadId
+	projectId: ProjectId
+	tenantId: TenantId
+	title: string
+	status: ThreadStatus
+	ownerVersion: number
+	createdAt: Date
+	updatedAt: Date
+}

package/src/session/migration/id-prefix.ts

@@ -1,23 +1,18 @@
 /**
  * ID-prefix migration window — read-side compat for legacy `thd_*` IDs.
  *
- * Phase 1 already ships {@link parseThreadId} in `utils/id.ts` that accepts
- * either `thd_*` or `prj_*` silently. This module formalises the warning
- * emission path called out in session-hierarchy.md §13.3.1:
- *
- * | Version | Reader accepts      | Writer emits | Legacy read behaviour         |
- * |---------|---------------------|--------------|-------------------------------|
- * | 0.2.x   | `thd_*` AND `prj_*` | `prj_*` only | emits `MigrationWarning` once |
- * | 0.3.x   | `prj_*` only        | `prj_*` only | rejects `StalePrefixError`    |
- *
  * Consumers that touch raw legacy IDs (filesystem migrator, wire decoders,
  * CLI imports) route through {@link acceptLegacyThreadId} so the warning
  * signal is structured rather than ad-hoc console output (Convention #18).
  *
- * The `WINDOW_OPEN` constant is the single switch that flips this module
- * from soft-accept to hard-reject when 0.3.0 cuts. Convention #0: no silent
- * long-lived compat — the window is explicit, dated, and fails closed when
- * the clock runs out.
+ * | Window state | Reader accepts      | Writer emits | Legacy read behaviour         |
+ * |--------------|---------------------|--------------|-------------------------------|
+ * | OPEN (now)   | `thd_*` AND `prj_*` | `prj_*` only | emits `MigrationWarning` once |
+ * | CLOSED       | `prj_*` only        | `prj_*` only | rejects `StalePrefixError`    |
+ *
+ * The {@link WINDOW_OPEN} constant is the single switch that flips this
+ * module from soft-accept to hard-reject. Convention #0: no silent
+ * long-lived compat — the window is explicit and fails closed when closed.
  */
 
 import type { ProjectId } from '../../types/session/ids.js'

package/src/session/retention/__tests__/archive.test.ts

@@ -10,7 +10,7 @@ import { WorkspaceBackendRegistry } from '../../../session/workspace/registry.js
 import { InMemorySessionStore } from '../../../store/session/memory.js'
 import type { AgentId, TenantId, UserId } from '../../../types/ids/index.js'
 import { createUserMessage } from '../../../types/message/index.js'
-import type { WorkspaceId } from '../../../types/session/ids.js'
+import type { ThreadId, WorkspaceId } from '../../../types/session/ids.js'
 import {
 	ArchivalManager,
 	ArchiveNotConfiguredError,
@@ -18,6 +18,8 @@ import {
 } from '../archive.js'
 import { DiskArchiveBackend } from '../disk-backend.js'
 
+const TEST_THREAD_ID = 'thd_test' as ThreadId
+
 const tenantA = 'tnt_alpha' as TenantId
 
 function stubLogger() {
@@ -43,11 +45,11 @@ function agentActor(tenantId: TenantId): ActorRef {
 async function seedIdleSubSession(store: InMemorySessionStore) {
 	const project = await store.createProject({ tenantId: tenantA, name: 'p' }, tenantA)
 	const parent = await store.createSession(
-		{ projectId: project.id, currentActor: userActor(tenantA) },
+		{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor(tenantA) },
 		tenantA,
 	)
 	const child = await store.createSession(
-		{ projectId: project.id, currentActor: agentActor(tenantA) },
+		{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
 		tenantA,
 	)
 	const sub = await store.createSubSession(

package/src/session/summary/__tests__/materialize.test.ts

@@ -3,7 +3,7 @@ import { TenantIsolationError } from '../../../session/errors.js'
 import type { ActorRef } from '../../../session/hierarchy/actor.js'
 import { InMemorySessionStore } from '../../../store/session/memory.js'
 import type { AgentId, SessionId, TenantId, UserId } from '../../../types/ids/index.js'
-import type { SummaryId } from '../../../types/session/ids.js'
+import type { SummaryId, ThreadId } from '../../../types/session/ids.js'
 import type { DeliverableRef } from '../deliverable.js'
 import { SessionSummaryMaterializer } from '../materialize.js'
 import {
@@ -12,6 +12,8 @@ import {
 	SessionAlreadySummarizedError,
 } from '../ref.js'
 
+const TEST_THREAD_ID = 'thd_test' as ThreadId
+
 const tenantA = 'tnt_alpha' as TenantId
 const tenantB = 'tnt_beta' as TenantId
 
@@ -31,7 +33,7 @@ function makeSummaryIdGenerator(): () => SummaryId {
 async function seedActiveSession(store: InMemorySessionStore, tenantId: TenantId) {
 	const project = await store.createProject({ tenantId, name: 'p1' }, tenantId)
 	const session = await store.createSession(
-		{ projectId: project.id, currentActor: agentActor(tenantId) },
+		{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantId) },
 		tenantId,
 	)
 	// Put the session into `active` so the materializer's status-flip behavior
@@ -232,7 +234,7 @@ describe('SessionSummaryMaterializer.materialize', () => {
 		const store = new InMemorySessionStore()
 		const project = await store.createProject({ tenantId: tenantA, name: 'p1' }, tenantA)
 		const session = await store.createSession(
-			{ projectId: project.id, currentActor: userActor(tenantA) },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor(tenantA) },
 			tenantA,
 		)
 		// session.status defaults to 'idle'
@@ -255,7 +257,7 @@ describe('SessionSummaryMaterializer.materialize', () => {
 		const store = new InMemorySessionStore()
 		const project = await store.createProject({ tenantId: tenantA, name: 'p1' }, tenantA)
 		const session = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor(tenantA) },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
 			tenantA,
 		)
 		await store.updateSession({ ...session, status: 'failed' }, tenantA)

package/src/store/index.ts

@@ -10,9 +10,6 @@ export { InMemoryTaskStore } from './task/memory.js'
 export { DiskTaskStore } from './task/disk.js'
 export type { DiskTaskStoreConfig } from './task/disk.js'
 
-export { InMemoryConversationStore } from './conversation/memory.js'
-export type { InMemoryConversationStoreConfig } from './conversation/memory.js'
-
 export { InMemoryMemoryIndex } from './memory/index.js'
 export { InMemoryMemoryStore } from './memory/memory.js'
 export { DiskMemoryStore } from './memory/disk.js'