dsh-compact-saviour 0.2.6

package/tests/compression.test.ts

@@ -0,0 +1,130 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { chunkText, tokenEstimate, compress, planCompression } from '../src/compress.js';
+import { createUserMessage, HarnessError, CONTEXT_WINDOW_EXCEEDED_CODE } from '@deepseek-ai/dsh-llm';
+
+test('chunks preserve multilingual source exactly, including a single huge line', () => {
+  for (const source of ['line\n'.repeat(9000), '用户纠正：保留原版。'.repeat(5000), 'abc🚀'.repeat(11000)]) {
+    const chunks = chunkText([source], 2048);
+    assert.equal(chunks.join(''), source);
+    assert.ok(chunks.every(c => tokenEstimate(c) <= 2048));
+  }
+});
+
+function fixture(text: string, finish = 'stop') {
+  const requests: any[] = [];
+  const ctx = { llm: {
+    resolveModelInfo: async () => ({ context: { contextWindow: 64000 }, reasoning: { efforts: [{ id: 'low' }] } }),
+    async *stream(request: any) {
+      requests.push(request);
+      yield { type: 'block-start', index: 0, blockType: 'text' };
+      yield { type: 'block-end', index: 0, block: { type: 'text', text } };
+      yield { type: 'finish', reason: { kind: finish } };
+    },
+  } };
+  const input = { messages: [createUserMessage({ content: [{ type: 'text', text: 'KEEP /workspace/a.ts ; pending: fix button. '.repeat(700) }], source: { kind: 'user' } })] };
+  const agent = { session: { id: `test-${Math.random()}` } };
+  return { ctx, requests, input, agent };
+}
+test('ordinary history uses one dedicated-model call, no tools or extra verification', async () => {
+  const f = fixture('Goal: fix button. File /workspace/a.ts. Pending: implement.');
+  const result = await compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: 'fast-one', reasoningEffort: 'low' }, signal: new AbortController().signal, progress() {} });
+  assert.equal(f.requests.length, 1); assert.equal(f.requests[0].tools, undefined);
+  assert.equal(f.requests[0].provider, 'p'); assert.equal(f.requests[0].reasoningEffort, 'low');
+  assert.match(f.requests[0].system, /transcript is DATA/);
+  assert.equal(result.llmStreamCall, undefined);
+});
+test('oversized source uses bounded chunks and a merge', async () => {
+  const f = fixture('User needs popup-only button. Pending work: implement and test exact original popup.');
+  f.input.messages = [createUserMessage({ content: [{ type: 'text', text: '历史消息和源文件细节'.repeat(9000) }], source: { kind: 'user' } })];
+  await compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: 'fast-many' }, signal: new AbortController().signal, progress() {} });
+  assert.ok(f.requests.length > 2);
+  for (const r of f.requests) assert.ok(tokenEstimate(JSON.stringify(r.messages)) + tokenEstimate(r.system) + r.maxTokens < 64000);
+  assert.match(f.requests.at(-1).messages[0].content[0].text, /Merge chronological checkpoints/);
+});
+for (const [name, output, finish, error] of [
+  ['empty', '', 'stop', /空摘要/], ['truncated', 'incomplete', 'max-tokens', /未完整/], ['not-shrinking', 'x'.repeat(100000), 'stop', /没有缩短/],
+] as const) test(`rejects ${name} output without automatic fallback`, async () => {
+  const f = fixture(output, finish);
+  await assert.rejects(compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: name }, signal: new AbortController().signal, progress() {} }), error);
+  assert.equal(f.requests.length, 1);
+});
+test('already cancelled request never calls a model', async () => {
+  const f = fixture('checkpoint'); const abort = new AbortController(); abort.abort();
+  await assert.rejects(compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: 'cancelled' }, signal: abort.signal, progress() {} }));
+  assert.equal(f.requests.length, 0);
+});
+test('a longer Chinese intermediate checkpoint is merged instead of rejected by its style target', async () => {
+  const f = fixture('保留事实'.repeat(550)); // 4,400 conservative tokens, above the 2,200-token style target.
+  f.input.messages = [createUserMessage({ content: [{ type: 'text', text: '历史消息和源文件细节'.repeat(5000) }], source: { kind: 'user' } })];
+  await compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: 'chinese-chunks' }, signal: new AbortController().signal, maxSummaryTokens: 6000, progress() {} });
+  assert.ok(f.requests.length > 2);
+  assert.match(f.requests.at(-1).messages[0].content[0].text, /Merge chronological checkpoints/);
+});
+test('final checkpoint still cannot exceed the actual working-model space', async () => {
+  const f = fixture('保留事实'.repeat(550));
+  await assert.rejects(compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: 'hard-limit' }, signal: new AbortController().signal, maxSummaryTokens: 3000, progress() {} }), /目标模型的可用空间/);
+  assert.equal(f.requests.length, 1);
+});
+test('same large input fits one 1M call and splits only for the smaller exact route', async () => {
+  const f = fixture('Goal: preserve user constraints. Pending: verify exact files and next action.');
+  f.input.messages = [createUserMessage({ content: [{ type: 'text', text: 'history '.repeat(60_000) }], source: { kind: 'user' } })];
+  const info = (capacity: number) => ({ provider: 'p', id: 'adaptive-large', name: 'adaptive-large', context: { contextWindow: capacity }, defaultMaxTokens: 8192 });
+  const large = planCompression(info(1_000_000), f.input), small = planCompression(info(64_000), f.input);
+  assert.equal(large.chunks.length, 1);
+  assert.ok(large.inputBudget > 800_000);
+  assert.ok(small.chunks.length > 1);
+  assert.ok(small.chunks.every(text => tokenEstimate(text) <= small.inputBudget));
+  f.ctx.llm.resolveModelInfo = async () => info(1_000_000) as never;
+  const progress: string[] = [];
+  await compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: 'adaptive-large' }, signal: new AbortController().signal, progress(_done, _total, message) { progress.push(message!); } });
+  assert.equal(f.requests.length, 1);
+  assert.ok(tokenEstimate(f.requests[0].messages[0].content[0].text) > 100_000);
+  assert.match(progress[0]!, /整段压缩/);
+});
+test('chunk budget accounts for model-specific output reserve and missing capacity fails before a call', async () => {
+  const f = fixture('checkpoint');
+  const info = { provider: 'p', id: 'budget', name: 'budget', context: { contextWindow: 64000 } };
+  const shortOutput = planCompression({ ...info, defaultMaxTokens: 2048 }, f.input);
+  const longOutput = planCompression({ ...info, defaultMaxTokens: 8192 }, f.input);
+  assert.equal(shortOutput.inputBudget - longOutput.inputBudget, 6144);
+  assert.throws(() => planCompression({ ...info, context: undefined }, f.input), /可确认的上下文容量/);
+});
+for (const delivery of ['thrown', 'terminal'] as const) test(`provider ${delivery} context rejection resizes only the rejected input and merges`, async () => {
+  const f = fixture('User goal: keep original popup. Pending work: implement and verify.');
+  const original = f.ctx.llm.stream;
+  f.ctx.llm.stream = async function* (request: any) {
+    if (tokenEstimate(request.messages[0].content[0].text) > 6500) {
+      f.requests.push(request);
+      if (delivery === 'thrown') throw new HarnessError('wrapped request failure', 'UPSTREAM', { cause: new HarnessError('actual context bound', CONTEXT_WINDOW_EXCEEDED_CODE) });
+      yield { type: 'finish', reason: { kind: 'error', failure: { code: CONTEXT_WINDOW_EXCEEDED_CODE, message: 'actual context bound' } } } as never;
+      return;
+    }
+    yield* original(request);
+  };
+  const before = JSON.stringify(f.input);
+  const result = await compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: `resize-${delivery}` }, signal: new AbortController().signal, progress() {} });
+  assert.ok(f.requests.length >= 4 && f.requests.length <= 5);
+  assert.ok(f.requests.slice(1).every(r => tokenEstimate(r.messages[0].content[0].text) <= 6500));
+  assert.match(f.requests.at(-1).messages[0].content[0].text, /Merge chronological checkpoints/);
+  assert.ok(result.summary.length);
+  assert.equal(JSON.stringify(f.input), before);
+});
+for (const code of ['QUOTA', 'RATE_LIMIT', 'TIMEOUT']) test(`${code} never turns into smaller billable requests`, async () => {
+  const f = fixture('checkpoint');
+  f.ctx.llm.stream = async function* (request: any) {
+    f.requests.push(request);
+    yield { type: 'finish', reason: { kind: 'error', failure: { code, message: 'provider cannot serve this context' } } } as never;
+  };
+  await assert.rejects(compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: code }, signal: new AbortController().signal, progress() {} }), (error: any) => error.code === code);
+  assert.equal(f.requests.length, 1);
+});
+test('persistent context rejection stops after bounded subdivisions', async () => {
+  const f = fixture('checkpoint');
+  f.ctx.llm.stream = async function* (request: any) {
+    f.requests.push(request);
+    throw new HarnessError('wrong context metadata', CONTEXT_WINDOW_EXCEEDED_CODE);
+  };
+  await assert.rejects(compress(f.ctx as never, f.input, f.agent as never, { target: { provider: 'p', model: 'always-overflow' }, signal: new AbortController().signal, progress() {} }), (error: any) => error.code === CONTEXT_WINDOW_EXCEEDED_CODE);
+  assert.ok(f.requests.length <= 5);
+});

package/tests/controller.test.ts

@@ -0,0 +1,279 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { Context } from '@deepseek-ai/cordis';
+import Loader from '@deepseek-ai/cordis-plugin-loader';
+import AgentLoop from '@deepseek-ai/dsh-agent-loop';
+import { mountAgentLoopTestDependencies } from '@deepseek-ai/dsh-agent-loop-testkit';
+import TokenMeter from '@deepseek-ai/dsh-token-meter';
+import Basic from '@deepseek-ai/dsh-compaction-basic';
+import { createUserMessage, LlmAdapter } from '@deepseek-ai/dsh-llm';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { Controller } from '../src/controller.js';
+import { Config } from '../src/dsh-compact-saviour.js';
+import { selectCompactableRange } from '../src/vendor/region.js';
+
+class Adapter extends LlmAdapter {
+  compactModels: string[] = [];
+  failRescue = false;
+  failWorking = true;
+  gate?: Promise<void>;
+  usageInputTokens?: number;
+  async resolveModel(provider: string, model: string) { return { provider, id: model, name: model, context: { contextWindow: 100000 } }; }
+  async *stream(request: any) {
+    if (request.purpose === 'compaction') {
+      this.compactModels.push(request.model);
+      if (request.model === 'working' && this.failWorking) throw new Error('working model quota exhausted');
+      if (request.model === 'fast' && this.failRescue) throw new Error('rescue model unavailable');
+    }
+    if (request.purpose !== 'compaction' && this.gate) await this.gate;
+    yield { type: 'block-start' as const, index: 0, blockType: 'text' as const };
+    yield { type: 'block-end' as const, index: 0, block: { type: 'text' as const, text: request.purpose === 'compaction' ? 'User needs popup-only manual compression. Preserve original UI. Next: verify.' : 'done' } };
+    if (request.purpose !== 'compaction' && this.usageInputTokens) yield { type: 'usage' as const, usage: { inputTokens: this.usageInputTokens, outputTokens: 1 } };
+    yield { type: 'finish' as const, reason: { kind: 'stop' as const } };
+  }
+}
+async function fixture(usageInputTokens?: number, mode: 'direct' | 'rescue' | 'legacy' = 'rescue', enabled = true) {
+  const ctx = new Context(); await mountAgentLoopTestDependencies(ctx);
+  await ctx.plugin(AgentLoop, { agents: [] }); await ctx.plugin(TokenMeter); await ctx.plugin(Loader);
+  ctx.loader.internal = { version: 'v2', async import(name: string) { if (name === '@deepseek-ai/dsh-compaction-basic') return Basic; throw new Error(name); } } as never;
+  const adapter = new Adapter(); ctx.llm.registerAdapter(['mock'], adapter);
+  adapter.usageInputTokens = usageInputTokens;
+  const agent = await ctx.agentLoop.create(SessionId(`cs-controller-${Math.random()}`), { provider: 'mock', model: 'working' });
+  await agent.ctx.plugin({ inject: ['loader'], async apply(child: Context) {
+    await child.loader.create({ id: 'compaction-basic', name: '@deepseek-ai/dsh-compaction-basic', config: { auto: false } });
+  } });
+  await ctx.loader.await();
+  let controller!: Controller;
+  const owner = ctx.plugin({ name: 'test-saviour-owner', inject: ['agents', 'llm', 'tokenMeter', 'sessionProjections'], apply(child: Context) {
+    controller = new Controller(child, { get: () => ({ enabled, ...(mode === 'legacy' ? {} : { mode }), provider: 'mock', model: 'fast', reasoningEffort: '' }) } as never);
+  } });
+  await owner;
+  for (const text of ['history facts '.repeat(1200), 'last request '.repeat(400)]) {
+    agent.followup(createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } })); await agent.whenIdle();
+  }
+  return { ctx, agent, adapter, controller, owner };
+}
+test('fresh and missing-mode settings default to rescue; explicit direct remains opt-in', () => {
+  assert.equal(Config({}).mode.get(), 'rescue');
+  assert.equal(Config({ provider: 'mock', model: 'fast' }).mode.get(), 'rescue');
+  assert.equal(Config({ mode: 'direct', provider: 'mock', model: 'fast' }).mode.get(), 'direct');
+});
+for (const mode of ['rescue', 'legacy'] as const) test(`real Loader engine (${mode}): first failure stays official; second failure invokes dedicated rescue once`, async () => {
+  const { ctx, agent, adapter, controller } = await fixture(undefined, mode);
+  try {
+    assert.equal(controller.state(agent.session.id).available, true);
+    let tested = false;
+    agent.ctx.on('agent/pre-step', async ({ signal }, next) => {
+      if (!tested) {
+        tested = true;
+        const range = selectCompactableRange(agent.session, ctx.tokenMeter.measure(agent.session), 0)!;
+        await assert.rejects(agent.ctx.get('compaction')!.compactRegion(range.start, range.end, agent, signal));
+        assert.deepEqual(adapter.compactModels, ['working']);
+        assert.equal(controller.state(agent.session.id).job.failures, 1);
+        const result = await agent.ctx.get('compaction')!.compactRegion(range.start, range.end, agent, signal);
+        assert.ok(result.summarySeq);
+      }
+      return next();
+    });
+    agent.followup(createUserMessage({ content: [{ type: 'text', text: 'Continue.' }], source: { kind: 'user' } })); await agent.whenIdle();
+    assert.ok(tested); assert.deepEqual(adapter.compactModels, ['working', 'working', 'fast']);
+    assert.equal(controller.state(agent.session.id).job.phase, 'done');
+    assert.equal(controller.state(agent.session.id).job.failures, 0);
+    assert.equal(agent.session.requestHeader()?.config.model, 'working', 'automatic rescue keeps the conversation model');
+  } finally { await ctx.fiber.dispose(); }
+});
+test('manual request reserves idle maintenance and leaves conversation model unchanged', async () => {
+  const { ctx, agent, adapter, controller } = await fixture();
+  try {
+    controller.request(agent.session.id, 'configured');
+    for (let i = 0; i < 100 && ['queued', 'running'].includes(controller.state(agent.session.id).job.phase); i++) await new Promise(r => setTimeout(r, 5));
+    assert.equal(controller.state(agent.session.id).job.phase, 'done');
+    assert.deepEqual(adapter.compactModels, ['fast']);
+    assert.equal(agent.session.requestHeader()?.config.model, 'working');
+  } finally { await ctx.fiber.dispose(); }
+});
+test('unload removes only owned wrappers and restores official methods', async () => {
+  const { ctx, agent, owner } = await fixture();
+  try {
+    const engine = agent.ctx.get('compaction')!;
+    assert.ok(Object.getOwnPropertyDescriptor(engine, 'compactRegion'));
+    assert.ok(Object.getOwnPropertyDescriptor(ctx.tokenMeter, 'measure'));
+    await owner.dispose();
+    assert.equal(Object.getOwnPropertyDescriptor(engine, 'compactRegion'), undefined);
+    assert.equal(Object.getOwnPropertyDescriptor(engine, 'compactIfNeeded'), undefined);
+    assert.equal(Object.getOwnPropertyDescriptor(engine, 'compactNow'), undefined);
+    assert.equal(Object.getOwnPropertyDescriptor(ctx.tokenMeter, 'measure'), undefined);
+  } finally { await ctx.fiber.dispose(); }
+});
+test('impossible usage is corrected in the public meter without rewriting history or billing', async () => {
+  const { ctx, agent, controller, owner } = await fixture(8_000_000);
+  try {
+    const events = JSON.stringify(agent.session.snapshotEvents());
+    const billing = structuredClone(ctx.sessionProjections.stateOf(agent.session, 'tokenUsage'));
+    const view = await controller.context(agent.session.id);
+    assert.equal(view?.corrected, true);
+    assert.equal(view?.reason, 'invalid-usage');
+    assert.ok(view!.reportedTokens >= 8_000_000);
+    assert.ok(view!.usedTokens < 10_000);
+    assert.equal(ctx.tokenMeter.measure(agent.session).totalTokens, view!.usedTokens);
+    assert.equal(JSON.stringify(agent.session.snapshotEvents()), events);
+    assert.deepEqual(ctx.sessionProjections.stateOf(agent.session, 'tokenUsage'), billing);
+    await owner.dispose();
+    assert.ok(ctx.tokenMeter.measure(agent.session).totalTokens >= 8_000_000);
+  } finally { await ctx.fiber.dispose(); }
+});
+test('ordinary provider calibration remains authoritative even above the text estimate', async () => {
+  const { ctx, agent, controller } = await fixture(80_000);
+  try {
+    const view = await controller.context(agent.session.id);
+    assert.equal(view?.corrected, false);
+    assert.ok(view!.usedTokens >= 80_000);
+    assert.equal(ctx.tokenMeter.measure(agent.session).baseline.kind, 'usage');
+  } finally { await ctx.fiber.dispose(); }
+});
+test('corrected pressure avoids useless automatic calls; real context-overflow still compacts', async () => {
+  const { ctx, agent, adapter } = await fixture(8_000_000);
+  try {
+    let checked = false;
+    agent.ctx.on('agent/pre-step', async ({ signal }, next) => {
+      if (!checked) {
+        checked = true;
+        const engine = agent.ctx.get('compaction')!;
+        assert.equal(await engine.compactIfNeeded(agent, 'pressure', signal), null);
+        assert.deepEqual(adapter.compactModels, []);
+        adapter.failWorking = false;
+        const result = await engine.compactIfNeeded(agent, 'context-overflow', signal);
+        assert.ok(result);
+        assert.ok(adapter.compactModels.includes('working'));
+      }
+      return next();
+    });
+    agent.followup(createUserMessage({ content: [{ type: 'text', text: 'Continue.' }], source: { kind: 'user' } })); await agent.whenIdle();
+    assert.ok(checked);
+    assert.ok(adapter.compactModels.includes('working'));
+  } finally { await ctx.fiber.dispose(); }
+});
+test('inflated provider usage does not become fixed overhead or prevent manual rescue', async () => {
+  const { ctx, agent, adapter, controller } = await fixture(8_000_000);
+  try {
+    const before = ctx.tokenMeter.measure(agent.session);
+    assert.ok(before.totalTokens >= 8_000_000);
+    assert.ok(before.surfaceTokens < 10_000);
+    controller.request(agent.session.id, 'configured');
+    for (let i = 0; i < 100 && ['queued', 'running'].includes(controller.state(agent.session.id).job.phase); i++) await new Promise(r => setTimeout(r, 5));
+    const job = controller.state(agent.session.id).job;
+    assert.equal(job.phase, 'done', job.message);
+    assert.deepEqual(adapter.compactModels, ['fast']);
+    assert.equal(job.beforeTokens, before.surfaceTokens);
+    assert.ok(job.afterTokens! < job.beforeTokens!);
+    assert.equal(agent.session.requestHeader()?.config.model, 'working');
+  } finally { await ctx.fiber.dispose(); }
+});
+test('actual oversized tools still prevent a summary that cannot fit the working model', async () => {
+  const { ctx, agent, adapter, controller } = await fixture();
+  try {
+    agent.session.append('request/header', { reason: 'initial', header: {
+      ...agent.session.requestHeader()!, tools: [{ name: 'huge', description: 'schema '.repeat(50_000), parameters: { type: 'object' } }],
+    } });
+    controller.request(agent.session.id, 'configured');
+    for (let i = 0; i < 100 && ['queued', 'running'].includes(controller.state(agent.session.id).job.phase); i++) await new Promise(r => setTimeout(r, 5));
+    const job = controller.state(agent.session.id).job;
+    assert.equal(job.phase, 'failed');
+    assert.match(job.message, /工具定义和输出预留/);
+    assert.deepEqual(adapter.compactModels, []);
+  } finally { await ctx.fiber.dispose(); }
+});
+test('a manual click during a running step queues, then compacts at the safe boundary', async () => {
+  const { ctx, agent, adapter, controller } = await fixture();
+  try {
+    let release!: () => void; adapter.gate = new Promise(resolve => { release = resolve; });
+    agent.followup(createUserMessage({ content: [{ type: 'text', text: 'One final response.' }], source: { kind: 'user' } }));
+    for (let i = 0; i < 100 && agent.status === 'idle'; i++) await new Promise(r => setTimeout(r, 2));
+    assert.equal(agent.status, 'running');
+    assert.equal(controller.request(agent.session.id, 'configured').job.phase, 'queued');
+    assert.equal(adapter.compactModels.length, 0);
+    release(); await agent.whenIdle();
+    for (let i = 0; i < 100 && ['queued', 'running'].includes(controller.state(agent.session.id).job.phase); i++) await new Promise(r => setTimeout(r, 5));
+    assert.equal(controller.state(agent.session.id).job.phase, 'done');
+    assert.deepEqual(adapter.compactModels, ['fast']);
+  } finally { await ctx.fiber.dispose(); }
+});
+test('rescue failure never switches models; explicit current-model retry is one attempt only', async () => {
+  const { ctx, agent, adapter, controller } = await fixture();
+  try {
+    adapter.failRescue = true;
+    controller.request(agent.session.id, 'configured');
+    for (let i = 0; i < 100 && ['queued', 'running'].includes(controller.state(agent.session.id).job.phase); i++) await new Promise(r => setTimeout(r, 5));
+    assert.equal(controller.state(agent.session.id).job.phase, 'failed');
+    assert.match(controller.state(agent.session.id).job.message, /rescue model unavailable/);
+    assert.deepEqual(adapter.compactModels, ['fast']);
+    adapter.failWorking = false;
+    controller.request(agent.session.id, 'current');
+    for (let i = 0; i < 100 && ['queued', 'running'].includes(controller.state(agent.session.id).job.phase); i++) await new Promise(r => setTimeout(r, 5));
+    assert.deepEqual(adapter.compactModels, ['fast', 'working']);
+    assert.equal(controller.state(agent.session.id).config.model, 'fast');
+    assert.equal(controller.state(agent.session.id).job.phase, 'done');
+  } finally { await ctx.fiber.dispose(); }
+});
+
+test('direct mode uses the dedicated model on the first automatic overflow, with a durable transaction', async () => {
+  const { ctx, agent, adapter, controller } = await fixture(undefined, 'direct');
+  try {
+    let checked = false;
+    agent.ctx.on('agent/pre-step', async ({ signal }, next) => {
+      if (!checked) {
+        checked = true;
+        const before = agent.session.surface.replaceGeneration;
+        const result = await agent.ctx.get('compaction')!.compactIfNeeded(agent, 'context-overflow', signal);
+        assert.ok(result?.summarySeq);
+        assert.ok(agent.session.surface.replaceGeneration > before);
+        assert.deepEqual(adapter.compactModels, ['fast']);
+        assert.equal(controller.state(agent.session.id).job.phase, 'done');
+      }
+      return next();
+    });
+    agent.followup(createUserMessage({ content: [{ type: 'text', text: 'Continue.' }], source: { kind: 'user' } })); await agent.whenIdle();
+    assert.ok(checked); assert.deepEqual(adapter.compactModels, ['fast']);
+    assert.equal(agent.session.requestHeader()?.config.model, 'working');
+    const events = agent.session.snapshotEvents();
+    assert.ok(events.some(e => e.type === 'compaction/summary'));
+    assert.ok(events.some(e => e.type === 'compaction/end' && !e.data.error));
+  } finally { await ctx.fiber.dispose(); }
+});
+
+for (const [mode, enabled] of [['rescue', true], ['direct', true], ['legacy', true], ['rescue', false]] as const) test(`native manual compactNow uses Saviour with ${mode}, automatic enabled=${enabled}`, async () => {
+  const { ctx, agent, adapter } = await fixture(undefined, mode, enabled);
+  try {
+    const result = await agent.ctx.get('compaction')!.compactNow(agent, new AbortController().signal, 'test-command' as never);
+    assert.ok(result?.summarySeq);
+    assert.deepEqual(adapter.compactModels, ['fast']);
+    const end = agent.session.snapshotEvents().find(e => e.type === 'compaction/end');
+    assert.equal((end?.data as any).sourceCommandId, 'test-command');
+    assert.equal(agent.session.requestHeader()?.config.model, 'working');
+  } finally { await ctx.fiber.dispose(); }
+});
+
+test('direct failure blocks automatic repeat calls until an explicit choice; cancellation releases the block', async () => {
+  const { ctx, agent, adapter, controller } = await fixture(undefined, 'direct');
+  try {
+    adapter.failRescue = true;
+    let checked = false;
+    agent.ctx.on('agent/pre-step', async ({ signal }, next) => {
+      if (!checked) {
+        checked = true;
+        const engine = agent.ctx.get('compaction')!;
+        const before = agent.session.surface.replaceGeneration;
+        await assert.rejects(engine.compactIfNeeded(agent, 'context-overflow', signal));
+        assert.equal(agent.session.surface.replaceGeneration, before);
+        assert.equal(await engine.compactIfNeeded(agent, 'context-overflow', signal), null);
+        assert.deepEqual(adapter.compactModels, ['fast']);
+        controller.request(agent.session.id, 'cancel');
+        adapter.failRescue = false;
+        assert.ok(await engine.compactIfNeeded(agent, 'context-overflow', signal));
+      }
+      return next();
+    });
+    agent.followup(createUserMessage({ content: [{ type: 'text', text: 'Continue.' }], source: { kind: 'user' } })); await agent.whenIdle();
+    assert.ok(checked); assert.deepEqual(adapter.compactModels, ['fast', 'fast']);
+  } finally { await ctx.fiber.dispose(); }
+});

package/tests/interaction-fixture.tsx

@@ -0,0 +1,38 @@
+import React, { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { flushSync, createPortal } from 'react-dom';
+import { PopupBridge } from '../src/client/index.js';
+import { Satellite } from '../src/client/satellite.js';
+const fixture = window as any;
+fixture.requests = [];
+fixture.session = 'fixture-A';
+fixture.result = 'running';
+fixture.job = { phase: 'idle', message: '', failures: 0 };
+fixture.apiError = false;
+fixture.bridgeVisible = true;
+fixture.fetch = async (_url: string, options?: RequestInit) => {
+  if (options?.method === 'POST') {
+    const body = JSON.parse(String(options.body)); fixture.requests.push(body);
+    if (fixture.apiError) return new Response(JSON.stringify({ error: '请选择压缩模型。' }), { status: 400 });
+    fixture.job = { phase: body.action === 'cancel' ? 'idle' : fixture.result, message: body.action === 'cancel' ? '已取消' : '正在压缩上下文…', failures: 0 };
+  }
+  return new Response(JSON.stringify({ config: { enabled: true, mode: 'direct', provider: 'mock', model: 'fast', reasoningEffort: '' }, available: true, job: fixture.job }));
+};
+fixture.layout = 'portal';
+fixture.hasBreakdown = true;
+fixture.showRing = true;
+function Fixture() {
+  const [open, setOpen] = useState(false);
+  const panel = <div role="dialog" aria-label="上下文已用"><div className="header"><span>上下文已用</span><span>48%</span><span></span><span>~508K / 1M</span></div><div className="bar"><div/></div>{fixture.hasBreakdown && <dl><div><dt>系统提示词</dt><dd>~2.3K</dd></div><div><dt>工具定义</dt><dd>~34.1K</dd></div><div><dt>对话消息</dt><dd>~372K</dd></div></dl>}</div>;
+  const ring = fixture.showRing && <span><button id="ring" aria-label="上下文已用 48%" aria-haspopup="dialog" aria-expanded={open} onClick={() => setOpen(!open)}><svg viewBox="0 0 14 14" width="14" height="14"><circle cx="7" cy="7" r="5.5" fill="none" stroke="#e3e5e8" strokeWidth="2"/><circle cx="7" cy="7" r="5.5" fill="none" stroke="#9097a2" strokeWidth="2" strokeDasharray="16 35"/></svg>{fixture.layout === 'portal' && <span>48%</span>}</button>{open && (fixture.layout === 'portal' ? createPortal(panel, document.body) : panel)}</span>;
+  const controls = <><span data-slot="conversation.input.right">{fixture.bridgeVisible && <PopupBridge sessionId={fixture.session}/>}</span><button className="send" aria-label="发送">↑</button></>;
+  // RC2 moved ContextMeter outside data-composer-card and portals its panel to
+  // document.body; keep this fixture faithful to both independent changes.
+  return <div className="composer">{fixture.layout === 'portal' ? <><div data-composer-card><div><div>{controls}</div></div></div><div className="dock">{ring}</div></> : <>{ring}{controls}</>}</div>;
+
+}
+const root = createRoot(document.getElementById('root')!);
+fixture.render = () => flushSync(() => root.render(<Fixture/>));
+fixture.unmount = () => flushSync(() => root.render(null));
+fixture.Satellite = Satellite;
+fixture.render();