import * as Effect from 'effect/Effect';
import * as Deferred from 'effect/Deferred';
import * as Fiber from 'effect/Fiber';
import * as Layer from 'effect/Layer';
import * as Scope from 'effect/Scope';
import * as Exit from 'effect/Exit';
import * as Stream from 'effect/Stream';
import * as Option from 'effect/Option';
import * as Logger from 'effect/Logger';
import * as NodeServices from '@effect/platform-node/NodeServices';
import {ThreadId,RunId,CheckpointScopeId,CommandId,GitManagerError} from '@t3tools/contracts';
import * as Vcs from './src/vcs/VcsProcess.ts';
import * as Broadcaster from './src/vcs/VcsStatusBroadcaster.ts';
import * as Workflow from './src/git/GitWorkflowService.ts';
import * as Background from './src/background/BackgroundPolicy.ts';
import * as Workspace from './src/workspace/WorkspaceEntries.ts';
import * as Projections from './src/orchestration-v2/ProjectionStore.ts';
import * as Capture from './src/orchestration-v2/CheckpointCaptureService.ts';
import * as Finalization from './src/orchestration-v2/RunFinalizationService.ts';
import * as PullRequests from './src/pullRequest/PullRequestService.ts';
import * as Sqlite from './src/persistence/Sqlite.ts';
import * as Outbox from './src/orchestration-v2/EffectOutbox.ts';
import * as Worker from './src/orchestration-v2/EffectWorker.ts';
import * as ProviderSessions from './src/orchestration-v2/ProviderSessionManager.ts';
import * as ProviderControl from './src/orchestration-v2/ProviderTurnControlService.ts';
import * as Rollback from './src/orchestration-v2/CheckpointRollbackService.ts';
import * as Requests from './src/orchestration-v2/RuntimeRequestService.ts';
import * as Titles from './src/orchestration-v2/ThreadTitleRegenerationService.ts';
import * as Management from './src/orchestration-v2/ThreadManagementService.ts';
import * as Settings from './src/serverSettings.ts';
import * as ProviderStart from './src/orchestration-v2/ProviderTurnStartService.ts';
import {root,sha,after,runDir,log,hub,makeRepo,makeBin,assert} from '/tmp/lead-28431-r1b/evidence-capture/common.mjs';
const h=await hub(), repoA=makeRepo('repo-a'),repoB=makeRepo('repo-b'),bin=makeBin();
const bundle=process.env.CAP_BUNDLE;
const watchdog=setTimeout(()=>{log('WATCHDOG_FAILURE',{bundle});h.releaseAll();},45000);
const waitId=(id,event='CLI_START')=>Effect.promise(()=>h.wait(es=>es.some(e=>e.type===event&&e.id===id)));
const fork=eff=>eff.pipe(Effect.forkScoped({startImmediately:true}));
const remoteBase={hasUpstream:true,aheadCount:0,behindCount:0,pr:null};
const localBase={isRepo:true,hasPrimaryRemote:true,isDefaultRef:false,refName:'feature',hasWorkingTreeChanges:false,workingTree:{files:[],insertions:0,deletions:0}};
const threadA=ThreadId.make('thread:A'),threadB=ThreadId.make('thread:B'),scopeId=CheckpointScopeId.make('scope:fixture');
const input=(run='R1',threadId=threadA)=>({threadId,runId:RunId.make(run),scopeId});
function environment(label,opts={}){
 const state={label,local:{...localBase,...opts.local},thread:{branch:'feature',activeRunId:null,...opts.thread},missing:opts.missing??false,capture:0,workspace:0,localCalls:0,threadCalls:0,remoteCalls:0,published:[],gates:{},signals:new Map(),remoteIds:new Map(),failIds:new Set(),...opts.state};
 const signal=name=>{let d=state.signals.get(name);if(!d){d=Deferred.makeUnsafe();state.signals.set(name,d);}return d;};
 const mark=(name,data={})=>Effect.gen(function*(){log(name,{case:label,...data});yield* Deferred.succeed(signal(name),undefined);});
 const wait=name=>Deferred.await(signal(name));
 const step=(name,counter,gate)=>Effect.gen(function*(){state[counter]++;yield* mark(name+'_START',{count:state[counter]});if(state.gates[gate])yield* Deferred.await(state.gates[gate]);yield* mark(name+'_DONE',{count:state[counter]});});
 const processLayer=Vcs.layer.pipe(Layer.provide(NodeServices.layer));
 const workflow=Layer.effect(Workflow.GitWorkflowService,Effect.gen(function*(){const vcs=yield* Vcs.VcsProcess;return Workflow.GitWorkflowService.of({
  localStatus:()=>step('LOCAL','localCalls','local').pipe(Effect.as(state.local)),
  currentBranch:()=>Effect.sync(()=>state.local.refName),
  invalidateLocalStatus:cwd=>mark('LOCAL_INVALIDATE',{cwd}),
  invalidateRemoteStatus:cwd=>mark('REMOTE_INVALIDATE',{cwd}),
  invalidateStatus:cwd=>mark('STATUS_INVALIDATE',{cwd}),
  remoteStatus:({cwd},options)=>Effect.gen(function*(){const ids=state.remoteIds.get(cwd)??[];const id=ids.shift()??label+'-lookup-'+(++state.remoteCalls);yield* mark('REMOTE_REQUEST',{id,cwd,options});const output=yield* vcs.run({command:'tea',args:['synthetic-remote-status',id],cwd,operation:'capture.remoteStatus',env:{CAP_ID:id,CAP_PORT:String(h.port),PATH:bin+':'+process.env.PATH},timeoutMs:30000});yield* mark('REMOTE_PROCESS_RETURN',{id,stdout:output.stdout.trim()});if(state.failIds.has(id)){yield* mark('REMOTE_TYPED_FAILURE',{id,tag:'GitManagerError'});return yield* new GitManagerError({operation:'harness.remoteStatus',cwd,detail:'synthetic typed failure'});}const remote={...remoteBase,pr:{number:1,title:id,url:'https://example.invalid/synthetic/pull/1',baseRef:'main',headRef:'feature',state:'open'}};yield* mark('REMOTE_VALUE',{id});return remote;}).pipe(Effect.onInterrupt(()=>mark('REMOTE_EFFECT_INTERRUPT',{cwd}))),
 });})).pipe(Layer.provide(processLayer));
 const broadcaster=Broadcaster.layer.pipe(Layer.provide(Layer.mergeAll(workflow,NodeServices.layer,Layer.mock(Background.BackgroundPolicy)({shouldRunScopeWork:()=>Effect.succeed(true)}))));
 const projections=Layer.mock(Projections.ProjectionStoreV2)({getCheckpointContext:threadId=>mark('CHECKPOINT_CONTEXT',{threadId}).pipe(Effect.as({runs:[],checkpoints:[],checkpointScopes:[{id:scopeId,runId:RunId.make('R1'),kind:'root_run',cwd:threadId===threadB?repoB:repoA}]})),getThreadShell:threadId=>Effect.gen(function*(){state.threadCalls++;yield* mark('THREAD_READ',{threadId,count:state.threadCalls});yield* Deferred.succeed(signal('THREAD_READ_'+state.threadCalls),undefined);return state.missing?null:{id:threadId,...state.thread};})});
 const observer=Finalization.layerObserver.pipe(Layer.provide(Layer.mergeAll(broadcaster,projections,Layer.mock(Workspace.WorkspaceEntries)({refresh:()=>step('WORKSPACE','workspace','workspace')}),Layer.mock(PullRequests.PullRequestService)({refreshAfterTurn:()=>Effect.void}))));
 const finalization=Finalization.layer.pipe(Layer.provide(Layer.mergeAll(observer,projections,Layer.mock(Capture.CheckpointCaptureServiceV2)({execute:()=>step('CHECKPOINT_HARNESS','capture','capture')}))));
 const logger=Logger.layer([Logger.make(options=>{log('SERVICE_LOG',{case:label,level:options.logLevel,message:options.message});if(String(options.message).includes('failed to refresh pull request'))Deferred.doneUnsafe(signal('WARNING'),Exit.void);})]);
 const all=Layer.mergeAll(finalization,broadcaster).pipe(Layer.provideMerge(logger));
 return {state,layer:all,finalization,broadcaster,mark,wait,signal};
}
function watch(env,cwd){return Effect.gen(function*(){const vcs=yield* Broadcaster.VcsStatusBroadcaster;const ready=Deferred.makeUnsafe();const f=yield* vcs.streamStatus({cwd,includeRemote:false}).pipe(Stream.tap(event=>Effect.gen(function*(){log('CACHE_EVENT',{case:env.state.label,cwd,event});if(event._tag==='snapshot')yield* Deferred.succeed(ready,undefined);if(event._tag==='remoteUpdated'){env.state.published.push(event.remote?.pr?.title??null);yield* Deferred.succeed(env.signal('PUBLISHED_'+(event.remote?.pr?.title??'null')),undefined);}})),Stream.runDrain,fork);yield* Deferred.await(ready);log('PRECONDITIONS',{case:env.state.label,cwd,cachedLocal:true,remoteCache:'absent, not cached entire-null',backgroundEnabled:true,branch:env.state.local.refName});return f;});}
const finalize=(env,i)=>Effect.gen(function*(){const service=yield* Finalization.RunFinalizationService;log('FINALIZE_CALL',{case:env.state.label,...i});yield* service.finalize(i);log('FINALIZE_RETURN',{case:env.state.label,...i});});
async function run(env,program){log('SCOPE_OPEN',{case:env.state.label});await Effect.runPromise(Effect.scoped(program).pipe(Effect.provide(Layer.fresh(env.layer))));log('SCOPE_CLOSED',{case:env.state.label,active:h.active});h.reset();}
async function c2(){
 for(const activeRunId of [null,RunId.make('R1')]){const label='F01-'+(activeRunId===null?'null':'equal'),env=environment(label,{thread:{activeRunId}}),id=label+'-remote';env.state.remoteIds.set(repoA,[id]);log('CASE',{rows:['F01'],label,kind:'service harness; checkpoint marker is controlled, not disk-write proof'});await run(env,Effect.gen(function*(){yield* watch(env,repoA);const f=yield* fork(finalize(env,input()));yield* waitId(id);if(after){yield* Fiber.join(f);assert(h.active===1,'finalize returns while real CLI remains gated');}else assert(f.pollUnsafe()===undefined,'Before finalize remains pending at actual CLI START');log('HELD_LOOKUP_SNAPSHOT',{finalizePending:f.pollUnsafe()===undefined,active:h.active});h.release(id);yield* Fiber.join(f);yield* env.wait('PUBLISHED_'+id);const b=yield* Broadcaster.VcsStatusBroadcaster;log('CACHED_STATUS',{case:label,status:yield* b.getStatus({cwd:repoA})});assert(env.state.published.includes(id),'released lookup publishes into real broadcaster cache');}));}
 for(const first of ['workspace','local']){const label='F02-'+first+'-first',env=environment(label),id=label+'-remote';for(const key of ['capture','workspace','local'])env.state.gates[key]=Deferred.makeUnsafe();env.state.remoteIds.set(repoA,[id]);log('CASE',{rows:['F02'],label,kind:'service harness; independently controlled prerequisite gates'});await run(env,Effect.gen(function*(){const f=yield* fork(finalize(env,input()));yield* env.wait('CHECKPOINT_HARNESS_START');assert(env.state.localCalls===0&&env.state.workspace===0,'no refresh before checkpoint completion');log('PREREQUISITE_RELEASE',{gate:'capture'});yield* Deferred.succeed(env.state.gates.capture,undefined);yield* env.wait('LOCAL_START');yield* env.wait('WORKSPACE_START');assert(f.pollUnsafe()===undefined,'workspace and local both started while finalize waits');log('PREREQUISITE_RELEASE',{gate:first});yield* Deferred.succeed(env.state.gates[first],undefined);yield* env.wait(first.toUpperCase()+'_DONE');assert(f.pollUnsafe()===undefined&&env.state.threadCalls===0,'finalize and thread read still wait for other prerequisite');const other=first==='workspace'?'local':'workspace';log('PREREQUISITE_RELEASE',{gate:other});yield* Deferred.succeed(env.state.gates[other],undefined);yield* waitId(id);if(after)yield* Fiber.join(f);else assert(f.pollUnsafe()===undefined,'Before also waits remote');h.release(id);yield* Fiber.join(f);const b=yield* Broadcaster.VcsStatusBroadcaster;const status=yield* b.getStatus({cwd:repoA});assert(status.pr?.title===id,'remote success cached after prerequisites');}));}
 for(const sc of [{id:'F03',local:{refName:null}},{id:'F04',local:{refName:'main',isDefaultRef:true},thread:{branch:'main'}},{id:'F05',missing:true},{id:'F06-other',local:{refName:'other'}},{id:'F06-null-branch',thread:{branch:null}},{id:'F07',thread:{activeRunId:RunId.make('R2')}}]){const env=environment(sc.id,sc);log('CASE',{rows:[sc.id.split('-')[0]],label:sc.id,kind:'guard harness with real observer and broadcaster'});await run(env,Effect.gen(function*(){yield* finalize(env,input());assert(h.seen.filter(e=>e.type==='CLI_START').length===0,'guard prevents all forge processes');assert(env.state.workspace===1&&env.state.localCalls===1,'local and workspace completed');const expected=['F03','F04'].includes(sc.id)?0:1;assert(env.state.threadCalls===expected,'thread fetch count='+expected);log('GUARD_COUNTS',{case:sc.id,workspace:env.state.workspace,local:env.state.localCalls,thread:env.state.threadCalls,cliStarts:0});}));}
 {const label='F12',env=environment(label),first='F12-failing',second='F12-success';env.state.remoteIds.set(repoA,[first,second]);env.state.failIds.add(first);log('CASE',{rows:['F12'],label,kind:'typed workflow failure harness with real broadcaster/process/observer'});await run(env,Effect.gen(function*(){yield* watch(env,repoA);let f=yield* fork(finalize(env,input('R1')));yield* waitId(first);if(after)yield* Fiber.join(f);else assert(f.pollUnsafe()===undefined,'Before pending until typed remote failure');h.release(first);yield* env.wait('WARNING');yield* Fiber.join(f);log('FAILURE_HANDLED',{case:label,active:h.active,published:[...env.state.published]});f=yield* fork(finalize(env,input('R2')));yield* waitId(second);if(after)yield* Fiber.join(f);h.release(second);yield* Fiber.join(f);yield* env.wait('PUBLISHED_'+second);assert(env.state.published.join(',')===second,'failure is warned and next accepted lookup publishes');}));}
}
async function c3(){
 {const label='F08',env=environment(label),first='F08-R1',second='F08-R2';env.state.remoteIds.set(repoA,[first,second]);log('CASE',{rows:['F08'],label,kind:'same exact cwd; distinct R1/R2; real broadcaster lock and CLI'});await run(env,Effect.gen(function*(){yield* watch(env,repoA);const f1=yield* fork(finalize(env,input('R1')));yield* waitId(first);if(after)yield* Fiber.join(f1);env.state.thread.activeRunId=RunId.make('R2');const f2=yield* fork(finalize(env,input('R2')));yield* env.wait('THREAD_READ_2');if(after){yield* waitId(first,'CLI_INTERRUPT');yield* waitId(second);yield* Fiber.join(f2);assert(!env.state.published.includes(first),'replaced lookup has no stale publication');}else{assert(f1.pollUnsafe()===undefined&&f2.pollUnsafe()===undefined,'both Before finalize callers pending behind first lookup/lock');assert(h.seen.filter(e=>e.type==='CLI_START').length===1,'second Before CLI not started behind same-cwd lock');log('REPLACEMENT_SNAPSHOT',{firstPending:true,secondPending:true,actualStarts:1,active:h.active});h.release(first);yield* Fiber.join(f1);yield* waitId(second);}h.release(second);yield* Fiber.join(f2);yield* env.wait('PUBLISHED_'+second);assert(env.state.published.join(',')===(after?second:first+','+second),'publication sequence matches replacement behavior');log('PUBLICATION_SEQUENCE',{case:label,values:env.state.published});}));}
 {const label='F10',env=environment(label),first='F10-A',second='F10-B';env.state.remoteIds.set(repoA,[first]);env.state.remoteIds.set(repoB,[second]);log('CASE',{rows:['F10'],label,kind:'different canonical cwd; real shared broadcaster and process service'});await run(env,Effect.gen(function*(){yield* watch(env,repoA);yield* watch(env,repoB);const f1=yield* fork(finalize(env,input('R1',threadA)));yield* waitId(first);const f2=yield* fork(finalize(env,input('R2',threadB)));yield* waitId(second);assert(h.active===2,'different cwd lookups coexist');h.release(second);yield* Fiber.join(f2);yield* env.wait('PUBLISHED_'+second);assert(h.active===1&&!h.seen.some(e=>e.type==='CLI_INTERRUPT'&&e.id===first),'B completes without canceling or releasing A');log('INDEPENDENCE_SNAPSHOT',{active:h.active,AStillGated:true});h.release(first);yield* Fiber.join(f1);yield* env.wait('PUBLISHED_'+first);}));}
 {const label='F11',env=environment(label),id='F11-scope';env.state.remoteIds.set(repoA,[id]);log('CASE',{rows:['F11'],label,kind:'explicit observer-layer scope close before gate release'});const scope=await Effect.runPromise(Scope.make());log('SCOPE_OPEN',{case:label});try{await Effect.runPromise(Effect.gen(function*(){const ctx=yield* Layer.buildWithScope(Layer.fresh(env.layer),scope);yield* Effect.gen(function*(){yield* watch(env,repoA);const f=yield* finalize(env,input()).pipe(Effect.forkIn(scope,{startImmediately:true}));yield* waitId(id);if(after){yield* Fiber.join(f);assert(h.active===1,'lookup survives finalize caller completion');}else assert(f.pollUnsafe()===undefined,'Before scoped caller remains blocked');log('CALLER_BEFORE_SCOPE_CLOSE',{pending:f.pollUnsafe()===undefined,active:h.active});}).pipe(Effect.provideContext(ctx),Effect.provideService(Scope.Scope,scope));}));log('SCOPE_CLOSE_BEGIN',{case:label});await Effect.runPromise(Scope.close(scope,Exit.void));await Effect.runPromise(waitId(id,'CLI_INTERRUPT'));log('SCOPE_CLOSED',{case:label,active:h.active});assert(h.active===0,'scope closes and interrupts actual CLI without gate release');assert(env.state.published.length===0,'scope shutdown publishes no remote result');}finally{await Effect.runPromise(Scope.close(scope,Exit.void));}h.reset();}
}
async function c4(){
for(const mode of ['prequeued','inflight']){
const label='Q01-'+mode,env=environment(label),id=label+'-forge',providerStarted=Deferred.makeUnsafe();env.state.remoteIds.set(repoA,[id]);
const executor=Worker.layerExecutor.pipe(Layer.provide(Layer.mergeAll(env.finalization,Layer.mock(ProviderSessions.ProviderSessionManagerV2)({}),Layer.mock(ProviderControl.ProviderTurnControlServiceV2)({}),Layer.mock(Rollback.CheckpointRollbackServiceV2)({}),Layer.mock(Requests.RuntimeRequestServiceV2)({}),Layer.mock(Titles.ThreadTitleRegenerationService)({}),Layer.mock(Management.ThreadManagementService)({}),Settings.layerTest(),Layer.mock(ProviderStart.ProviderTurnStartServiceV2)({start:i=>Effect.gen(function*(){log('PROVIDER_START_HARNESS',{...i});yield* Deferred.succeed(providerStarted,undefined);})}))));
const outbox=Outbox.layer.pipe(Layer.provide(Sqlite.layerMemory));const worker=Worker.layer.pipe(Layer.provideMerge(Layer.merge(executor,outbox)));env.layer=Layer.mergeAll(worker,env.broadcaster);
log('CASE',{rows:['Q01'],label,mode,kind:'queue/service harness; real in-memory SQLite outbox/EffectWorker; controlled provider marker, no actual agent'});
await run(env,Effect.gen(function*(){yield* watch(env,repoA);const queue=yield* Outbox.EffectOutboxV2,worker=yield* Worker.OrchestrationEffectWorkerV2;const captureRequest={id:'fixture:capture',commandId:CommandId.make('cmd:capture'),threadId:threadA,request:{type:'checkpoint.capture',runId:RunId.make('R1'),scopeId}};const startRequest={id:'fixture:start',commandId:CommandId.make('cmd:start'),threadId:threadA,request:{type:'provider-turn.start',runId:RunId.make('R2')}};yield* queue.enqueue(mode==='prequeued'?[captureRequest,startRequest]:[captureRequest]);
const snapshot=phase=>Effect.gen(function*(){const rows=[];for(const effectId of ['fixture:capture','fixture:start']){const maybe=yield* queue.get(effectId);if(Option.isNone(maybe)){rows.push({id:effectId,status:'not-enqueued'});continue;}const row=maybe.value;rows.push({id:effectId,status:row.status,attemptCount:row.attemptCount,lastError:row.lastError});}log('PERSISTED_OUTBOX',{phase,rows,forgeActive:h.active});return rows;});
yield* snapshot('enqueued');const draining=yield* fork(worker.drain(2).pipe(Effect.tap(count=>Effect.sync(()=>log('WORKER_DRAIN_RETURN',{count})))));yield* waitId(id);
if(mode==='inflight'){log('ENQUEUE_NEXT_AFTER_ACTUAL_CLI_START',{case:label});yield* queue.enqueue([startRequest]);const count=yield* worker.drain(1);log('INFLIGHT_ADDITIONAL_DRAIN',{case:label,count});assert(count===(after?1:0),'new next-turn request is '+(after?'claimable':'blocked')+' while actual forge CLI holds gate');}
if(after){yield* Deferred.await(providerStarted);yield* Fiber.join(draining);const rows=yield* snapshot('while-forge-gated');assert(rows.every(r=>r.status==='succeeded'&&r.attemptCount===1),'capture and next start persisted succeeded while forge remains held');assert(h.active===1,'provider start occurred before forge release');}else{const rows=yield* snapshot('while-forge-gated');assert(rows[0].status==='running'&&rows[1].status==='pending'&&rows[1].attemptCount===0,'Before capture running and next start remains unclaimed');assert(draining.pollUnsafe()===undefined,'Before worker drain pending');}
h.release(id);yield* env.wait('PUBLISHED_'+id);yield* Fiber.join(draining);yield* Deferred.await(providerStarted);const rows=yield* snapshot('after-forge-release');assert(rows.every(r=>r.status==='succeeded'&&r.attemptCount===1),'both effects finish exactly once');assert(env.state.capture===1,'remote completion does not rerun capture');}));
}
}
try{if(bundle==='C2')await c2();else if(bundle==='C3')await c3();else if(bundle==='C4')await c4();else throw Error('unknown bundle');log('BUNDLE_COMPLETE',{bundle});}finally{clearTimeout(watchdog);await h.close();}