diff --git a/src/cli/fleet.test.ts b/src/cli/fleet.test.ts
index 06fbff4..9d85454 100644
--- a/src/cli/fleet.test.ts
+++ b/src/cli/fleet.test.ts
@@ -1494,6 +1494,7 @@ describe('fleet CLI runtime', () => {
 
   it('configures guarded GitHub writeback when close-probe creates a cloud mount', async () => {
     const output = buffer()
+    const errors = buffer()
     const closes: Array<{ repo: string; number: number }> = []
     const cloudMountFromConfig = vi.fn(async (opts) => {
       const mount = new FakeMountClient()
@@ -1503,6 +1504,26 @@ describe('fleet CLI runtime', () => {
           const path = `/github/repos/${input.repo}/pulls/${input.number}/close.json`
           const allowed = await opts?.isAllowedDraft?.(path, {}, { guarded: true })
           if (!allowed) throw new Error('GitHub close draft rejected by mount predicate')
+          expect(await opts?.isAllowedDraft?.(
+            `/github/repos/${input.repo}/refs/factory.json`,
+            { ref: 'refs/heads/factory/77', sha: 'abc123' },
+            { guarded: true },
+          )).toBe(true)
+          expect(await opts?.isAllowedDraft?.(
+            `/github/repos/${input.repo}/refs/refs%2Fheads%2Ffactory%2F77.json`,
+            { ref: 'refs/heads/factory/77', sha: 'abc123' },
+            { guarded: true },
+          )).toBe(true)
+          expect(await opts?.isAllowedDraft?.(
+            `/github/repos/${input.repo}/refs/refs%2Fheads%2Fmain.json`,
+            { ref: 'refs/heads/main', sha: 'abc123' },
+            { guarded: true },
+          )).toBe(false)
+          expect(await opts?.isAllowedDraft?.(
+            `/github/repos/${input.repo}/refs/arbitrary.json`,
+            { ref: 'refs/heads/factory/77', sha: 'abc123' },
+            { guarded: true },
+          )).toBe(false)
           closes.push(input)
         },
       }
@@ -1519,7 +1540,7 @@ describe('fleet CLI runtime', () => {
       'AR-77',
     ], {
       stdout: output,
-      stderr: buffer(),
+      stderr: errors,
       resolveWorkspace: async () => ({ workspaceId: 'rw_test' }),
       cloudMountFromConfig,
       probePrGhRunner: async () => ({
@@ -1532,7 +1553,7 @@ describe('fleet CLI runtime', () => {
       }),
     })
 
-    expect(code).toBe(0)
+    expect(code, errors.text()).toBe(0)
     expect(cloudMountFromConfig).toHaveBeenCalledWith(expect.objectContaining({
       workspaceId: 'rw_test',
       isAllowedDraft: expect.any(Function),
diff --git a/src/cli/fleet.ts b/src/cli/fleet.ts
index 7c2626b..60b6d03 100644
--- a/src/cli/fleet.ts
+++ b/src/cli/fleet.ts
@@ -990,7 +990,7 @@ async function isAllowedFactoryDraft(
 }
 
 const isFactoryGithubWritebackPath = (path: string): boolean =>
-  /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/refs%2Fheads%2F[^/]+\.json|pulls\/[1-9]\d*\/close\.json)$/iu.test(path)
+  /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/(?:factory\.json|refs%2Fheads%2Ffactory%2F[^/]+\.json)|pulls\/[1-9]\d*\/close\.json)$/iu.test(path)
 
 const isAllowedFactoryGithubDraft = (
   path: string,
diff --git a/src/issue-key-match.test.ts b/src/issue-key-match.test.ts
index fc3b0a1..7d24d61 100644
--- a/src/issue-key-match.test.ts
+++ b/src/issue-key-match.test.ts
@@ -16,4 +16,11 @@ describe('issue key matching', () => {
     expect(containsExplicitIssueReference('Closes AR-229', 'AR-229')).toBe(true)
     expect(containsExplicitIssueReference('This merely mentions ar-229 in passing.', 'AR-229')).toBe(false)
   })
+
+  it('does not treat numeric test counts as GitHub issue references', () => {
+    expect(containsExplicitIssueReference('tsc, eslint, and 52 tests all pass.', '52')).toBe(false)
+    expect(containsExplicitIssueReference('Fixes #52', '52')).toBe(true)
+    expect(containsExplicitIssueReference('Issue: 52', '52')).toBe(true)
+    expect(containsExplicitIssueReference('https://github.com/AgentWorkforce/hoopsheet/issues/52', '52')).toBe(true)
+  })
 })
diff --git a/src/issue-key-match.ts b/src/issue-key-match.ts
index f804b73..73b508c 100644
--- a/src/issue-key-match.ts
+++ b/src/issue-key-match.ts
@@ -16,7 +16,21 @@ export const containsIssueKey = (value: string, issueKey: string): boolean => {
 
 export const containsExplicitIssueReference = (value: string, issueKey: string): boolean => {
   const parts = ISSUE_KEY_PARTS.exec(issueKey)
-  if (!parts) return containsIssueKey(value, issueKey)
+  if (!parts) {
+    if (/^\d+$/u.test(issueKey)) {
+      const number = escapeRegex(issueKey)
+      return new RegExp(
+        [
+          `#${number}(?!\\d)`,
+          `https?://github\\.com/[^\\s/]+/[^\\s/]+/issues/${number}(?!\\d)`,
+          `(?:^|\\n)\\s*(?:github\\s+)?issue\\s*:?[ \\t]*#?${number}(?!\\d)`,
+          `(?:^|\\n)\\s*(?:closes|fixes|resolves)\\s*:?[ \\t]*#?${number}(?!\\d)`,
+        ].join('|'),
+        'i',
+      ).test(value)
+    }
+    return containsIssueKey(value, issueKey)
+  }
 
   const prefix = escapeRegex(parts[1] ?? '')
   const number = escapeRegex(parts[2] ?? '')
diff --git a/src/mount/relayfile-cloud-mount-client.test.ts b/src/mount/relayfile-cloud-mount-client.test.ts
index 883b71c..d2bd2b1 100644
--- a/src/mount/relayfile-cloud-mount-client.test.ts
+++ b/src/mount/relayfile-cloud-mount-client.test.ts
@@ -11,6 +11,7 @@ import {
   type RelayfileCloudMountClientConfig,
   type RelayFileClientLike,
 } from './relayfile-cloud-mount-client'
+import { RelayfileGithubConnectionWrite } from './relayfile-github-connection-write'
 
 const storedAuth = (overrides: Partial<StoredAuth> = {}): StoredAuth => ({
   apiUrl: 'https://cloud.example',
@@ -1066,6 +1067,51 @@ describe('RelayfileCloudMountClient', () => {
 
     await expect(mount.confirmWrite('/linear/issues/new.json', { timeoutMs: 5 }))
       .rejects.toThrow(/Field "id" is read-only/)
+    await expect(mount.getConfirmedWriteFailureReason('/linear/issues/new.json'))
+      .resolves.toBe('Field "id" is read-only and cannot be written')
+  })
+
+  it('feeds an existing-reference provider failure into the GitHub update-ref fallback', async () => {
+    const fake = new FakeRelayFileClient()
+    fake.ops.set('op-1', {
+      opId: 'op-1',
+      status: 'failed',
+      attemptCount: 1,
+      lastError: 'GitHub writeback failed with status 422: Reference already exists',
+    })
+    fake.ops.set('op-2', {
+      opId: 'op-2',
+      status: 'succeeded',
+      attemptCount: 1,
+      providerResult: { status: 200, externalId: 'factory/test-existing-ref' },
+    })
+    fake.ops.set('op-3', {
+      opId: 'op-3',
+      status: 'succeeded',
+      attemptCount: 1,
+      providerResult: { status: 201, externalId: '66' },
+    })
+    const mount = new RelayfileCloudMountClient({
+      workspaceId: 'rw_test',
+      client: fake,
+      isAllowedDraft: () => true,
+    })
+    const writer = new RelayfileGithubConnectionWrite({ mount })
+
+    await expect(writer.publishPullRequest({
+      repo: 'AgentWorkforce/factory',
+      headRef: 'factory/test-existing-ref',
+      headSha: '1234567890abcdef1234567890abcdef12345678',
+      baseRef: 'main',
+      title: 'Title',
+      body: 'Body',
+    })).resolves.toMatchObject({ number: 66 })
+
+    expect(fake.writeFileCalls.map((call) => call.path)).toEqual([
+      '/github/repos/AgentWorkforce/factory/refs/factory.json',
+      '/github/repos/AgentWorkforce/factory/refs/refs%2Fheads%2Ffactory%2Ftest-existing-ref.json',
+      expect.stringMatching(/\/github\/repos\/AgentWorkforce\/factory\/pull-requests\/factory-/u),
+    ])
   })
 
   it('delegates subscribe through the workspace-scoped event client', () => {
diff --git a/src/mount/relayfile-cloud-mount-client.ts b/src/mount/relayfile-cloud-mount-client.ts
index 899845d..9f5a6bc 100644
--- a/src/mount/relayfile-cloud-mount-client.ts
+++ b/src/mount/relayfile-cloud-mount-client.ts
@@ -184,6 +184,7 @@ export class RelayfileCloudMountClient implements MountClient {
   readonly #isAllowedDelete?: (path: string, currentContent: unknown) => boolean | Promise<boolean>
   readonly #lastOpByPath = new Map<string, string>()
   readonly #confirmedExternalIdByPath = new Map<string, string>()
+  readonly #confirmedFailureReasonByPath = new Map<string, string>()
 
   constructor(config: RelayfileCloudMountClientConfig = {}) {
     if (!config.client) {
@@ -301,6 +302,7 @@ export class RelayfileCloudMountClient implements MountClient {
 
     const serialized = serializeContent(content)
     this.#confirmedExternalIdByPath.delete(path)
+    this.#confirmedFailureReasonByPath.delete(path)
 
     const writeAtCurrentRevision = async (): Promise<WriteQueuedResponse> => {
       let baseRevision = '0'
@@ -329,6 +331,7 @@ export class RelayfileCloudMountClient implements MountClient {
 
   async deleteFile(path: string): Promise<void> {
     this.#confirmedExternalIdByPath.delete(path)
+    this.#confirmedFailureReasonByPath.delete(path)
     const current = await this.#client.readFile(this.workspaceId, path)
     const currentContent = parseRemoteContent(current)
     if (isProviderPath(path)) {
@@ -440,7 +443,13 @@ export class RelayfileCloudMountClient implements MountClient {
     const deadline = Date.now() + (opts.timeoutMs ?? 90_000)
     for (;;) {
       const operation = await this.#client.getOp(this.workspaceId, opId)
-      const status = mapOperationStatus(operation)
+      let status: 'acked' | 'pending' | 'failed'
+      try {
+        status = mapOperationStatus(operation)
+      } catch (error) {
+        this.#confirmedFailureReasonByPath.set(path, providerResultError(operation))
+        throw error
+      }
       if (status !== 'pending') {
         const providerId = [
           operation.providerResult?.externalId,
@@ -457,6 +466,10 @@ export class RelayfileCloudMountClient implements MountClient {
     }
   }
 
+  async getConfirmedWriteFailureReason(path: string): Promise<string | undefined> {
+    return this.#confirmedFailureReasonByPath.get(path)
+  }
+
   async getConfirmedWriteExternalId(path: string): Promise<string | undefined> {
     return this.#confirmedExternalIdByPath.get(path)
   }
diff --git a/src/mount/relayfile-github-connection-write.test.ts b/src/mount/relayfile-github-connection-write.test.ts
index bd93dbc..32f55f9 100644
--- a/src/mount/relayfile-github-connection-write.test.ts
+++ b/src/mount/relayfile-github-connection-write.test.ts
@@ -99,7 +99,7 @@ describe('RelayfileGithubConnectionWrite', () => {
     expect(git).toHaveBeenNthCalledWith(2, ['-C', '/work/factory', 'rev-parse', 'HEAD'])
     expect(mount.writes).toEqual([
       {
-        path: '/github/repos/AgentWorkforce/factory/refs/refs%2Fheads%2Ffix%2Fissue-52.json',
+        path: '/github/repos/AgentWorkforce/factory/refs/factory.json',
         content: {
           ref: 'refs/heads/fix/issue-52',
           sha: '1234567890abcdef1234567890abcdef12345678',
@@ -118,6 +118,48 @@ describe('RelayfileGithubConnectionWrite', () => {
     ])
   })
 
+  it('serializes concurrent create-ref confirmations that share the repository draft path', async () => {
+    const createRefPath = '/github/repos/AgentWorkforce/factory/refs/factory.json'
+    let releaseFirst!: () => void
+    const firstConfirmation = new Promise<void>((resolve) => { releaseFirst = resolve })
+    class ConcurrentRefMount extends FakeMountClient {
+      createConfirmations = 0
+
+      override async confirmWrite(path: string): Promise<'acked'> {
+        if (path === createRefPath && ++this.createConfirmations === 1) await firstConfirmation
+        return 'acked'
+      }
+
+      async getConfirmedWriteExternalId(path: string): Promise<string | undefined> {
+        if (!path.includes('/pull-requests/')) return undefined
+        return path.includes('concurrent-one') ? '71' : '72'
+      }
+    }
+    const mount = new ConcurrentRefMount()
+    const write = new RelayfileGithubConnectionWrite({ mount })
+    const publish = (headRef: string, headSha: string) => write.publishPullRequest({
+      repo: 'AgentWorkforce/factory',
+      headRef,
+      headSha,
+      baseRef: 'main',
+      title: headRef,
+      body: 'Concurrent publication proof',
+    })
+
+    const first = publish('factory/concurrent-one', '1111111111111111111111111111111111111111')
+    await vi.waitFor(() => expect(mount.createConfirmations).toBe(1))
+    const second = publish('factory/concurrent-two', '2222222222222222222222222222222222222222')
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(mount.writes.filter((entry) => entry.path === createRefPath)).toHaveLength(1)
+
+    releaseFirst()
+    await expect(Promise.all([first, second])).resolves.toMatchObject([
+      { number: 71 },
+      { number: 72 },
+    ])
+    expect(mount.writes.filter((entry) => entry.path === createRefPath)).toHaveLength(2)
+  })
+
   it('closes a pull request through its exact Relayfile writeback path', async () => {
     const mount = new FakeMountClient()
     const write = new RelayfileGithubConnectionWrite({ mount, gitRunner: gitRunner() })
@@ -132,7 +174,7 @@ describe('RelayfileGithubConnectionWrite', () => {
 
   it('fails closed when the provider does not acknowledge a write', async () => {
     const mount = new FakeMountClient()
-    const refPath = '/github/repos/AgentWorkforce/factory/refs/refs%2Fheads%2Ffix%2Fissue-52.json'
+    const refPath = '/github/repos/AgentWorkforce/factory/refs/factory.json'
     mount.setConfirmWrite(refPath, 'timeout')
     const write = new RelayfileGithubConnectionWrite({ mount, gitRunner: gitRunner() })
 
@@ -145,6 +187,89 @@ describe('RelayfileGithubConnectionWrite', () => {
     })).rejects.toThrow(`GitHub writeback did not complete for ${refPath}: timeout`)
   })
 
+  it('updates an existing branch when retrying local-clone publication', async () => {
+    const draft = 'factory-fix-issue-52-1234567890ab'
+    const createRefPath = '/github/repos/AgentWorkforce/factory/refs/factory.json'
+    const updateRefPath = '/github/repos/AgentWorkforce/factory/refs/refs%2Fheads%2Ffix%2Fissue-52.json'
+    const pullRequestPath = `/github/repos/AgentWorkforce/factory/pull-requests/${draft}.json`
+    class ExistingRefMount extends FakeMountClient {
+      override async confirmWrite(path: string): Promise<'acked' | 'failed'> {
+        return path === createRefPath ? 'failed' : 'acked'
+      }
+
+      async getConfirmedWriteFailureReason(path: string): Promise<string | undefined> {
+        return path === createRefPath
+          ? 'GitHub writeback failed with status 422: Reference already exists'
+          : undefined
+      }
+
+      override async writeFile(path: string, content: unknown, opts?: { guarded?: boolean }): Promise<void> {
+        await super.writeFile(path, content, opts)
+        if (path === pullRequestPath) {
+          this.files.set(path, { content: { created: 66, url: 'https://github.com/AgentWorkforce/factory/pull/66' } })
+        }
+      }
+    }
+    const mount = new ExistingRefMount()
+    const write = new RelayfileGithubConnectionWrite({ mount, gitRunner: gitRunner() })
+
+    await expect(write.publishPullRequest({
+      repo: 'AgentWorkforce/factory',
+      clonePath: '/work/factory',
+      baseRef: 'main',
+      title: 'Title',
+      body: 'Body',
+    })).resolves.toMatchObject({ number: 66 })
+
+    expect(mount.writes.slice(0, 2)).toEqual([
+      {
+        path: createRefPath,
+        content: {
+          ref: 'refs/heads/fix/issue-52',
+          sha: '1234567890abcdef1234567890abcdef12345678',
+        },
+      },
+      {
+        path: updateRefPath,
+        content: {
+          ref: 'refs/heads/fix/issue-52',
+          sha: '1234567890abcdef1234567890abcdef12345678',
+          force: false,
+        },
+      },
+    ])
+  })
+
+  it('recognizes an existing-reference failure from a plain provider error object', async () => {
+    const createRefPath = '/github/repos/AgentWorkforce/factory/refs/factory.json'
+    const pullRequestPath = '/github/repos/AgentWorkforce/factory/pull-requests/factory-fix-issue-52-1234567890ab.json'
+    class PlainErrorMount extends FakeMountClient {
+      override async confirmWrite(path: string): Promise<'acked'> {
+        if (path === createRefPath) {
+          throw { message: 'GitHub writeback failed with status 422: Reference already exists' }
+        }
+        return 'acked'
+      }
+
+      override async writeFile(path: string, content: unknown, opts?: { guarded?: boolean }): Promise<void> {
+        await super.writeFile(path, content, opts)
+        if (path === pullRequestPath) {
+          this.files.set(path, { content: { created: 67, url: 'https://github.com/AgentWorkforce/factory/pull/67' } })
+        }
+      }
+    }
+    const mount = new PlainErrorMount()
+    const write = new RelayfileGithubConnectionWrite({ mount, gitRunner: gitRunner() })
+
+    await expect(write.publishPullRequest({
+      repo: 'AgentWorkforce/factory',
+      clonePath: '/work/factory',
+      baseRef: 'main',
+      title: 'Title',
+      body: 'Body',
+    })).resolves.toMatchObject({ number: 67 })
+  })
+
   it('rejects publishing from the base branch before writing a ref', async () => {
     const mount = new FakeMountClient()
     const write = new RelayfileGithubConnectionWrite({ mount, gitRunner: gitRunnerForBranch('main') })
@@ -197,4 +322,37 @@ describe('RelayfileGithubConnectionWrite', () => {
     })).resolves.toMatchObject({ number: 65 })
     expect(mount.receiptReads).toBe(2)
   })
+
+  it('uses the acknowledged provider id when Relayfile reconciles the create draft', async () => {
+    const draft = 'factory-fix-issue-52-1234567890ab'
+    const pullRequestPath = `/github/repos/AgentWorkforce/hoopsheet/pull-requests/${draft}.json`
+    class ReconciledDraftMount extends FakeMountClient {
+      override async readFile(path: string): Promise<{ content: unknown; revision?: string }> {
+        if (path === pullRequestPath) throw new Error('draft was reconciled after provider acknowledgement')
+        return super.readFile(path)
+      }
+
+      override async getConfirmedWriteExternalId(path: string): Promise<string | undefined> {
+        return path === pullRequestPath ? '53' : undefined
+      }
+    }
+    const mount = new ReconciledDraftMount()
+    const write = new RelayfileGithubConnectionWrite({
+      mount,
+      gitRunner: gitRunner(),
+      receiptReadAttempts: 1,
+      receiptReadDelayMs: 0,
+    })
+
+    await expect(write.publishPullRequest({
+      repo: 'AgentWorkforce/hoopsheet',
+      clonePath: '/work/hoopsheet',
+      baseRef: 'main',
+      title: '52: Bug: Creating a new league does not work',
+      body: 'Fixes #52',
+    })).resolves.toMatchObject({
+      number: 53,
+      url: 'https://github.com/AgentWorkforce/hoopsheet/pull/53',
+    })
+  })
 })
diff --git a/src/mount/relayfile-github-connection-write.ts b/src/mount/relayfile-github-connection-write.ts
index 857dc45..b60715f 100644
--- a/src/mount/relayfile-github-connection-write.ts
+++ b/src/mount/relayfile-github-connection-write.ts
@@ -16,7 +16,7 @@ const RECEIPT_READ_DELAY_MS = 100
 export type GitCommandRunner = (args: string[]) => Promise<{ stdout: string; stderr?: string }>
 
 export interface RelayfileGithubConnectionWriteConfig {
-  mount: Pick<MountClient, 'confirmWrite' | 'readFile' | 'writeFile'>
+  mount: Pick<MountClient, 'confirmWrite' | 'getConfirmedWriteExternalId' | 'getConfirmedWriteFailureReason' | 'readFile' | 'writeFile'>
   gitRunner?: GitCommandRunner
   receiptReadAttempts?: number
   receiptReadDelayMs?: number
@@ -32,6 +32,7 @@ export class RelayfileGithubConnectionWrite implements GithubConnectionWrite {
   readonly #git: GitCommandRunner
   readonly #receiptReadAttempts: number
   readonly #receiptReadDelayMs: number
+  readonly #writesByPath = new Map<string, Promise<string | undefined>>()
 
   constructor(config: RelayfileGithubConnectionWriteConfig) {
     this.#mount = config.mount
@@ -57,19 +58,33 @@ export class RelayfileGithubConnectionWrite implements GithubConnectionWrite {
     const draftName = githubDraftName(headRef, headSha)
     const repoRoot = `/github/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`
     const fullHeadRef = `refs/heads/${headRef}`
-    const refPath = `${repoRoot}/refs/${encodeURIComponent(fullHeadRef)}.json`
-
-    // A remote implementer already pushed its branch. Only synthesize/update
-    // the ref for the legacy local-clone path where the publisher owns HEAD.
+    // Relayfile's GitHub adapter exposes one guarded draft endpoint for create
+    // and a canonical encoded endpoint for update. The draft filename is an
+    // adapter contract; the requested branch identity lives in the payload.
+    const createRefPath = `${repoRoot}/refs/factory.json`
+    const updateRefPath = `${repoRoot}/refs/${encodeURIComponent(fullHeadRef)}.json`
+
+    // A remote implementer already pushed its branch. For the legacy local-clone
+    // path, create the branch before opening the PR. Relayfile's canonical encoded
+    // ref path updates an existing ref and GitHub rejects it for a new branch.
     if (headSha) {
-      await this.#writeAndConfirm(refPath, {
-        ref: fullHeadRef,
-        sha: headSha,
-      })
+      try {
+        await this.#writeAndConfirm(createRefPath, {
+          ref: fullHeadRef,
+          sha: headSha,
+        })
+      } catch (error) {
+        if (!isGithubReferenceAlreadyExistsError(error)) throw error
+        await this.#writeAndConfirm(updateRefPath, {
+          ref: fullHeadRef,
+          sha: headSha,
+          force: false,
+        })
+      }
     }
 
     const pullRequestPath = `${repoRoot}/pull-requests/${draftName}.json`
-    await this.#writeAndConfirm(pullRequestPath, {
+    const confirmedPullRequestId = await this.#writeAndConfirm(pullRequestPath, {
       title: input.title,
       head: headRef,
       base: input.baseRef,
@@ -79,7 +94,11 @@ export class RelayfileGithubConnectionWrite implements GithubConnectionWrite {
       author: 'app',
     })
 
-    const { number, url } = await this.#readPullRequestReceipt(pullRequestPath, input.repo)
+    const { number, url } = await this.#readPullRequestReceipt(
+      pullRequestPath,
+      input.repo,
+      confirmedPullRequestId,
+    )
 
     return {
       repo: input.repo,
@@ -111,7 +130,22 @@ export class RelayfileGithubConnectionWrite implements GithubConnectionWrite {
     throw new Error(`Unable to resolve ${description} for GitHub PR publication`)
   }
 
-  async #readPullRequestReceipt(path: string, repo: string): Promise<{ number: number; url: string }> {
+  async #readPullRequestReceipt(
+    path: string,
+    repo: string,
+    confirmedExternalId?: string,
+  ): Promise<{ number: number; url: string }> {
+    // The cloud mount confirms provider success from the durable operation and
+    // retains its externalId. Relayfile may immediately reconcile (rename or
+    // remove) the authored draft, so reading that draft is not a reliable way
+    // to recover the receipt after an acknowledged create.
+    const confirmedNumber = positiveInteger(confirmedExternalId)
+    if (confirmedNumber) {
+      return {
+        number: confirmedNumber,
+        url: `https://github.com/${repo}/pull/${confirmedNumber}`,
+      }
+    }
     for (let attempt = 0; attempt < this.#receiptReadAttempts; attempt += 1) {
       try {
         const receipt = record((await this.#mount.readFile(path)).content)
@@ -128,12 +162,29 @@ export class RelayfileGithubConnectionWrite implements GithubConnectionWrite {
     throw new Error(`GitHub pull request writeback returned an incomplete receipt for ${repo}`)
   }
 
-  async #writeAndConfirm(path: string, content: unknown): Promise<void> {
+  async #writeAndConfirm(path: string, content: unknown): Promise<string | undefined> {
+    const previous = this.#writesByPath.get(path) ?? Promise.resolve(undefined)
+    const current = previous
+      .catch(() => undefined)
+      .then(async () => await this.#writeAndConfirmUnlocked(path, content))
+    this.#writesByPath.set(path, current)
+    try {
+      return await current
+    } finally {
+      if (this.#writesByPath.get(path) === current) this.#writesByPath.delete(path)
+    }
+  }
+
+  async #writeAndConfirmUnlocked(path: string, content: unknown): Promise<string | undefined> {
     await this.#mount.writeFile(path, content, { guarded: true })
     const status = await this.#mount.confirmWrite(path, { timeoutMs: WRITE_CONFIRM_TIMEOUT_MS })
     if (status !== 'acked') {
-      throw new Error(`GitHub writeback did not complete for ${path}: ${status}`)
+      const failureReason = status === 'failed'
+        ? await this.#mount.getConfirmedWriteFailureReason?.(path)
+        : undefined
+      throw new Error(`GitHub writeback did not complete for ${path}: ${failureReason ?? status}`)
     }
+    return this.#mount.getConfirmedWriteExternalId?.(path)
   }
 }
 
@@ -174,4 +225,13 @@ const nonNegativeInteger = (value: unknown): number | undefined =>
 
 const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))
 
-const errorMessage = (error: unknown): string => error instanceof Error ? error.message : String(error)
+const errorMessage = (error: unknown): string => {
+  if (error instanceof Error) return error.message
+  if (error !== null && typeof error === 'object' && 'message' in error) {
+    return String((error as { message?: unknown }).message)
+  }
+  return String(error)
+}
+
+const isGithubReferenceAlreadyExistsError = (error: unknown): boolean =>
+  /reference already exists/iu.test(errorMessage(error))
diff --git a/src/orchestrator/factory.test.ts b/src/orchestrator/factory.test.ts
index d108c02..2f15c87 100644
--- a/src/orchestrator/factory.test.ts
+++ b/src/orchestrator/factory.test.ts
@@ -135,6 +135,7 @@ const githubIssueFile = (
     labels?: Array<string | { name: string }>
     url?: string
     author?: string
+    updatedAt?: string
   } = {},
 ) => {
   const owner = payload.owner ?? 'AgentWorkforce'
@@ -148,6 +149,7 @@ const githubIssueFile = (
       title: payload.title ?? `GitHub factory issue ${number}`,
       body: payload.body ?? 'Implement the requested GitHub issue change and verify it with tests.',
       state: payload.state ?? 'open',
+      updated_at: payload.updatedAt,
       labels: payload.labels ?? [{ name: 'factory' }],
       url: payload.url ?? `https://github.com/${owner}/${repo}/issues/${number}`,
       author: { login: payload.author ?? 'issue-author' },
@@ -1619,7 +1621,7 @@ describe('FactoryLoop', () => {
   it('dispatches a labeled GitHub issue without Linear and writes in-progress then human-review to GitHub', async () => {
     const path = githubIssuePath('AgentWorkforce', 'pear', 48)
     const mount = new FakeMountClient({
-      [path]: githubIssueFile(48, { labels: ['factory'] }),
+      [path]: githubIssueFile(48, { labels: ['factory', 'bug'] }),
     })
     mount.setSubRoot('/linear/issues', 'absent')
     const fleet = new FakeFleetClient()
@@ -1901,24 +1903,165 @@ describe('FactoryLoop', () => {
     }
   })
 
-  it('preserves an in-progress GitHub issue when a matching open PR exists', async () => {
+  it('prioritizes fresh GitHub-ready work ahead of orphan recovery', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'factory-ready-before-orphans-'))
+    try {
+      const orphanPath = githubIssuePath('AgentWorkforce', 'pear', 11)
+      const freshPath = githubIssuePath('AgentWorkforce', 'pear', 52)
+      const mount = new FakeMountClient({
+        [orphanPath]: githubIssueFile(11, { labels: ['factory', 'pear', 'factory:in-progress'] }),
+        [freshPath]: githubIssueFile(52, { labels: ['factory', 'pear'] }),
+      })
+      const fleet = new FakeFleetClient()
+      const githubWriteback = new RecordingGithubWriteback()
+      const factory = createFactory(config({
+        issueSource: 'github',
+        batchSize: 1,
+        loop: { registryPath: join(root, 'registry.json') },
+      }), {
+        mount,
+        fleet,
+        triage: new StaticTriage(),
+        githubWriteback,
+        probePrGhRunner: async () => ({ stdout: '[]' }),
+      })
+
+      const report = await factory.runOnce()
+
+      expect(report.dispatched.map((result) => result.issue.key)).toEqual(['52'])
+      expect(fleet.spawns.map((spawn) => spawn.name)).toEqual(['ar-52-impl-pear', 'ar-52-review-pear'])
+      expect(factory.status().queued.map((issue) => issue.key)).toEqual(['11'])
+      expect(githubWriteback.statuses[0]).toEqual({ key: '52', status: 'in-progress' })
+      expect(githubWriteback.statuses).toContainEqual({ key: '11', status: 'ready' })
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it('reconciles the most recently updated GitHub orphan before an older numeric backlog', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'factory-newest-orphan-first-'))
+    try {
+      const olderPath = githubIssuePath('AgentWorkforce', 'pear', 11)
+      const interruptedPath = githubIssuePath('AgentWorkforce', 'pear', 52)
+      const mount = new FakeMountClient({
+        [olderPath]: githubIssueFile(11, {
+          labels: ['factory', 'pear', 'factory:in-progress'],
+          updatedAt: '2026-07-17T12:00:00.000Z',
+        }),
+        [interruptedPath]: githubIssueFile(52, {
+          labels: ['factory', 'pear', 'factory:in-progress'],
+          updatedAt: '2026-07-18T12:00:00.000Z',
+        }),
+      })
+      const fleet = new FakeFleetClient()
+      const factory = createFactory(config({
+        issueSource: 'github',
+        batchSize: 1,
+        loop: { registryPath: join(root, 'registry.json') },
+      }), {
+        mount,
+        fleet,
+        triage: new StaticTriage(),
+        githubWriteback: new RecordingGithubWriteback(),
+        probePrGhRunner: async () => ({ stdout: '[]' }),
+      })
+
+      const report = await factory.runOnce()
+
+      expect(report.dispatched.map((result) => result.issue.key)).toEqual(['52'])
+      expect(fleet.spawns.map((spawn) => spawn.name)).toEqual(['ar-52-impl-pear', 'ar-52-review-pear'])
+      expect(factory.status().queued.map((issue) => issue.key)).toEqual(['11'])
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it.each([true, false])(
+    'continues startup reconciliation when an issue changes state during dispatch (worktrees: %s)',
+    async (withWorktrees) => {
+    const racedPath = githubIssuePath('AgentWorkforce', 'pear', 59)
+    const freshPath = githubIssuePath('AgentWorkforce', 'pear', 60)
+    const racedReady = githubIssueFile(59, { labels: ['factory', 'pear'] })
+    class ConcurrentStateChangeMount extends FakeMountClient {
+      racedReads = 0
+
+      override async readFile(path: string): Promise<{ content: unknown; revision?: string }> {
+        if (path === racedPath) {
+          this.racedReads += 1
+          if (this.racedReads >= 3) {
+            return {
+              content: githubIssueFile(59, { labels: ['factory', 'pear', 'factory:in-progress'] }),
+            }
+          }
+        }
+        return super.readFile(path)
+      }
+    }
+    const mount = new ConcurrentStateChangeMount({
+      [racedPath]: racedReady,
+      [freshPath]: githubIssueFile(60, { labels: ['factory', 'pear'] }),
+    })
+    const fleet = new FakeFleetClient()
+    const worktrees = new RecordingWorktreeManager()
+    const factory = createFactory(config({ issueSource: 'github', batchSize: 4 }), {
+      mount,
+      fleet,
+      triage: new StaticTriage(),
+      githubWriteback: new RecordingGithubWriteback(),
+      ...(withWorktrees ? { worktrees } : {}),
+    })
+
+    const report = await factory.runOnce()
+
+    expect(report.skipped).toContainEqual({
+      issue: { uuid: 'AgentWorkforce/pear#59', key: '59', path: racedPath },
+      reason: 'live state changed during dispatch',
+    })
+    expect(report.dispatched.map((result) => result.issue.key)).toEqual(['60'])
+    expect(fleet.spawns.map((spawn) => spawn.name)).toEqual([
+      'ar-59-impl-pear',
+      'ar-59-review-pear',
+      'ar-60-impl-pear',
+      'ar-60-review-pear',
+    ])
+    expect(fleet.releases.map((release) => release.name).sort()).toEqual([
+      'ar-59-impl-pear',
+      'ar-59-review-pear',
+    ])
+    expect(factory.status().counters.dispatchLiveStateRaces).toBe(1)
+    expect(factory.status().counters.errors ?? 0).toBe(0)
+    },
+  )
+
+  it('adopts an orphaned in-progress GitHub issue when its ready PR already exists', async () => {
     const root = await mkdtemp(join(tmpdir(), 'factory-orphan-open-pr-'))
     try {
       const path = githubIssuePath('AgentWorkforce', 'pear', 53)
       const mount = new FakeMountClient({
         [path]: githubIssueFile(53, { labels: ['factory', 'pear', 'factory:in-progress'] }),
       })
-      const fleet = new FakeFleetClient()
+      const fleet = new RemoteLifecycleFleetClient()
+      const worktrees = new RecordingWorktreeManager()
       const githubWriteback = new RecordingGithubWriteback()
+      const stateStore = new InMemoryStateStore({ batchSize: 2 })
       const factory = createFactory(config({
         issueSource: 'github',
+        babysitter: { enabled: true },
+        terminalState: 'human-review',
         loop: { registryPath: join(root, 'registry.json') },
       }), {
         mount,
         fleet,
         triage: new StaticTriage(),
         githubWriteback,
-        probePrResolver: async () => ({ repo: 'AgentWorkforce/pear', prNumber: 153 }),
+        stateStore,
+        worktrees,
+        probePrResolver: async () => ({
+          repo: 'AgentWorkforce/pear',
+          prNumber: 153,
+          headRef: 'factory/53-agentworkforce-pear-proof',
+          url: 'https://github.com/AgentWorkforce/pear/pull/153',
+        }),
       })
 
       const report = await factory.runOnce()
@@ -1928,14 +2071,135 @@ describe('FactoryLoop', () => {
         issue: { uuid: 'AgentWorkforce/pear#53', key: '53', path },
         reason: 'live state is not ready-for-agent',
       }])
-      expect(fleet.spawns).toEqual([])
+      expect(fleet.spawns.map((spawn) => spawn.name)).toEqual(['ar-53-babysit-pear'])
+      expect(fleet.spawns[0]).toMatchObject({
+        repo: 'AgentWorkforce/pear',
+        cwd: expect.stringMatching(/\/\.factory-worktrees\/pear\/53-pear-[a-z0-9]+$/u),
+      })
+      expect(fleet.spawns[0]?.task)
+        .toContain('Continue in the existing isolated issue worktree on branch `factory/53-agentworkforce-pear-proof`.')
+      expect(worktrees.prepared).toEqual([expect.objectContaining({
+        issueKey: '53',
+        branch: 'factory/53-agentworkforce-pear-proof',
+      })])
       expect(githubWriteback.statuses).toEqual([])
       expect(factory.status().counters.githubOrphanRecoveriesBlockedOpenPr).toBe(1)
+      expect(factory.status().counters.githubOrphanedPullRequestsAdopted).toBe(1)
+      expect(factory.status().inFlight.map((issue) => issue.key)).toEqual(['53'])
+      expect(await stateStore.getDispatchLifecycle('factory-test', issueKey({
+        uuid: 'AgentWorkforce/pear#53',
+        key: '53',
+        path,
+      }))).toMatchObject({
+        phase: 'running',
+        pullRequest: {
+          repo: 'AgentWorkforce/pear',
+          number: 153,
+          headRef: 'factory/53-agentworkforce-pear-proof',
+        },
+      })
     } finally {
       await rm(root, { recursive: true, force: true })
     }
   })
 
+  it('queues an orphaned open PR and promotes it directly to a babysitter when capacity opens', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'factory-orphan-open-pr-queued-'))
+    const clock = new ManualClock()
+    const stateStore = new InMemoryStateStore({ batchSize: 1 })
+    const runningPath = githubIssuePath('AgentWorkforce', 'pear', 54)
+    const adoptedPath = githubIssuePath('AgentWorkforce', 'pear', 53)
+    const mount = new FakeMountClient({
+      [runningPath]: githubIssueFile(54, {
+        labels: ['factory', 'pear'],
+        updatedAt: '2026-07-18T12:00:00.000Z',
+      }),
+      [adoptedPath]: githubIssueFile(53, {
+        labels: ['factory', 'pear', 'factory:in-progress'],
+        updatedAt: '2026-07-18T11:00:00.000Z',
+      }),
+    })
+    const firstFleet = new RemoteLifecycleFleetClient()
+    const worktrees = new RecordingWorktreeManager()
+    const githubWriteback = new RecordingGithubWriteback()
+    const factoryConfig = config({
+      issueSource: 'github',
+      batchSize: 1,
+      babysitter: { enabled: true },
+      terminalState: 'human-review',
+      loop: { registryPath: join(root, 'registry.json') },
+    })
+    const dependencies = {
+      mount,
+      stateStore,
+      triage: new StaticTriage(),
+      githubWriteback,
+      worktrees,
+      clock,
+      probePrResolver: async (issue: LinearIssue) => issue.key === '53'
+        ? {
+            repo: 'AgentWorkforce/pear',
+            prNumber: 153,
+            headRef: 'factory/53-agentworkforce-pear-proof',
+            url: 'https://github.com/AgentWorkforce/pear/pull/153',
+          }
+        : undefined,
+    }
+    const first = createFactory(factoryConfig, { ...dependencies, fleet: firstFleet })
+    let restarted: ReturnType<typeof createFactory> | undefined
+    try {
+      await first.runOnce()
+
+      expect(firstFleet.spawns.map((spawn) => spawn.name)).toEqual(['ar-54-impl-pear', 'ar-54-review-pear'])
+      const adoptedRef = { uuid: 'AgentWorkforce/pear#53', key: '53', path: adoptedPath }
+      expect(await stateStore.getDispatchLifecycle('factory-test', issueKey(adoptedRef))).toMatchObject({
+        phase: 'queued',
+        pullRequest: {
+          repo: 'AgentWorkforce/pear',
+          number: 153,
+          headRef: 'factory/53-agentworkforce-pear-proof',
+        },
+      })
+      expect(first.status().counters.githubOrphanedPullRequestsAdopted).toBe(1)
+
+      await first.stop()
+      clock.advance(5 * 60_000)
+      const runningRef = { uuid: 'AgentWorkforce/pear#54', key: '54', path: runningPath }
+      const runningKey = issueKey(runningRef)
+      const running = await stateStore.getDispatchLifecycle('factory-test', runningKey)
+      expect(running).toBeDefined()
+      const completion = await stateStore.claimDispatchLifecycle(
+        'factory-test',
+        runningKey,
+        running!,
+        'test-completer',
+        clock.now(),
+        60_000,
+      )
+      expect(completion.acquired).toBe(true)
+      expect(await stateStore.saveDispatchLifecycle(
+        'factory-test',
+        runningKey,
+        'test-completer',
+        completion.lease!.epoch,
+        clock.now(),
+        { ...completion.lifecycle, phase: 'complete', updatedAtMs: clock.now() },
+      )).toBe(true)
+
+      const restartedFleet = new RemoteLifecycleFleetClient()
+      restarted = createFactory(factoryConfig, { ...dependencies, fleet: restartedFleet })
+      await restarted.start({ mode: 'dispatch-owner' })
+      await vi.waitFor(() => expect(restartedFleet.spawns.map((spawn) => spawn.name))
+        .toEqual(['ar-53-babysit-pear']), { timeout: 4_000 })
+      expect(restartedFleet.spawns.some((spawn) => spawn.name.includes('-impl-') || spawn.name.includes('-review-')))
+        .toBe(false)
+    } finally {
+      await restarted?.stop()
+      await first.stop()
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
   it('preserves an in-progress GitHub issue while its registered agent is still online', async () => {
     const root = await mkdtemp(join(tmpdir(), 'factory-orphan-active-agent-'))
     try {
@@ -4009,6 +4273,111 @@ describe('FactoryLoop', () => {
     }
   })
 
+  it('reconciles the exact existing branch after PR creation succeeded before receipt persistence', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'factory-publish-reconcile-existing-'))
+    const watchStatePath = join(root, 'state.json')
+    let publishAttempts = 0
+    let branch: string | undefined
+    const githubWrite: GithubConnectionWrite = {
+      publishPullRequest: async (input) => {
+        publishAttempts += 1
+        branch = input.headRef
+        mount.files.set('/github/repos/AgentWorkforce/pear/pulls/1186/metadata.json', { content: {
+          number: 1186,
+          state: 'open',
+          draft: false,
+          head_ref: branch,
+          url: 'https://github.com/AgentWorkforce/pear/pull/1186',
+        } })
+        throw new Error('receipt was lost after the provider created the PR')
+      },
+      closePullRequest: async () => undefined,
+    }
+    const mount = new FakeMountClient({
+      [issuePath(186)]: issueFile(186),
+      '/github/repos/AgentWorkforce/pear/meta.json': { default_branch: 'main' },
+    }, githubWrite)
+    const fleet = new RemoteLifecycleFleetClient()
+    const stateStore = new FileStateStore({ batchSize: 2, watchStatePath })
+    const factory = createFactory(config(), {
+      mount,
+      fleet,
+      stateStore,
+      triage: new StaticTriage(),
+      probePrResolver: async () => undefined,
+    })
+    try {
+      const decision = await factory.triageIssue(parseLinearIssue(issuePath(186), issueFile(186)))
+      await factory.dispatch(decision)
+      const lifecycle = await stateStore.getDispatchLifecycle('factory-test', issueKey(decision.issue))
+      expect(lifecycle?.decision.implementers[0]?.branch)
+        .toEqual(expect.stringMatching(/^factory\/ar-186-agentworkforce-pear-[0-9a-f]{8}$/u))
+
+      fleet.emitAgentExit('ar-186-impl-pear', 'exited')
+
+      await vi.waitFor(() => expect(factory.status().counters.done).toBe(1), { timeout: 4_000 })
+      expect(branch).toBe(lifecycle?.decision.implementers[0]?.branch)
+      expect(publishAttempts).toBe(1)
+      expect(factory.status().counters.githubPullRequestsReconciled).toBe(1)
+      expect(fleet.resumes).toEqual([])
+      expect(fleet.releases.map((release) => release.name).sort()).toEqual(['ar-186-impl-pear', 'ar-186-review'])
+    } finally {
+      await factory.stop()
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it('does not reconcile an existing branch when its PR draft state is unknown', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'factory-publish-reject-unknown-draft-'))
+    const watchStatePath = join(root, 'state.json')
+    let publishAttempts = 0
+    const githubWrite: GithubConnectionWrite = {
+      publishPullRequest: async (input) => {
+        publishAttempts += 1
+        if (publishAttempts === 1) {
+          mount.files.set('/github/repos/AgentWorkforce/pear/pulls/1187/metadata.json', { content: {
+            number: 1187,
+            state: 'open',
+            head_ref: input.headRef,
+            url: 'https://github.com/AgentWorkforce/pear/pull/1187',
+          } })
+          throw new Error('receipt was lost after the provider created a PR with unknown draft state')
+        }
+        return {
+          repo: input.repo,
+          number: 1188,
+          url: 'https://github.com/AgentWorkforce/pear/pull/1188',
+          headRef: input.headRef!,
+        }
+      },
+      closePullRequest: async () => undefined,
+    }
+    const mount = new FakeMountClient({
+      [issuePath(187)]: issueFile(187),
+      '/github/repos/AgentWorkforce/pear/meta.json': { default_branch: 'main' },
+    }, githubWrite)
+    const fleet = new RemoteLifecycleFleetClient()
+    const factory = createFactory(config(), {
+      mount,
+      fleet,
+      stateStore: new FileStateStore({ batchSize: 2, watchStatePath }),
+      triage: new StaticTriage(),
+      probePrResolver: async () => undefined,
+    })
+    try {
+      const decision = await factory.triageIssue(parseLinearIssue(issuePath(187), issueFile(187)))
+      await factory.dispatch(decision)
+      fleet.emitAgentExit('ar-187-impl-pear', 'exited')
+
+      await vi.waitFor(() => expect(factory.status().counters.done).toBe(1), { timeout: 4_000 })
+      expect(publishAttempts).toBe(2)
+      expect(factory.status().counters.githubPullRequestsReconciled).toBeUndefined()
+    } finally {
+      await factory.stop()
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
   it('reuses the provider receipt after losing the lifecycle lease between publication and persistence', async () => {
     class RejectFirstPublishedSaveStore extends FileStateStore {
       rejected = false
@@ -7397,12 +7766,14 @@ describe('FactoryLoop', () => {
   it('signals and releases a waiting reviewer when an implementer resume collides and no PR exists (#67)', async () => {
     const mount = new FakeMountClient({ [issuePath(82)]: issueFile(82) })
     const fleet = new ResumeNameCollisionFleetClient()
+    const worktrees = new RecordingWorktreeManager()
     fleet.setSessionRef('ar-82-impl-pear', 'session-impl-82')
     const factory = createFactory(config(), {
       mount,
       fleet,
       triage: new StaticTriage(),
       probePrResolver: async () => undefined,
+      worktrees,
     })
     const decision = await factory.triageIssue(parseLinearIssue(issuePath(82), issueFile(82)))
 
@@ -7418,13 +7789,101 @@ describe('FactoryLoop', () => {
     expect(reviewerSignal).toBeDefined()
     expect(reviewerSignal?.text).toMatch(/terminated/i)
     // ... and then torn down so the dispatch does not hang.
-    expect(fleet.releases.map((release) => release.name)).toContain('ar-82-review')
+    await vi.waitFor(() => expect(worktrees.cleaned).toHaveLength(1))
+    expect(fleet.releases.map((release) => release.name).sort()).toEqual(['ar-82-impl-pear', 'ar-82-review'])
     expect(factory.status().counters.resumeNameCollisions).toBe(1)
     expect(factory.status().counters.issuesStalledNoPr).toBe(1)
     expect(factory.status().counters.errors ?? 0).toBe(0)
     expect(factory.status().inFlight).toEqual([])
   })
 
+  it('releases non-worktree agents while tearing down a mixed abandoned dispatch', async () => {
+    const path = issuePath(820)
+    const issue = realIssueFile(820, ready, {
+      labels: [{ name: 'pear' }, { name: 'remote' }, { name: 'factory:team' }],
+    })
+    const mount = new FakeMountClient({ [path]: issue })
+    const fleet = new ResumeNameCollisionFleetClient()
+    const worktrees = new RecordingWorktreeManager()
+    fleet.setSessionRef('ar-820-impl-pear', 'session-impl-820')
+    const factory = createFactory(config({
+      repos: {
+        byLabel: {
+          pear: 'AgentWorkforce/pear',
+          remote: 'AgentWorkforce/remote',
+        },
+        clonePaths: { 'AgentWorkforce/pear': '/work/pear' },
+        default: 'AgentWorkforce/pear',
+      },
+    }), {
+      mount,
+      fleet,
+      triage: new StaticTriage(),
+      probePrResolver: async () => undefined,
+      worktrees,
+    })
+    const decision = await factory.triageIssue(parseLinearIssue(path, issue))
+
+    await factory.dispatch(decision)
+    fleet.emitAgentExit('ar-820-impl-pear', 'crash')
+
+    await vi.waitFor(() => expect(worktrees.cleaned).toHaveLength(1))
+    expect(fleet.releases.map((release) => release.name).sort()).toEqual([
+      'ar-820-impl-pear',
+      'ar-820-impl-remote',
+      'ar-820-review',
+    ])
+    expect(factory.status().inFlight).toEqual([])
+  })
+
+  it('retains mixed abandoned-dispatch ownership until a failed agent release succeeds', async () => {
+    class FailOnceReleaseFleet extends ResumeNameCollisionFleetClient {
+      failed = false
+
+      override async release(name: string, reason?: string): Promise<void> {
+        if (name === 'ar-821-impl-remote' && !this.failed) {
+          this.failed = true
+          throw new Error('transient remote release failure')
+        }
+        await super.release(name, reason)
+      }
+    }
+
+    const path = issuePath(821)
+    const issue = realIssueFile(821, ready, {
+      labels: [{ name: 'pear' }, { name: 'remote' }, { name: 'factory:team' }],
+    })
+    const mount = new FakeMountClient({ [path]: issue })
+    const fleet = new FailOnceReleaseFleet()
+    const worktrees = new RecordingWorktreeManager()
+    fleet.setSessionRef('ar-821-impl-pear', 'session-impl-821')
+    const factory = createFactory(config({
+      repos: {
+        byLabel: {
+          pear: 'AgentWorkforce/pear',
+          remote: 'AgentWorkforce/remote',
+        },
+        clonePaths: { 'AgentWorkforce/pear': '/work/pear' },
+        default: 'AgentWorkforce/pear',
+      },
+    }), {
+      mount,
+      fleet,
+      triage: new StaticTriage(),
+      probePrResolver: async () => undefined,
+      worktrees,
+    })
+    const decision = await factory.triageIssue(parseLinearIssue(path, issue))
+
+    await factory.dispatch(decision)
+    fleet.emitAgentExit('ar-821-impl-pear', 'crash')
+
+    await vi.waitFor(() => expect(factory.status().counters.abandonedDispatchReleaseRetries).toBe(1))
+    expect(factory.status().inFlight.map((entry) => entry.key)).toEqual(['AR-821'])
+    await vi.waitFor(() => expect(factory.status().inFlight).toEqual([]), { timeout: 3_000 })
+    expect(fleet.releases.map((release) => release.name)).toContain('ar-821-impl-remote')
+  })
+
   // If the PR the implementer opened becomes visible only after the collision
   // (mount lag at exit time is why we fell through to resume), re-probing lets
   // the dispatch complete cleanly and release the reviewer instead of abandoning.
@@ -7699,7 +8158,7 @@ describe('FactoryLoop', () => {
     })
   })
 
-  it('emits an escalation on delivery_failed for an in-flight agent', async () => {
+  it('ignores an untracked delivery_failed event for an in-flight agent', async () => {
     const mount = new FakeMountClient({ [issuePath(8)]: issueFile(8) })
     const fleet = new FakeFleetClient()
     const factory = createFactory(config(), { mount, fleet, triage: new StaticTriage() })
@@ -7712,11 +8171,38 @@ describe('FactoryLoop', () => {
     fleet.emitDeliveryFailed({ to: 'ar-8-review', reason: 'dead-lettered' })
     await flush()
 
-    expect(errors).toHaveLength(1)
-    expect(errors[0]).toMatchObject({ issue: { key: 'AR-8' } })
+    expect(errors).toEqual([])
+    expect(factory.status().counters.nonCriticalDeliveryFailuresIgnored).toBe(1)
     await factory.stop()
   })
 
+  it('surfaces a tracked critical delivery failure once without retrying a dead worker', async () => {
+    const mount = new FakeMountClient({ [issuePath(68)]: issueFile(68) })
+    const fleet = new FakeFleetClient()
+    const stateStore = new InMemoryStateStore({ batchSize: 2 })
+    const factory = createFactory(config(), { mount, fleet, triage: new StaticTriage(), stateStore })
+    const errors: unknown[] = []
+    factory.on('error', (payload) => errors.push(payload))
+    const decision = await factory.triageIssue(parseLinearIssue(issuePath(68), issueFile(68)))
+
+    await factory.dispatch(decision)
+    await stateStore.recordCritical('factory-test', 'critical-68', {
+      issue: decision.issue,
+      input: { to: 'ar-68-review', from: 'factory', text: 'Review the completed PR.' },
+    })
+    fleet.emitDeliveryFailed({
+      to: 'ar-68-review',
+      msgId: 'critical-68',
+      reason: 'max delivery retries exceeded',
+    })
+    await flush()
+
+    expect(errors).toHaveLength(1)
+    expect(errors[0]).toMatchObject({ issue: { key: 'AR-68' } })
+    expect(fleet.messages).toEqual([])
+    expect(factory.status().counters.criticalDeliveryTerminalFailures).toBe(1)
+  })
+
   it('delivers the complete implementer and reviewer briefings in their spawn tasks', async () => {
     const mount = new FakeMountClient({ [issuePath(62)]: issueFile(62) })
     const fleet = new FakeFleetClient()
@@ -7800,8 +8286,8 @@ describe('FactoryLoop', () => {
       .toContain('Linear issue: AR-63')
     expect(fleet.messages).toEqual([])
     expect(fleet.inputs).toEqual([])
-    expect(errors).toHaveLength(1)
-    expect(errors[0]).toMatchObject({ issue: { key: 'AR-63' } })
+    expect(errors).toEqual([])
+    expect(factory.status().counters.nonCriticalDeliveryFailuresIgnored).toBe(1)
   })
 
   it('does not retry an obsolete reviewer handoff injection after delivery_failed', async () => {
@@ -9753,7 +10239,11 @@ describe('FactoryLoop', () => {
     expect(slackRoots).toHaveLength(1)
     expect((slackRoots[0]?.content as { text?: string }).text).toContain('AR-20: factory triage escalation for [factory-e2e] Fix factory issue 20')
     expect((slackRoots[0]?.content as { text?: string }).text).toContain('Reason: low-confidence triage and thin issue context: Matched repository from Linear label.')
-    expect((slackRoots[0]?.content as { text?: string }).text).toContain('Question: Factory matched AgentWorkforce/pear. Please clarify the concrete expected behavior, constraints, and acceptance criteria/tests before dispatch.')
+    expect((slackRoots[0]?.content as { text?: string }).text).toContain('Question: Factory matched AgentWorkforce/pear.')
+    expect((slackRoots[0]?.content as { text?: string }).text).toContain('For "[factory-e2e] Fix factory issue 20", please reply with:')
+    expect((slackRoots[0]?.content as { text?: string }).text).toContain('(1) the exact user flow—where it starts, required inputs/actions, and the successful result;')
+    expect((slackRoots[0]?.content as { text?: string }).text).toContain('(3) observable acceptance checks or tests.')
+    expect((slackRoots[0]?.content as { text?: string }).text).toContain('successful work will be opened as a pull request.')
     expect(factory.status().counters.errors).toBeUndefined()
     expect(factory.status().counters.triageEscalations).toBe(1)
     expect(slack.roots).toEqual([])
@@ -9763,11 +10253,13 @@ describe('FactoryLoop', () => {
     const path = githubIssuePath('AgentWorkforce', 'pear', 55)
     const mount = new CountingEventsMount({ [path]: githubIssueFile(55, { labels: ['factory'] }) })
     const githubWriteback = new RecordingGithubWriteback()
+    const stateStore = new InMemoryStateStore({ batchSize: 4 })
     const factory = createFactory(config({ issueSource: 'github' }), {
       mount,
       fleet: new FakeFleetClient(),
       triage: new EscalatingTriage({ rationale: 'Issue lacks acceptance criteria.' }),
       githubWriteback,
+      stateStore,
     })
 
     const report = await factory.runOnce()
@@ -9777,6 +10269,9 @@ describe('FactoryLoop', () => {
     expect(githubWriteback.comments[0]?.body).toContain('Factory needs clarification before dispatching 55.')
     expect(githubWriteback.comments[0]?.body).toContain('Reason: low-confidence triage and thin issue context: Issue lacks acceptance criteria.')
     expect(githubWriteback.comments[0]?.body).toContain('Question: Factory matched AgentWorkforce/pear.')
+    expect(githubWriteback.comments[0]?.body).toContain('For "GitHub factory issue 55", please reply with:')
+    expect(githubWriteback.comments[0]?.body).toContain('(2) permissions, validation, failure behavior, important edge cases, and anything out of scope;')
+    expect(githubWriteback.comments[0]?.body).toContain('successful work will be opened as a pull request.')
     expect(githubWriteback.comments[0]?.body).toMatch(/<!-- factory-escalation:factory-triage-/u)
     expect(factory.status().counters.triageEscalationsPostedToGithub).toBe(1)
     expect(factory.status().counters.errors).toBeUndefined()
@@ -9797,6 +10292,15 @@ describe('FactoryLoop', () => {
       glob,
       '/github/repos/OtherOrg/pear/issues/55/comments/9003/meta.json',
     ))).toBe(false)
+
+    const issue = parseGithubFactoryIssue(path, githubIssueFile(55, { labels: ['factory'] }))
+    const actionableDecision = await new StaticTriage().triage(issue)
+    await factory.dispatch(actionableDecision)
+
+    const watches = await stateStore.listGithubIssueCommentWatches('factory-test')
+    expect(watches).toHaveLength(1)
+    expect(watches[0]?.[1]).toMatchObject({ detectAgentQuestions: true, pending: [] })
+    expect(factory.status().counters.triageEscalationsSupersededByActionableIssue).toBe(1)
   })
 
   it('preserves the GitHub reporter on a Linear mirror and authorizes their escalation reply', async () => {
@@ -9881,7 +10385,20 @@ describe('FactoryLoop', () => {
 
   it('keeps GitHub clarification durable on GitHub and mirrors one stakeholder escalation to Slack', async () => {
     const path = githubIssuePath('AgentWorkforce', 'pear', 56)
-    const mount = new CloudWritebackFakeMountClient({ [path]: githubIssueFile(56, { labels: ['factory'] }) })
+    const mount = new CloudWritebackFakeMountClient({
+      [path]: githubIssueFile(56, { labels: ['factory'] }),
+      '/slack/channels/C0PRODUCT__product/messages/1780751600_000001/meta.json': {
+        provider: 'slack',
+        objectType: 'message',
+        payload: {
+          user: 'UISSUEAUTHOR',
+          user_name: 'issue-author',
+          user_real_name: 'Issue Author',
+          user_is_bot: false,
+          text: 'A previously mounted message from the GitHub reporter.',
+        },
+      },
+    })
     const githubWriteback = new RecordingGithubWriteback()
     const factory = createFactory(config({
       issueSource: 'github',
@@ -9901,12 +10418,13 @@ describe('FactoryLoop', () => {
     const slackRoots = mount.writes.filter((write) => isSlackRootWritePath(write.path))
     expect(slackRoots).toHaveLength(1)
     expect((slackRoots[0]?.content as { text?: string }).text).toContain('<@UOWNER> <@ULEAD>')
-    expect((slackRoots[0]?.content as { text?: string }).text).toContain('GitHub reporter: @issue-author.')
+    expect((slackRoots[0]?.content as { text?: string }).text).toContain('GitHub reporter: <@UISSUEAUTHOR>.')
     expect((slackRoots[0]?.content as { text?: string }).text)
       .toContain('Reply on the GitHub issue so Factory can resume: https://github.com/AgentWorkforce/pear/issues/56')
     expect(factory.status().counters.triageEscalationsPostedToGithub).toBe(1)
     expect(factory.status().counters.triageEscalationsMirroredToSlack).toBe(1)
     expect(factory.status().counters.triageEscalationSlackMirrorDuplicatesSuppressed).toBe(1)
+    expect(factory.status().counters.slackReporterIdentitiesResolved).toBe(1)
   })
 
   it('resolves a missing mounted GitHub reporter before posting and mirrors that reporter to Slack', async () => {
@@ -9933,7 +10451,7 @@ describe('FactoryLoop', () => {
     expect(githubWriteback.comments[0]?.body).toContain('@provider-reporter, Factory needs clarification')
     const slackRoots = mount.writes.filter((write) => isSlackRootWritePath(write.path))
     expect(slackRoots).toHaveLength(1)
-    expect((slackRoots[0]?.content as { text?: string }).text).toContain('GitHub reporter: @provider-reporter.')
+    expect((slackRoots[0]?.content as { text?: string }).text).toContain('GitHub reporter: provider-reporter (GitHub).')
     expect(factory.status().counters.githubIssueAuthorsResolvedFromProvider).toBe(1)
   })
 
@@ -9987,7 +10505,24 @@ describe('FactoryLoop', () => {
 
   it('dispatches a thin GitHub issue after a human replies to the clarification comment', async () => {
     const path = githubIssuePath('AgentWorkforce', 'pear', 58)
-    const mount = new FakeMountClient({ [path]: githubIssueFile(58, { labels: ['factory'] }) })
+    const publishInputs: GithubPublishPullRequestInput[] = []
+    const githubWrite: GithubConnectionWrite = {
+      publishPullRequest: async (input) => {
+        publishInputs.push(input)
+        return {
+          repo: input.repo,
+          number: 158,
+          url: 'https://github.com/AgentWorkforce/pear/pull/158',
+          headRef: 'factory/58-agentworkforce-pear',
+          headSha: 'sha-58',
+        }
+      },
+      closePullRequest: async () => undefined,
+    }
+    const mount = new FakeMountClient({
+      [path]: githubIssueFile(58, { labels: ['factory'] }),
+      '/github/repos/AgentWorkforce/pear/meta.json': { default_branch: 'main' },
+    }, githubWrite)
     const fleet = new FakeFleetClient()
     const githubWriteback = new RecordingGithubWriteback()
     const factory = createFactory(config({ issueSource: 'github' }), {
@@ -10013,6 +10548,16 @@ describe('FactoryLoop', () => {
     expect(fleet.inputs).toEqual([])
     expect(factory.status().counters.githubTriageAnswersDispatched).toBe(1)
     expect(factory.status().counters.githubTriageAnswersInjectedToAgents).toBeUndefined()
+
+    fleet.emitAgentExit('ar-58-impl-pear', 'issue-done')
+    await vi.waitFor(() => expect(publishInputs).toHaveLength(1))
+    expect(publishInputs[0]).toMatchObject({
+      repo: 'AgentWorkforce/pear',
+      clonePath: '/work/pear',
+      baseRef: 'main',
+      title: '58: GitHub factory issue 58',
+    })
+    expect(factory.status().counters.githubPullRequestsPublished).toBe(1)
   })
 
   it('requires a start-of-body correlation token from the issue reporter before resolving GitHub triage', async () => {
@@ -12970,6 +13515,44 @@ describe('FactoryLoop PR babysitter', () => {
     expect(factory.status().inFlight.map((ref) => ref.key)).toEqual(['AR-401'])
   })
 
+  it('does not attach a numeric GitHub issue to a merged PR whose body only contains a test count', async () => {
+    const path = githubIssuePath('AgentWorkforce', 'pear', 52)
+    const issueFile = githubIssueFile(52, {
+      title: 'Add the requested widget',
+      labels: ['factory', 'pear'],
+    })
+    const mount = new FakeMountClient({
+      [path]: issueFile,
+      '/github/repos/AgentWorkforce__pear/pulls/by-id/5.json': prFile(5, {
+        title: 'Unrelated observability work',
+        body: 'tsc, eslint, and 52 tests all pass.',
+        head_ref: 'claude/unrelated-observability',
+        state: 'merged',
+        merged: true,
+      }),
+    })
+    mount.setSubRoot('/linear/issues', 'absent')
+    const fleet = new FakeFleetClient()
+    const factory = createFactory(config({
+      issueSource: 'github',
+      babysitter: { enabled: true },
+    }), {
+      mount,
+      fleet,
+      triage: new StaticTriage(),
+      githubWriteback: new RecordingGithubWriteback(),
+      probePrGhRunner: async () => ({ stdout: '[]' }),
+    })
+
+    const issue = parseGithubFactoryIssue(path, issueFile)
+    await factory.dispatch(await factory.triageIssue(issue))
+    fleet.emitAgentExit('ar-52-impl-pear', 'issue-done')
+    await flush()
+
+    expect(fleet.spawns.map((spawn) => spawn.name)).not.toContain('ar-52-babysit-pear')
+    expect(factory.status().inFlight.map((ref) => ref.key)).toEqual(['52'])
+  })
+
   it('does not respawn the babysitter on repeated implementer exits', async () => {
     const issue = realIssueFile(403, ready, { title: 'Real babysitter idempotent' })
     const mount = new FakeMountClient({ [issuePath(403)]: issue })
@@ -13789,6 +14372,7 @@ describe('FactoryLoop PR babysitter', () => {
       mount.emit(changeEvent(commentPath, 'pre-restart-comment'))
       await vi.waitFor(() => expect(first.status().counters.babysitterEventsQueued).toBe(1))
       expect(firstFleet.messages.filter((message) => message.text.startsWith('<integration-event'))).toEqual([])
+      mount.files.set(prPath, { content: { number: 423, state: 'open', head_ref: 'ar-423-fix', draft: false } })
       await first.stop()
 
       const restartedFleet = new FakeFleetClient()
@@ -13831,6 +14415,51 @@ describe('FactoryLoop PR babysitter', () => {
     }
   })
 
+  it('discards restored babysitter ownership when the persisted PR is merged and unrelated', async () => {
+    const issue = { uuid: 'AgentWorkforce/pear#52', key: '52', path: githubIssuePath('AgentWorkforce', 'pear', 52) }
+    const persistedKey = issueKey(issue)
+    const stateStore = new InMemoryStateStore({ batchSize: 2 })
+    await stateStore.setBabysitterSession('factory-test', persistedKey, {
+      issue,
+      repo: 'AgentWorkforce/pear',
+      prNumber: 5,
+      agentName: 'ar-52-babysit-pear',
+      path: '/github/repos/AgentWorkforce__pear/pulls/by-id/5.json',
+      critical: false,
+      pendingKinds: [],
+    })
+    const mount = new FakeMountClient({
+      [issue.path]: githubIssueFile(52, { labels: ['factory', 'pear', 'factory:in-progress'] }),
+      '/github/repos/AgentWorkforce__pear/pulls/by-id/5.json': prFile(5, {
+        title: 'Unrelated observability work',
+        body: 'tsc, eslint, and 52 tests all pass.',
+        head_ref: 'claude/unrelated-observability',
+        state: 'merged',
+        merged: true,
+      }),
+    })
+    mount.setSubRoot('/linear/issues', 'absent')
+    const factory = createFactory(config({
+      issueSource: 'github',
+      babysitter: { enabled: true },
+    }), {
+      mount,
+      fleet: new FakeFleetClient(),
+      triage: new StaticTriage(),
+      stateStore,
+      githubWriteback: new RecordingGithubWriteback(),
+    })
+
+    await factory.start({ mode: 'live', liveSubscription: { transport: 'subscribe' } })
+    try {
+      await expect(stateStore.listBabysitterSessions('factory-test')).resolves.toEqual([])
+      expect(factory.status().counters.babysitterOwnershipRestoreStale).toBe(1)
+      expect(factory.status().counters.babysitterOwnershipRestored).toBeUndefined()
+    } finally {
+      await factory.stop()
+    }
+  })
+
   it('routes paginated poll events through the same exact-PR coalescer', async () => {
     const issue = realIssueFile(424, ready, { title: 'Real babysitter poll routing' })
     const prPath = '/github/repos/AgentWorkforce/pear/pulls/424/metadata.json'
diff --git a/src/orchestrator/factory.ts b/src/orchestrator/factory.ts
index deaa0b5..2644859 100644
--- a/src/orchestrator/factory.ts
+++ b/src/orchestrator/factory.ts
@@ -85,7 +85,14 @@ type Listener = (payload: FactoryEventPayload) => void
 type SlackThreadWatcher = { stop(): Promise<void> }
 type GithubIssueCommentWatcher = { stop(): Promise<void> }
 type TerminationRoots = { pids: number[]; status: AgentPidResolution['status'] }
-type ResolvedIssuePr = { repo: string; prNumber: number; draft?: boolean }
+type ResolvedIssuePr = {
+  repo: string
+  prNumber: number
+  draft?: boolean
+  headRef?: string
+  url?: string
+  path?: string
+}
 type EventHighWatermarkResult = { highWatermark?: string; routeUnavailable: boolean }
 type PreparedLiveEvent = { path?: string; dispatchRelayflow: boolean }
 type GithubOrphanRecoveryContext = {
@@ -202,6 +209,8 @@ const PUBLISHED_PR_CONFIRM_ATTEMPTS = 20
 const PUBLISHED_PR_CONFIRM_DELAY_MS = 100
 const SLACK_REPLY_EVENTS_LIMIT = 100
 const SLACK_REPLY_POLL_INTERVAL_MS = 5_000
+const SLACK_IDENTITY_MESSAGE_SCAN_LIMIT = 250
+const SLACK_IDENTITY_READ_BATCH_SIZE = 25
 const AGENT_QUESTION_DEDUPE_LIMIT = 500
 const AGENT_NEEDS_INPUT_MARKER = '[factory-needs-input]'
 const LEGACY_AGENT_NEEDS_INPUT_MARKER = 'FACTORY_NEEDS_INPUT'
@@ -290,6 +299,8 @@ export class FactoryLoop implements Factory {
   readonly #githubIssueCommentQueues = new Map<string, Promise<void>>()
   readonly #githubIssueAuthors = new Map<string, string | undefined>()
   readonly #githubIssueAuthorLookups = new Map<string, Promise<string | undefined>>()
+  readonly #slackReporterUserIds = new Map<string, string | undefined>()
+  readonly #slackReporterUserIdLookups = new Map<string, Promise<string | undefined>>()
   readonly #reconciledGithubInProgress = new Set<string>()
   #resolvedSlackChannelDir?: string
   #slackChannelDirRefresh?: Promise<string | undefined>
@@ -1335,6 +1346,16 @@ export class FactoryLoop implements Factory {
     })
   }
 
+  async #openPrForIssue(issue: LinearIssue): Promise<ResolvedIssuePr | undefined> {
+    if (this.#customProbePrResolver) {
+      return this.#probePrResolver(issue)
+    }
+    return this.#resolveIssuePr(issue, {
+      titleMarker: FACTORY_E2E_MARKER,
+      openOnly: true,
+    })
+  }
+
   async #resolveIssuePr(
     issue: LinearIssue,
     opts: { requireTitleMarker?: boolean; titleMarker?: string; openOnly?: boolean; failOnLookupError?: boolean } = {},
@@ -1399,6 +1420,7 @@ export class FactoryLoop implements Factory {
       let lastReadyReadProgressAtMs = this.#clock.now()
       let readyIssueReads = 0
 
+      const issueEntries: Array<{ path: string; issue?: LinearIssue }> = []
       for (const path of paths) {
         const issue = await this.#readIssue(path)
         readyIssueReads += 1
@@ -1413,6 +1435,24 @@ export class FactoryLoop implements Factory {
         if (issue && issueSource === 'linear') {
           await this.#recordCanonicalIssueState(issue)
         }
+        issueEntries.push({ path, issue })
+      }
+      if (issueSource === 'github') {
+        // New ready work must not sit behind a long sequence of stale
+        // in-progress recoveries. Load the canonical snapshots first, then
+        // prioritize genuinely ready issues over orphan-recovery candidates.
+        // Within either bucket, resume the most recently changed provider work
+        // first so a just-interrupted dispatch does not sit behind an old
+        // numeric backlog of leaked in-progress labels.
+        issueEntries.sort((left, right) => {
+          const readiness = Number(Boolean(right.issue && this.#isIssueReady(right.issue))) -
+            Number(Boolean(left.issue && this.#isIssueReady(left.issue)))
+          if (readiness !== 0) return readiness
+          return githubIssueUpdatedAtMs(right.issue) - githubIssueUpdatedAtMs(left.issue)
+        })
+      }
+
+      for (const { issue } of issueEntries) {
         if (!issue) {
           continue
         }
@@ -1480,7 +1520,17 @@ export class FactoryLoop implements Factory {
 
           const decision = await this.triageIssue(issue)
           triaged.push(decision)
-          const result = await this.dispatch(decision, { dryRun })
+          let result: DispatchResult
+          try {
+            result = await this.dispatch(decision, { dryRun })
+          } catch (error) {
+            if (!(error instanceof LiveDispatchStateChangedError)) throw error
+            skipped.push({ issue: decision.issue, reason: 'live state changed during dispatch' })
+            this.#logger.info?.('[factory] skipped issue whose live state changed during dispatch', {
+              issue: decision.issue.key,
+            })
+            continue
+          }
           if (result.agents.length === 0 && !dryRun) {
             skipped.push({ issue: decision.issue, reason: 'queued or escalated' })
           } else {
@@ -1601,9 +1651,9 @@ export class FactoryLoop implements Factory {
       return false
     }
 
-    let hasOpenPr: boolean
+    let openPr: ResolvedIssuePr | undefined
     try {
-      hasOpenPr = await this.#hasOpenCompletionPr(issue)
+      openPr = await this.#openCompletionPr(issue)
     } catch (error) {
       this.#increment('githubOrphanRecoveryPrProbeFailures')
       this.#logger.warn?.('[factory] could not prove an in-progress GitHub issue has no open PR; preserving it', {
@@ -1612,10 +1662,26 @@ export class FactoryLoop implements Factory {
       })
       return false
     }
-    if (hasOpenPr) {
+    if (openPr) {
+      let adopted = false
+      try {
+        adopted = await this.#adoptOrphanedGithubPullRequest(issue, openPr)
+      } catch (error) {
+        this.#increment('githubOrphanedPullRequestAdoptionFailures')
+        this.#logger.warn?.('[factory] could not adopt orphaned in-progress GitHub issue at its open PR', {
+          issue: issue.key,
+          repo: openPr.repo,
+          prNumber: openPr.prNumber,
+          error: describeError(error).errorMessage,
+        })
+      }
       this.#increment('githubOrphanRecoveriesBlockedOpenPr')
-      this.#logger.info?.('[factory] preserved in-progress GitHub issue because a matching open PR exists', {
+      this.#logger.info?.(adopted
+        ? '[factory] adopted orphaned in-progress GitHub issue at its existing PR'
+        : '[factory] preserved in-progress GitHub issue because a matching open PR exists', {
         issue: issue.key,
+        repo: openPr.repo,
+        prNumber: openPr.prNumber,
       })
       return false
     }
@@ -1645,15 +1711,109 @@ export class FactoryLoop implements Factory {
     }
   }
 
-  async #hasOpenCompletionPr(issue: LinearIssue): Promise<boolean> {
+  async #openCompletionPr(issue: LinearIssue): Promise<ResolvedIssuePr | undefined> {
     if (this.#customProbePrResolver) {
-      return Boolean(await this.#probePrResolver(issue))
+      return await this.#probePrResolver(issue)
     }
-    return Boolean(await this.#resolveIssuePr(issue, {
+    return await this.#resolveIssuePr(issue, {
       titleMarker: FACTORY_E2E_MARKER,
       openOnly: true,
       failOnLookupError: true,
-    }))
+    })
+  }
+
+  async #adoptOrphanedGithubPullRequest(issue: LinearIssue, pr: ResolvedIssuePr): Promise<boolean> {
+    if (
+      !this.#config.babysitter.enabled ||
+      pr.draft === true ||
+      !pr.headRef?.startsWith('factory/') ||
+      !factoryBranchMatchesIssue(pr.headRef, issue.key)
+    ) return false
+
+    const triaged = await this.triageIssue(issue)
+    const routed = labelDerivedDispatchDecision(issue, triaged, this.#config)
+    if (!routed.ok) return false
+    const route = routed.decision.routes.find((candidate) =>
+      normalizeGithubRepo(candidate.repo, this.#config.repos.org).toLowerCase() === pr.repo.toLowerCase()
+    )
+    if (!route) return false
+
+    let decision = routed.decision
+    if (this.#worktrees && route.clonePath) {
+      const worktreePath = factoryWorktreePath(
+        route.clonePath,
+        issue.key,
+        route.repo,
+        stableHash(`${pr.repo}#${pr.prNumber}:${pr.headRef}`),
+      )
+      decision = {
+        ...decision,
+        implementers: decision.implementers.map((spec) => spec.repo === route.repo
+          ? {
+              ...spec,
+              baseClonePath: route.clonePath,
+              clonePath: worktreePath,
+              branch: pr.headRef,
+            }
+          : spec),
+      }
+    }
+
+    const durableRemoteAdoption = this.#fleet.placementLocality === 'remote'
+    const publishedPr: GithubPublishPullRequestResult = {
+      repo: pr.repo,
+      number: pr.prNumber,
+      url: pr.url ?? `https://github.com/${pr.repo}/pull/${pr.prNumber}`,
+      headRef: pr.headRef,
+    }
+    if (durableRemoteAdoption) {
+      const claim = await this.#claimDispatchLifecycle(decision, false, randomUUID(), {
+        phase: 'published',
+        pullRequest: publishedPr,
+      })
+      decision = structuredClone(claim.lifecycle.decision)
+      if (claim.lifecycle.phase === 'queued') {
+        this.#scheduleDispatchLifecycleRetry(inFlightRecordFromLifecycle(claim.lifecycle))
+        this.#increment('queued')
+        this.#increment('githubOrphanedPullRequestsAdopted')
+        return true
+      }
+    }
+
+    const batch = await this.#batch()
+    const record = batch.start(decision, false)
+    if (!record) {
+      if (durableRemoteAdoption) {
+        const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(decision.issue))
+        if (durable) {
+          this.#scheduleDispatchLifecycleRetry(inFlightRecordFromLifecycle(durable))
+          this.#increment('githubOrphanedPullRequestsAdopted')
+          return true
+        }
+      }
+      return false
+    }
+    await this.#ensureBabysitter(record, {
+      repo: pr.repo,
+      prNumber: pr.prNumber,
+      url: pr.url ?? `https://github.com/${pr.repo}/pull/${pr.prNumber}`,
+      path: pr.path,
+      headRef: pr.headRef,
+    })
+    const babysitter = [...record.agents.values()].find((tracked) => tracked.spec.role === 'babysitter')
+    if (!babysitter) {
+      if (durableRemoteAdoption) this.#scheduleDispatchLifecycleRetry(record)
+      else batch.abandon(record.issue)
+      return false
+    }
+    record.result = {
+      issue: record.issue,
+      agents: [{ name: babysitter.result?.name ?? babysitter.spec.name, role: 'babysitter' }],
+      dryRun: false,
+    }
+    await this.#writeInFlightRegistry()
+    this.#increment('githubOrphanedPullRequestsAdopted')
+    return true
   }
 
   async #listRelayfileTree(prefix: string, phase: string): Promise<string[]> {
@@ -2009,7 +2169,7 @@ export class FactoryLoop implements Factory {
       if (!dryRun) {
         const issue = await this.#readIssue(dispatchDecision.issue.path)
         if (!issue || !this.#isIssueReady(issue)) {
-          throw new Error(`Live state changed before writeback for ${dispatchDecision.issue.key}`)
+          throw new LiveDispatchStateChangedError(dispatchDecision.issue.key)
         }
         try {
           await this.#postIssueComment(issue, comment)
@@ -2046,13 +2206,37 @@ export class FactoryLoop implements Factory {
       // acknowledged spawns, so cleanup never races a name-only survivor.
       const failureHandoffs = this.#dispatchFailureHandoffs(record, spawnedForReaperHandoff)
       await this.#persistDispatchFailureReaperHandoff(record, failureHandoffs)
-      const worktreesTornDown = await this.#teardownFailedDispatchWorktrees(failureHandoffs)
-      await this.#recordDispatchFailure(decision.issue)
-      const failedState = await this.#state.getDispatchAttempts(this.#workspaceId, decision.issue.key)
-      await this.#saveDispatchLifecycle(record, failedState?.terminal ? 'abandoned' : 'retryable')
+      let worktreesTornDown = await this.#teardownFailedDispatchWorktrees(failureHandoffs)
+      const liveStateChanged = error instanceof LiveDispatchStateChangedError
+      if (liveStateChanged && !failureHandoffs.some((handoff) => handoff.worktree)) {
+        const failed = await this.#releaseAndTerminateAgents(
+          failureHandoffs.map((handoff) => [handoff.name, handoff.tracked]),
+          'live dispatch state changed',
+          'completion',
+        )
+        if (failed.length === 0) {
+          for (const handoff of failureHandoffs) {
+            await this.#state.clearFailureHandoff(
+              this.#workspaceId,
+              registryHandoffKey(handoff.issue, handoff.name),
+            )
+          }
+          worktreesTornDown = failureHandoffs.length > 0
+        }
+      }
+      let failedState: { terminal: boolean } | undefined
+      if (liveStateChanged) {
+        await this.#clearDispatchInFlight(decision.issue)
+        await this.#saveDispatchLifecycle(record, 'abandoned')
+        this.#increment('dispatchLiveStateRaces')
+      } else {
+        await this.#recordDispatchFailure(decision.issue)
+        failedState = await this.#state.getDispatchAttempts(this.#workspaceId, decision.issue.key)
+        await this.#saveDispatchLifecycle(record, failedState?.terminal ? 'abandoned' : 'retryable')
+      }
       batch.abandon(decision.issue)
-      if (!failedState?.terminal) this.#scheduleDispatchLifecycleRetry(record)
-      this.#error(error, decision.issue)
+      if (!liveStateChanged && !failedState?.terminal) this.#scheduleDispatchLifecycleRetry(record)
+      if (!liveStateChanged) this.#error(error, decision.issue)
       // The teardown runs while the record still exists so it can safely
       // derive every shared checkout. Rewrite the registry only after abandon
       // removes those agents from the ordinary in-flight view.
@@ -2215,6 +2399,10 @@ export class FactoryLoop implements Factory {
     decision: TriageDecision,
     dryRun: boolean,
     preparedRunId?: string,
+    initial: {
+      phase?: DispatchLifecyclePhase
+      pullRequest?: GithubPublishPullRequestResult
+    } = {},
   ): Promise<{ created: boolean; lifecycle: DispatchLifecycle }> {
     const key = issueKey(decision.issue)
     const seed: DispatchLifecycle = {
@@ -2222,11 +2410,12 @@ export class FactoryLoop implements Factory {
       issue: { ...decision.issue },
       decision: structuredClone(decision),
       dryRun,
-      phase: 'dispatching',
+      phase: initial.phase ?? 'dispatching',
       agents: [],
       invocationIds: [],
       updatedAtMs: this.#clock.now(),
     }
+    if (initial.pullRequest) seed.pullRequest = initial.pullRequest
     if (!preparedRunId) seed.decision = decisionWithLifecycleBranches(seed.decision, seed.runId)
     const claim = await this.#state.claimDispatchLifecycle(
       this.#workspaceId,
@@ -2387,7 +2576,17 @@ export class FactoryLoop implements Factory {
       if (!promoted || promoted.phase !== 'dispatching') {
         throw new Error(`durable dispatch ${lifecycle.issue.key} lost its promoted lifecycle`)
       }
-      lifecycle = promoted
+      if (promoted.pullRequest) {
+        const promotedRecord = inFlightRecordFromLifecycle(promoted)
+        if (!await this.#saveDispatchLifecycle(promotedRecord, 'published', promoted.pullRequest)) return
+        const published = await this.#state.getDispatchLifecycle(this.#workspaceId, key)
+        if (!published || published.phase !== 'published') {
+          throw new Error(`durable dispatch ${lifecycle.issue.key} lost its published PR during promotion`)
+        }
+        lifecycle = published
+      } else {
+        lifecycle = promoted
+      }
     }
     const batch = await this.#batch()
     const durableRecord = inFlightRecordFromLifecycle(lifecycle)
@@ -2422,7 +2621,7 @@ export class FactoryLoop implements Factory {
     if (lifecycle.phase === 'publishing') {
       const implementer = [...record.agents.values()].find((agent) => agent.spec.role === 'implementer')
       if (!implementer) throw new Error(`durable dispatch ${record.issue.key} has no implementer to publish`)
-      const published = await this.#publishImplementerPullRequest(record, implementer)
+      const published = await this.#publishImplementerPullRequest(record, implementer, { reconcileExisting: true })
       if (!published) throw new Error(`durable dispatch ${record.issue.key} did not produce a pull request`)
       if (!await this.#saveDispatchLifecycle(record, 'published', published)) return
       if (this.#config.babysitter.enabled) {
@@ -2646,6 +2845,12 @@ export class FactoryLoop implements Factory {
         }
       }
     } catch (error) {
+      if (error instanceof LiveDispatchStateChangedError) {
+        this.#logger.info?.('[factory] ignored issue event whose live state changed during dispatch', {
+          issue: error.issueKey,
+        })
+        return
+      }
       this.#logger.error?.('[factory] failed to handle issue change', error)
     }
   }
@@ -2808,7 +3013,6 @@ export class FactoryLoop implements Factory {
             continue
           } else if (isGithubIssueTreePath(path)) {
             this.#increment('githubIssuesIgnoredByPathRegex')
-            this.#logger.debug?.('[factory] ignored GitHub issue path with unsupported relayfile shape', { path })
           }
         }
       }
@@ -3666,7 +3870,9 @@ export class FactoryLoop implements Factory {
     }
 
     if (isCompletionReason(reason)) {
-      if (exiting?.spec.role === 'implementer' && await this.#issueHasCompletionPr(record)) {
+      if (exiting?.spec.role === 'implementer' && await this.#issueHasCompletionPr(record, {
+        openOnly: this.#config.babysitter.enabled,
+      })) {
         if (this.#config.babysitter.enabled) await this.#ensureBabysitterForIssue(record)
         else await this.#completeIssue(record)
         return
@@ -3716,7 +3922,9 @@ export class FactoryLoop implements Factory {
     }
 
     try {
-      if (tracked.spec.role === 'implementer' && await this.#issueHasCompletionPr(record)) {
+      if (tracked.spec.role === 'implementer' && await this.#issueHasCompletionPr(record, {
+        openOnly: this.#config.babysitter.enabled,
+      })) {
         if (this.#config.babysitter.enabled) {
           await this.#ensureBabysitterForIssue(record)
           return
@@ -3889,6 +4097,7 @@ export class FactoryLoop implements Factory {
   async #publishImplementerPullRequest(
     record: InFlightIssue,
     implementer: TrackedAgent,
+    opts: { reconcileExisting?: boolean } = {},
   ): Promise<GithubPublishPullRequestResult | undefined> {
     const key = `${issueKey(record.issue)}:${implementer.spec.repo}`
     const durable = await this.#state.getDispatchLifecycle(this.#workspaceId, issueKey(record.issue))
@@ -3918,6 +4127,21 @@ export class FactoryLoop implements Factory {
       ? sourceRepoParts.owner
       : undefined
     const repo = normalizeGithubRepo(implementer.spec.repo, this.#config.repos.org ?? sourceOwner)
+    const expectedHeadRef = implementer.spec.branch ?? remoteBranch
+    if (opts.reconcileExisting && expectedHeadRef) {
+      const existing = await this.#openPullRequestByHead(repo, expectedHeadRef)
+      if (existing) {
+        this.#publishedPullRequests.set(key, existing)
+        this.#increment('githubPullRequestsReconciled')
+        this.#logger.info?.('[factory] reconciled existing PR from implementer branch', {
+          issue: issue.key,
+          repo: existing.repo,
+          prNumber: existing.number,
+          url: existing.url,
+        })
+        return existing
+      }
+    }
     const baseRef = await this.#githubDefaultBranch(repo)
     const result = await githubWrite.publishPullRequest({
       repo,
@@ -3949,6 +4173,55 @@ export class FactoryLoop implements Factory {
     return result
   }
 
+  async #openPullRequestByHead(
+    repo: string,
+    expectedHeadRef: string,
+  ): Promise<GithubPublishPullRequestResult | undefined> {
+    const parts = githubRepoParts(repo)
+    if (!parts) return undefined
+    const roots = [
+      `/github/repos/${encodeURIComponent(parts.owner)}/${encodeURIComponent(parts.repo)}/pulls/`,
+      `/github/repos/${encodeURIComponent(parts.owner)}__${encodeURIComponent(parts.repo)}/pulls/`,
+    ]
+    const candidates: GithubPublishPullRequestResult[] = []
+    for (const root of roots) {
+      let paths: string[]
+      try {
+        paths = await this.#mount.listTree(root)
+      } catch {
+        continue
+      }
+      for (const path of paths) {
+        const pathParts = githubPullPathParts(path)
+        if (
+          !pathParts ||
+          pathParts.owner.toLowerCase() !== parts.owner.toLowerCase() ||
+          pathParts.repo.toLowerCase() !== parts.repo.toLowerCase()
+        ) continue
+        try {
+          const snapshot = parsePullSnapshot((await this.#mount.readFile(path)).content, pathParts.number)
+          const state = snapshot?.state?.trim().toUpperCase()
+          if (
+            !snapshot ||
+            snapshot.headRef !== expectedHeadRef ||
+            state !== 'OPEN' ||
+            snapshot.draft !== false ||
+            snapshot.merged === true
+          ) continue
+          candidates.push({
+            repo,
+            number: snapshot.number,
+            url: snapshot.url ?? `https://github.com/${repo}/pull/${snapshot.number}`,
+            headRef: expectedHeadRef,
+          })
+        } catch {
+          // A partially materialized PR record cannot prove exact ownership.
+        }
+      }
+    }
+    return candidates.sort((a, b) => b.number - a.number)[0]
+  }
+
   async #prepareAgentWorktree(record: InFlightIssue, spec: AgentSpec): Promise<void> {
     const worktree = this.#agentWorktree(record, spec)
     if (!worktree || !this.#worktrees) return
@@ -4165,12 +4438,35 @@ export class FactoryLoop implements Factory {
   // the release-driven exit event so it cannot re-trigger a resume before the
   // record leaves the batch.
   async #abandonStuckDispatch(record: InFlightIssue, reason: string): Promise<void> {
-    const remaining = [...record.agents].filter(([, tracked]) => tracked.spec.role !== 'implementer')
-    for (const [agentName] of remaining) {
+    const agents = [...record.agents]
+    for (const [agentName, tracked] of agents) {
+      if (tracked.spec.role === 'implementer') continue
       this.#fleet.markAgentTerminal?.(agentName, `implementer-terminal:${reason}`)
     }
-    if (remaining.length > 0) {
-      await this.#releaseAndTerminateAgents(remaining, 'issue-abandoned', 'completion')
+    const worktreeHandoffs = this.#dispatchFailureHandoffs(record, [])
+    let cleanupComplete = true
+    if (worktreeHandoffs.length > 0) {
+      // A terminal no-PR dispatch no longer owns useful work. Fence and release
+      // every agent sharing the checkout before removing it. If release or
+      // cleanup fails, the durable handoff reaper retains responsibility rather
+      // than leaving an invisible orphan under .factory-worktrees.
+      await this.#persistDispatchFailureReaperHandoff(record, worktreeHandoffs)
+      const worktreeAgentNames = new Set(worktreeHandoffs.map((handoff) => handoff.name))
+      const nonWorktreeAgents = agents.filter(([name]) => !worktreeAgentNames.has(name))
+      if (nonWorktreeAgents.length > 0) {
+        const failed = await this.#releaseAndTerminateAgents(nonWorktreeAgents, 'issue-abandoned', 'completion')
+        cleanupComplete = failed.length === 0
+      }
+      cleanupComplete = await this.#teardownFailedDispatchWorktrees(worktreeHandoffs) && cleanupComplete
+    } else if (agents.length > 0) {
+      const failed = await this.#releaseAndTerminateAgents(agents, 'issue-abandoned', 'completion')
+      cleanupComplete = failed.length === 0
+    }
+    if (!cleanupComplete) {
+      this.#increment('abandonedDispatchReleaseRetries')
+      this.#scheduleAbandonedDispatchRetry(record, reason)
+      await this.#writeInFlightRegistry()
+      return
     }
     await this.#recordDispatchTerminal(record.issue)
     const next = (await this.#batch()).complete(record.issue)
@@ -4183,7 +4479,24 @@ export class FactoryLoop implements Factory {
     }
   }
 
-  async #issueHasCompletionPr(record: InFlightIssue): Promise<boolean> {
+  #scheduleAbandonedDispatchRetry(record: InFlightIssue, reason: string): void {
+    const key = issueKey(record.issue)
+    if (this.#stopping || this.#dispatchLifecycleRetryTimers.has(key)) return
+    const timer = setTimeout(() => {
+      this.#dispatchLifecycleRetryTimers.delete(key)
+      void this.#abandonStuckDispatch(record, reason).catch((error) => {
+        this.#logger.warn?.('[factory] abandoned dispatch cleanup retry failed', {
+          issue: record.issue.key,
+          error: describeError(error).errorMessage,
+        })
+        this.#scheduleAbandonedDispatchRetry(record, reason)
+      })
+    }, DISPATCH_LIFECYCLE_RETRY_MS)
+    timer.unref?.()
+    this.#dispatchLifecycleRetryTimers.set(key, timer)
+  }
+
+  async #issueHasCompletionPr(record: InFlightIssue, opts: { openOnly?: boolean } = {}): Promise<boolean> {
     try {
       const issue = await this.#readIssue(record.issue.path)
       if (!issue) {
@@ -4193,7 +4506,9 @@ export class FactoryLoop implements Factory {
       // work isn't review-ready, so an implementer exiting with only a draft PR
       // must NOT mark the issue done / release agents — mirror the
       // #sweepPrStateCompletions draft guard, which keeps draft-PR issues in flight.
-      const pr = await this.#completionPrForIssue(issue)
+      const pr = opts.openOnly
+        ? await this.#openPrForIssue(issue)
+        : await this.#completionPrForIssue(issue)
       return Boolean(pr && !pr.draft)
     } catch (error) {
       this.#logger.warn?.('[factory] PR probe failed after implementer exit; preserving restart behavior', {
@@ -4259,12 +4574,21 @@ export class FactoryLoop implements Factory {
 
   async #handleDeliveryFailed(info: { to: string; msgId?: string; reason?: string }): Promise<void> {
     const critical = await this.#state.consumeCritical(this.#workspaceId, info.msgId ?? '')
+    if (!critical) {
+      this.#increment('nonCriticalDeliveryFailuresIgnored')
+      return
+    }
     const record = (await this.#batch()).getIssueByAgent(info.to)
-    const issue = critical?.issue ?? record?.issue
+    const issue = critical.issue ?? record?.issue
     const error = new Error(`Critical delivery failed to ${info.to}${info.reason ? `: ${info.reason}` : ''}`)
     this.#error(error, issue)
 
-    if (critical && this.#fleet.waitForInjected) {
+    if (isTerminalDeliveryFailure(info.reason)) {
+      this.#increment('criticalDeliveryTerminalFailures')
+      return
+    }
+
+    if (this.#fleet.waitForInjected) {
       try {
         const ack = await this.#waitForInjectedAndSubmit(critical.input)
         await this.#state.recordCritical(this.#workspaceId, ack.eventId, critical)
@@ -5179,6 +5503,14 @@ export class FactoryLoop implements Factory {
     } else {
       watch.issue = { ...record.issue }
       watch.detectAgentQuestions = true
+      const humanReplyDispatch = record.decision.rationale.includes('Human answered the GitHub triage escalation')
+      if (!triageEscalationReason(record.decision) && !humanReplyDispatch) {
+        const pendingCount = watch.pending.length
+        watch.pending = watch.pending.filter((pending) => pending.kind !== 'triage')
+        if (watch.pending.length < pendingCount) {
+          this.#increment('triageEscalationsSupersededByActionableIssue')
+        }
+      }
     }
     if (this.#githubIssueCommentWatchers.has(key)) {
       const normalizedWatch = normalizeGithubIssueCommentWatch(watch)
@@ -5668,7 +6000,9 @@ export class FactoryLoop implements Factory {
     }
 
     this.#pendingGithubClarifications.set(issueKey(decision.issue), text)
-    const result = await this.#startOrQueueGithubClarifiedDecision(decision)
+    const result = await this.#startOrQueueGithubClarifiedDecision(
+      dispatchAfterGithubClarification(decision, 'human clarification resolved triage'),
+    )
     this.#increment('githubTriageAnswersDispatched')
     return Boolean(result) || (await this.#batch()).isQueued(decision.issue)
   }
@@ -5826,6 +6160,23 @@ export class FactoryLoop implements Factory {
         this.#increment('babysitterOwnershipRestoreSkippedNonOwner')
         continue
       }
+      const snapshot = await this.#readPrSnapshot(session)
+      const guard = snapshot ? prMetaAllowsHumanReview(snapshot) : undefined
+      if (!snapshot || !guard?.ok || prSnapshotIssueMatchScore(snapshot, session.issue.key) < 30) {
+        await this.#state.clearBabysitterSession(this.#workspaceId, persistedKey)
+        this.#increment('babysitterOwnershipRestoreStale')
+        this.#logger.warn?.('[factory] discarded stale babysitter ownership during restore', {
+          issue: session.issue.key,
+          repo: session.repo,
+          prNumber: session.prNumber,
+          reason: !snapshot
+            ? 'authoritative PR meta is unavailable'
+            : !guard?.ok
+              ? guard?.reason
+              : 'PR branch does not identify the issue',
+        })
+        continue
+      }
       const record = batch.getIssue(session.issue)
       const tracked = record?.agents.get(session.agentName)
         ?? [...(record?.agents.values() ?? [])].find((agent) => agent.spec.role === 'babysitter')
@@ -6475,14 +6826,20 @@ export class FactoryLoop implements Factory {
     if (!issue) {
       return
     }
-    const pr = await this.#completionPrForIssue(issue)
+    const pr = await this.#openPrForIssue(issue)
     if (!pr || pr.draft) {
       return
     }
     await this.#ensureBabysitter(record, { repo: pr.repo, prNumber: pr.prNumber })
   }
 
-  async #ensureBabysitter(record: InFlightIssue, prRef: { repo: string; prNumber: number; url?: string; path?: string }): Promise<void> {
+  async #ensureBabysitter(record: InFlightIssue, prRef: {
+    repo: string
+    prNumber: number
+    url?: string
+    path?: string
+    headRef?: string
+  }): Promise<void> {
     const babysitterKey = issueKey(record.issue)
     if (!await this.#assertIssueDispatchLifecycleOwner(record.issue)) {
       this.#increment('babysitterLifecycleOwnershipRejected')
@@ -6550,7 +6907,9 @@ export class FactoryLoop implements Factory {
       const sharedCheckout = [...record.agents.values()]
         .map((agent) => agent.spec)
         .find((candidate) => candidate.repo === initialSpec.repo && candidate.baseClonePath && candidate.clonePath)
-      const implementerBranch = record.decision.implementers
+        ?? record.decision.implementers
+          .find((candidate) => candidate.repo === initialSpec.repo && candidate.baseClonePath && candidate.clonePath)
+      const implementerBranch = prRef.headRef ?? record.decision.implementers
         .find((candidate) => candidate.repo === initialSpec.repo && candidate.branch)?.branch
       const spec: AgentSpec = sharedCheckout
         ? {
@@ -6686,7 +7045,12 @@ export class FactoryLoop implements Factory {
     if (!ref) {
       return undefined
     }
-    const candidatePaths = ref.path ? [ref.path] : await this.#pullMetaPathsFor(ref.repo, ref.prNumber)
+    return await this.#readPrSnapshot(ref)
+  }
+
+  async #readPrSnapshot(ref: Pick<BabysitterPrRef, 'repo' | 'prNumber' | 'path'>): Promise<PullSnapshot | undefined> {
+    const discoveredPaths = await this.#pullMetaPathsFor(ref.repo, ref.prNumber)
+    const candidatePaths = [...new Set([ref.path, ...discoveredPaths].filter((path): path is string => Boolean(path)))]
     for (const path of candidatePaths) {
       try {
         const snapshot = parsePullSnapshot((await this.#mount.readFile(path)).content, ref.prNumber)
@@ -7270,9 +7634,9 @@ export class FactoryLoop implements Factory {
   }
 
   async #escalateTriageToGithub(decision: TriageDecision, reason: string): Promise<DispatchResult | undefined> {
-    const question = triageEscalationQuestion(decision)
-    const correlationId = githubEscalationCorrelationId('triage', decision.issue, question)
     const issue = await this.#readIssue(decision.issue.path)
+    const question = triageEscalationQuestion(decision, issue)
+    const correlationId = githubEscalationCorrelationId('triage', decision.issue, question)
     const source = issue ? githubIssueSourceRef(issue) : undefined
     const authorizedAuthor = issue ? await this.#resolveGithubIssueAuthor(issue) : undefined
     if (!issue || !source || !authorizedAuthor) {
@@ -7369,7 +7733,11 @@ export class FactoryLoop implements Factory {
     const source = githubIssueSourceRef(issue)
     const stakeholderMentions = slackMentions(this.#config.slack.stakeholderUserIds)
     const reporter = await this.#resolveGithubIssueAuthor(issue)
-    const audience = [stakeholderMentions, reporter ? `GitHub reporter: @${reporter}.` : undefined]
+    const reporterSlackUserId = reporter ? await this.#resolveSlackUserIdForGithubReporter(reporter) : undefined
+    const reporterAudience = reporter
+      ? `GitHub reporter: ${reporterSlackUserId ? `<@${reporterSlackUserId}>` : `${reporter} (GitHub)`}.`
+      : undefined
+    const audience = [stakeholderMentions, reporterAudience]
       .filter((part): part is string => Boolean(part))
       .join(' ')
     const replyInstruction = source?.url
@@ -7380,7 +7748,7 @@ export class FactoryLoop implements Factory {
       text: [
         `${audience ? `${audience} ` : ''}${decision.issue.key}: factory triage escalation for ${issue.title}`,
         `Reason: ${reason}`,
-        `Question: ${triageEscalationQuestion(decision)} ${replyInstruction}`,
+        `Question: ${triageEscalationQuestion(decision, issue)} ${replyInstruction}`,
       ].join('\n'),
     })
     await this.#state.setSlackThread(this.#workspaceId, issueKey(decision.issue), root.threadId)
@@ -7430,6 +7798,71 @@ export class FactoryLoop implements Factory {
     return pending
   }
 
+  async #resolveSlackUserIdForGithubReporter(reporter: string): Promise<string | undefined> {
+    const identity = normalizedCrossProviderIdentity(reporter)
+    if (!identity) return undefined
+    if (this.#slackReporterUserIds.has(identity)) {
+      return this.#slackReporterUserIds.get(identity)
+    }
+    const existing = this.#slackReporterUserIdLookups.get(identity)
+    if (existing) return existing
+
+    const pending = this.#findSlackUserIdByIdentity(identity)
+      .then((userId) => {
+        this.#slackReporterUserIds.set(identity, userId)
+        if (userId) this.#increment('slackReporterIdentitiesResolved')
+        return userId
+      })
+      .catch(() => {
+        this.#slackReporterUserIds.set(identity, undefined)
+        this.#increment('slackReporterIdentityLookupFailures')
+        return undefined
+      })
+      .finally(() => {
+        this.#slackReporterUserIdLookups.delete(identity)
+      })
+    this.#slackReporterUserIdLookups.set(identity, pending)
+    return pending
+  }
+
+  async #findSlackUserIdByIdentity(identity: string): Promise<string | undefined> {
+    const list = async (prefix: string): Promise<string[]> => {
+      try {
+        return await this.#mount.listTree(prefix)
+      } catch {
+        return []
+      }
+    }
+    const [userPaths, channelPaths] = await Promise.all([
+      list('/slack/users'),
+      list('/slack/channels'),
+    ])
+    const candidates = [
+      ...userPaths.filter(isSlackIdentityRecordPath),
+      ...channelPaths
+        .filter(isSlackIdentityRecordPath)
+        .sort((left, right) => slackIdentityPathTimestamp(right) - slackIdentityPathTimestamp(left))
+        .slice(0, SLACK_IDENTITY_MESSAGE_SCAN_LIMIT),
+    ]
+    const matches = new Set<string>()
+    for (let offset = 0; offset < candidates.length; offset += SLACK_IDENTITY_READ_BATCH_SIZE) {
+      const batch = candidates.slice(offset, offset + SLACK_IDENTITY_READ_BATCH_SIZE)
+      const records = await Promise.all(batch.map(async (path) => {
+        try {
+          return wrappedPayload((await this.#mount.readFile(path)).content)
+        } catch {
+          return undefined
+        }
+      }))
+      for (const payload of records) {
+        const userId = payload ? slackUserIdMatchingIdentity(payload, identity) : undefined
+        if (userId) matches.add(userId)
+        if (matches.size > 1) return undefined
+      }
+    }
+    return matches.size === 1 ? [...matches][0] : undefined
+  }
+
   async #postAndWatchSlackEscalationThread(decision: TriageDecision, reason: string): Promise<DispatchResult | undefined> {
     if (!this.#slack || !this.#config.slack) {
       return
@@ -7442,7 +7875,7 @@ export class FactoryLoop implements Factory {
       text: [
         `${stakeholderMentions ? `${stakeholderMentions} ` : ''}${decision.issue.key}: factory triage escalation for ${issue?.title ?? decision.issue.key}`,
         `Reason: ${reason}`,
-        `Question: ${triageEscalationQuestion(decision)}`,
+        `Question: ${triageEscalationQuestion(decision, issue)}`,
       ].join('\n'),
     })
     await this.#state.setSlackThread(this.#workspaceId, issueKey(decision.issue), root.threadId)
@@ -8699,6 +9132,15 @@ const githubIssueAsFactoryIssue = (issue: GithubIssueSource): LinearIssue => {
   }
 }
 
+const githubIssueUpdatedAtMs = (issue?: LinearIssue): number => {
+  if (!issue || !isGithubIssue(issue)) return 0
+  const payload = wrappedPayload(issue.raw)
+  const updatedAt = stringValue(payload.updated_at) ?? stringValue(payload.updatedAt)
+  if (!updatedAt) return 0
+  const parsed = Date.parse(updatedAt)
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
 export async function readFactoryLoopHeartbeat(
   path = DEFAULT_FACTORY_LOOP_HEARTBEAT_PATH,
 ): Promise<FactoryLoopHeartbeat | undefined> {
@@ -9011,22 +9453,32 @@ function labelRoutesForIssue(
   offendingLabels: string[]
   routes: Array<{ slug: string; route: TriageDecision['routes'][number] }>
 } {
-  const githubReadinessLabel = isGithubIssue(issue) ? config.safety.requireLabel.trim().toLowerCase() : undefined
-  const labels = uniqueNormalizedLabels(issue.labels).filter((label) =>
+  const githubIssue = isGithubIssue(issue)
+  const githubReadinessLabel = githubIssue ? config.safety.requireLabel.trim().toLowerCase() : undefined
+  const candidateLabels = uniqueNormalizedLabels(issue.labels).filter((label) =>
     !isShapeLabel(label) &&
     label.toLowerCase() !== githubReadinessLabel &&
-    (!isGithubIssue(issue) || !GITHUB_LIFECYCLE_LABELS.has(label.toLowerCase())),
+    (!githubIssue || !GITHUB_LIFECYCLE_LABELS.has(label.toLowerCase())),
   )
+  const labels: string[] = []
   const routes: Array<{ slug: string; route: TriageDecision['routes'][number] }> = []
   const offendingLabels: string[] = []
   const seenRepos = new Set<string>()
 
-  for (const label of labels) {
+  for (const label of candidateLabels) {
     const entry = findLabelRoute(config.repos.byLabel, label)
     if (!entry) {
-      offendingLabels.push(label)
+      // GitHub repositories commonly carry metadata labels such as `bug` and
+      // `enhancement`; only explicitly configured repo labels participate in
+      // routing. Linear labels remain authoritative and therefore fail closed
+      // when unmapped.
+      if (!githubIssue) {
+        labels.push(label)
+        offendingLabels.push(label)
+      }
       continue
     }
+    labels.push(label)
 
     const repo = entry.repo
     if (seenRepos.has(repo)) {
@@ -9506,7 +9958,15 @@ const resolveIssuePrFromMount = async (
         ? issuePrMatchScore(pr, issue, opts.titleMarker ?? config.safety.requireTitlePrefix, opts)
         : 0
       if (!pr || score <= 0) continue
-      candidates.push({ repo, prNumber: pr.number, draft: pr.draft, score })
+      candidates.push({
+        repo,
+        prNumber: pr.number,
+        draft: pr.draft,
+        headRef: pr.headRef,
+        url: pr.url,
+        path,
+        score,
+      })
     }
   }
 
@@ -9533,7 +9993,7 @@ const resolveIssuePrFromGh = async (
         '--state',
         'all',
         '--json',
-        'number,title,body,headRefName,isDraft,state',
+        'number,title,body,headRefName,isDraft,state,url',
         '--limit',
         String(PROBE_PR_GH_CANDIDATE_LIMIT),
       ])
@@ -9561,7 +10021,7 @@ const resolveIssuePrFromGh = async (
 
     for (const entry of payload) {
       const pr = ghProbePrCandidate(entry)
-      if (!pr || !containsIssueKey(pr.headRef, issue.key)) continue
+      if (!pr || !factoryBranchMatchesIssue(pr.headRef, issue.key)) continue
       if (opts.openOnly && normalizePrState(pr.state) !== 'OPEN') continue
       const score = issuePrMatchScore(pr, issue, opts.titleMarker ?? config.safety.requireTitlePrefix, opts)
       if (score <= 0) continue
@@ -9569,6 +10029,8 @@ const resolveIssuePrFromGh = async (
         repo,
         prNumber: pr.number,
         draft: pr.draft,
+        headRef: pr.headRef,
+        url: pr.url,
         score,
         open: normalizePrState(pr.state) === 'OPEN',
       })
@@ -9675,7 +10137,15 @@ const githubPullRoot = (repo: string): string => {
 const readProbePrCandidate = async (
   mount: MountClient,
   path: string,
-): Promise<{ number: number; title: string; body: string; headRef: string; draft?: boolean; state?: string } | undefined> => {
+): Promise<{
+  number: number
+  title: string
+  body: string
+  headRef: string
+  draft?: boolean
+  state?: string
+  url?: string
+} | undefined> => {
   try {
     const payload = wrappedPayload((await mount.readFile(path)).content)
     const number = typeof payload.number === 'number'
@@ -9689,6 +10159,7 @@ const readProbePrCandidate = async (
       headRef: refName(payload.headRef) ?? refName(payload.head) ?? stringValue(payload.head_ref) ?? '',
       draft: booleanValue(payload.isDraft) ?? booleanValue(payload.draft),
       state: stringValue(payload.state),
+      url: stringValue(payload.url) ?? stringValue(payload.html_url),
     }
   } catch {
     return undefined
@@ -9697,7 +10168,15 @@ const readProbePrCandidate = async (
 
 const ghProbePrCandidate = (
   value: unknown,
-): { number: number; title: string; body: string; headRef: string; draft?: boolean; state?: string } | undefined => {
+): {
+  number: number
+  title: string
+  body: string
+  headRef: string
+  draft?: boolean
+  state?: string
+  url?: string
+} | undefined => {
   const payload = asRecord(value)
   if (!payload) return undefined
   const number = numberValue(payload.number)
@@ -9709,6 +10188,7 @@ const ghProbePrCandidate = (
     headRef: stringValue(payload.headRefName) ?? '',
     draft: booleanValue(payload.isDraft),
     state: stringValue(payload.state),
+    url: stringValue(payload.url),
   }
 }
 
@@ -9720,7 +10200,7 @@ const issuePrMatchScore = (
 ): number => {
   if (opts.requireTitleMarker && !hasTitlePrefix(pr.title, marker)) return 0
 
-  if (containsIssueKey(pr.headRef, issue.key)) return 30
+  if (factoryBranchMatchesIssue(pr.headRef, issue.key)) return 30
   if (containsIssueKey(pr.title, issue.key)) return 20
   if (containsExplicitIssueReference(pr.body, issue.key)) return 10
   return 0
@@ -9729,6 +10209,12 @@ const issuePrMatchScore = (
 const hasTitlePrefix = (title: string, marker: string): boolean =>
   title === marker || title.startsWith(`${marker} `)
 
+const factoryBranchMatchesIssue = (headRef: string, issueKey: string): boolean =>
+  /^\d+$/u.test(issueKey)
+    ? headRef.toLowerCase() === `factory/${issueKey.toLowerCase()}` ||
+      headRef.toLowerCase().startsWith(`factory/${issueKey.toLowerCase()}-`)
+    : containsIssueKey(headRef, issueKey)
+
 const normalizePrState = (state?: string): string | undefined => state?.toUpperCase()
 
 const failClosedGhRunner: GhRunner = async () => ({ stdout: '[]' })
@@ -10101,7 +10587,7 @@ const babysitterCriticalIssueMatches = (signalKey: string, issue: IssueRef): boo
 }
 
 const prSnapshotIssueMatchScore = (snapshot: PullSnapshot, issueKey: string): number => {
-  if (containsIssueKey(snapshot.headRef ?? '', issueKey)) return 30
+  if (factoryBranchMatchesIssue(snapshot.headRef ?? '', issueKey)) return 30
   if (containsIssueKey(snapshot.title ?? '', issueKey)) return 20
   if (containsExplicitIssueReference(snapshot.body ?? '', issueKey)) return 10
   return 0
@@ -10209,7 +10695,7 @@ const isAllowedFactoryDraft = async (
 }
 
 const isFactoryGithubWritebackPath = (path: string): boolean =>
-  /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/refs%2Fheads%2F[^/]+\.json|pulls\/[1-9]\d*\/close\.json)$/iu.test(path)
+  /^\/github\/repos\/[^/]+\/[^/]+\/(?:pull-requests\/factory-[^/]+\.json|refs\/(?:factory\.json|refs%2Fheads%2Ffactory%2F[^/]+\.json)|pulls\/[1-9]\d*\/close\.json)$/iu.test(path)
 
 const isIssuePathInFactoryScope = async (
   mount: MountClient,
@@ -10661,26 +11147,32 @@ const triageEscalationReason = (decision: TriageDecision): string | undefined =>
   return `${reasons.join(' and ')}${decision.rationale ? `: ${decision.rationale}` : ''}`
 }
 
-const triageEscalationQuestion = (decision: TriageDecision): string => {
+class LiveDispatchStateChangedError extends Error {
+  readonly issueKey: string
+
+  constructor(issueKey: string) {
+    super(`Live state changed before writeback for ${issueKey}`)
+    this.name = 'LiveDispatchStateChangedError'
+    this.issueKey = issueKey
+  }
+}
+
+const triageEscalationQuestion = (decision: TriageDecision, issue?: { title?: string }): string => {
   const routedRepos = decision.routes.map((route) => route.repo).filter(Boolean)
+  const subject = issue?.title?.trim() || decision.issue.key
+  const details = `For "${subject}", please reply with: (1) the exact user flow—where it starts, required inputs/actions, and the successful result; (2) permissions, validation, failure behavior, important edge cases, and anything out of scope; and (3) observable acceptance checks or tests. Say "use reasonable product defaults" for anything Factory may decide. After an authorized GitHub reply, Factory will dispatch agents; successful work will be opened as a pull request.`
   if (routedRepos.length === 0) {
-    return [
-      'Which repository or repositories should handle this issue?',
-      'Please include the intended approach and the acceptance criteria/tests the agent should satisfy.',
-    ].join(' ')
+    return `Which repository or repositories should handle this issue? ${details}`
   }
   if (decision.thin) {
-    return [
-      `Factory matched ${routedRepos.join(', ')}.`,
-      'Please clarify the concrete expected behavior, constraints, and acceptance criteria/tests before dispatch.',
-    ].join(' ')
+    return `Factory matched ${routedRepos.join(', ')}. ${details}`
   }
-  return [
-    `Factory matched ${routedRepos.join(', ')}, but triage confidence is low.`,
-    'Please confirm the intended repo/approach or correct the route before dispatch.',
-  ].join(' ')
+  return `Factory matched ${routedRepos.join(', ')}, but triage confidence is low. Please confirm that repository and intended approach, or provide the correct route. ${details}`
 }
 
+const isTerminalDeliveryFailure = (reason?: string): boolean =>
+  /worker[_ -]?(?:exited|disappeared)|max delivery retries exceeded/iu.test(reason ?? '')
+
 const isTriageEscalationWatchRecord = (record: InFlightIssue): boolean =>
   record.agents.size === 0 && record.invocationIds.size === 0 && triageEscalationReason(record.decision) !== undefined
 
@@ -10814,6 +11306,47 @@ const slackMentions = (userIds: string[]): string | undefined => {
   return mentions.length > 0 ? mentions.join(' ') : undefined
 }
 
+const normalizedCrossProviderIdentity = (value: string): string =>
+  value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, '')
+
+const isSlackIdentityRecordPath = (path: string): boolean =>
+  path.endsWith('.json') && (
+    path.startsWith('/slack/users/') ||
+    path.startsWith('/slack/channels/')
+  )
+
+const slackIdentityPathTimestamp = (path: string): number => {
+  const timestamps = [...path.matchAll(/(?:^|\/)(\d{10})[_\.][0-9]+/gu)]
+  return Number(timestamps.at(-1)?.[1] ?? 0)
+}
+
+const slackUserIdMatchingIdentity = (
+  payload: Record<string, unknown>,
+  identity: string,
+): string | undefined => {
+  if (
+    payload.is_bot === true ||
+    payload.user_is_bot === true ||
+    payload.is_deleted === true ||
+    payload.deleted === true
+  ) return undefined
+  const userId = stringValue(payload.id) ?? stringValue(payload.user)
+  if (!userId || !/^[UW][A-Z0-9]+$/u.test(userId)) return undefined
+  const email = stringValue(payload.email) ?? stringValue(payload.user_email)
+  const aliases = [
+    stringValue(payload.name),
+    stringValue(payload.real_name),
+    stringValue(payload.display_name),
+    stringValue(payload.user_name),
+    stringValue(payload.user_real_name),
+    stringValue(payload.user_display_name),
+    email?.split('@')[0],
+  ]
+  return aliases.some((alias) => alias && normalizedCrossProviderIdentity(alias) === identity)
+    ? userId
+    : undefined
+}
+
 const agentQuestionSlackText = (issue: IssueRef, question: AgentQuestion, stakeholderUserIds: string[] = []): string => [
   slackMentions(stakeholderUserIds),
   `${issue.key}: ${question.agentName} needs input.`,
diff --git a/src/ports/mount.ts b/src/ports/mount.ts
index ba458f2..e3302ec 100644
--- a/src/ports/mount.ts
+++ b/src/ports/mount.ts
@@ -89,6 +89,8 @@ export interface MountClient {
   getEventHighWatermark?(opts?: { provider?: string }): Promise<string | undefined>
   getSyncStatus?(provider: string): Promise<ProviderSyncStatus | undefined>
   confirmWrite(path: string, opts?: { timeoutMs?: number }): Promise<'acked' | 'pending' | 'failed' | 'timeout'>
+  /** Provider failure detail retained for a completed failed write, when available. */
+  getConfirmedWriteFailureReason?(path: string): Promise<string | undefined>
   /** Provider object id returned by the acknowledged write operation, when available. */
   getConfirmedWriteExternalId?(path: string): Promise<string | undefined>
   ensureSubRoot(prefix: string, opts?: { timeoutMs?: number }): Promise<'ready' | 'absent'>
diff --git a/src/triage/heuristic.ts b/src/triage/heuristic.ts
index 905efa8..d5ad6a3 100644
--- a/src/triage/heuristic.ts
+++ b/src/triage/heuristic.ts
@@ -269,7 +269,8 @@ function implementationAssignments(
 }
 
 function hasAcceptanceSignal(issue: LinearIssue): boolean {
-  return ACCEPTANCE_SIGNAL_PATTERNS.some((pattern) => pattern.test(issue.description))
+  const taskText = `${issue.title}\n${issue.description}`
+  return ACCEPTANCE_SIGNAL_PATTERNS.some((pattern) => pattern.test(taskText))
 }
 
 function issueRefFor(issue: LinearIssue): IssueRef {
diff --git a/src/triage/triage.test.ts b/src/triage/triage.test.ts
index 6c83159..a643cf5 100644
--- a/src/triage/triage.test.ts
+++ b/src/triage/triage.test.ts
@@ -140,10 +140,16 @@ describe('HeuristicTriage routing', () => {
 describe('HeuristicTriage thin and scope detection', () => {
   it.each([
     { name: 'short description is thin', description: 'Fix tests in src/main/broker.ts.', thin: true },
-    { name: 'long description without acceptance signal is thin', description: 'Background '.repeat(30), thin: true },
+    { name: 'long description without acceptance signal is thin', title: 'Background context', description: 'Background '.repeat(30), thin: true },
     { name: 'long description with acceptance signal is not thin', description: richDescription('Add regression tests in src/main/broker.ts and verify the error path.'), thin: false },
-  ])('$name', async ({ description, thin }) => {
-    const decision = await new HeuristicTriage().triage(issue({ description }), ctx)
+    {
+      name: 'bug title makes detailed reproduction steps actionable',
+      title: 'Bug: Creating a new league does not work',
+      description: 'Steps to reproduce: Login, click new league, enter a league name, submit, and observe the broken admin page. '.repeat(2),
+      thin: false,
+    },
+  ])('$name', async ({ title, description, thin }) => {
+    const decision = await new HeuristicTriage().triage(issue({ ...(title ? { title } : {}), description }), ctx)
 
     expect(decision.thin).toBe(thin)
   })