Merge branch 'master' into worktree/command-row-copy

packages/client/runtime/tests/fake-api.ts

@@ -64,6 +64,7 @@ export class FakeApiClient implements IApiClient {
   onCreate: (payload: unknown) => Promise<RpcResponse<{ sessionId: SessionId }>> = () => Promise.resolve(ok({ sessionId: 'fk-new' as SessionId }))
   readonly defaultModel: ModelTarget = { provider: 'deepseek', model: 'deepseek-v4-flash' }
   onRename: (payload: unknown) => Promise<RpcResponse<{ title: string; seq: number }>> = () => Promise.resolve(ok({ title: 'fk-renamed', seq: 0 }))
+  onFork: (payload: unknown) => Promise<RpcResponse<{ sessionId: SessionId }>> = () => Promise.resolve(ok({ sessionId: 'fk-fork' as SessionId }))
   onHistory: (payload: { sessionId: SessionId; beforeSeq?: number; maxMessages?: number })
   => Promise<RpcResponse<{ events: never[]; hasMore: boolean }>> =
     () => Promise.resolve(ok({ events: [], hasMore: false }))
@@ -118,6 +119,7 @@ export class FakeApiClient implements IApiClient {
     selectModel: (payload: { provider: string; model: string }) =>
       this.record('session.selectModel', payload, this.onSelectModel(payload)),
     rename: (payload: unknown) => this.record('session.rename', payload, this.onRename(payload)),
+    fork: (payload: unknown) => this.record('session.fork', payload, this.onFork(payload)),
     prompt: (payload: unknown) => this.record('session.prompt', payload, this.onPrompt(payload)),
     updateQueue: (payload: unknown) => this.record('session.updateQueue', payload, this.onUpdateQueue(payload)),
     cancel: (payload: unknown) => this.record('session.cancel', payload, this.onCancel(payload)),

packages/client/runtime/tests/manager.spec.ts

@@ -277,6 +277,23 @@ describe('remaining branches', () => {
     expect(manager.getListSnapshot().items[0]).not.toHaveProperty('cwd')
   })
 
+  it('reconciles a fork child published before workspace attachment fails', async () => {
+    const api = new FakeApiClient()
+    api.onFork = () => Promise.resolve(err({
+      code: 'workspace-attach-failed',
+      message: 'forked but unattached',
+      details: { sessionId: S2, workspaceId: 'w1' },
+    } as never))
+    const manager = new SessionManager(api)
+    const result = await manager.fork({ sessionId: S1 })
+    expect(result).toMatchObject({ ok: false, error: { code: 'workspace-attach-failed' } })
+    expect(manager.getListSnapshot().items).toEqual([expect.objectContaining({
+      sessionId: S2,
+      parentSessionId: S1,
+      blank: false,
+    })])
+  })
+
   it('reconciles a preallocated id after an ordinary transport failure', async () => {
     const api = new FakeApiClient()
     api.onCreate = () => Promise.reject(new Error('response lost'))

packages/client/runtime/tests/sessions-service.spec.ts

@@ -10,7 +10,7 @@ import { Context } from 'cordis'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
 import { SessionCreateError, SessionsService, scopeOf } from '../src/client/sessions/service.ts'
-import { FakeApiClient, deferred, ok } from './fake-api.ts'
+import { FakeApiClient, deferred, err, ok } from './fake-api.ts'
 
 const sid = (s: string): SessionId => s as SessionId
 
@@ -399,6 +399,69 @@ describe('create', () => {
   })
 })
 
+describe('fork', () => {
+  it.each([
+    ['Roadmap', 'Roadmap (1)'],
+    ['Roadmap (1)', 'Roadmap (2)'],
+    ['计划（1）', '计划（2）'],
+    ['计划 （9）', '计划 （10）'],
+  ])('increments the durable title %j after the child is published', async (sourceTitle, childTitle) => {
+    const b = bench()
+    b.svc.handleMuxEnvelope({
+      rpcId: 'source-title' as never,
+      payload: { type: 'session/projection', sessionId: sid('source'), key: 'title', value: sourceTitle, seq: 2 } as never,
+    })
+    await feedList(b, [{ id: 'source', cwd: '/work' }])
+    b.api.onFork = () => Promise.resolve(ok({ sessionId: sid('child') }))
+    b.api.onRename = (payload) => {
+      const { title } = payload as { title: string }
+      return Promise.resolve(ok({ title, seq: 3 }))
+    }
+
+    await expect(b.svc.fork({
+      sessionId: sid('source'), atSeq: 7, increaseTitle: true,
+    })).resolves.toBe('child')
+
+    expect(b.api.callsOf('session.fork')).toEqual([{ sessionId: 'source', atSeq: 7 }])
+    expect(b.api.callsOf('session.rename')).toEqual([{ sessionId: 'child', title: childTitle }])
+    await Promise.resolve()
+    expect(b.svc.list.getSnapshot().byId[sid('child')]).toMatchObject({
+      title: childTitle,
+      displayTitle: childTitle,
+      parentId: 'source',
+    })
+  })
+
+  it('does not rename without the title policy or a durable source title', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 'source', cwd: '/work' }])
+    b.api.onFork = () => Promise.resolve(ok({ sessionId: sid('child') }))
+    await expect(b.svc.fork({ sessionId: sid('source'), increaseTitle: true })).resolves.toBe('child')
+    expect(b.api.callsOf('session.rename')).toEqual([])
+
+    b.api.onFork = () => Promise.resolve(ok({ sessionId: sid('child-2') }))
+    await expect(b.svc.fork({ sessionId: sid('source') })).resolves.toBe('child-2')
+    expect(b.api.callsOf('session.rename')).toEqual([])
+  })
+
+  it('rejects when child rename fails while keeping the published child addressable', async () => {
+    const b = bench()
+    b.svc.handleMuxEnvelope({
+      rpcId: 'source-title' as never,
+      payload: { type: 'session/projection', sessionId: sid('source'), key: 'title', value: 'Roadmap', seq: 2 } as never,
+    })
+    await feedList(b, [{ id: 'source' }])
+    b.api.onFork = () => Promise.resolve(ok({ sessionId: sid('child') }))
+    b.api.onRename = () => Promise.resolve(err({
+      code: 'title-invalid', message: 'rejected', details: { sessionId: sid('child') },
+    }))
+
+    await expect(b.svc.fork({ sessionId: sid('source'), increaseTitle: true }))
+      .rejects.toThrow('fork child rename failed: title-invalid: rejected')
+    expect(b.svc.binding(sid('child'))).toBeDefined()
+  })
+})
+
 describe('scope lifecycle rides the list mirror (entity parity: no client-side pre-birth)', () => {
   it('a session-added frame births the row (blank) and makes the scope resolvable; removal prunes it', async () => {
     const b = bench()