@@ -32,7 +32,7 @@ import * as SqlitePersistence from "../persistence/Sqlite.ts";
3232import * as ServerConfig from "../config.ts" ;
3333import * as ServerSettings from "../serverSettings.ts" ;
3434import * as GitWorkflow from "../git/GitWorkflowService.ts" ;
35- import { withWorkspaceLease } from "../workspace/workspaceLease.ts" ;
35+ import { withTurnStartReservation , withWorkspaceLease } from "../workspace/workspaceLease.ts" ;
3636import { ProviderWorkspaceMissingError } from "../provider/Errors.ts" ;
3737import { resolveCodexRollbackTurnCount } from "./Adapters/CodexAdapterV2.ts" ;
3838import * as CheckpointService from "./CheckpointService.ts" ;
@@ -394,6 +394,136 @@ it.effect.each([
394394 } ) . pipe ( Effect . scoped , Effect . provide ( NodeServices . layer ) ) ,
395395) ;
396396
397+ it . effect . each ( [ { restoreFiles : true } , { restoreFiles : false } ] ) (
398+ "holds turn starts inside the worktree during rollback with restoreFiles $restoreFiles" ,
399+ ( { restoreFiles } ) =>
400+ Effect . gen ( function * ( ) {
401+ const fileSystem = yield * FileSystem . FileSystem ;
402+ const path = yield * Path . Path ;
403+ const workspaceRoot = yield * fileSystem . realPath (
404+ yield * fileSystem . makeTempDirectoryScoped ( { prefix : "t3-rollback-reservation-" } ) ,
405+ ) ;
406+ const worktreesDir = path . join ( workspaceRoot , "worktrees" ) ;
407+ const worktreePath = path . join ( worktreesDir , "repo" , "feature" ) ;
408+ yield * fileSystem . makeDirectory ( path . join ( worktreePath , ".git" ) , { recursive : true } ) ;
409+ const threadId = ThreadId . make ( "rollback-reservation" ) ;
410+ const providerThreadId = ProviderThreadId . make ( "rollback-reservation-provider-thread" ) ;
411+ const providerInstanceId = ProviderInstanceId . make ( "rollback-reservation-provider" ) ;
412+ const checkpointId = CheckpointId . make ( "rollback-reservation-checkpoint" ) ;
413+ const scopeId = CheckpointScopeId . make ( "rollback-reservation-scope" ) ;
414+ const release = Deferred . makeUnsafe < void > ( ) ;
415+ const openEntered = Deferred . makeUnsafe < void > ( ) ;
416+ const restoreEntered = Deferred . makeUnsafe < void > ( ) ;
417+ const releaseRestore = Deferred . makeUnsafe < void > ( ) ;
418+ const calls : string [ ] = [ ] ;
419+ const projection = {
420+ thread : {
421+ id : threadId ,
422+ projectId : ProjectId . make ( "rollback-reservation-project" ) ,
423+ worktreePath,
424+ branch : "feature/rollback-reservation" ,
425+ activeProviderThreadId : providerThreadId ,
426+ modelSelection : { instanceId : providerInstanceId , model : "test-model" } ,
427+ } ,
428+ providerThread : {
429+ id : providerThreadId ,
430+ providerSessionId : ProviderSessionId . make ( "rollback-reservation-session" ) ,
431+ providerInstanceId,
432+ } ,
433+ providerSession : undefined ,
434+ checkpoint : { id : checkpointId , scopeId, status : "ready" , appRunOrdinal : 0 } ,
435+ scope : { id : scopeId , cwd : worktreePath } ,
436+ runsToRollback : [ ] ,
437+ targetAttempt : undefined ,
438+ rolledBackAttemptIds : [ ] ,
439+ staleCheckpoints : [ ] ,
440+ rootNodes : [ ] ,
441+ providerTurns : [ ] ,
442+ } as unknown as ProjectionStore . ProjectionCheckpointRollbackContext ;
443+ const testLayer = CheckpointRollbackService . layer . pipe (
444+ Layer . provide (
445+ Layer . mergeAll (
446+ ThreadCommandExecutor . layer ,
447+ NodeServices . layer ,
448+ Layer . mock ( ServerConfig . ServerConfig ) ( { worktreesDir } as never ) ,
449+ ServerSettings . layerTest ( ) ,
450+ Layer . mock ( ProjectStore . ProjectStoreV2 ) ( {
451+ get : ( ) => Effect . succeedSome ( { workspaceRoot } as never ) ,
452+ } ) ,
453+ Layer . mock ( GitWorkflow . GitWorkflowService ) ( { } ) ,
454+ Layer . mock ( CheckpointService . CheckpointServiceV2 ) ( {
455+ restore : ( ) =>
456+ Deferred . succeed ( restoreEntered , undefined ) . pipe (
457+ Effect . andThen ( Deferred . await ( releaseRestore ) ) ,
458+ Effect . andThen ( Effect . sync ( ( ) => calls . push ( "files" ) ) ) ,
459+ ) ,
460+ } ) ,
461+ Layer . mock ( EventSink . EventSinkV2 ) ( { write : ( ) => Effect . succeed ( [ ] ) } ) ,
462+ IdAllocator . layer ,
463+ Layer . mock ( ProjectionStore . ProjectionStoreV2 ) ( {
464+ getThread : ( ) => Effect . succeed ( projection . thread ) ,
465+ getCheckpointRollbackContext : ( ) => Effect . succeed ( projection ) ,
466+ getShellSnapshot : ( ) =>
467+ Effect . succeed ( {
468+ schemaVersion : 1 ,
469+ snapshotSequence : 0 ,
470+ threads : [ ] ,
471+ archivedThreads : [ ] ,
472+ } ) ,
473+ } ) ,
474+ Layer . mock ( ProviderSessionManager . ProviderSessionManagerV2 ) ( {
475+ open : ( ) =>
476+ Deferred . succeed ( openEntered , undefined ) . pipe (
477+ Effect . andThen ( Deferred . await ( release ) ) ,
478+ Effect . as ( { } as never ) ,
479+ ) ,
480+ } ) ,
481+ Layer . mock ( RuntimePolicy . RuntimePolicyV2 ) ( {
482+ resolve : ( ) => Effect . succeed ( { cwd : worktreePath } as never ) ,
483+ } ) ,
484+ ) ,
485+ ) ,
486+ ) ;
487+ yield * Effect . gen ( function * ( ) {
488+ const service = yield * CheckpointRollbackService . CheckpointRollbackServiceV2 ;
489+ const rollback = yield * service
490+ . execute ( { threadId, providerThreadId, checkpointId, scopeId, restoreFiles } )
491+ . pipe ( Effect . forkChild ( { startImmediately : true } ) ) ;
492+ yield * Deferred . await ( openEntered ) ;
493+ // A synchronous realPath lets the forked start reach the reservation
494+ // before the next assertion, so "not entered" means "waiting".
495+ const startTurn = withTurnStartReservation (
496+ FileSystem . makeNoop ( { realPath : ( target ) => Effect . succeed ( target ) } ) ,
497+ path ,
498+ path . join ( worktreePath , "packages" , "app" ) ,
499+ Effect . sync ( ( ) => calls . push ( "turn start" ) ) ,
500+ ) . pipe ( Effect . forkChild ( { startImmediately : true } ) ) ;
501+ const turnStart = yield * startTurn ;
502+ if ( restoreFiles ) {
503+ assert . deepEqual ( calls , [ ] ) ;
504+ yield * Deferred . succeed ( release , undefined ) ;
505+ // The reservation must still be held while files are being restored,
506+ // not only while the provider rollback is in flight.
507+ yield * Deferred . await ( restoreEntered ) ;
508+ const duringRestore = yield * startTurn ;
509+ assert . deepEqual ( calls , [ ] ) ;
510+ yield * Deferred . succeed ( releaseRestore , undefined ) ;
511+ yield * Fiber . join ( duringRestore ) ;
512+ } else {
513+ // Nothing is rewritten, so the turn start must not wait for the provider.
514+ yield * Fiber . join ( turnStart ) ;
515+ yield * Deferred . succeed ( release , undefined ) ;
516+ }
517+ yield * Fiber . join ( rollback ) ;
518+ yield * Fiber . join ( turnStart ) ;
519+ assert . deepEqual (
520+ calls ,
521+ restoreFiles ? [ "files" , "turn start" , "turn start" ] : [ "turn start" ] ,
522+ ) ;
523+ } ) . pipe ( Effect . provide ( testLayer ) ) ;
524+ } ) . pipe ( Effect . scoped , Effect . provide ( NodeServices . layer ) ) ,
525+ ) ;
526+
397527const seedRollbackHistory = Effect . gen ( function * ( ) {
398528 const store = yield * ProjectionStore . ProjectionStoreV2 ;
399529 const now = yield * DateTime . now ;
0 commit comments