coding-tool-x 3.8.1 → 3.8.2

package/dist/web/index.html

@@ -5,7 +5,7 @@
     <link rel="icon" href="/favicon.ico">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>coding-tool-x · AI 编程工作台</title>
-    <script type="module" crossorigin src="/assets/index-DIWJmyL6.js"></script>
+    <script type="module" crossorigin src="/assets/index-D5hyHPj7.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/markdown-BNJfEgCA.js">
     <link rel="modulepreload" crossorigin href="/assets/vue-vendor-B5RqjEjQ.js">
     <link rel="modulepreload" crossorigin href="/assets/naive-ui-BALVpMgd.js">

package/docs/superpowers/plans/2026-08-10-codex-conversion-compatibility.md

@@ -0,0 +1,251 @@
+# Codex Conversion Compatibility Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make both OpenCode's Codex conversion proxy and OMP's managed Codex provider work with Codex-only OpenAI-compatible services.
+
+**Architecture:** Add a small shared Codex wire helper for current client identity, request metadata, headers, and body normalization. OpenCode uses it before sending upstream; OMP provider API normalization emits `openai-codex-responses` only for explicit Codex channels while generic OpenAI Responses remains unchanged.
+
+**Tech Stack:** Node.js 22 CommonJS, Express/http, Vitest, js-yaml, installed `codex-cli 0.144.1`, OMP 17.2.12.
+
+---
+
+### Task 1: Lock the Codex wire contract with failing tests
+
+**Files:**
+- Create: `tests/unit/services/codex-wire.test.js`
+- Modify: `tests/unit/services/opencode-gateway-adapters.test.js` if the existing adapter test file exists; otherwise extend `scripts/test-opencode-gateway-adapters.js`
+- Modify: `tests/unit/services/omp-settings-manager.test.js:41-90`
+
+- [ ] **Step 1: Write the failing shared-wire test**
+
+Add a Vitest test that calls the planned `codex-wire` exports with a payload containing `system` input, `temperature`, `top_p`, `max_output_tokens`, `max_completion_tokens`, `service_tier`, `prompt_cache_retention`, and a caller session id. Assert the output has:
+
+```js
+expect(result.body.input[0].role).toBe('developer');
+expect(result.body.stream).toBe(true);
+expect(result.body.store).toBe(false);
+expect(result.body.include).toContain('reasoning.encrypted_content');
+expect(result.body.temperature).toBeUndefined();
+expect(result.body.max_output_tokens).toBeUndefined();
+expect(result.headers['version']).toBe('0.144.1');
+expect(result.headers.originator).toBe('codex_exec');
+expect(result.headers['session-id']).toBe('session-test');
+expect(result.headers['thread-id']).toBeTruthy();
+expect(result.headers['x-codex-window-id']).toBeTruthy();
+expect(result.body.client_metadata['x-codex-turn-metadata']).toBeTruthy();
+```
+
+The test must import `createCodexRequest` from `src/server/services/codex-wire.js`, so it fails with module-not-found before implementation.
+
+- [ ] **Step 2: Run the focused test and verify the expected red failure**
+
+Run: `npx vitest run tests/unit/services/codex-wire.test.js`
+
+Expected: FAIL because `src/server/services/codex-wire.js` does not exist.
+
+- [ ] **Step 3: Add the OMP mapping regression test**
+
+In `tests/unit/services/omp-settings-manager.test.js`, add a test beside the provider writer tests:
+
+```js
+test('writes Codex-source providers with the Codex Responses API while preserving generic Responses', () => {
+  const manager = require('../../../src/server/services/omp-settings-manager');
+  const target = manager.writeManagedOmpProviders([
+    {
+      id: 'edge-codex',
+      providerKey: 'edge-codex',
+      baseUrl: 'https://edge.example/v1',
+      apiKey: 'secret',
+      gatewaySourceType: 'codex',
+      providerApi: 'responses',
+      model: 'gpt-5.5'
+    },
+    {
+      id: 'generic-openai',
+      providerKey: 'generic-openai',
+      baseUrl: 'https://generic.example/v1',
+      apiKey: 'secret',
+      gatewaySourceType: 'openai_compatible',
+      providerApi: 'openai-responses',
+      model: 'gpt-4.1'
+    }
+  ]);
+  const config = yaml.load(fs.readFileSync(target, 'utf8'));
+  expect(config.providers['ctx-edge-codex'].api).toBe('openai-codex-responses');
+  expect(config.providers['ctx-generic-openai'].api).toBe('openai-responses');
+});
+```
+
+- [ ] **Step 4: Run the OMP test and verify it fails for the current mapping**
+
+Run: `npx vitest run tests/unit/services/omp-settings-manager.test.js -t "Codex-source providers"`
+
+Expected: FAIL because `normalizeProviderApi('responses')` currently returns `responses`, or the provider entry does not classify the Codex source.
+
+---
+
+### Task 2: Implement the shared Codex wire helper
+
+**Files:**
+- Create: `src/server/services/codex-wire.js`
+- Test: `tests/unit/services/codex-wire.test.js`
+
+- [ ] **Step 1: Implement deterministic request identity and headers**
+
+Export:
+
+```js
+const CODEX_CLIENT_VERSION = '0.144.1';
+function createCodexRequest(payload, options = {}) { /* { body, headers, model } */ }
+function normalizeCodexResponsesInput(inputValue) { /* exported for direct tests */ }
+function buildCodexTargetUrl(baseUrl) { /* exported for direct tests */ }
+```
+
+Use `options.sessionId` as the stable prompt/session identity, defaulting to `crypto.randomUUID()`. Generate UUIDs for `threadId`, `windowId`, `turnId`, and a process-local installation id. Use `originator: 'codex_exec'` and `user-agent: codex_exec/0.144.1 (<OS> <release>; <arch>) <terminal> (codex_exec; 0.144.1)`, with `process.platform`, `process.release.name`/`TERM_PROGRAM` fallback, and `process.arch`; tests may inject `userAgent` to avoid platform dependence.
+
+Emit lowercase header keys:
+
+```js
+{
+  authorization: `Bearer ${apiKey}`,
+  accept: 'text/event-stream',
+  'content-type': 'application/json',
+  originator: 'codex_exec',
+  'user-agent': userAgent,
+  'session-id': sessionId,
+  'thread-id': threadId,
+  'x-client-request-id': sessionId,
+  'x-codex-window-id': windowId,
+  'x-codex-turn-metadata': JSON.stringify({
+    installation_id: installationId,
+    session_id: sessionId,
+    thread_id: threadId,
+    turn_id: turnId,
+    window_id: windowId,
+    request_kind: 'turn'
+  })
+}
+```
+
+Do not include `openai-beta`, `version`, `session_id`, or `conversation_id` because the verified official `0.144.1` request to the target service did not emit them. Never log the authorization value.
+
+- [ ] **Step 2: Implement Codex body normalization**
+
+Clone JSON-compatible payload data. Fill `model` from `fallbackModel` if absent. Convert string input to a single `message/user/input_text` item. Clone array input and rewrite only `role: 'system'` to `role: 'developer'`. Force `stream: true`, `store: false`; preserve tools, tool choice, reasoning, text, and unknown fields. Ensure `include` is a clean string array containing `reasoning.encrypted_content`.
+
+Delete Codex-rejected fields: `max_output_tokens`, `max_completion_tokens`, `temperature`, `top_p`, `top_k`, `min_p`, `presence_penalty`, `frequency_penalty`, `repetition_penalty`, `stop`, `service_tier`, `user`, `previous_response_id`, `prompt_cache_retention`, and `safety_identifier`. Set `prompt_cache_key` to the stable session id unless the caller supplied a non-empty key. Add `client_metadata` with the same identity projection as the official client; preserve non-reserved caller metadata.
+
+- [ ] **Step 3: Run focused tests and verify green**
+
+Run: `npx vitest run tests/unit/services/codex-wire.test.js`
+
+Expected: PASS.
+
+---
+
+### Task 3: Replace OpenCode's duplicated Codex conversion path
+
+**Files:**
+- Modify: `src/server/opencode-proxy-server.js:24-30,1044-1121,1335-1356,3089-3158`
+- Modify: `src/server/services/opencode-gateway-adapters.js:741-811`
+- Create: `tests/unit/services/opencode-codex-proxy.test.js`
+
+- [ ] **Step 1: Add the local fake-upstream integration regression test**
+
+Start a local `http.createServer` that records request headers/body and returns a minimal successful Responses SSE stream containing `response.created`, `response.completed`, and `[DONE]`. Start the OpenCode proxy on port 0 with stubs for channel allocation, API key, and configuration dependencies as needed by the existing module seams. POST `/v1/responses` with a Codex channel and payload containing a system input plus rejected sampling fields. Assert the fake upstream receives `/v1/responses`, `originator: codex_exec`, `user-agent` containing `0.144.1`, `session-id`, `thread-id`, `x-codex-window-id`, `x-codex-turn-metadata`, and a body without the rejected fields. Assert the downstream response completes and the upstream API key was not written to logs or body metadata.
+
+- [ ] **Step 2: Run the integration test and verify the old path fails**
+
+Run: `npx vitest run tests/unit/services/opencode-codex-proxy.test.js`
+
+Expected: FAIL because the current handler sends `codex_cli_rs/0.101.0`, `Version: 0.101.0`, and lacks the current Codex identity metadata.
+
+- [ ] **Step 3: Make the proxy use the shared helper**
+
+Import `createCodexRequest` and `buildCodexTargetUrl` in `opencode-proxy-server.js`. Remove the local `normalizeCodexResponsesInput`, `convertOpenCodePayloadToCodexResponses`, and `buildCodexTargetUrl` implementations. Keep the independent response relay functions unchanged.
+
+In `handleCodexGatewayRequest`, derive `sessionId` from `extractSessionIdFromRequest(req, originalPayload)` or let the helper generate it. Call `createCodexRequest(originalPayload, { apiKey: effectiveKey, fallbackModel: channel.model, sessionId })`, use its `body` and `headers`, and dispatch to the helper's target URL. Keep `wantsStream`, target-model validation, and existing error reporting behavior.
+
+- [ ] **Step 4: Remove the second adapter implementation without changing its public API**
+
+Change `convertOpenCodePayloadToCodexResponses` in `opencode-gateway-adapters.js` to delegate to `createCodexRequest(payload, { fallbackModel, apiKey: '' })` and return `{ requestBody: body, model }`, or remove the export only after updating every test/callsite. Keep the adapter export during this cutover because the existing regression script imports it.
+
+- [ ] **Step 5: Run focused tests and verify green**
+
+Run: `npx vitest run tests/unit/services/codex-wire.test.js tests/unit/services/opencode-codex-proxy.test.js tests/unit/services/opencode-gateway-adapters.test.js`
+
+Expected: PASS.
+
+---
+
+### Task 4: Emit the correct Codex API in OMP configuration
+
+**Files:**
+- Modify: `src/server/services/omp-settings-manager.js:63-71,308-364`
+- Modify: `src/server/services/omp-channels.js:1-16,608-615`
+- Modify: `tests/unit/services/omp-settings-manager.test.js`
+- Modify: `tests/unit/services/omp-channels.test.js` if a direct normalization seam is available
+
+- [ ] **Step 1: Implement explicit Codex alias normalization**
+
+Change `normalizeProviderApi(value, options = {})` so:
+
+```js
+if (normalized === 'responses' && options.gatewaySourceType === 'codex') {
+  return 'openai-codex-responses';
+}
+if (normalized === 'responses') return 'openai-responses';
+```
+
+Preserve all explicit supported API identifiers exactly. In `buildProviderEntry`, pass `channel.gatewaySourceType` into `normalizeProviderApi`. In the OMP sync candidate, normalize the provider API once using the source provider's `api` and the selected gateway source; keep the raw `wireApi` for compatibility with existing UI fields.
+
+- [ ] **Step 2: Run the OMP mapping regression and verify green**
+
+Run: `npx vitest run tests/unit/services/omp-settings-manager.test.js -t "Codex-source providers"`
+
+Expected: PASS, with generic OpenAI Responses still serialized as `openai-responses`.
+
+- [ ] **Step 3: Run all affected service tests**
+
+Run: `npx vitest run tests/unit/services/omp-settings-manager.test.js tests/unit/services/omp-channels.test.js tests/unit/services/omp-gateway-routing.test.js`
+
+Expected: PASS.
+
+---
+
+### Task 5: Verify both live paths and finish cleanup
+
+**Files:**
+- Modify: `CHANGELOG.md:7-12`
+- No credential-bearing files
+
+- [ ] **Step 1: Run the project's OpenCode adapter regression script**
+
+Run: `node scripts/test-opencode-gateway-adapters.js`
+
+Expected: `OpenCode gateway adapters regression tests passed`.
+
+- [ ] **Step 2: Exercise the OpenCode proxy against the real target**
+
+Start the project proxy with a temporary channel/config supplied through an isolated temporary HOME or injected test seam. Send a minimal OpenAI Responses request using `gpt-5.5`, `stream: true`, and a prompt asking for `OK`. Pass the key only through `EDGE_API_KEY` in the process environment. Assert the response reaches `response.completed` and contains non-empty output; capture only redacted headers and status.
+
+- [ ] **Step 3: Exercise OMP with generated Codex provider configuration**
+
+Generate a temporary `models.yml` entry for `openai-codex-responses` with base URL `https://api.ai-edge.xyz/v1`, model `gpt-5.5`, and an environment-backed key. Run installed `omp` with the temporary config and `EDGE_API_KEY` environment variable, asking for `OK`. Assert the command succeeds. Delete temporary config and ensure the repository contains no key.
+
+- [ ] **Step 4: Run the complete relevant verification suite**
+
+Run:
+
+```bash
+npx vitest run tests/unit/services/codex-wire.test.js tests/unit/services/opencode-codex-proxy.test.js tests/unit/services/opencode-gateway-adapters.test.js tests/unit/services/omp-settings-manager.test.js tests/unit/services/omp-gateway-routing.test.js
+node scripts/test-opencode-gateway-adapters.js
+npm run test:basic
+```
+
+Expected: all commands exit 0. If unrelated existing failures appear, report their exact command/output separately instead of weakening the new assertions.
+
+- [ ] **Step 5: Record the fix in the changelog and scan for credentials**
+
+Add one Unreleased fixed entry describing the current Codex compatibility headers/metadata and OMP API classification. Run a repository search for the literal key prefix/value and confirm no match in tracked source, tests, docs, or logs. Do not add a “follow-up” placeholder.

package/docs/superpowers/plans/2026-08-11-windows-command-window-hiding.md

@@ -0,0 +1,90 @@
+# Windows Command Window Hiding Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Ensure every non-interactive child process launched by the project hides its Windows console window, without changing interactive session resume behavior.
+
+**Architecture:** Keep the existing direct child-process APIs and add `windowsHide: true` at each missing launch boundary. Use the existing injectable command runners and Windows regression script to prove options are passed, and use a focused source audit for launchers without test seams.
+
+**Tech Stack:** Node.js `child_process`, Vitest, Node assertion-based Windows regression script.
+
+---
+
+### Task 1: Add failing regression coverage for missing launch options
+
+**Files:**
+- Modify: `scripts/test-windows-regression.js`
+- Test reference: `src/commands/resume.js`, `src/server/services/session-history-worker.js`, `src/commands/update.js`
+
+- [ ] **Step 1: Add source-level assertions for known missing launch sites**
+
+Add a helper that reads a file and asserts each child-process call's surrounding options contain `windowsHide: true`. Apply it to the session-history worker, update version probe, and resume launcher with separate expectations: the worker and update probe require hidden windows; resume requires both `stdio: 'inherit'` and `windowsHide: true` so its terminal behavior remains explicit.
+
+- [ ] **Step 2: Run the focused regression to verify it fails**
+
+Run: `npm run test:windows`
+Expected: FAIL because `session-history-worker.js` has no `windowsHide: true`, `update.js`'s `execFileAsync` options omit it, and/or other audited launch sites remain unhidden.
+
+---
+
+### Task 2: Hide command and worker windows at missing launch boundaries
+
+**Files:**
+- Modify: `src/server/services/session-history-worker.js:13-24`
+- Modify: `src/commands/update.js:15-19`
+- Modify: `src/server/services/plugins-service.js:2817-2822`
+- Modify: `src/server/services/notification-hooks.js` generated OpenCode/OMP spawn option templates around lines 393 and 446, if absent after the audit
+- Modify: any additional `spawn`/`exec`/`execFile`/`spawnSync`/`fork` site found by the launch inventory that lacks `windowsHide: true`
+
+- [ ] **Step 1: Add only the missing option fields**
+
+For `session-history-worker`, add `windowsHide: true` to the `fork` options while preserving `silent`, `stdio`, environment, IPC, timeout, and signal handling.
+
+For `update.getLatestVersion`, add `windowsHide: true` to the options passed to `execFileAsync` while preserving the 15-second timeout.
+
+For every other non-interactive launcher found by the audit, add `windowsHide: true` directly to its existing options object. Do not change command strings, argument arrays, shell settings, output routing, cwd, environment, or error handling. Keep `src/commands/resume.js`'s `stdio: 'inherit'` unchanged; its existing `windowsHide: true` is retained as an explicit compatibility option.
+
+- [ ] **Step 2: Run the focused regression to verify it passes**
+
+Run: `npm run test:windows`
+Expected: PASS with `Windows 专项回归测试通过`.
+
+---
+
+### Task 3: Add runner-level tests for command option propagation
+
+**Files:**
+- Modify: `tests/unit/services/omp-settings-manager.test.js` or the existing closest service test file for each injectable runner
+- Modify: `tests/unit/services/omp-auth-gateway-client.test.js` or relevant existing test file if it already covers the runner
+- Modify: `tests/unit/commands/daemon.test.js` only if a tested command launcher is added there
+
+- [ ] **Step 1: Add behavior assertions where the module exposes an injected runner**
+
+Capture the options argument in existing `catalogRunner`, `modelsRunner`, `commandRunner`, or equivalent test callbacks and assert `options.windowsHide === true`. Use real module behavior with only the existing runner seam; do not test a mock's own implementation.
+
+- [ ] **Step 2: Run the focused unit tests**
+
+Run: `npx vitest run tests/unit/services/omp-settings-manager.test.js tests/unit/services/omp-auth-gateway-client.test.js tests/unit/commands/daemon.test.js`
+Expected: PASS with zero failures. If a listed file has no relevant test, run the closest existing test file instead and record the exact command output.
+
+---
+
+### Task 4: Verify complete launch inventory and interactive behavior
+
+**Files:**
+- Modify: `scripts/test-windows-regression.js` only if the audit needs a final explicit launcher list
+
+- [ ] **Step 1: Re-run the scoped launch inventory**
+
+Run the repository search for `spawn`, `spawnSync`, `exec`, `execFile`, `execSync`, and `fork` under `src`, `bin`, and `scripts`. Review every actual child-process call, ignoring regex `.exec` and database `.exec` calls. Confirm every non-interactive launch has `windowsHide: true` and the resume launcher retains `stdio: 'inherit'`.
+
+- [ ] **Step 2: Run all required verification commands**
+
+Run: `npm run test:windows`
+Run: `npm run test:unit`
+Run: `npm test`
+Expected: each command exits 0 with no test failures. The Windows-specific script may be run on the current non-Windows host because it uses platform-parameterized helpers and source assertions.
+
+- [ ] **Step 3: Inspect the final diff for scope**
+
+Confirm only the approved spec/plan, runtime launch options, and focused regression tests changed. Do not alter unrelated existing working-tree changes in `CHANGELOG.md`, `package.json`, `package-lock.json`, `src/server/services/omp-gateway.js`, or `tests/unit/services/omp-gateway.test.js`.

package/docs/superpowers/specs/2026-08-10-codex-conversion-compatibility-design.md

@@ -0,0 +1,61 @@
+# Codex Conversion Compatibility Design
+
+## Goal
+
+Restore Codex-only upstream compatibility for both OpenCode conversion proxy requests and OMP-managed providers, using `https://api.ai-edge.xyz/v1` with `gpt-5.5` as the live acceptance target without persisting credentials.
+
+## Observed failure
+
+- The installed official `codex-cli 0.144.1` succeeds against the target service and returns `OK`.
+- The project's current simulated Codex request uses a hard-coded `0.101.0` identity and receives HTTP 403: `This account only allows Codex official clients`.
+- The OpenCode proxy contains a duplicated Codex payload converter in `opencode-proxy-server.js` in addition to `opencode-gateway-adapters.js`.
+- OMP maps `responses` to generic `openai-responses`; Codex-only services require OMP's `openai-codex-responses` provider contract.
+
+## Architecture
+
+### Shared Codex compatibility module
+
+Add one focused module under `src/server/services/` that owns Codex wire compatibility:
+
+- current pinned client identity matching the reference implementation;
+- stable request-scoped session, conversation, thread, window, and client metadata;
+- Codex request headers;
+- Codex Responses body normalization.
+
+The body normalization will force streaming upstream, disable storage, convert system roles to developer roles, ensure encrypted reasoning inclusion, and remove unsupported sampling/output-cap fields. It will preserve caller-owned tools, input items, model selection, and response conversion semantics.
+
+### OpenCode conversion path
+
+`opencode-proxy-server.js` will import the shared compatibility functions instead of maintaining a second payload converter. Its responsibilities remain routing, credential selection, upstream transport, SSE collection/relay, and conversion back to the caller's requested streaming mode.
+
+Session identity will derive from an existing prompt cache/session identifier when supplied; otherwise the handler creates one request identity and uses it consistently in headers and body metadata.
+
+### OMP configuration path
+
+OMP remains a byte-transparent data-plane gateway. For channels configured with Codex conversion semantics, generated provider configuration must use `openai-codex-responses`, allowing OMP's native provider implementation to construct the official Codex wire request. Generic OpenAI Responses providers remain `openai-responses`; no global remapping is allowed.
+
+The normalization decision is based on the channel's explicit provider API first and Codex gateway source only when a generic `responses` alias would otherwise be emitted.
+
+## Error handling
+
+- Invalid or missing models continue to fail before upstream dispatch.
+- Invalid upstream URLs continue to return the existing structured proxy error.
+- Upstream status and body remain visible through the existing failure logger without logging authorization credentials.
+- The compatibility layer is deterministic and side-effect free except for explicitly injected/generated identity values.
+
+## Tests
+
+1. Adapter unit test: Codex body contains current compatibility metadata and removes every unsupported sampling/output-cap field.
+2. Header unit test: current version, beta, originator, session/conversation/thread/window identifiers, and official-compatible user agent are emitted consistently.
+3. OpenCode proxy integration test with a local fake upstream: inspect the actual headers/body crossing the process boundary and return a minimal Responses SSE stream.
+4. OMP settings test: a Codex-source channel using `responses` emits `openai-codex-responses`; a generic OpenAI channel remains `openai-responses`.
+5. Live acceptance:
+   - OpenCode proxy conversion path against the provided service;
+   - generated OMP provider exercised by installed OMP against the same service.
+
+## Non-goals
+
+- No WebSocket implementation in the OpenCode proxy.
+- No OAuth or ChatGPT account-token handling.
+- No change to generic OpenAI, Claude, or Gemini conversion behavior.
+- No persistence of the provided API key in source, fixtures, logs, or design documents.

package/docs/superpowers/specs/2026-08-11-windows-command-window-hiding-design.md

@@ -0,0 +1,44 @@
+# Windows Command Window Hiding Design
+
+**Date:** 2026-08-11
+
+## Goal
+
+Prevent Windows console windows from appearing for every background, non-interactive command launched by the project, including `ps`, PowerShell, `node`, `npm`, PM2, MCP, and worker processes, while preserving the current terminal behavior of interactive session resume commands.
+
+## Scope
+
+The audit covers actual child-process launch APIs under `src/`, `bin/`, and project scripts: `spawn`, `spawnSync`, `exec`, `execFile`, `execSync`, and `fork`.
+
+Every non-interactive child-process launch must pass `windowsHide: true`. This includes command probes, process inspection/termination, package installation and update operations, PM2 shell commands, MCP transports, OAuth/provider probes, generated notification helpers, certificate generation, web builds, and background workers.
+
+The interactive session-resume path in `src/commands/resume.js` remains terminal-attached (`stdio: 'inherit'`) so Claude/CLI input and output continue to work in the caller's terminal. It is not treated as a hidden background process.
+
+## Design
+
+Use the existing project convention: add or retain `windowsHide: true` directly in each child-process options object. Do not introduce a process wrapper or global monkey patch. This keeps dependency injection used by tests intact, limits the behavioral change to Windows process creation, and avoids changing command arguments, shell selection, stdio, environment, cwd, timeout, or error handling.
+
+The implementation will update only missing call sites. Existing `windowsHide: true` options remain unchanged. For `fork` workers, add the option alongside the existing `stdio`/`silent` configuration. For callback and promise-based APIs, options must be passed to the actual launch call, not merely to a higher-level helper that may be bypassed.
+
+## Affected Areas
+
+The implementation audit will verify and update the following areas when a launch lacks the option:
+
+- `src/commands/`: log following, updates, and any other command launchers; preserve interactive resume semantics.
+- `src/utils/`: process/port inspection and termination commands.
+- `src/plugins/`: plugin installation commands.
+- `src/server/api/`: PM2 autostart and API-triggered command launches.
+- `src/server/services/`: MCP clients, OAuth/provider probes, OMP model probes, marketplace sync, certificate/web-build helpers, notification-generated Node helpers, and all worker forks.
+- `scripts/`: Windows regression coverage; scripts themselves are not runtime package APIs unless they launch child processes as part of tested project behavior.
+
+## Testing
+
+Add focused regression assertions using existing injectable runners where available. The assertions must verify `windowsHide: true` is passed to command runners and worker/process launch options. Extend the Windows regression test for source-level worker/background launch coverage only where existing source checks are insufficient. Keep the interactive resume test/behavior unchanged and verify its `stdio: 'inherit'` option remains present.
+
+Run the focused unit tests for changed modules, `npm run test:windows`, and the project test command appropriate to the changed contract. A passing test must demonstrate the options are present at the actual launch boundary; source-only checks are a fallback for modules without injectable launch seams.
+
+## Non-goals
+
+- Do not hide the user's interactive Claude/CLI terminal.
+- Do not alter process lifetime, signal handling, shell quoting, command resolution, or output routing.
+- Do not add retries, new abstractions, or unrelated Windows compatibility changes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-tool-x",
-  "version": "3.8.1",
+  "version": "3.8.2",
   "description": "Vibe Coding 增强工作助手 - 智能会话管理、动态渠道切换、全局搜索、实时监控",
   "main": "src/index.js",
   "bin": {

package/src/commands/update.js

@@ -15,7 +15,7 @@ async function getLatestVersion(packageName) {
   const { stdout } = await execFileAsync(
     npmCommand,
     ['view', packageName, 'version', '--json'],
-    { timeout: 15000 }
+    { timeout: 15000, windowsHide: true }
   );
   const parsed = JSON.parse(stdout.trim());
   if (typeof parsed === 'string') return parsed;