Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
37 commits
Select commit Hold shift + click to select a range
cc4950a
feat(agent): add GraphDocument registry and activation seam
ampagent Aug 31, 2026
a1b86de
fix(agent): treat malformed frame bytes as a failed commit, not a throw
christian-byrne Sep 1, 2026
e8846fc
fix(agent): reject inherited sequences in isCommitted after lineage r…
christian-byrne Sep 1, 2026
c43525d
fix(agent): serialize slots via explicit allowlist to exclude runtime…
christian-byrne Sep 1, 2026
7ed7c0b
fix(agent): sort widgets by code unit for locale-independent canonica…
christian-byrne Sep 1, 2026
f4f872c
fix(agent): reject target frames with malformed entries before mutati…
christian-byrne Sep 1, 2026
64af88f
fix(agent): make activation handoff exception-safe
christian-byrne Sep 1, 2026
ec3285e
fix(agent): let deactivate cancel an unpublished in-flight activation
christian-byrne Sep 1, 2026
a8c9415
fix(agent): refuse agent writes when the bound tab is unresolved
christian-byrne Sep 1, 2026
8da1e22
fix(agent): re-resolve document id per commit instead of caching it
christian-byrne Sep 1, 2026
75eafd9
fix(agent): advance document revision on successful graph writes
christian-byrne Sep 1, 2026
dfff06c
fix(agent): make activation handoff safe against reentrant calls
christian-byrne Sep 1, 2026
df51222
fix(agent): resume strict frame sequencing after a lineage reset
christian-byrne Sep 1, 2026
634ac4a
fix(agent): resolve mutation-tracking document id per write call
christian-byrne Sep 1, 2026
512309e
fix(agent): don't cancel unrelated in-flight activation on deactivate
christian-byrne Sep 1, 2026
486db4a
fix(agent): allow closing documents that never hydrated
christian-byrne Sep 1, 2026
17190d3
feat(agent): bind ChangeTracker/ComfyWorkflow dirty tracking to the G…
christian-byrne Sep 2, 2026
a264be4
[automated] Apply ESLint and Oxfmt fixes
actions-user Sep 2, 2026
0073af0
fix(agent): harden document activation lifecycle
christian-byrne Sep 2, 2026
000dee9
test(agent): keep projection harness merge-compatible
christian-byrne Sep 2, 2026
8867729
feat(agent): add document graph lease lifecycle
christian-byrne Sep 3, 2026
9257f4a
fix(agent): satisfy current document diagnostics lint
Sep 3, 2026
3a70e38
fix: preserve hard failures for document invariants
christian-byrne Sep 3, 2026
1309936
fix: address graph document lifecycle review feedback
christian-byrne Sep 4, 2026
4463c64
fix(agent): commit semantic stores and layout atomically
christian-byrne Sep 10, 2026
d6199e8
fix(agent): bind the remote target to the workflow's own document
christian-byrne Sep 10, 2026
fb2da29
chore: realign the document seam with main's lint and store contracts
christian-byrne Sep 10, 2026
bef5075
fix: contain graph lease disposal failures
christian-byrne Sep 12, 2026
edfc1f2
test(graph): distinguish cross-target assertion modes
christian-byrne Sep 12, 2026
5ade35e
fix(graph): preserve newer shared hydration lease
christian-byrne Sep 14, 2026
8cdb944
fix(graph): limit no-capture layout rollback
christian-byrne Sep 14, 2026
bd7c172
test(graph): cover partial detached-session drain
christian-byrne Sep 14, 2026
bf29f44
refactor(graph): narrow serializer projections
christian-byrne Sep 14, 2026
158cbf2
test(graph): use typed serializer fixtures
christian-byrne Sep 14, 2026
6c696df
fix(workflow): rebaseline forced remote reloads
christian-byrne Sep 14, 2026
df402b1
test(agent): strengthen persistence isolation coverage
christian-byrne Sep 14, 2026
6106524
test(agent): cover link presentation rollback
christian-byrne Sep 14, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
351 changes: 351 additions & 0 deletions src/core/graph/document/activationCoordinator.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,351 @@
import { describe, expect, it, vi } from 'vitest'

import type {
ActivationOutcome,
DocumentViewBinding
} from '@/core/graph/document/activationCoordinator'
import { createActivationCoordinator } from '@/core/graph/document/activationCoordinator'
import { reportError } from '@/platform/telemetry/reportError'
import type { DocumentId } from '@/types/documentId'
import { toDocumentId } from '@/types/documentId'

vi.mock(import('@/platform/telemetry/reportError'), () => ({
reportError: vi.fn()
}))

function recordingBinding(log: string[], name: string): DocumentViewBinding {
return {
attach: (id: DocumentId) => log.push(`attach:${name}:${id}`),
detach: (id: DocumentId) => log.push(`detach:${name}:${id}`)
}
}

function deferred(): { promise: Promise<void>; resolve: () => void } {
let resolve!: () => void
const promise = new Promise<void>((r) => {
resolve = r
})
return { promise, resolve }
}

describe('createActivationCoordinator', () => {
it('activates a loaded document and publishes it as active', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => true })
const log: string[] = []
const docA = toDocumentId('doc-a')

const outcome = await coordinator.activate(docA, recordingBinding(log, 'a'))

expect(outcome).toEqual({ status: 'activated', documentId: docA })
expect(coordinator.activeDocumentId()).toBe(docA)
expect(log).toEqual([`attach:a:${docA}`])
})

it('rejects activation of a document that is not loaded', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => false })
const log: string[] = []
const docA = toDocumentId('doc-a')

const outcome = await coordinator.activate(docA, recordingBinding(log, 'a'))

expect(outcome).toEqual({
status: 'rejected',
documentId: docA,
reason: 'not-loaded'
})
expect(coordinator.activeDocumentId()).toBeNull()
expect(log).toEqual([])
})

it('rejects when hydration fails and leaves the previous binding intact', async () => {
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')
const coordinator = createActivationCoordinator({
isLoaded: () => true,
hydrate: (id) =>
id === docB ? Promise.reject(new Error('boom')) : Promise.resolve()
})
const log: string[] = []
await coordinator.activate(docA, recordingBinding(log, 'a'))

const outcome = await coordinator.activate(docB, recordingBinding(log, 'b'))

expect(outcome).toEqual({
status: 'rejected',
documentId: docB,
reason: 'hydration-failed'
})
expect(coordinator.activeDocumentId()).toBe(docA)
expect(log).toEqual([`attach:a:${docA}`])
expect(reportError).toHaveBeenCalledWith(expect.any(Error), {
errorType: 'document_activation_hydration_failure'
})
})

it('performs an ordered detach-then-attach handoff between documents', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => true })
const log: string[] = []
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')

await coordinator.activate(docA, recordingBinding(log, 'a'))
await coordinator.activate(docB, recordingBinding(log, 'b'))

expect(log).toEqual([
`attach:a:${docA}`,
`detach:a:${docA}`,
`attach:b:${docB}`
])
expect(coordinator.activeDocumentId()).toBe(docB)
})

it('supersedes a slow activate when a newer activate wins the race', async () => {
const slowHydration = deferred()
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')
const coordinator = createActivationCoordinator({
isLoaded: () => true,
hydrate: (id) => (id === docA ? slowHydration.promise : Promise.resolve())
})
const log: string[] = []

const first = coordinator.activate(docA, recordingBinding(log, 'a'))
const second = await coordinator.activate(docB, recordingBinding(log, 'b'))
slowHydration.resolve()
const firstOutcome = await first

expect(second).toEqual({ status: 'activated', documentId: docB })
expect(firstOutcome).toEqual({ status: 'superseded', documentId: docA })
expect(coordinator.activeDocumentId()).toBe(docB)
expect(log).toEqual([`attach:b:${docB}`])
})

it('reports superseded when a stale request fails hydration after being overtaken', async () => {
const slowHydration = deferred()
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')
const coordinator = createActivationCoordinator({
isLoaded: () => true,
hydrate: (id) =>
id === docA
? slowHydration.promise.then(() => {
throw new Error('late failure')
})
: Promise.resolve()
})
const log: string[] = []

const first = coordinator.activate(docA, recordingBinding(log, 'a'))
await coordinator.activate(docB, recordingBinding(log, 'b'))
slowHydration.resolve()

expect(await first).toEqual({ status: 'superseded', documentId: docA })
expect(coordinator.activeDocumentId()).toBe(docB)
})

it('deactivate detaches the active document without cancelling an unrelated in-flight activation', async () => {
const slowHydration = deferred()
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')
const coordinator = createActivationCoordinator({
isLoaded: () => true,
hydrate: (id) => (id === docB ? slowHydration.promise : Promise.resolve())
})
const log: string[] = []
await coordinator.activate(docA, recordingBinding(log, 'a'))

const inFlight = coordinator.activate(docB, recordingBinding(log, 'b'))
expect(coordinator.deactivate(docA)).toBe(true)
expect(coordinator.activeDocumentId()).toBeNull()
slowHydration.resolve()

expect(await inFlight).toEqual({ status: 'activated', documentId: docB })
expect(coordinator.activeDocumentId()).toBe(docB)
expect(log).toEqual([
`attach:a:${docA}`,
`detach:a:${docA}`,
`attach:b:${docB}`
])
})

it('deactivate cancels an in-flight activate for the same document', async () => {
const slowHydration = deferred()
const docB = toDocumentId('doc-b')
const coordinator = createActivationCoordinator({
isLoaded: () => true,
hydrate: () => slowHydration.promise
})
const log: string[] = []

const inFlight = coordinator.activate(docB, recordingBinding(log, 'b'))
expect(coordinator.deactivate(docB)).toBe(true)
slowHydration.resolve()

expect(await inFlight).toEqual({ status: 'superseded', documentId: docB })
expect(coordinator.activeDocumentId()).toBeNull()
expect(log).toEqual([])
})

it('rejects with handoff-failed and clears active when attach throws', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => true })
const log: string[] = []
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')
await coordinator.activate(docA, recordingBinding(log, 'a'))

const throwingBinding: DocumentViewBinding = {
attach: () => {
throw new Error('attach boom')
},
detach: (id) => log.push(`detach:b:${id}`)
}
const outcome = await coordinator.activate(docB, throwingBinding)

expect(outcome).toEqual({
status: 'rejected',
documentId: docB,
reason: 'handoff-failed'
})
expect(coordinator.activeDocumentId()).toBeNull()
// The previous document was detached exactly once before the failure,
// and the failed binding received a best-effort undo-detach.
expect(log).toEqual([
`attach:a:${docA}`,
`detach:a:${docA}`,
`detach:b:${docB}`
])
expect(reportError).toHaveBeenCalledWith(expect.any(Error), {
errorType: 'document_view_binding_attach_failure'
})
})

it('a reentrant deactivate from within attach supersedes the activation', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => true })
const log: string[] = []
const docB = toDocumentId('doc-b')
const reentrantBinding: DocumentViewBinding = {
attach: (id) => {
log.push(`attach:b:${id}`)
coordinator.deactivate(docB)
},
detach: (id) => log.push(`detach:b:${id}`)
}

const outcome = await coordinator.activate(docB, reentrantBinding)

expect(outcome).toEqual({ status: 'superseded', documentId: docB })
expect(coordinator.activeDocumentId()).toBeNull()
// The attach was undone instead of publishing over the deactivate.
expect(log).toEqual([`attach:b:${docB}`, `detach:b:${docB}`])
})

it('a reentrant activate from within detach wins over the in-progress handoff', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => true })
const log: string[] = []
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')
const docC = toDocumentId('doc-c')
let reentrant: Promise<ActivationOutcome> | undefined
const bindingA: DocumentViewBinding = {
attach: (id) => log.push(`attach:a:${id}`),
detach: (id) => {
log.push(`detach:a:${id}`)
reentrant = coordinator.activate(docC, recordingBinding(log, 'c'))
}
}
await coordinator.activate(docA, bindingA)

const outcome = await coordinator.activate(docB, recordingBinding(log, 'b'))

expect(outcome).toEqual({ status: 'superseded', documentId: docB })
expect(await reentrant).toEqual({ status: 'activated', documentId: docC })
expect(coordinator.activeDocumentId()).toBe(docC)
// B never attached; C attached exactly once after A's detach.
expect(log).toEqual([
`attach:a:${docA}`,
`detach:a:${docA}`,
`attach:c:${docC}`
])
})

it('deactivate of a superseded in-flight document is a no-op', async () => {
const slowHydration = deferred()
const docB = toDocumentId('doc-b')
const docC = toDocumentId('doc-c')
const coordinator = createActivationCoordinator({
isLoaded: () => true,
hydrate: (id) => (id === docB ? slowHydration.promise : Promise.resolve())
})
const log: string[] = []

const inFlight = coordinator.activate(docB, recordingBinding(log, 'b'))
await coordinator.activate(docC, recordingBinding(log, 'c'))
slowHydration.resolve()
expect(await inFlight).toEqual({ status: 'superseded', documentId: docB })

// The superseded request cleared its own pending record, so deactivating
// the never-activated document reports that nothing was cancelled.
expect(coordinator.deactivate(docB)).toBe(false)
expect(coordinator.activeDocumentId()).toBe(docC)
expect(log).toEqual([`attach:c:${docC}`])
})

it('does not detach the previous document twice after a throwing detach', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => true })
const log: string[] = []
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')
const throwingDetach: DocumentViewBinding = {
attach: (id) => log.push(`attach:a:${id}`),
detach: () => {
throw new Error('detach boom')
}
}
await coordinator.activate(docA, throwingDetach)

const outcome = await coordinator.activate(docB, recordingBinding(log, 'b'))

expect(outcome).toEqual({
status: 'rejected',
documentId: docB,
reason: 'handoff-failed'
})
expect(coordinator.activeDocumentId()).toBeNull()
expect(reportError).toHaveBeenCalledWith(expect.any(Error), {
errorType: 'document_view_binding_previous_detach_failure'
})

// A follow-up activate succeeds without re-detaching the failed binding.
const retry = await coordinator.activate(docB, recordingBinding(log, 'b'))
expect(retry).toEqual({ status: 'activated', documentId: docB })
expect(log).toEqual([`attach:a:${docA}`, `attach:b:${docB}`])
})

it('deactivate of a non-active document is a no-op', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => true })
const log: string[] = []
const docA = toDocumentId('doc-a')
const docB = toDocumentId('doc-b')
await coordinator.activate(docA, recordingBinding(log, 'a'))

expect(coordinator.deactivate(docB)).toBe(false)
expect(coordinator.activeDocumentId()).toBe(docA)
})

it('treats a throwing detach during deactivate as detached', async () => {
const coordinator = createActivationCoordinator({ isLoaded: () => true })
const docA = toDocumentId('doc-a')
await coordinator.activate(docA, {
attach: () => {},
detach: () => {
throw new Error('detach boom')
}
})

expect(coordinator.deactivate(docA)).toBe(true)
expect(coordinator.activeDocumentId()).toBeNull()
expect(reportError).toHaveBeenCalledWith(expect.any(Error), {
errorType: 'document_view_binding_detach_failure'
})
})
})
Loading
Loading