feat(serve): add runtime context injection for per-turn system-reminders

.gitignore

@@ -126,3 +126,4 @@ tmp/
 .codegraph
 .qwen/computer-use/installed.json
 .playwright-mcp/
+pnpm-lock.yaml

integration-tests/cli/qwen-serve-routes.test.ts

@@ -298,6 +298,7 @@ describe('qwen serve — capabilities envelope', () => {
       'permission_mediation',
       'non_blocking_prompt',
       'session_language',
+      'session_runtime_context',
       'session_rewind',
       'workspace_hooks',
       'session_hooks',

packages/acp-bridge/src/bridge.ts

@@ -4808,6 +4808,35 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge {
       }
     },
 
+    async setSessionRuntimeContext(sessionId, entries, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const info = channelInfoForEntry(entry);
+      if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+
+      const response = (await Promise.race([
+        withTimeout(
+          entry.connection.extMethod(
+            SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext,
+            { sessionId, entries },
+          ),
+          initTimeoutMs,
+          SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext,
+        ),
+        getTransportClosedReject(entry),
+      ])) as {
+        keys: string[];
+        rejected?: Array<{ key: string; reason: string }>;
+      };
+
+      return {
+        sessionId,
+        keys: response.keys,
+        rejected: response.rejected ?? [],
+      };
+    },
+
     async generateSessionRecap(sessionId, _context) {
       // Thin pass-through to `qwen/control/session/
       // recap` — the ACP child runs `generateSessionRecap` against the

packages/acp-bridge/src/bridgeTypes.ts

@@ -743,6 +743,21 @@ export interface AcpSessionBridge {
     persisted: boolean;
   }>;
 
+  /**
+   * Set, update, or remove runtime context entries on a live session.
+   * Entries are injected as per-turn <system-reminder> blocks on the
+   * next model call. Passing an empty string for a value removes that key.
+   */
+  setSessionRuntimeContext(
+    sessionId: string,
+    entries: Record<string, string>,
+    context?: BridgeClientRequestContext,
+  ): Promise<{
+    sessionId: string;
+    keys: string[];
+    rejected: Array<{ key: string; reason: string }>;
+  }>;
+
   /**
    * Generate a one-sentence "where did I leave off" recap of a live
    * session. Forwards through `qwen/control/session/recap`, which

packages/acp-bridge/src/status.ts

@@ -146,6 +146,7 @@ export const SERVE_CONTROL_EXT_METHODS = {
   sessionGoalClear: 'qwen/control/session/goal/clear',
   workspaceMcpRuntimeAdd: 'qwen/control/workspace/mcp/runtime-add',
   workspaceMcpRuntimeRemove: 'qwen/control/workspace/mcp/runtime-remove',
+  sessionRuntimeContext: 'qwen/control/session/runtime_context',
   workspaceReload: 'qwen/control/workspace/reload',
   workspaceExtensionsRefresh: 'qwen/control/workspace/extensions/refresh',
   /**

packages/cli/src/acp-integration/acpAgent.test.ts

@@ -8028,3 +8028,228 @@ describe('deliverClientMcpMessage — reverse tool channel (#5626)', () => {
     });
   });
 });
+
+describe('sessionRuntimeContext handler', () => {
+  let capturedAgentFactory:
+    | ((conn: { closed: Promise<void> }) => {
+        initialize: (args: Record<string, unknown>) => Promise<unknown>;
+        newSession: (args: Record<string, unknown>) => Promise<unknown>;
+        extMethod: (
+          method: string,
+          args: Record<string, unknown>,
+        ) => Promise<Record<string, unknown>>;
+      })
+    | undefined;
+
+  let processExitSpy: MockInstance<typeof process.exit>;
+  let stdinDestroySpy: MockInstance<typeof process.stdin.destroy>;
+  let stdoutDestroySpy: MockInstance<typeof process.stdout.destroy>;
+
+  const mockConnectionState = {
+    promise: undefined as unknown as Promise<void>,
+    resolve: undefined as unknown as () => void,
+    reset() {
+      this.promise = new Promise<void>((r) => {
+        this.resolve = r;
+      });
+    },
+  };
+
+  const runtimeCtxMap = new Map<string, string>();
+
+  function makeRuntimeCtxConfig(overrides: Record<string, unknown> = {}) {
+    return {
+      initialize: vi.fn().mockResolvedValue(undefined),
+      waitForMcpReady: vi.fn().mockResolvedValue(undefined),
+      getModel: vi.fn().mockReturnValue('m'),
+      getModelsConfig: vi.fn().mockReturnValue({
+        getCurrentAuthType: vi.fn().mockReturnValue('api-key'),
+        syncAfterAuthRefresh: vi.fn(),
+      }),
+      reloadModelProvidersConfig: vi.fn(),
+      refreshAuth: vi.fn().mockResolvedValue(undefined),
+      getTargetDir: vi.fn().mockReturnValue('/tmp'),
+      getContentGeneratorConfig: vi.fn().mockReturnValue({}),
+      getAvailableModels: vi.fn().mockReturnValue([]),
+      getModes: vi.fn().mockReturnValue([]),
+      getApprovalMode: vi.fn().mockReturnValue('default'),
+      getSessionId: vi.fn().mockReturnValue('rt-sid'),
+      getAuthType: vi.fn().mockReturnValue('api-key'),
+      getAllConfiguredModels: vi.fn().mockReturnValue([]),
+      getGeminiClient: vi.fn().mockReturnValue({
+        isInitialized: vi.fn().mockReturnValue(true),
+        initialize: vi.fn().mockResolvedValue(undefined),
+        waitForMcpReady: vi.fn().mockResolvedValue(undefined),
+        refreshSystemInstruction: vi.fn().mockResolvedValue(undefined),
+      }),
+      getFileSystemService: vi.fn().mockReturnValue(undefined),
+      setFileSystemService: vi.fn(),
+      getHookSystem: vi.fn().mockReturnValue(undefined),
+      getDisableAllHooks: vi.fn().mockReturnValue(true),
+      hasHooksForEvent: vi.fn().mockReturnValue(false),
+      getWorkspaceContext: vi.fn().mockReturnValue({}),
+      getDebugMode: vi.fn().mockReturnValue(false),
+      getRuntimeContext: vi.fn().mockReturnValue(runtimeCtxMap),
+      setRuntimeContextEntry: vi
+        .fn()
+        .mockImplementation((key: string, value: string) => {
+          if (!/^[a-zA-Z0-9_-]{1,64}$/.test(key)) return false;
+          if (Buffer.byteLength(value, 'utf8') > 32 * 1024) return false;
+          if (!runtimeCtxMap.has(key) && runtimeCtxMap.size >= 16) return false;
+          runtimeCtxMap.set(key, value);
+          return true;
+        }),
+      removeRuntimeContextEntry: vi.fn().mockImplementation((key: string) => {
+        runtimeCtxMap.delete(key);
+      }),
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    runtimeCtxMap.clear();
+    mockConnectionState.reset();
+    capturedAgentFactory = undefined;
+
+    vi.mocked(AgentSideConnection).mockImplementation((factory: unknown) => {
+      capturedAgentFactory = factory as typeof capturedAgentFactory;
+      return {
+        get closed() {
+          return mockConnectionState.promise;
+        },
+      } as unknown as InstanceType<typeof AgentSideConnection>;
+    });
+
+    processExitSpy = vi
+      .spyOn(process, 'exit')
+      .mockImplementation((() => undefined) as unknown as typeof process.exit);
+    stdinDestroySpy = vi
+      .spyOn(process.stdin, 'destroy')
+      .mockImplementation(() => process.stdin);
+    stdoutDestroySpy = vi
+      .spyOn(process.stdout, 'destroy')
+      .mockImplementation(() => process.stdout);
+  });
+
+  afterEach(() => {
+    mockConnectionState.resolve();
+    processExitSpy.mockRestore();
+    stdinDestroySpy.mockRestore();
+    stdoutDestroySpy.mockRestore();
+  });
+
+  async function setupAgent() {
+    const cfg = makeRuntimeCtxConfig();
+
+    vi.mocked(loadSettings).mockReturnValue({
+      merged: { mcpServers: {} },
+      getUserHooks: vi.fn().mockReturnValue({}),
+      getProjectHooks: vi.fn().mockReturnValue({}),
+    } as unknown as LoadedSettings);
+
+    vi.mocked(loadCliConfig).mockResolvedValue(cfg as unknown as Config);
+
+    vi.mocked(Session).mockImplementation(
+      () =>
+        ({
+          getId: vi.fn().mockReturnValue('rt-sid'),
+          getConfig: vi.fn().mockReturnValue(cfg),
+          sendAvailableCommandsUpdate: vi.fn().mockResolvedValue(undefined),
+          installRewriter: vi.fn(),
+          startCronScheduler: vi.fn(),
+          dispose: vi.fn(),
+        }) as unknown as Session,
+    );
+
+    vi.mocked(buildAvailableCommandsSnapshot).mockResolvedValue({
+      availableCommands: [],
+      availableSkills: [],
+    });
+
+    const bootConfig = makeRuntimeCtxConfig();
+    runAcpAgent(
+      bootConfig as unknown as Config,
+      { merged: { mcpServers: {} } } as unknown as LoadedSettings,
+      {} as CliArgs,
+    );
+    await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined());
+    const agent = capturedAgentFactory!({
+      closed: mockConnectionState.promise,
+    });
+    await agent.initialize({});
+    await agent.newSession({ cwd: '/tmp', mcpServers: [] });
+    return agent;
+  }
+
+  it('sets entries and returns applied keys', async () => {
+    const agent = await setupAgent();
+    const result = await agent.extMethod(
+      SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext,
+      {
+        sessionId: 'rt-sid',
+        entries: { operator: 'Alice', rules: 'no-prod' },
+      },
+    );
+    expect(result['keys']).toEqual(['operator', 'rules']);
+    expect(result['rejected']).toEqual([]);
+    expect(runtimeCtxMap.get('operator')).toBe('Alice');
+  });
+
+  it('removes entries with empty string values', async () => {
+    runtimeCtxMap.set('old-key', 'stale');
+    const agent = await setupAgent();
+    const result = await agent.extMethod(
+      SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext,
+      { sessionId: 'rt-sid', entries: { 'old-key': '' } },
+    );
+    expect(result['keys']).toEqual(['old-key']);
+    expect(runtimeCtxMap.has('old-key')).toBe(false);
+  });
+
+  it('rejects non-string values', async () => {
+    const agent = await setupAgent();
+    const result = await agent.extMethod(
+      SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext,
+      { sessionId: 'rt-sid', entries: { bad: 123 } },
+    );
+    expect(result['keys']).toEqual([]);
+    expect(
+      (result['rejected'] as Array<{ key: string; reason: string }>)[0],
+    ).toEqual({
+      key: 'bad',
+      reason: 'value_not_string',
+    });
+  });
+
+  it('rejects invalid keys', async () => {
+    const agent = await setupAgent();
+    const result = await agent.extMethod(
+      SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext,
+      { sessionId: 'rt-sid', entries: { 'invalid key!': 'value' } },
+    );
+    expect(result['keys']).toEqual([]);
+    expect(
+      (result['rejected'] as Array<{ key: string; reason: string }>)[0]?.reason,
+    ).toBe('invalid_key');
+  });
+
+  it('throws on missing sessionId', async () => {
+    const agent = await setupAgent();
+    await expect(
+      agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext, {
+        entries: { a: 'b' },
+      }),
+    ).rejects.toThrow(/sessionId/);
+  });
+
+  it('throws on invalid entries shape', async () => {
+    const agent = await setupAgent();
+    await expect(
+      agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext, {
+        sessionId: 'rt-sid',
+        entries: 'not-an-object',
+      }),
+    ).rejects.toThrow(/entries/);
+  });
+});

packages/cli/src/acp-integration/acpAgent.ts

@@ -6174,6 +6174,55 @@ class QwenAgent implements Agent {
 
         return { language: resolvedLanguage, outputLanguage, refreshed };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionRuntimeContext: {
+        const sessionId = params['sessionId'];
+        const entries = params['entries'];
+        if (typeof sessionId !== 'string' || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            undefined,
+            'Invalid or missing sessionId',
+          );
+        }
+        if (
+          typeof entries !== 'object' ||
+          entries === null ||
+          Array.isArray(entries)
+        ) {
+          throw RequestError.invalidParams(
+            undefined,
+            '`entries` must be a non-null object',
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const config = session.getConfig();
+        const appliedKeys: string[] = [];
+        const rejected: Array<{ key: string; reason: string }> = [];
+        for (const [key, value] of Object.entries(
+          entries as Record<string, unknown>,
+        )) {
+          if (typeof value !== 'string') {
+            rejected.push({ key, reason: 'value_not_string' });
+            continue;
+          }
+          if (value === '') {
+            if (config.getRuntimeContext().has(key)) {
+              config.removeRuntimeContextEntry(key);
+              appliedKeys.push(key);
+            }
+          } else if (config.setRuntimeContextEntry(key, value)) {
+            appliedKeys.push(key);
+          } else if (!/^[a-zA-Z0-9_-]{1,64}$/.test(key)) {
+            rejected.push({ key, reason: 'invalid_key' });
+          } else if (
+            Buffer.byteLength(value, 'utf8') > 32 * 1024
+          ) {
+            rejected.push({ key, reason: 'value_too_large' });
+          } else {
+            rejected.push({ key, reason: 'capacity_full' });
+          }
+        }
+        return { keys: appliedKeys, rejected };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionRecap: {
         // Generate a one-sentence "where did I leave off" summary.
         // Best-effort: returns `null` on short history or model failure.

packages/cli/src/serve/capabilities.ts

@@ -246,6 +246,7 @@ export const SERVE_CAPABILITY_REGISTRY = {
   writer_idle_timeout: { since: 'v1' },
   non_blocking_prompt: { since: 'v1' },
   session_language: { since: 'v1' },
+  session_runtime_context: { since: 'v1' },
   session_rewind: { since: 'v1' },
   workspace_hooks: { since: 'v1' },
   session_hooks: { since: 'v1' },