fix: complete scoped lifecycle simplification

packages/core/agent-loop/src/index.ts

@@ -54,7 +54,6 @@ class FactoryOwnership {
   }
 
   track(transaction: AgentCreationTransaction): () => void {
-    if (!this.isActive()) throw new Error('agent loop is not active')
     this.transactions.add(transaction)
     return () => { this.transactions.delete(transaction) }
   }
@@ -62,12 +61,9 @@ class FactoryOwnership {
   async dispose(): Promise<void> {
     this.accepting = false
     const reason = new Error('agent loop is not active')
-    const results = await Promise.allSettled(
+    await Promise.all(
       [...this.transactions].map(transaction => transaction.disposeForFactory(reason)),
     )
-    const errors = results.flatMap(result => result.status === 'rejected' ? [result.reason as unknown] : [])
-    if (errors.length === 1) throw errors[0]
-    if (errors.length > 1) throw new AggregateError(errors, 'agent loop transaction disposal failed')
   }
 }
 
@@ -101,8 +97,6 @@ class AgentCreationTransaction {
   private detachAgent: (() => void) | undefined
   private publishing = false
   private cleanupTask: Promise<void> | undefined
-  private finished = false
-  private wrapperFinished = false
   private ownerFollowing = true
   private readonly ownerDispose: () => Promise<void> | void
   private readonly untrackFactory: () => void
@@ -120,20 +114,17 @@ class AgentCreationTransaction {
     ownerCtx.fiber.assertActive()
     this.ownerAgent = ownerCtx.agent
     this.ownerFiber = ownerCtx.fiber
+    if (!ownership.isActive()) throw new Error('agent loop is not active')
+    this.ownerDispose = ownerCtx.effect(() => () => {
+      if (!this.ownerFollowing) return
+      return this.dispose(new Error(`agent "${id}" setup aborted: owner disposed during setup`))
+    }, `agentLoop.owner(${id})`)
     this.untrackFactory = ownership.track(this)
-    try {
-      this.ownerDispose = ownerCtx.effect(() => () => {
-        if (!this.ownerFollowing) return
-        return this.dispose(new Error(`agent "${id}" setup aborted: owner disposed during setup`))
-      }, `agentLoop.owner(${id})`)
-    } catch (error: unknown) {
-      this.untrackFactory()
-      throw error
-    }
     if (signal === undefined) {
       this.abortListener = undefined
     } else {
       this.abortListener = () => {
+        /* v8 ignore next 3 -- transaction teardown contains callback/driver failures; rejection is a future-drift backstop. */
         void this.dispose(signalAbortError(id, signal)).catch((error: unknown) => {
           this.loopCtx.logger.error(error)
         })
@@ -168,6 +159,7 @@ class AgentCreationTransaction {
     return await Promise.race([
       Promise.resolve(operation),
       this.deactivation.promise.then(() => {
+        /* v8 ignore next -- deactivate() assigns failure before resolving deactivation. */
         throw this.failure ?? new Error(`agent "${this.id}" creation deactivated`)
       }),
     ])
@@ -229,9 +221,11 @@ class AgentCreationTransaction {
   publish(source: SessionStartSource): AgentHandle {
     this.assertActive()
     const driver = this.driver
+    /* v8 ignore next -- publish() is private and every caller invokes prepare() first. */
     if (driver === undefined) throw new Error(`agent "${this.id}" is not prepared`)
     const agent = driver.agent
     const session = this.session
+    /* v8 ignore next -- prepare() assigns the session before it can produce the driver above. */
     if (session === undefined) throw new Error(`agent "${this.id}" has no prepared session`)
     this.publishing = true
     try {
@@ -274,8 +268,6 @@ class AgentCreationTransaction {
 
   /** Complete ownership bookkeeping after every resource reached quiescence. */
   private finish(): void {
-    if (this.finished) return
-    this.finished = true
     this.untrackFactory()
     this.ownerFollowing = false
     void this.ownerDispose()
@@ -310,8 +302,6 @@ class AgentCreationTransaction {
 
   /** Mark the public create/resume continuation settled and detach its creation-only signal. */
   finishWrapper(): void {
-    if (this.wrapperFinished) return
-    this.wrapperFinished = true
     if (this.signal !== undefined && this.abortListener !== undefined) {
       this.signal.removeEventListener('abort', this.abortListener)
     }

packages/core/agent-loop/tests/agent.spec.ts

@@ -49,6 +49,20 @@ function send(agent: ReactLoopAgent, text: string) {
 }
 
 describe('ReactLoopAgent', () => {
+  it('rejects access before context binding and a second driver for one session', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SessionStore)
+    const session = ctx.sessions.create(SessionId('exclusive-driver'))
+    const prepared = prepareReactLoopAgent(ctx, AgentId('first-driver'), { model: 'mock' }, session)
+
+    expect(() => prepared.agent.ctx).toThrow('context is not bound')
+    expect(() => prepareReactLoopAgent(ctx, AgentId('second-driver'), { model: 'mock' }, session))
+      .toThrow('already has a concrete agent driver')
+
+    await prepared.dispose()
+    await ctx.fiber.dispose()
+  })
+
   it('borrows caller options and binds its scoped context exactly once', async () => {
     const ctx = await harness(new MockAdapter([textResponse('unused')]))
     const options = { model: 'mock' }

packages/core/agent-loop/tests/resume.spec.ts

@@ -69,7 +69,29 @@ async function promptly<T>(task: Promise<T>): Promise<T> {
   }
 }
 
+/** Throw an arbitrary callback value to exercise the public unknown-error boundary. */
+function throwUnknown(value: unknown): never {
+  throw value
+}
+
 describe('the session-persistence RFC: AgentLoop factory create/resume', () => {
+  it('normalizes a non-Error resume publication failure for rollback and rethrows it', async () => {
+    const sessionId = SessionId('unknown-resume-failure-s')
+    const root = await persistSession(sessionId)
+    const ctx = await mountPersistentHarness(root, new MockAdapter([textResponse('next')]))
+    const failure = { source: 'resume' }
+    ctx.on('session/created', () => throwUnknown(failure))
+
+    await expect(ctx.agents.resume({
+      agentId: AgentId('unknown-resume-failure'),
+      resumeSessionId: sessionId,
+    })).rejects.toBe(failure)
+
+    expect(ctx.agents.get(AgentId('unknown-resume-failure'))).toBeUndefined()
+    expect(ctx.sessions.get(sessionId)).toBeUndefined()
+    await ctx.fiber.dispose()
+  })
+
   it('createAgent uses the caller-supplied sessionId (not ${id}-session)', async () => {
     const adapter = new MockAdapter([textResponse('hi')])
     const { ctx } = await persistentHarness(adapter)

packages/core/agent-loop/tests/scope-lifecycle.spec.ts

@@ -40,6 +40,11 @@ function waitForIdle(ctx: Context, agent: ReactLoopAgent): Promise<void> {
 
 const text = (t: string): ContentBlock[] => [{ type: 'text', text: t }]
 
+/** Throw an arbitrary callback value to exercise the public unknown-error boundary. */
+function throwUnknown(value: unknown): never {
+  throw value
+}
+
 /** Invoke the exact lifecycle effect to exercise same-stack reentrant teardown. */
 function disposeCurrentLifecycle(ownerCtx: Context): void {
   const lifecycle = [...ownerCtx.fiber._disposables]
@@ -52,6 +57,91 @@ function disposeCurrentLifecycle(ownerCtx: Context): void {
 }
 
 describe('agent scope lifecycle', () => {
+  it('rejects an already-aborted creation signal before publishing either identity', async () => {
+    const ctx = await harness()
+    const reason = new Error('cancelled before creation')
+    const controller = new AbortController()
+    controller.abort(reason)
+
+    await expect(ctx.agents.create({
+      agentId: AgentId('pre-aborted'),
+      sessionId: SessionId('pre-aborted-s'),
+      signal: controller.signal,
+    })).rejects.toBe(reason)
+
+    expect(ctx.agents.get(AgentId('pre-aborted'))).toBeUndefined()
+    expect(ctx.sessions.get(SessionId('pre-aborted-s'))).toBeUndefined()
+
+    const valueController = new AbortController()
+    valueController.abort('plain cancellation reason')
+    await expect(ctx.agents.create({
+      agentId: AgentId('pre-aborted-value'),
+      sessionId: SessionId('pre-aborted-value-s'),
+      signal: valueController.signal,
+    })).rejects.toMatchObject({
+      message: 'agent "pre-aborted-value" creation aborted',
+      cause: 'plain cancellation reason',
+    })
+
+    expect(ctx.agents.get(AgentId('pre-aborted-value'))).toBeUndefined()
+    expect(ctx.sessions.get(SessionId('pre-aborted-value-s'))).toBeUndefined()
+    await ctx.fiber.dispose()
+  })
+
+  it('joins cleanup when an abort lands reentrantly during scope preparation', async () => {
+    const ctx = await harness()
+    const reason = new Error('cancelled while preparing')
+    const controller = new AbortController()
+    let aborted = false
+    ctx.on('internal/plugin', (fiber) => {
+      if (aborted || fiber.name !== 'scope') return
+      aborted = true
+      controller.abort(reason)
+    })
+
+    await expect(ctx.agents.create({
+      agentId: AgentId('prepare-abort'),
+      sessionId: SessionId('prepare-abort-s'),
+      signal: controller.signal,
+    })).rejects.toBe(reason)
+
+    expect(ctx.agents.get(AgentId('prepare-abort'))).toBeUndefined()
+    expect(ctx.sessions.get(SessionId('prepare-abort-s'))).toBeUndefined()
+    await ctx.fiber.dispose()
+  })
+
+  it('normalizes non-Error create failures for rollback while rethrowing the original value', async () => {
+    const ctx = await harness()
+    let thrown: unknown
+    ctx.on('session/created', () => {
+      if (thrown === undefined) return
+      const value = thrown
+      thrown = undefined
+      throwUnknown(value)
+    })
+
+    const createFailure = { source: 'create' }
+    thrown = createFailure
+    let createCaught: unknown
+    try {
+      ctx.agentLoop.create(AgentId('unknown-create'))
+    } catch (error: unknown) {
+      createCaught = error
+    }
+    expect(createCaught).toBe(createFailure)
+
+    const ownedFailure = { source: 'createAgent' }
+    thrown = ownedFailure
+    await expect(ctx.agents.create({
+      agentId: AgentId('unknown-owned-create'),
+      sessionId: SessionId('unknown-owned-create-s'),
+    })).rejects.toBe(ownedFailure)
+
+    expect(ctx.agents.get(AgentId('unknown-create'))).toBeUndefined()
+    expect(ctx.agents.get(AgentId('unknown-owned-create'))).toBeUndefined()
+    await ctx.fiber.dispose()
+  })
+
   it('wires agent.ctx: tagged with the agent, DX field set, ctx.agent safe elsewhere', async () => {
     const ctx = await harness()
     const agent = ctx.agentLoop.create(AgentId('a1'), { model: 'mock' })

packages/core/agent/src/index.ts

@@ -364,6 +364,7 @@ export class AgentRegistry extends Service {
     entry.detachRequested = false
     // A stale capability can never delete a later same-id lifecycle. The
     // captured entry identity is the final boundary.
+    /* v8 ignore next -- enter() rejects replacement while this single-shot detach capability is live. */
     if (this.store.get(entry.id) !== entry) return
     this.store.delete(entry.id)
     this.entries.delete(entry.agent)

packages/core/session/src/index.ts

@@ -731,6 +731,7 @@ export class SessionStore extends Service {
     entry.detachRequested = false
     // A stale capability cannot remove observers or storage belonging to a
     // later same-id lifecycle.
+    /* v8 ignore next -- enter() rejects replacement while this single-shot detach capability is live. */
     if (this.store.get(entry.id) !== entry) return
     this.store.delete(entry.id)
     attachments.delete(entry.session)

packages/core/tools/src/index.ts

@@ -843,7 +843,8 @@ export class ToolRegistry extends Service {
     // invariant assertion as well as protection against future layer changes.
     if (this.codeTransport !== undefined) {
       visible.set(RUN_CODE_NAME, this.codeTransport)
-      if (this.codeTransport.ownerFinal === true) ownerFinalNames.add(RUN_CODE_NAME)
+      // createRunCodeTool() owns this internal transport and always marks it owner-final.
+      ownerFinalNames.add(RUN_CODE_NAME)
     }
     return { visible, knownNames, restrictableNames, ownerFinalNames }
   }

packages/core/tools/tests/scoped.spec.ts

@@ -103,6 +103,21 @@ describe('scoped tool registration', () => {
       .toThrow(/owner-final tool "reserved" cannot be registered while a scoped shadow exists/)
   })
 
+  it('restores global and scoped owner-final tools removed by assembly middleware', async () => {
+    const ctx = await mount()
+    const { scope, key } = await mintAgentScope(ctx, 'owner-final')
+    ctx.tools.register({ ...tool('required'), ownerFinal: true })
+    scope.ctx.tools.register({ ...tool('scoped-required'), ownerFinal: true })
+    ctx.on('system-prompt/assemble', async assembly => ({
+      ...assembly,
+      tools: assembly.tools.filter(schema => !schema.name.includes('required')),
+    }))
+
+    expect((await ctx.systemPrompt.assemble()).tools.map(schema => schema.name)).toContain('required')
+    expect((await ctx.systemPrompt.assemble({ scope: key })).tools.map(schema => schema.name))
+      .toEqual(expect.arrayContaining(['required', 'scoped-required']))
+  })
+
   it('disposing the scope unwinds its registrations and leaves no residue', async () => {
     const ctx = await mount()
     const { scope, key } = await mintAgentScope(ctx, 'a')