+ {['Request', 'Progress', 'Approval', 'Complete'].map((label, i) => {
+ const x = 50 + i * 430;
+ const reached = progress >= i / 3;
+ return
{label}
{i < 3 && = (i + 1) / 3 ? '#59d8d7' : '#36505a' }} />};
+ })}
+
+ Synthetic product illustration · automated checks are separate from live Desktop or CLI acceptance
+ ;
+};
+
+const Root = () => ;
+registerRoot(Root);
diff --git a/src/backends/backend.ts b/src/backends/backend.ts
index 1174c83..0e663a0 100644
--- a/src/backends/backend.ts
+++ b/src/backends/backend.ts
@@ -202,6 +202,12 @@ export class CompositeBackend implements FreebuffBackend {
await backend.stop(session);
}
+ async resume(session: BackendSession): Promise {
+ const backend = this.sessions.get(session.id)?.backend ?? await this.pickForSession(session);
+ if (!backend.resume) throw new BridgeError(ErrorCodes.BACKEND_UNAVAILABLE, `The ${backend.kind} backend cannot resume turns.`);
+ return backend.resume(session);
+ }
+
/** Route model/reasoning changes to the backend that owns the session. */
async setModel(session: BackendSession, model: string, harnessId = 'codebuff'): Promise {
const backend = this.sessions.get(session.id)?.backend ?? await this.pickForSession(session);
diff --git a/src/backends/desktop-backend.ts b/src/backends/desktop-backend.ts
index 43fb686..904a258 100644
--- a/src/backends/desktop-backend.ts
+++ b/src/backends/desktop-backend.ts
@@ -393,12 +393,12 @@ export class DesktopBackend implements FreebuffBackend {
* Polling reads fresh HTTP state while completion is unproven (the SSE cache
* may be the same stale frame forever during an outage).
*/
- private async waitForTurnEnd(threadId: string, before: ThreadTurnState, signal?: AbortSignal): Promise {
+ private async waitForTurnEnd(threadId: string, before: ThreadTurnState, signal?: AbortSignal, startGraceMs = this.options.turnStartGraceMs ?? TURN_START_GRACE_MS): Promise {
const deadline = Date.now() + TURN_DEADLINE_MS;
// If the turn never visibly starts (an instant turn, or a prompt the Desktop
// discarded), don't hold the request open for the full deadline — but do
// NOT treat the unproven idle state as completion either.
- const startDeadline = Math.min(deadline, Date.now() + (this.options.turnStartGraceMs ?? TURN_START_GRACE_MS));
+ const startDeadline = Math.min(deadline, Date.now() + startGraceMs);
let sawRunning = false;
for (;;) {
if (signal?.aborted) return this.threadStates.get(threadId);
@@ -612,8 +612,13 @@ export class DesktopBackend implements FreebuffBackend {
async resume(session: BackendSession): Promise {
await this.assertWritable();
const threadId = assertSafeId(session.backendSessionId ?? session.id);
+ const before = await this.readThreadState(threadId, { fresh: true }).catch((): ThreadTurnState => ({ turnState: 'idle' }));
const response = await this.request('POST', `/api/thread/${encodeURIComponent(threadId)}/resume`, {});
- return { state: 'completed', result: redact(response) };
+ // A resume acknowledgement does not itself prove that a turn started.
+ // Give the queue a short chance to move, then report uncertainty promptly.
+ const end = await this.waitForTurnEnd(threadId, before, undefined, 2_000);
+ const mapped = this.mapTurnOutcome(end, false);
+ return { state: mapped.state, result: redact(response), ...(mapped.error ? { error: mapped.error } : {}) };
}
async setModel(session: BackendSession, model: string, harnessId = 'codebuff'): Promise {
diff --git a/src/bridge/event-store.ts b/src/bridge/event-store.ts
index 5782920..b147cc5 100644
--- a/src/bridge/event-store.ts
+++ b/src/bridge/event-store.ts
@@ -301,7 +301,10 @@ export class EventStore {
currentState: turnState ?? [...all].reverse().find((x) => x.state)?.state,
phase: [...all].reverse().find((x) => x.phase && (x.sequence > afterSequence))?.phase ?? meaningful?.phase,
events,
- nextSequence: this.lastSequenceFor({ threadId }),
+ // A cursor is an acknowledgement of delivered data. Returning the
+ // thread's newest sequence here can skip filtered events or events past
+ // this page's limit forever.
+ nextSequence: events.at(-1)?.sequence ?? afterSequence,
// A thread explicitly marked live (a running CLI/PTY turn) is connected
// regardless of the global flag; an explicitly finished one is not,
// even when some other backend's stream is healthy. Every other thread
diff --git a/src/bridge/session-manager.ts b/src/bridge/session-manager.ts
index 11069ed..7bc4365 100644
--- a/src/bridge/session-manager.ts
+++ b/src/bridge/session-manager.ts
@@ -320,7 +320,17 @@ export class SessionManager {
const target = turnId ?? session.activeTurnId;
if (!target) return { aborted: false, stopped: false };
const controller = this.controllers.get(target);
- if (!controller) return { aborted: false, stopped: false };
+ if (!controller) {
+ const turn = this.turns.get(target);
+ if (!turn || turn.sessionId !== sessionId || turn.state !== 'waiting_for_user' || !this.backend.stop) return { aborted: false, stopped: false };
+ try {
+ await this.backend.stop(this.toBackendSession(session), target);
+ this.transitionWaitingTurn(session, turn, 'cancelled');
+ return { aborted: false, stopped: true };
+ } catch (error) {
+ return { aborted: false, stopped: false, stopError: error instanceof Error ? error.message : String(error) };
+ }
+ }
// Aborting synchronously runs the turn's abort listener, which issues the
// backend stop; capture that promise before awaiting so we report real truth.
if (!controller.signal.aborted) controller.abort();
@@ -329,6 +339,34 @@ export class SessionManager {
return { aborted: true, stopped: outcome?.stopped ?? false, ...(outcome?.error ? { stopError: outcome.error } : {}) };
}
+ /** Apply a backend-confirmed resume outcome to its existing canonical turn. */
+ reconcileResume(sessionId: string, result: BackendTurnResult): BridgeTurn | undefined {
+ const session = this.sessions.get(sessionId);
+ const turn = session?.activeTurnId ? this.turns.get(session.activeTurnId) : undefined;
+ if (!session || !turn || turn.state !== 'waiting_for_user') return undefined;
+ if (result.state === 'waiting_for_user' || result.state === 'running' || result.state === 'queued') return turn;
+ this.transitionWaitingTurn(session, turn, result.state, result);
+ return turn;
+ }
+
+ private transitionWaitingTurn(session: BridgeSession, turn: BridgeTurn, state: BridgeTurnState, result?: BackendTurnResult): void {
+ turn.state = state;
+ if (result?.result !== undefined) turn.result = result.result;
+ if (result?.error) turn.error = result.error;
+ if (result?.backendTurnId) turn.backendTurnId = result.backendTurnId;
+ turn.lastSequence = this.events.lastSequenceFor({ turnId: turn.id });
+ const threadId = session.backendSessionId ?? session.id;
+ this.events.setTurnState(threadId, session.id, turn.id, state, turn.error);
+ if (isTerminalTurnState(state)) {
+ turn.completedAt = new Date().toISOString();
+ if (session.activeTurnId === turn.id) session.activeTurnId = undefined;
+ session.state = 'ready';
+ this.events.setThreadLive(threadId, false);
+ } else {
+ session.state = state === 'waiting_for_user' ? 'waiting_for_user' : 'running';
+ }
+ }
+
/** Drop old terminal turns so long-lived processes cannot accumulate them. */
private pruneTerminalTurns(maxTurns = 500): void {
if (this.turns.size <= maxTurns) return;
diff --git a/src/bridge/turn-manager.ts b/src/bridge/turn-manager.ts
index adcb962..1f2982b 100644
--- a/src/bridge/turn-manager.ts
+++ b/src/bridge/turn-manager.ts
@@ -60,16 +60,25 @@ export class TurnManager {
const turn = this.getTurn(turnId);
const deadline = Date.now() + Math.min(Math.max(timeoutMs, 0), 120_000);
let cursor = afterSequence;
+ const maxEvents = Math.max(1, Math.min(limit, 100));
+ const delivered: TurnProgressSnapshot['events'] = [];
for (;;) {
- const snapshot = this.progressForTurn(turnId, cursor, limit);
- if (snapshot.nextSequence && snapshot.nextSequence > cursor) cursor = snapshot.nextSequence;
+ const snapshot = this.progressForTurn(turnId, cursor, maxEvents - delivered.length);
+ delivered.push(...snapshot.events);
+ cursor = delivered.at(-1)?.sequence ?? cursor;
const state = this.manager.getTurn(turnId)?.state;
- if (state && isTerminalTurnState(state)) return snapshot;
- if (state === 'waiting_for_user') return snapshot;
+ if (delivered.length >= maxEvents || (state && isTerminalTurnState(state)) || state === 'waiting_for_user') {
+ return { ...snapshot, turnId, sessionId: turn.sessionId, events: delivered, nextSequence: cursor };
+ }
const remaining = deadline - Date.now();
- if (remaining <= 0) return snapshot;
- const waited = await this.events.wait(snapshot.threadId, cursor, Math.min(remaining, 5_000), limit, turn.sessionId, turnId);
- if (waited.nextSequence && waited.nextSequence > cursor) cursor = waited.nextSequence;
+ if (remaining <= 0) return { ...snapshot, turnId, sessionId: turn.sessionId, events: delivered, nextSequence: cursor };
+ const waited = await this.events.wait(snapshot.threadId, cursor, Math.min(remaining, 5_000), maxEvents - delivered.length, turn.sessionId, turnId);
+ delivered.push(...waited.events);
+ cursor = delivered.at(-1)?.sequence ?? cursor;
+ const nextState = this.manager.getTurn(turnId)?.state;
+ if (delivered.length >= maxEvents || (nextState && isTerminalTurnState(nextState)) || nextState === 'waiting_for_user' || Date.now() >= deadline) {
+ return { ...waited, turnId, sessionId: turn.sessionId, events: delivered, nextSequence: cursor };
+ }
}
}
}
diff --git a/src/mcp-v2.ts b/src/mcp-v2.ts
index 2533ef6..2daba80 100644
--- a/src/mcp-v2.ts
+++ b/src/mcp-v2.ts
@@ -5,7 +5,7 @@ import { CompositeBackend } from './backends/backend.js';
import { MAX_DIFF_FILES } from './backends/desktop-backend.js';
import { SessionManager } from './bridge/session-manager.js';
import { TurnManager } from './bridge/turn-manager.js';
-import { BridgeError, ErrorCodes, toErrorShape, BackendSession } from './bridge/types.js';
+import { BackendTurnResult, BridgeError, ErrorCodes, toErrorShape, BackendSession } from './bridge/types.js';
import { Json } from './types.js';
import { assertSafeId, redact } from './security.js';
import { VERSION } from './version.js';
@@ -242,12 +242,11 @@ export function createV2ServerFromAdapter(adapter: V2Adapter): McpServer {
// the thread id; only the CLI harness takes `/resume` as a command.
// Submitting `/resume` as Desktop prompt text would start a turn with that
// literal text instead.
- if (backendSession.backend === 'cli') {
- const result = await adapter.backend.sendMessage({ session: backendSession, text: '/resume' });
- return { ok: true, ...result } as Json;
- }
- await (adapter.backend.desktop as unknown as { resume(session: BackendSession): Promise }).resume(backendSession);
- return { ok: true };
+ const result = backendSession.backend === 'cli'
+ ? await adapter.backend.sendMessage({ session: backendSession, text: '/resume' })
+ : await (adapter.backend as unknown as { resume(session: BackendSession): Promise }).resume(backendSession);
+ if (session) adapter.sessions.reconcileResume(session.id, result);
+ return { ok: true, ...result } as Json;
}));
write('set_model', 'Set the model for an existing thread.', { threadId: id, model: z.string().min(1).max(200), harnessId: z.string().optional() }, async (args) => shapeError(async () => {
diff --git a/src/security.ts b/src/security.ts
index f5f9cc5..b17ff86 100644
--- a/src/security.ts
+++ b/src/security.ts
@@ -9,24 +9,23 @@ const SENSITIVE_KEY = /^(authorization|proxy-authorization|www-authenticate|bear
const SENSITIVE_KEY_SUBSTRING = /token|secret|password|cookie|credential|authkey|privatekey|fingerprint/i;
// Value-pattern based redaction for strings.
-const secretText = /(authorization\s*[:=]\s*|bearer\s+|access[_-]?token\s*["']?\s*[:=]\s*["']?|refresh[_-]?token\s*["']?\s*[:=]\s*["']?|api[_-]?key\s*["']?\s*[:=]\s*["']?|api-key\s*[:=]\s*|client[_-]?secret\s*["']?\s*[:=]\s*["']?|private[_-]?key\s*[:=]\s*|cookie\s*[:=]\s*|session[_-]?token\s*[:=]\s*)[^\s,;'"}]+/gi;
+const secretText = /(authorization\s*[:=]\s*|bearer\s+|(?:access|refresh|id)[_-]?token\s*["']?\s*[:=]\s*["']?|api[_-]?key\s*["']?\s*[:=]\s*["']?|client[_-]?secret\s*["']?\s*[:=]\s*["']?|private[_-]?key\s*[:=]\s*|cookie\s*[:=]\s*|session[_-]?token\s*[:=]\s*|(?:pass(?:word|wd|phrase)?|pwd)\s*[:=]\s*["']?)[^\s,;'"}]+/gi;
// Query-string tokens (e.g. ?token=..., &api_key=...) when recognizable.
-const queryStringToken = /([?&](?:token|access_token|refresh_token|api_key|apikey|api-key|key|secret|password|sig|signature|session)")[^&\s"']*/gi;
-const queryStringToken2 = /([?&](?:token|access_token|refresh_token|api_key|apikey|api-key|key|secret|password|sig|signature|session)=)[^&\s"']+/gi;
+const queryStringToken = /([?&](?:token|access_token|refresh_token|api_key|apikey|api-key|key|secret|password|passwd|passphrase|pwd|sig|signature|session)")[^&\s"']*/gi;
+const queryStringToken2 = /([?&](?:token|access_token|refresh_token|api_key|apikey|api-key|key|secret|password|passwd|passphrase|pwd|sig|signature|session)=)[^&\s"']+/gi;
const bearerHeader = /bearer\s+[\w.\-~+/=]{8,}/gi;
export function redactString(value: string): string {
let out = value.replace(bearerHeader, 'Bearer [REDACTED]');
out = out.replace(secretText, (match) => `${match.split(/[:=]/)[0]?.trim() ?? match}=[REDACTED]`);
+ out = out.replace(/-----BEGIN ((?:[A-Z0-9]+ )*PRIVATE KEY)-----[\s\S]*?-----END \1-----/g, (_match, label: string) => `-----BEGIN ${label}-----[REDACTED]-----END ${label}-----`);
out = out.replace(queryStringToken, '$1[REDACTED]');
out = out.replace(queryStringToken2, '$1[REDACTED]');
return out;
}
export function redact(value: unknown): unknown {
- if (typeof value === 'string') {
- return redactString(value.replace(/(authToken|access_token|authorization|cookie|fingerprintHash|api[_-]?key|client[_-]?secret|private[_-]?key)(["']?\s*[:=]\s*["']?)[^,"'\s}]+/gi, '$1$2[REDACTED]'));
- }
+ if (typeof value === 'string') return redactString(value);
if (Array.isArray(value)) return value.map(redact);
if (value && typeof value === 'object') {
return Object.fromEntries(Object.entries(value as Record).map(([key, item]) => [
diff --git a/test/desktop-completion.test.ts b/test/desktop-completion.test.ts
index 1146d54..4774859 100644
--- a/test/desktop-completion.test.ts
+++ b/test/desktop-completion.test.ts
@@ -97,12 +97,13 @@ test('desktop: idempotent control routes retry safely after an ambiguous drop',
});
test('desktop: /resume and /effort replay-safe after an ambiguous drop', async () => {
- const desktop = await startFakeDesktop({ dropAfterCommitSuffixes: ['/resume', '/effort'] });
+ const desktop = await startFakeDesktop({ dropAfterCommitSuffixes: ['/resume', '/effort'], resumeTurn: true, turnDelayMs: 20 });
const restoreEnv = withEnv(desktop.url, desktop.launchId);
const backend = new DesktopBackend();
try {
const session = { id: 'bridge-1', backend: 'desktop' as const, backendSessionId: desktop.threadId, cwd: desktop.projectPath };
- await backend.resume(session);
+ const resumed = await backend.resume(session);
+ assert.equal(resumed.state, 'completed', 'resume is complete only after a finish transition');
const resumes = desktop.calls.filter((c) => c.method === 'POST' && c.path.endsWith('/resume')).length;
assert.equal(resumes, 2, `idempotent resume retried once (saw ${resumes})`);
diff --git a/test/event-store.test.ts b/test/event-store.test.ts
index 3b749ac..b72445e 100644
--- a/test/event-store.test.ts
+++ b/test/event-store.test.ts
@@ -120,6 +120,19 @@ test('event store: concurrent threads do not leak events', () => {
assert.ok(two.events.every((e) => e.threadId === 'thread-2'));
});
+test('event store: nextSequence never moves past events omitted by page limits or filters', () => {
+ const store = new EventStore();
+ for (let i = 0; i < 4; i++) store.append({ sessionId: i === 3 ? 's2' : 's1', turnId: `t${i}`, threadId: 'shared', type: 'phase', message: `${i}` });
+ const first = store.progress('shared', 0, 2, 's1');
+ assert.deepEqual(first.events.map((event) => event.sequence), [1, 2]);
+ assert.equal(first.nextSequence, 2);
+ const second = store.progress('shared', first.nextSequence!, 2, 's1');
+ assert.deepEqual(second.events.map((event) => event.sequence), [3]);
+ assert.equal(second.nextSequence, 3);
+ const empty = store.progress('shared', 3, 2, 's1');
+ assert.equal(empty.nextSequence, 3, 'empty filtered pages retain the caller cursor');
+});
+
test('event store: session and turn filters partition correctly', () => {
const store = new EventStore();
store.append({ sessionId: 's1', turnId: 't1', threadId: 'th1', type: 'phase' });
diff --git a/test/helpers/fake-desktop.ts b/test/helpers/fake-desktop.ts
index 41ffe21..1a09ed8 100644
--- a/test/helpers/fake-desktop.ts
+++ b/test/helpers/fake-desktop.ts
@@ -50,6 +50,7 @@ export interface FakeDesktop {
export interface FakeDesktopOptions {
/** How long a turn stays `running` before it settles. */
turnDelayMs?: number;
+ resumeTurn?: boolean;
/** Record the turn as failed (`lastTurnOutcome: "error"`). */
failTurn?: boolean;
/** Launch id the Desktop expects on writes. */
@@ -239,6 +240,7 @@ const threads = new Map>([
}
if (method === 'POST' && suffix === '/resume') {
if (dropAfterCommit('/resume')) return undefined;
+ if (options.resumeTurn) runTurn(id);
return json(response, { ok: true });
}
if (method === 'POST' && suffix === '/agent') {
diff --git a/test/mcp-v2.test.ts b/test/mcp-v2.test.ts
index 5762e01..7cf4e7a 100644
--- a/test/mcp-v2.test.ts
+++ b/test/mcp-v2.test.ts
@@ -28,9 +28,7 @@ test('MCP v2: resume_thread uses the Desktop resume route instead of submitting
const calls: string[] = [];
const backend = {
kind: 'desktop' as const,
- desktop: {
- resume: async (session: { backendSessionId?: string }) => { calls.push(`resume:${session.backendSessionId}`); return { ok: true }; },
- },
+ resume: async (session: { backendSessionId?: string }) => { calls.push(`resume:${session.backendSessionId}`); return { state: 'waiting_for_user' as const }; },
probe: async () => ({ backend: 'desktop' as const, connection: 'connected_writable' as const, authorization: 'write_authorized' as const, liveProgress: 'connected' as const, canCreateSession: true, canSendMessage: true, canStop: true, canResume: true, canSetModel: true, canSetReasoning: true, notes: [] }),
sendMessage: async () => { calls.push('sendMessage'); return { state: 'completed' as const }; },
dispose: () => undefined,
@@ -43,12 +41,12 @@ test('MCP v2: resume_thread uses the Desktop resume route instead of submitting
const ctx = { mcpReq: { _meta: {}, signal: new AbortController().signal, notify: async () => undefined } };
const result = await toolOf(server, 'resume_thread').handler({ sessionId: session.id, threadId: 'thread-abc' }, ctx);
assert.equal(result.structuredContent?.ok, true);
- assert.deepEqual(calls, ['resume:thread-abc'], 'the Desktop resume route is used and no prompt is submitted');
+ assert.deepEqual(calls, ['resume:thread-abc'], 'the backend resume operation is used and no prompt is submitted');
// threadId is the required argument, so it must work on its own.
const byThreadOnly = await toolOf(server, 'resume_thread').handler({ threadId: 'thread-xyz' }, ctx);
assert.equal(byThreadOnly.structuredContent?.ok, true);
- assert.deepEqual(calls, ['resume:thread-abc', 'resume:thread-xyz'], 'a bare threadId still resumes through the route');
+ assert.deepEqual(calls, ['resume:thread-abc', 'resume:thread-xyz'], 'a bare threadId still resumes through the backend');
});
type LooseTool = { handler: (args: unknown, ctx: unknown) => Promise<{ structuredContent?: Record }> };
diff --git a/test/security.test.ts b/test/security.test.ts
index 95a4c18..f07a7e2 100644
--- a/test/security.test.ts
+++ b/test/security.test.ts
@@ -16,6 +16,15 @@ test('redacts secrets in strings and rejects unsafe file content', () => {
assert.throws(() => safeTextContent(Buffer.from('a\0b'), 'x.bin'), /Binary/);
assert.throws(() => safeTextContent(Buffer.alloc(1_000_001), 'x'), /1 MB/);
});
+test('redacts password lines, PEM keys, nested transcript text, errors, and URLs while keeping useful text', () => {
+ const pem = '-----BEGIN PRIVATE KEY-----\nSYNTHETIC_PEM_SECRET\n-----END PRIVATE KEY-----';
+ const text = safeTextContent(Buffer.from(`Notes remain readable\npassword=SYNTHETIC_PASSWORD\n${pem}\nDone`), 'notes.txt');
+ assert.match(text, /Notes remain readable/);
+ assert.match(text, /Done/);
+ assert.doesNotMatch(text, /SYNTHETIC_(PASSWORD|PEM_SECRET)/);
+ const clean = redact({ messages: [{ text: 'passwd: SYNTHETIC_PASSWD' }], error: 'password=SYNTHETIC_ERROR', url: 'https://example.test/?pwd=SYNTHETIC_URL' });
+ assert.doesNotMatch(JSON.stringify(clean), /SYNTHETIC_(PASSWD|ERROR|URL)/);
+});
test('protected file rules cover common credential files and directories', () => {
for (const name of ['.git-credentials', '.aws', '.ssh', '.gnupg', '.azure', '.kube', '.docker', '.npmrc', 'id_ed25519', 'client.pem']) {
assert.equal(blocked.test(name), true, `${name} should be protected`);
diff --git a/test/session-manager.test.ts b/test/session-manager.test.ts
index 11ab672..7ed2683 100644
--- a/test/session-manager.test.ts
+++ b/test/session-manager.test.ts
@@ -185,7 +185,7 @@ test('session manager: unknown session and unknown turn produce structured error
assert.throws(() => turns.getTurn('missing'), (error: unknown) => error instanceof BridgeError && error.code === ErrorCodes.TURN_NOT_FOUND);
});
-test('turn manager: waitForTurn returns terminal snapshot and cursor advances past 100 events', async () => {
+test('turn manager: bounded wait returns only delivered events and callers can fetch the next page', async () => {
const manager = new SessionManager(fakeBackend());
const turns = new TurnManager(manager);
const session = await manager.createSession({ cwd: '/tmp/project' });
@@ -195,6 +195,40 @@ test('turn manager: waitForTurn returns terminal snapshot and cursor advances pa
for (let i = 0; i < 120; i++) manager.events.append({ sessionId: session.id, turnId: handle.turn.id, threadId, type: 'phase', message: `step ${i}` });
const snapshot = await turns.waitForTurn(handle.turn.id, 5000, 0, 100);
assert.ok(snapshot.events.length <= 100);
- assert.ok((snapshot.nextSequence ?? 0) > 100, 'cursor advanced beyond 100');
+ assert.equal(snapshot.events.length, 100);
+ assert.equal(snapshot.nextSequence, snapshot.events.at(-1)?.sequence, 'cursor matches the final delivered event');
+ const next = turns.progressForTurn(handle.turn.id, snapshot.nextSequence, 100);
+ assert.ok(next.events.length > 0, 'remaining events remain available');
+ assert.ok(!snapshot.events.some((event) => next.events.some((later) => later.sequence === event.sequence)), 'pages do not repeat events');
await handle.done;
});
+
+test('waiting turns reconcile only on confirmation and remain cancellable without a live request controller', async () => {
+ let stopCount = 0;
+ let sends = 0;
+ const backend = { ...fakeBackend(), sendMessage: async () => (++sends === 1 ? { state: 'waiting_for_user' as const } : { state: 'completed' as const }), stop: async () => { stopCount++; } } as FreebuffBackend;
+ const manager = new SessionManager(backend);
+ const session = await manager.createSession({ cwd: '/tmp/project' });
+ const turns = new TurnManager(manager);
+ const waiting = await turns.startTurn(session.id, { text: 'needs approval' });
+ assert.equal(session.activeTurnId, waiting.id);
+ assert.equal(manager.reconcileResume(session.id, { state: 'waiting_for_user' })?.state, 'waiting_for_user');
+ const stopped = await manager.cancelTurn(session.id, waiting.id);
+ assert.deepEqual(stopped, { aborted: false, stopped: true });
+ assert.equal(stopCount, 1);
+ assert.equal(waiting.state, 'cancelled');
+ assert.equal(session.activeTurnId, undefined);
+ const next = await turns.startTurn(session.id, { text: 'next work' });
+ assert.equal(next.state, 'completed');
+});
+
+test('a confirmed resume completes the existing waiting turn without submitting another prompt', async () => {
+ const manager = new SessionManager({ ...fakeBackend(), sendMessage: async () => ({ state: 'waiting_for_user' as const }) } as FreebuffBackend);
+ const session = await manager.createSession({ cwd: '/tmp/project' });
+ const turns = new TurnManager(manager);
+ const waiting = await turns.startTurn(session.id, { text: 'needs approval' });
+ manager.reconcileResume(session.id, { state: 'completed', result: { confirmed: true } });
+ assert.equal(waiting.state, 'completed');
+ assert.equal(session.activeTurnId, undefined);
+ assert.deepEqual(waiting.result, { confirmed: true });
+});