import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest'

// Database is resolved via vitest alias to better-sqlite3 at runtime

import { existsSync, mkdirSync, rmSync, writeFileSync, statSync } from 'fs'

import { execSync, spawnSync } from 'child_process'

import { join } from 'path'

// Mock ForgeRpcError for error handling

class MockForgeRpcError extends Error {

constructor(public code: string | undefined, message: string) {

super(message)

}

}

import { createLoopService } from '../src/loop/service'

import { generateUniqueName } from '../src/loop/name-uniqueness'

import { createPlansRepo } from '../src/storage/repos/plans-repo'

import { createLoopsRepo } from '../src/storage/repos/loops-repo'

import { createReviewFindingsRepo } from '../src/storage/repos/review-findings-repo'

import { openForgeDatabase } from '../src/storage/database'

import type { Logger } from '../src/types'

import { createToolExecuteBeforeHook, createToolExecuteAfterHook, createPlanApprovalEventHook } from '../src/hooks/plan-approval'

import type { ToolContext } from '../src/tools/types'

import type { PluginConfig } from '../src/types'

import { tmpdir } from 'os'

import { randomUUID } from 'crypto'

const TEST_DIR = '/tmp/opencode-manager-plan-approval-test-' + Date.now()

function createTestDb(): any {

return openForgeDatabase(join(tmpdir(), `forge-test-${randomUUID()}.db`))

}

function createMockLogger(): Logger {

return {

log: () => {},

error: () => {},

debug: () => {},

}

}

describe('Plan Approval Tool Interception', () => {

let db: any

let loopService: ReturnType<typeof createLoopService>

let plansRepo: ReturnType<typeof createPlansRepo>

const projectId = 'test-project'

const sessionID = 'test-session-123'

const PLAN_APPROVAL_LABELS = ['New session', 'Execute here', 'Loop']

const approvalArgs = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

beforeEach(() => {

db = createTestDb()

const loopsRepo = createLoopsRepo(db)

const reviewFindingsRepo = createReviewFindingsRepo(db)

plansRepo = createPlansRepo(db)

loopService = createLoopService(loopsRepo, plansRepo, reviewFindingsRepo, projectId, createMockLogger())

})

afterEach(() => {

db.close()

})

function simulateToolExecuteAfter(

tool: string,

args: unknown,

output: { title: string; output: string; metadata: unknown },

sessionActive = false

) {

if (sessionActive) {

const loopName = 'test-loop'

const state = {

active: true,

sessionId: sessionID,

loopName,

worktreeDir: '/test/worktree',

worktreeBranch: 'opencode/loop-test',

iteration: 1,

maxIterations: 5,

startedAt: new Date().toISOString(),

prompt: 'Test prompt',

phase: 'coding' as const,

status: 'running' as const,

errorCount: 0,

auditCount: 0,

worktree: true,

currentSectionIndex: 0,

totalSections: 0,

finalAuditDone: false,

}

loopService.setState(loopName, state as any)

}

if (tool === 'question') {

const questionArgs = args as { questions?: Array<{ options?: Array<{ label: string }> }> } | undefined

const options = questionArgs?.questions?.[0]?.options

if (options) {

const labels = options.map((o) => o.label)

const isPlanApproval = PLAN_APPROVAL_LABELS.every((l) => labels.includes(l))

if (isPlanApproval) {

const metadata = output.metadata as { answers?: string[][] } | undefined

const answer = metadata?.answers?.[0]?.[0]?.trim() ?? output.output.trim()

const matchedLabel = PLAN_APPROVAL_LABELS.find((l) => answer === l || answer.startsWith(l))

if (matchedLabel?.toLowerCase() === 'execute here') {

output.output = `${output.output}\n\nSwitching to code agent for execution...`

} else if (matchedLabel) {

// Programmatic dispatch - no directive injection

output.output = `${output.output}\n\n[Programmatic dispatch - no directive]`

} else {

// Custom answer fallback

output.output = `${output.output}\n\n<system-reminder>\nThe user provided a custom response instead of selecting a predefined option. Review their answer and respond accordingly. If they want to proceed with execution, ask the question tool again with one of: "New session", "Execute here", or "Loop". If they want to cancel or revise the plan, help them with that instead.\n</system-reminder>`

}

}

}

return

}

if (!sessionActive) return

const LOOP_BLOCKED_TOOLS: Record<string, string> = {

question: 'The question tool is not available during a loop. Do not ask questions — continue working on the task autonomously.',

loop: 'The loop tool is not available during a loop. Focus on executing the current plan.',

}

if (!(tool in LOOP_BLOCKED_TOOLS)) return

output.title = 'Tool blocked'

output.output = LOOP_BLOCKED_TOOLS[tool]!

}

test('Detects plan approval question and handles "New session" programmatically', () => {

const output = { title: '', output: 'New session', metadata: {} }

simulateToolExecuteAfter('question', approvalArgs, output)

expect(output.output).toContain('New session')

expect(output.output).not.toContain('<system-reminder>')

})

test('Detects plan approval question and handles "Execute here" with abort', () => {

const output = { title: '', output: 'Execute here', metadata: {} }

simulateToolExecuteAfter('question', approvalArgs, output)

expect(output.output).toContain('Execute here')

expect(output.output).toContain('Switching to code agent')

expect(output.output).not.toContain('<system-reminder>')

})

test('Detects plan approval question and handles "Loop" programmatically', () => {

const output = { title: '', output: 'Loop', metadata: {} }

simulateToolExecuteAfter('question', approvalArgs, output)

expect(output.output).toContain('Loop')

expect(output.output).not.toContain('<system-reminder>')

expect(output.output).not.toContain('memory-loop')

})

test('Injects directive for unknown answer', () => {

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = { title: '', output: 'Custom answer', metadata: {} }

simulateToolExecuteAfter('question', args, output)

expect(output.output).toContain('Custom answer')

expect(output.output).toContain('<system-reminder>')

expect(output.output).toContain('custom response')

expect(output.output).toContain('respond accordingly')

})

test('Matches partial answer that starts with label', () => {

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = { title: '', output: 'New session (with custom config)', metadata: {} }

simulateToolExecuteAfter('question', args, output)

expect(output.output).toContain('New session (with custom config)')

expect(output.output).not.toContain('<system-reminder>')

})

test('Does not match partial label in middle of text', () => {

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = { title: '', output: 'I want to create a session', metadata: {} }

simulateToolExecuteAfter('question', args, output)

expect(output.output).toContain('I want to create a session')

expect(output.output).toContain('<system-reminder>')

expect(output.output).toContain('custom response')

})

test('Does not modify non-approval questions', () => {

const args = {

questions: [{

question: 'What is your preference?',

options: [

{ label: 'Option A', description: 'First option' },

{ label: 'Option B', description: 'Second option' },

],

}],

}

const output = { title: '', output: 'Option A', metadata: {} }

const originalOutput = output.output

simulateToolExecuteAfter('question', args, output)

expect(output.output).toBe(originalOutput)

expect(output.output).not.toContain('<system-reminder>')

})

test('Does not modify non-question tools', () => {

const output = { title: '', output: 'Some result', metadata: {} }

const originalOutput = output.output

simulateToolExecuteAfter('plan-read', {}, output)

expect(output.output).toBe(originalOutput)

expect(output.output).not.toContain('<system-reminder>')

})

test('Does not treat pre-plan approval question as execution approval', () => {

const args = {

questions: [{

question: 'Should I write the implementation plan?',

options: [

{ label: 'Yes', description: 'Write the plan' },

{ label: 'No', description: 'Not yet' },

],

}],

}

const output = { title: '', output: 'Yes', metadata: {} }

const originalOutput = output.output

simulateToolExecuteAfter('question', args, output)

expect(output.output).toBe(originalOutput)

expect(output.output).not.toContain('<system-reminder>')

expect(output.output).not.toContain('Switching to code agent')

})

test('Loop blocking still works for question tool when loop is active', () => {

const output = { title: '', output: 'test', metadata: {} }

simulateToolExecuteAfter('question', {}, output, true)

expect(output.title).toBe('')

expect(output.output).toBe('test')

})

test('Loop blocking works for loop tool', () => {

const output = { title: '', output: 'test', metadata: {} }

simulateToolExecuteAfter('loop', {}, output, true)

expect(output.title).toBe('Tool blocked')

expect(output.output).toContain('loop tool is not available')

})

test('Loop blocking does not affect non-blocked tools', () => {

const output = { title: '', output: 'test', metadata: {} }

simulateToolExecuteAfter('plan-read', {}, output, true)

expect(output.title).toBe('')

expect(output.output).toBe('test')

})

test('Loop blocking only applies when loop is active', () => {

const output = { title: '', output: 'test', metadata: {} }

simulateToolExecuteAfter('loop', {}, output, false)

expect(output.title).toBe('')

expect(output.output).toBe('test')

})

test('Matches metadata answer exactly', async () => {

const v2AbortSpy = vi.fn(() => Promise.resolve({ data: {} }))

const legacyAbortSpy = vi.fn(() => Promise.resolve({ data: {} } as any))

const ctx = {

loopService: {

resolveLoopName: () => 'test-loop',

getActiveState: () => null,

},

logger: createMockLogger(),

v2: {

session: {

abort: v2AbortSpy,

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2'],

plansRepo,

config: {} as PluginConfig,

projectId,

directory: '/test',

dataDir: TEST_DIR,

cleanup: async () => {},

input: {

messages: [],

systemPrompt: '',

client: {

session: {

abort: legacyAbortSpy,

create: async () => ({ data: { id: 'new-session-id' } }),

promptAsync: async () => ({ data: {} }),

},

} as any,

},

systemPrompt: '',

messages: [],

loopsRepo: createLoopsRepo(db),

reviewFindingsRepo: createReviewFindingsRepo(db),

sandboxManager: null,

} as unknown as ToolContext

// Write a plan for the session so resolveCurrentSessionPlan succeeds

plansRepo.writeForSession(projectId, sessionID, '# Test Plan\n\nThis is a test plan.')

const hook = createToolExecuteAfterHook(ctx)

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = {

title: 'Asked 1 question',

output: 'Execute here',

metadata: { answers: [['Execute here']] },

}

await expect(hook(

{ tool: 'question', sessionID, callID: 'test-call', args },

output

)).resolves.toBeUndefined()

expect(output.output).toBe('Execute here')

expect((output.metadata as any).forgePlanApprovalHandled).toBe(true)

expect(legacyAbortSpy).toHaveBeenCalled()

})

test('Matches metadata answer by prefix', async () => {

const abortSpy = vi.fn(() => Promise.resolve({ data: {} }))

const ctx = {

loopService: {

resolveLoopName: () => 'test-loop',

getActiveState: () => null,

},

logger: createMockLogger(),

v2: {

session: {

abort: abortSpy,

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2'],

plansRepo,

config: {} as PluginConfig,

projectId,

directory: '/test',

dataDir: TEST_DIR,

cleanup: async () => {},

input: { messages: [], systemPrompt: '' },

systemPrompt: '',

messages: [],

loopsRepo: createLoopsRepo(db),

reviewFindingsRepo: createReviewFindingsRepo(db),

sandboxManager: null,

} as unknown as ToolContext

// Write a plan for the session so resolveCurrentSessionPlan succeeds

plansRepo.writeForSession(projectId, sessionID, '# Test Plan\n\nThis is a test plan.')

const hook = createToolExecuteAfterHook(ctx)

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = {

title: 'Asked 1 question',

output: 'User has answered your questions: ...',

metadata: { answers: [['New session (Recommended)']] },

}

await expect(hook(

{ tool: 'question', sessionID, callID: 'test-call', args },

output

)).resolves.toBeUndefined()

expect(output.output).toBe('User has answered your questions: ...')

expect((output.metadata as any).forgePlanApprovalHandled).toBe(true)

expect(abortSpy).toHaveBeenCalledWith({ sessionID, directory: "/test" })

})

test('Does not match middle-of-string text', async () => {

const abortSpy = vi.fn(() => Promise.resolve({ data: {} }))

const ctx = {

loopService: {

resolveLoopName: () => 'test-loop',

getActiveState: () => null,

},

logger: createMockLogger(),

v2: {

session: {

abort: abortSpy,

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2'],

plansRepo,

config: {} as PluginConfig,

projectId,

directory: '/test',

dataDir: TEST_DIR,

cleanup: async () => {},

input: { messages: [], systemPrompt: '' },

systemPrompt: '',

messages: [],

loopsRepo: createLoopsRepo(db),

reviewFindingsRepo: createReviewFindingsRepo(db),

sandboxManager: null,

} as unknown as ToolContext

// Write a plan for the session so resolveCurrentSessionPlan succeeds

plansRepo.writeForSession(projectId, sessionID, '# Test Plan\n\nThis is a test plan.')

const hook = createToolExecuteAfterHook(ctx)

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = {

title: 'Asked 1 question',

output: 'User has answered your questions: ...',

metadata: { answers: [['Please use New session']] },

}

await hook(

{ tool: 'question', sessionID, callID: 'test-call', args },

output

)

expect(output.output).toContain('<system-reminder>')

expect(abortSpy).not.toHaveBeenCalled()

})

test('Falls back to output when metadata answers are missing', async () => {

const abortSpy = vi.fn(() => Promise.resolve({ data: {} }))

const ctx = {

loopService: {

resolveLoopName: () => 'test-loop',

getActiveState: () => null,

},

logger: createMockLogger(),

v2: {

session: {

abort: abortSpy,

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2'],

plansRepo,

config: {} as PluginConfig,

projectId,

directory: '/test',

dataDir: TEST_DIR,

cleanup: async () => {},

input: { messages: [], systemPrompt: '' },

systemPrompt: '',

messages: [],

loopsRepo: createLoopsRepo(db),

reviewFindingsRepo: createReviewFindingsRepo(db),

sandboxManager: null,

} as unknown as ToolContext

// Write a plan for the session so resolveCurrentSessionPlan succeeds

plansRepo.writeForSession(projectId, sessionID, '# Test Plan\n\nThis is a test plan.')

const hook = createToolExecuteAfterHook(ctx)

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = {

title: 'Asked 1 question',

output: 'New session',

metadata: {},

}

await expect(hook(

{ tool: 'question', sessionID, callID: 'test-call', args },

output

)).resolves.toBeUndefined()

expect(output.output).toContain('New session')

expect((output.metadata as any).forgePlanApprovalHandled).toBe(true)

expect(abortSpy).toHaveBeenCalledWith({ sessionID, directory: "/test" })

})

test('Execute here approval schedules source abort and returns without throwing', async () => {

const abortSpy = vi.fn(() => Promise.resolve({ data: {} }))

const ctx = {

loopService: {

resolveLoopName: () => 'test-loop',

getActiveState: () => null,

},

logger: createMockLogger(),

v2: {

session: {

abort: abortSpy,

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2'],

plansRepo,

config: {} as PluginConfig,

projectId,

directory: '/test',

dataDir: TEST_DIR,

cleanup: async () => {},

input: { messages: [], systemPrompt: '' },

systemPrompt: '',

messages: [],

loopsRepo: createLoopsRepo(db),

reviewFindingsRepo: createReviewFindingsRepo(db),

sandboxManager: null,

} as unknown as ToolContext

plansRepo.writeForSession(projectId, sessionID, '# Test Plan\n\nThis is a test plan.')

const hook = createToolExecuteAfterHook(ctx)

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = {

title: 'Asked 1 question',

output: 'Execute here',

metadata: { answers: [['Execute here']] },

}

await expect(hook(

{ tool: 'question', sessionID, callID: 'test-call', args },

output

)).resolves.toBeUndefined()

expect(output.output).toBe('Execute here')

expect((output.metadata as any).forgePlanApprovalHandled).toBe(true)

expect(abortSpy).toHaveBeenCalledWith({ sessionID, directory: "/test" })

})

test('New session approval schedules source abort and returns without throwing', async () => {

const abortSpy = vi.fn(() => Promise.resolve({ data: {} }))

const ctx = {

loopService: {

resolveLoopName: () => 'test-loop',

getActiveState: () => null,

},

logger: createMockLogger(),

v2: {

session: {

abort: abortSpy,

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2'],

plansRepo,

config: {} as PluginConfig,

projectId,

directory: '/test',

dataDir: TEST_DIR,

cleanup: async () => {},

input: { messages: [], systemPrompt: '' },

systemPrompt: '',

messages: [],

loopsRepo: createLoopsRepo(db),

reviewFindingsRepo: createReviewFindingsRepo(db),

sandboxManager: null,

} as unknown as ToolContext

plansRepo.writeForSession(projectId, sessionID, '# Test Plan\n\nThis is a test plan.')

const hook = createToolExecuteAfterHook(ctx)

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = {

title: 'Asked 1 question',

output: 'New session',

metadata: { answers: [['New session']] },

}

await expect(hook(

{ tool: 'question', sessionID, callID: 'test-call', args },

output

)).resolves.toBeUndefined()

expect(output.output).toContain('New session')

expect((output.metadata as any).forgePlanApprovalHandled).toBe(true)

expect(abortSpy).toHaveBeenCalledWith({ sessionID, directory: "/test" })

})

test('Loop approval schedules source abort and returns without throwing', async () => {

const abortSpy = vi.fn(() => Promise.resolve({ data: {} }))

const loopsRepo = createLoopsRepo(db)

const reviewFindingsRepo = createReviewFindingsRepo(db)

const loopService = createLoopService(loopsRepo, plansRepo, reviewFindingsRepo, projectId, createMockLogger())

const ctx = {

loopService,

logger: createMockLogger(),

v2: {

session: {

abort: abortSpy,

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2'],

plansRepo,

config: {} as PluginConfig,

projectId,

directory: '/test',

dataDir: TEST_DIR,

cleanup: async () => {},

input: { messages: [], systemPrompt: '', client: { session: { promptAsync: async () => ({ data: {} }) } } as any },

systemPrompt: '',

messages: [],

loopsRepo,

reviewFindingsRepo,

sandboxManager: null,

} as unknown as ToolContext

plansRepo.writeForSession(projectId, sessionID, '# Test Plan\n\nThis is a test plan.')

const hook = createToolExecuteAfterHook(ctx)

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = {

title: 'Asked 1 question',

output: 'Loop',

metadata: { answers: [['Loop']] },

}

await expect(hook(

{ tool: 'question', sessionID, callID: 'test-call', args },

output

)).resolves.toBeUndefined()

expect(output.output).toBe('Loop')

expect((output.metadata as any).forgePlanApprovalHandled).toBe(true)

expect(abortSpy).toHaveBeenCalledWith({ sessionID, directory: "/test" })

})

test('dispatches loop.start without a mode field when Loop is selected', async () => {

const abortSpy = vi.fn(() => Promise.resolve({ data: {} }))

const loopsRepo = createLoopsRepo(db)

const reviewFindingsRepo = createReviewFindingsRepo(db)

const loopService = createLoopService(loopsRepo, plansRepo, reviewFindingsRepo, projectId, createMockLogger())

const uniqueSessionId = `loop-dispatch-${Date.now()}`

const ctx = {

loopService,

logger: createMockLogger(),

v2: {

session: {

abort: abortSpy,

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2'],

plansRepo,

config: {} as PluginConfig,

projectId,

directory: '/test-dispatch',

dataDir: TEST_DIR,

cleanup: async () => {},

input: { messages: [], systemPrompt: '', client: { session: { promptAsync: async () => ({ data: {} }) } } as any },

systemPrompt: '',

messages: [],

loopsRepo,

reviewFindingsRepo,

sandboxManager: null,

} as unknown as ToolContext

plansRepo.writeForSession(projectId, uniqueSessionId, '# Dispatch Test Plan\n\nUnique plan for dispatch test.')

const executionModule = await import('../src/services/execution')

let capturedCommand: any = null

vi.spyOn(executionModule, 'createForgeExecutionService').mockImplementation((deps: any) => ({

dispatch: async (_execCtx: any, command: any) => {

capturedCommand = command

return { ok: true, data: {} }

},

}))

try {

const hook = createToolExecuteAfterHook(ctx)

const args = {

questions: [{

question: 'How would you like to proceed?',

options: [

{ label: 'New session', description: 'Create new session' },

{ label: 'Execute here', description: 'Execute here' },

{ label: 'Loop', description: 'Loop' },

],

}],

}

const output = {

title: 'Asked 1 question',

output: 'Loop',

metadata: { answers: [['Loop']] },

}

await expect(hook(

{ tool: 'question', sessionID: uniqueSessionId, callID: 'dispatch-test-call', args },

output

)).resolves.toBeUndefined()

// The scheduled dispatch fires synchronously before the first await in the IIFE.

// Since our mock service.dispatch resolves immediately, the task completes within one microtask.

await new Promise(resolve => setTimeout(resolve, 10))

expect((output.metadata as any).forgePlanApprovalHandled).toBe(true)

expect(abortSpy).toHaveBeenCalled()

expect(capturedCommand).toBeDefined()

expect(capturedCommand.type).toBe('loop.start')

expect(capturedCommand).not.toHaveProperty('mode')

} finally {

vi.restoreAllMocks()

}

})

})

describe('Tool blocking hook', () => {

const sessionID = 'outside-session'

const loopSessionID = 'loop-session'

const loopName = 'active-loop'

function createContextForLoopState(state: { active: boolean; sessionId: string; phase?: string } | null): ToolContext {

return {

loopService: {

resolveLoopName: () => state ? loopName : null,

getActiveState: () => state,

},

logger: createMockLogger(),

} as unknown as ToolContext

}

test('does not block question when resolved loop belongs to another session', async () => {

const hook = createToolExecuteBeforeHook(createContextForLoopState({

active: true,

sessionId: loopSessionID,

phase: 'auditing',

}))!

await expect(hook({ tool: 'question', sessionID, callID: 'call-1' }, { args: {} })).resolves.toBeUndefined()

})

test('blocks question for active loop session', async () => {

const hook = createToolExecuteBeforeHook(createContextForLoopState({

active: true,

sessionId: loopSessionID,

phase: 'auditing',

}))!

await expect(hook({ tool: 'question', sessionID: loopSessionID, callID: 'call-1' }, { args: {} })).rejects.toThrow('question tool is not available')

})

test('blocks question for active audit session', async () => {

const hook = createToolExecuteBeforeHook(createContextForLoopState({

active: true,

sessionId: loopSessionID,

phase: 'auditing',

}))!

await expect(hook({ tool: 'question', sessionID: loopSessionID, callID: 'call-1' }, { args: {} })).rejects.toThrow('question tool is not available')

})

test('blocks question for child sessions resolved into an active loop', async () => {

const hook = createToolExecuteBeforeHook(createContextForLoopState(null), {

resolveActiveLoopForSession: async (sessionID) => sessionID === 'child-session'

? { active: true, loopName, phase: 'auditing' }

: null,

})!

await expect(hook({ tool: 'question', sessionID: 'child-session', callID: 'call-1' }, { args: {} })).rejects.toThrow('question tool is not available')

})

test('rewrites blocked question output for child sessions resolved into an active loop', async () => {

const hook = createToolExecuteAfterHook(createContextForLoopState(null), {

resolveActiveLoopForSession: async (sessionID) => sessionID === 'child-session'

? { active: true, loopName, phase: 'auditing' }

: null,

})!

const output = { title: '', output: 'original output', metadata: {} }

await hook({ tool: 'question', sessionID: 'child-session', callID: 'call-1', args: {} }, output)

expect(output.title).toBe('Tool blocked')

expect(output.output).toContain('question tool is not available')

})

test('does not rewrite after-hook output when resolved loop belongs to another session', async () => {

const hook = createToolExecuteAfterHook(createContextForLoopState({

active: true,

sessionId: loopSessionID,

phase: 'auditing',

}))!

const output = { title: '', output: 'original output', metadata: {} }

await hook({ tool: 'loop', sessionID, callID: 'call-1', args: {} }, output)

expect(output.title).toBe('')

expect(output.output).toBe('original output')

})

})

describe('Execute here bypass', () => {

const projectId = 'test-project'

const sessionID = 'test-session-456'

const testDir = '/test/dir'

const openDbs: any[] = []

afterEach(() => {

for (const db of openDbs) db.close()

openDbs.length = 0

})

function createMockContext(overrides?: Partial<ToolContext>): ToolContext {

const mockV2 = {

session: {

abort: async () => ({ data: {} }),

promptAsync: async () => ({ data: {} }),

create: async () => ({ data: { id: 'new-session-id' } }),

},

tui: {

selectSession: async () => ({ data: {} }),

publish: async () => ({ data: {} }),

},

} as unknown as ToolContext['v2']

const mockConfig = {

executionModel: 'test-provider/test-model',

} as PluginConfig

const mockLogger = createMockLogger()

const db = createTestDb()

openDbs.push(db)

const loopsRepo = createLoopsRepo(db)

const reviewFindingsRepo = createReviewFindingsRepo(db)

const plansRepo = createPlansRepo(db)

const loopService = createLoopService(loopsRepo, plansRepo, reviewFindingsRepo, projectId, mockLogger)

return {

projectId,

directory: testDir,

config: mockConfig,

logger: mockLogger,

db,

loopService,

plansRepo,

loopsRepo,

reviewFindingsRepo,

v2: mockV2,

input: { messages: [], systemPrompt: '', client: { session: { promptAsync: async () => ({ data: {} }) } } as any },

...overrides,