* feat(core)!: redesign auto-compaction thresholds with three-tier ladder
Replaces the single 70% proportional threshold with a three-tier ladder
(warn/auto/hard) that combines proportional fallback with absolute
reservation. Large-window models (>=128K) now reserve ~33K instead of
30% of the window, freeing tens of thousands of context tokens that the
old formula wasted.
Other improvements bundled in the same redesign:
- Compression sideQuery now disables thinking and caps maxOutputTokens
at 20K, matching claude-code so the buffer math is predictable across
providers (Anthropic/OpenAI/Gemini handle thinking budgets
inconsistently)
- Failure handling upgraded from one-shot permanent lock to a 3-strike
circuit breaker; reactive overflow still latches immediately
- New estimatePromptTokens helper closes the lag-by-one-turn and
first-send-is-0 gaps in lastPromptTokenCount
- Hard-tier rescue pulls reactive overflow recovery forward to before
the API call, saving an oversized round-trip
- /context command displays the three-tier ladder + current tier
- tipRegistry's context-* tips track the new thresholds instead of
fixed 50/80/95 percentages
BREAKING CHANGE: chatCompression.contextPercentageThreshold setting is
removed. Settings files containing the field log a one-line deprecation
warning at startup and the value is ignored; behaviour is now controlled
by built-in thresholds via the new computeThresholds() function.
Design: docs/design/auto-compaction-threshold-redesign.md
Plan: docs/plans/2026-05-14-auto-compaction-threshold-redesign.md
* test(core): fix leftover hasFailedCompressionAttempt option in compress test
A pre-existing test case at chatCompressionService.test.ts:678 still
passed `hasFailedCompressionAttempt: false` in the CompressOptions
shape; rebasing onto current main surfaced this as a typecheck error
because the field was renamed to `consecutiveFailures` (Task 7 of the
three-tier ladder migration). Update to `consecutiveFailures: 0` —
semantically equivalent, the test asserts the side-query is called
when `force: true`, no other behaviour change.
* fix(core): drop compaction summary when output hits maxOutputTokens cap
Adds a defensive guard in ChatCompressionService.compress() that detects
when the side-query summary hit COMPACT_MAX_OUTPUT_TOKENS (20K). In that
case the summary is likely truncated mid-content, so we drop it and
return NOOP rather than persist a half-summary. The next send re-tries;
reactive overflow still catches the catastrophic case where the API
rejects the next request as too large.
Documented in the design doc as risk #2; the bot reviewer on PR #4168
correctly pushed for it to land alongside the threshold redesign rather
than as a follow-up since the new 20K cap is what makes truncation
likely in the first place.
* fix(cli): render three-tier thresholds in /context TUI view
The Task 11 redesign updated the non-interactive text formatter
(formatContextUsageText) but left ContextUsage.tsx — the interactive
React component that real /context users see — unchanged. As a result
the TUI still showed the old single "Autocompact buffer" line and none
of the new warn/auto/hard ladder.
Adds a "Compaction thresholds" section after the per-category breakdown:
- Effective window
- Warn / Auto / Hard threshold rows with a ▶ marker on the row the
current usage has crossed
- Current tier label coloured by severity (safe→green, warn/auto→
yellow, hard→red)
The existing progress bar legend (Used / Free / Autocompact buffer)
is preserved because it's tied to the three-segment progress bar
visualisation; the new section adds the absolute numbers + tier badge
on top of that.
Caught by the tmux e2e test (PR #4168 ci-monitor follow-up). Pre-fix
the assertion 'Compaction thresholds' missed completely from the TUI;
post-fix the new section renders correctly for fresh and live sessions
on 1M / 200K / 128K windows.
* fix(core,cli): address PR #4168 review batch 4
Behavior fixes:
- MAX_TOKENS truncation guard now returns COMPRESSION_FAILED_EMPTY_SUMMARY
instead of NOOP so the consecutive-failure breaker actually trips after
repeated max-length summaries (R1.1).
- Reactive overflow failure increments consecutiveFailures by 1 instead
of latching to MAX in one shot, so a transient network blip doesn't
permanently disable auto-compaction. The hard-tier rescue resets the
counter, which remains the designated recovery path (R1.2).
- /context current-tier classification uses rawOverhead (system + tools +
memory + skills) as the tier input when API data is not yet available,
rather than 0 — large inherited contexts no longer silently show 'safe'
(R2.2).
Performance:
- sendMessageStream computes effectiveTokens ONCE and passes it through
TryCompressOptions.precomputedEffectiveTokens, so the cheap-gate inside
service.compress doesn't redo the estimation. Also fixes the
imageTokenEstimate inconsistency between the rescue and cheap-gate
paths (R1.3 + R1.4).
- Steady-state path (lastPromptTokenCount > 0) skips the costly
getHistory(true) clone — estimatePromptTokens only needs the user
message in that branch.
Code hygiene:
- BYTES_PER_TOKEN → CHARS_PER_TOKEN (inputs are char counts, not byte
counts; CJK text would mislead under the old name) (R3.1).
- Drop dead getContextUsagePercent helper + index re-export — no callers
in source after the threshold rewire (R1.5).
- Add a comment on estimatePromptTokens' first-send fallback documenting
the ~15-20K under-estimate (system prompt + tools + skills) and that
reactive overflow is the safety net (R3.3).
Tests:
- New CLI ContextUsage.test.tsx exercises the React renderer for the
three-tier section: section presence, ▶ marker placement per tier,
current-tier label coloring (R1.6).
- New chatCompressionService.test.ts case pins that a stale
contextPercentageThreshold: 0 value in user settings no longer
short-circuits compaction (R2.1).
- New tokenEstimation.test.ts case covers functionResponse (distinct
nested-parts branch from functionCall) (R3.5).
- New geminiChat.test.ts integration test exercises the real
ChatCompressionService — not a mock — for the first-send-after-
inherited-history scenario where lastPromptTokenCount=0 and only the
full-history estimate can cross the auto threshold (R3.4).
Declined: R3.2 (change `>=` to `>` on the MAX_TOKENS guard). The current
operator catches the at-cap case as suspicious, which is intentional —
landing exactly at the output cap is far more likely truncation than
clean stop given p99.99 ≈ 17K. With R1.1 in place, persistent truncations
trip the breaker after MAX_CONSECUTIVE_FAILURES so the worst case is
bounded.
* fix(core,cli): address PR #4168 review batch 5
- R5.1: tighten /context tier comment + TODO. The rawOverhead-based fix
doesn't cover `--continue` restores with many history messages (since
rawOverhead excludes messagesTokens). UI may still show 'safe' for one
render until the first send. Documented inline and added a TODO to plumb
chat history into collectContextData for same-source-of-truth as the
cheap-gate.
- R5.2a: add TODO(finish_reason) at the truncation guard. The `>= cap`
heuristic false-positives on legitimate at-cap summaries; the proper
signal is finish_reason which runSideQuery doesn't surface today.
- R5.2b: split telemetry — new CompressionStatus.COMPRESSION_FAILED_OUTPUT_TRUNCATED
enum value. Distinct from EMPTY_SUMMARY so logs/telemetry can tell
prompt-quality failures (tune prompt / splitter) from capacity failures
(raise cap / shrink splitter input). isCompressionFailureStatus()
treats both as failures so the breaker behavior is unchanged.
- R5.3: expand consecutiveFailures JSDoc to clarify it tracks
"non-force, non-hard-rescue consecutive failures" — hard-rescue resets
the counter and force=true skips increments, so the counter is the
"regular path" health signal only; reactive overflow is the real
safety net for the force-only paths.
- R5.4: document the CompressOptions field rename
(hasFailedCompressionAttempt: boolean → consecutiveFailures: number)
as an SDK breaking change in the design doc with migration guide.
* fix(core): disambiguate hard-rescue from manual /compress orphan-strip
Self-review (dual reviewer / pr-triage round 1) caught a correctness
regression in the hard-rescue path:
`sendMessageStream` calls `tryCompress(force=true)` from inside the
pre-push window when `effectiveTokens >= hard`. The service's
orphan-strip predicate at `chatCompressionService.ts:426-429` gated on
`force` alone, which conflated two distinct call shapes:
- manual `/compress` (force=true, trigger='manual'): user-initiated
between turns; trailing model funcCall IS orphaned because no
funcResponse is coming
- hard-rescue (force=true, trigger='auto'): automatic mid-turn;
trailing model funcCall is ACTIVE because its matching funcResponse
is sitting in the pending `userContent` waiting to be pushed
The strip fired for both, so a hard-rescue triggered mid tool-use loop
would drop the active funcCall. After compression returned and
`userContent` (the funcResponse) was pushed, the next API request
carried tool_result with no matching tool_use → provider validation
error.
The in-code comment at L422-424 already documented this exact
constraint for the auto-compress case (`force=false`), but reusing
`force=true` for hard-rescue silently violated the same constraint.
Fix:
- Gate `hasOrphanedFuncCall` on `compactTrigger === 'manual'` instead
of `force`. The trigger field already disambiguates intent.
- `sendMessageStream` hard-rescue now passes `trigger: 'auto'`
explicitly (without it, `force=true` defaults to `trigger='manual'`
via the `?? (force ? 'manual' : 'auto')` resolver).
Sibling audit for "force=true non-manual callsites":
- `GeminiClient.tryCompressChat` (manual /compress): correct — manual
- `sendMessageStream` hard-rescue: fixed in this commit
- `sendMessageStream` reactive overflow catch: already passes
trigger='auto'; runs AFTER API call (userContent in history), so if
it observes a trailing funcCall it IS orphaned but findCompressSplitPoint
handles the case without needing the strip
RED-first regression test added:
`preserves trailing model+funcCall under hard-rescue (force=true + trigger=auto)`
in `chatCompressionService.test.ts`. Failed against pre-fix code (the
strip dropped the funcCall); passes against the fix.
Adjacent fixes from the same triage round:
- `docs/users/configuration/settings.md`: the
`chatCompression.contextPercentageThreshold` row still said "use 0
to disable compression entirely" — code has ignored the value since
the removal commit. Marked the row REMOVED with migration guidance
pointing at the design doc.
- `packages/core/src/config/config.ts`: the deprecation warning now
tells users how to silence it (remove the key) and where to read
current behavior, instead of just announcing the removal.
- `docs/design/auto-compaction-threshold-redesign.md`: closed Open
Question 2 (small-window hard/auto collapse) — decision is to NOT
annotate `/context`, with rationale on file.
Tests: 2395 core tests passing, typecheck clean.
* docs(core): fix tier-collapse direction in auto-compaction design doc
Self-review on the 50bac974b commit caught a direction error in the
M2a Open Question 2 closure note: said `currentTier` skips `'hard'`
and goes to `'auto'` on collapsed windows, which is backwards.
`contextCommand.ts:43-44` checks `tokens >= thresholds.hard` first
(no `hard > auto` guard — that fix lives in a separate follow-up), so
when `hard === auto` the `'hard'` branch matches first and the
`'auto'` band is the empty one. Updated the rationale to describe the
actual collapse direction and cite the source-of-truth file:line.
Conclusion of the open question (don't annotate `/context`) is
unchanged — only the explanation is corrected.
* refactor(core): extract shared in-flight funcCall fixture in compression tests
The auto-compress and hard-rescue tests for "trailing funcCall is
active, not orphaned" shared a byte-identical 4-message history and
mock setup. Pull both into setupInFlightFuncCallFixture() inside the
describe block so each test only contains the scenario name, the
compress() call shape, and its own assertions.
Net -29 LOC, no behavior change.
* fix(core,cli): address PR #4345 round-2 review feedback
- geminiChat: remove pre-call consecutiveFailures reset in hard-rescue.
force=true already bypasses the breaker check in chatCompressionService;
the pre-reset was redundant on success (post-call L614 already handles it)
and *broke* the breaker on failure paths — hard-rescue failures don't
increment via tryCompress (force=true skips that branch), only the
reactive overflow path at L992 explicitly increments. With the pre-reset
the counter oscillated 0↔1 every send and MAX_CONSECUTIVE_FAILURES=3 was
unreachable. Wrote a RED test asserting the forwarded counter is the
latched value, not zero; the test failed against the old code and passes
with the reset removed.
- geminiChat: log hard-tier-rescue triggers via debugLogger.warn including
effectiveTokens, hard, and the current consecutiveFailures so operators
debugging "compaction stopped working" have a breadcrumb.
- chatCompressionService: clamp effectiveWindow to >= 0 in computeThresholds
so the value surfaced in /context stays meaningful for tiny windows
(window < SUMMARY_RESERVE). auto/warn/hard outputs are unaffected because
each is Math.max(proportional, absolute) and the proportional branch
dominates whenever the absolute branch goes negative.
- turn.ts: rewrite COMPRESSION_FAILED_OUTPUT_TRUNCATED docstring. Drop the
misleading "compression succeeded" framing (the summary is dropped and
isCompressionFailureStatus returns true) and reference the full enum name
COMPRESSION_FAILED_EMPTY_SUMMARY instead of the abbreviation.
- contextCommand.test.ts: reword the no-API-data-session test comment.
collectContextData classifies estimated sessions against rawOverhead;
with default fixtures rawOverhead lands in `safe`, but heavy
system-prompt / skill / MCP loads can push it into warn/auto/hard.
- design doc Background: prepend a blockquote clarifying the section
describes pre-redesign behavior and that the inline file:line references
point at code before PR #4345 (which removes them).
- ui/types: replace the duplicated ContextThresholds interface with a
type alias to the core's CompactionThresholds. Field-by-field copy in
contextCommand.ts becomes a direct spread. ContextUsage.tsx keeps its
CompactionThresholds React component name — the alias avoids the
collision a direct import would have caused.
- contextCommand: interpolate the actual reserve value into the
"(window − 20K reserve)" annotation so SUMMARY_RESERVE retuning doesn't
leave the text stale.
* fix(core): address PR #4345 round-3 + round-4 review feedback
R3-1: rewrite the stale "Hard-tier rescue resets the counter" comment in
the reactive-overflow path. The R2 commit removed the pre-call reset
from hard-rescue; the only counter-reset path is now the post-call
COMPRESSED branch in tryCompress. Two contradicting comments in the
same file would mislead a future maintainer tracing the lifecycle.
R3-2: rewrite the JSDoc on CompactionThresholds.hard. The "(resets
failure counter)" phrasing was true under the pre-R2 design; after R2
the hard threshold force-triggers compaction and bypasses the breaker,
but does not reset the counter (which only happens on COMPRESSED
success via the post-call branch). The type is consumed by both
geminiChat and the CLI UI (via ContextThresholds alias), so the
authoritative description had to match the actual contract.
R3-3: add a Step 3 to the hard-rescue regression test. The test title
claims "success recovers via the post-call branch" but the original
Steps 1-2 only verified the latched counter was forwarded INTO the
call. Step 3 follows up with a below-hard send and asserts the
forwarded counter is 0 — proving geminiChat.ts:614 ran on the
COMPRESSED result.
R3-4: assert effectiveWindow === 0 on the existing extreme-small-window
test and add a separate zero-window edge case. The Math.max(0, ...)
clamp from R2 was previously unasserted; a regression that removed
the clamp would go undetected.
R4-1: forward originalTokenCount on the breaker-NOOP path in
chatCompressionService.compress() to match the adjacent
threshold-NOOP path (L368-369). Returning {originalTokenCount: 0,
newTokenCount: 0} masked "breaker tripped at N tokens" as
"empty session" in telemetry dashboards.
R4-2a: add debugLogger.warn at the two consecutiveFailures increment
sites (cheap-gate path L586 and reactive-overflow path L955) when
the counter reaches MAX_CONSECUTIVE_FAILURES. The breaker is one of
the PR's headline safety features but, prior to this round, had zero
observability when it tripped. Required importing MAX_CONSECUTIVE_FAILURES
into geminiChat.ts.
R4-3: programmatically link tokenEstimation.ts's CHARS_PER_TOKEN to
compactionInputSlimming.ts's TOKEN_TO_CHAR_RATIO. Both are 4 today
and represent the same generic char/token conversion. Exporting from
compactionInputSlimming and aliasing in tokenEstimation eliminates
the silent-drift hazard the JSDoc already warned about.
Declined (round-weighted bar at round 4):
- R3-5: debugLogger test for hard-rescue trigger — observability test
coverage is overthinking at round 3+; the log is informational.
- R4-2b: expose breaker state in /context — new feature; out of scope.
- R4-4: render test for auto-tier marker — test coverage gap on
working code, defer to follow-up PR per round-weighted bar.
- R4-5a: extract makeFakeChat/makeFakeConfig shared factory — pure
test refactor at round 4, not a fix.
- R4-5b: direct unit test for precomputedEffectiveTokens — exercised
indirectly via hard-rescue path tests in geminiChat.test.ts.
- R4-6: truncation-guard fallback test for missing candidatesTokenCount
— code already has a TODO acknowledging the heuristic is imperfect
(chatCompressionService.ts:549-553); defer.
* fix(core): address PR #4345 round-5 review feedback
R5-1: assert breaker-NOOP forwards originalTokenCount. R4-1 changed the
breaker-NOOP return from `{0, 0}` to `{originalTokenCount, originalTokenCount}`
so telemetry can distinguish "breaker tripped at N tokens" from
"empty session", but the existing test only checked compressionStatus
and newHistory. Now seeds a non-zero originalTokenCount (120K) and
asserts both fields forward it.
R5-2: forward originalTokenCount on the empty-history NOOP. This was
sibling drift on R4-1 — I fixed the cited breaker-NOOP site but missed
the empty-history NOOP. Of 5 NOOP return sites in chatCompressionService,
4 now forward originalTokenCount (breaker, threshold-gate, post-split,
min-compression-fraction) and 1 (this one) was still returning `{0, 0}`,
breaking the project-wide invariant. Now consistent.
R5-3: replace 10 stale line-number references with semantic anchors.
After the R3+R4 push, the line refs in my R2/R3 comments (`geminiChat.ts:614`,
`chatCompressionService.ts:339`, `line 992`, `L627`, `line 944`) no longer
pointed at their original targets — `geminiChat.ts:614` now points at
`setSystemInstruction`'s body, completely unrelated to compaction. The
pattern itself is fragile; semantic phrasing ("the post-call reset in
tryCompress's COMPRESSED handler") doesn't drift when lines shift.
347/347 affected core tests passing locally; typecheck clean.
* fix(core): address PR #4345 round-6 review feedback (R6 sweep)
R6-1: rewrite the stale JSDoc bullet on `consecutiveFailures` (the
"Hard-tier rescue failures" bullet). The old wording said "the counter
is reset to 0 BEFORE the rescue call" — that contradicted R5 which
explicitly removed the pre-call reset. Now the bullet matches the
actual behavior: counter is NOT pre-reset, force=true bypasses the
breaker, post-call COMPRESSED handler resets on success, reactive
overflow is the explicit-increment safety net.
My R5 stale-comment sweep only grep'd inline `//` comments; this JSDoc
on the field declaration slipped through. Re-audited "reset to 0
BEFORE" / "pre-reset" across both packages — single site remaining.
R6-7: assert `passedOpts.trigger === 'auto'` in the hard-rescue test.
This field is the orphan-strip safety wire added by the C1 fix (the
service's `compactTrigger === 'manual'` check would otherwise strip
the trailing active funcCall mid tool-loop). The test asserted force
and pendingUserMessage but not the trigger; a refactor dropping the
'auto' from `trigger: shouldForceFromHard ? 'auto' : undefined` would
silently break orphan-strip safety. Now regression-guarded with a
single-line expect.
164/164 affected core tests passing locally.
Declined per round-weighted bar (round 6 defaults Suggestion / Test
coverage / Style to overthinking):
- R6-2/3/6: test-coverage gaps on working code — defer to follow-up
- R6-4: redundant truthy guard on always-set fields — style nit
- R6-5: text-vs-UI inconsistency on /context — existing test enforces
current behavior; treat as design decision (offer follow-up if
reviewer escalates)
- R6-8 (tipRegistry small-window context-high): explicitly closed in
design doc's Open Question 2 — small windows have empty context-high
band by design; UI work is out-of-scope for this PR
- R6-9: wasted clone on rare fallback path — Suggestion-level perf
- R6-10 (CompressionMessage missing case): file not in this PR's diff;
reviewer themselves proposed it as follow-up
* feat(telemetry): support custom resource attributes and add metric cardinality controls
Resolves#4365.
Adds two coupled OpenTelemetry capabilities to make qwen-code's telemetry
production-ready in multi-team / multi-tenant deployments:
1. Custom resource attributes via standard `OTEL_RESOURCE_ATTRIBUTES` and
`OTEL_SERVICE_NAME` env vars and a new `telemetry.resourceAttributes`
setting. Operators can now tag every span / log / metric with `team`,
`env`, `cost_center`, or anything else their backend needs.
2. Metric cardinality controls. `session.id` is moved off the OpenTelemetry
Resource (where it auto-attached to every metric data point and caused
unbounded time-series fan-out on Prometheus / ARMS Metric / etc.) and
gated behind a new opt-in `telemetry.metrics.includeSessionId` toggle.
Spans and logs still carry `session.id` for trace and log correlation.
Reserved keys (`service.version`, `session.id`) are stripped from both env
and settings sources with a `diag.warn`. `OTEL_SERVICE_NAME` follows the
OTel spec precedence (highest priority for `service.name`). Settings JSON
values are runtime-coerced to strings as defense against hand-edited
non-conforming JSON.
Breaking change: metrics no longer carry `session.id` by default. Operators
who need it can restore the previous behavior with
`QWEN_TELEMETRY_METRICS_INCLUDE_SESSION_ID=true` or
`telemetry.metrics.includeSessionId: true` in settings.json; recommended
only for short-term debugging since it re-introduces the cardinality
problem. For long-term session-level analysis, prefer trace and log
backends which handle per-event data without cardinality pressure.
Design doc: docs/design/telemetry-resource-attributes-design.md
🤖 Generated with [Qwen Code](https://github.com/QwenLM/qwen-code)
* docs(telemetry): align reserved-key descriptions with implementation
Round 1 review fixes (#4367). After session.id was added to
RESERVED_RESOURCE_ATTRIBUTE_KEYS in Codex review, four user-facing
descriptions still claimed only service.version was reserved:
- packages/core/src/telemetry/config.ts (merge comment)
- packages/core/src/config/config.ts (TelemetrySettings JSDoc)
- packages/cli/src/config/settingsSchema.ts (schema description)
- packages/vscode-ide-companion/schemas/settings.schema.json (regenerated)
Also corrects scope claim: resource attributes apply to every signal
the SDK exports (OTLP and file outfile share the same Resource), not
just OTLP.
🤖 Generated with [Qwen Code](https://github.com/QwenLM/qwen-code)
* docs(telemetry): clarify warning destination and surface percent-encoding hint
Round 2 self-review fixes (#4367). Two small but real UX gaps:
1. Reserved-key / malformed-pair / coerce warnings route to the debug
log (per #3986), not the console — so a user who types
`OTEL_RESOURCE_ATTRIBUTES=service.version=2.0` sees no feedback that
the value was silently dropped. Adds a "Troubleshooting" section in
telemetry.md telling users where to look, and a note in the parser
docstring documenting where warns go.
2. A literal (unencoded) comma in an env var value is a common foot-gun:
the parser splits on it, producing a malformed second half that is
silently dropped. Updates the warn text to include a "hint:
percent-encode literal commas as %2C" callout, and adds the same
guidance to the docs.
Deferred to a follow-up: startup-time stderr summary of dropped
attributes. Stderr during TUI render could break Ink rendering, so the
right surface needs separate design.
🤖 Generated with [Qwen Code](https://github.com/QwenLM/qwen-code)
* test(telemetry): cover first-`=` split contract in OTEL_RESOURCE_ATTRIBUTES parser
Per review feedback on #4367. The parser uses `indexOf('=')` so
the first `=` separates key and value while subsequent `=` stay in
the value. The behavior was correct but untested; a future refactor
to `split('=')` would silently break base64-padded, JWT, or
connection-string values.
🤖 Generated with [Qwen Code](https://github.com/QwenLM/qwen-code)
* feat(telemetry): tighten resource-attribute input validation + startup summary
Adopts review feedback from #4367 (wenshao via Qwen Code /review).
Five accepted suggestions, bundled because they all touch the same
parse/coerce/strip pipeline:
1. Key percent-decoding (CRITICAL). `parseOtelResourceAttributes` now
percent-decodes both keys and values per the OTel / W3C Baggage spec.
Without this, `OTEL_RESOURCE_ATTRIBUTES=service%2Eversion=99` lands
on Resource as the literal key `service%2Eversion`, bypassing the
reserved-key filter; a collector that decodes keys downstream could
then resurrect `service.version` and spoof the version label.
2. Startup summary of dropped attributes. Every `diag.warn` in
resource-attributes.ts routes only to the OTel debug log (per
#3986), giving operators zero feedback when their attributes are
silently dropped. Helpers now optionally accumulate diagnostics
into a `ResourceAttributeWarnings` array; the resolver collects
them and the SDK emits a one-time console summary at init (before
Ink renders, so no TUI conflict).
3. `||` instead of `??` for service.name fallback. Settings can put
an empty string through `??`, producing a blank `service.name`
that some backends reject. `||` falls through to the default.
4. `coerceStringResourceAttributes` now trims keys and skips
empty/whitespace-only keys, matching `parseOtelResourceAttributes`.
Previously `{" ": "x"}` or `{"team ": "y"}` from settings.json
would land as malformed Resource attributes.
5. `OTEL_SERVICE_NAME` is trimmed before the truthy check, so values
like `' '` or `'\t'` are treated as unset rather than producing
a whitespace-only service name on Resource.
One suggestion declined (in-thread reply on PR):
- "Redundant `?? {}` in sdk.ts:160" — intentional defense-in-depth for
`vi.mock('../config/config.js')` callers in `telemetry.test.ts` where
auto-stub returns undefined. The reviewer is right that production
code paths never hit it, but tests do.
🤖 Generated with [Qwen Code](https://github.com/QwenLM/qwen-code)
* fix(telemetry): trim whitespace-only service.name + add invalid-key-encoding test
Adopts two review suggestions on #4367 (wenshao via Qwen Code /review):
1. `service.name` fallback uses `.trim() || SERVICE_NAME` instead of plain
`||`. Plain `||` lets whitespace-only values (`" "`, `"\t"`) through as
truthy, producing a blank service name on Resource that some backends
reject. Both settings (no value trimming) and env (`%20` decodes to `" "`)
can deliver such values. Test added.
2. Adds `key%ZZ=val` to the parameterized parser test to cover the
invalid-percent-encoding-on-key catch branch. Previously only the
value-side catch was tested.
🤖 Generated with [Qwen Code](https://github.com/QwenLM/qwen-code)
* docs: add OOM investigation reports and auto-compaction redesign proposal
- Runtime memory investigation plan
- Non-interactive memory benchmark report
- OOM reproduction report with 2GiB/4GiB synthetic tests
- Runtime diagnostics benchmark report
- Auto-compaction threshold redesign proposal
* fix(core): replace structuredClone with shallow copy to prevent OOM
Replace `structuredClone(this.history)` (called up to 4x per turn on the
send path) with a lightweight shallow copy via `copyContentContainer()`.
This eliminates the OOM root cause in long tool-heavy sessions where the
full deep clone exceeded remaining V8 heap headroom.
Key changes:
- Add `copyContentContainer()` helper ({...content, parts: [...parts]})
- Add `getRequestHistory()` private method for the send path
- Add `getHistoryShallow()`, `getHistoryTailShallow()`,
`peekLastHistoryEntry()`, `getLastModelMessageText()`,
`getHistoryLength()` for read-only callers
- Remove HEAP_PRESSURE_COMPRESSION_RATIO safety net (no longer needed
now that the underlying OOM cause is fixed)
- Update chatCompressionService to use getHistoryShallow(true)
- Update nextSpeakerChecker to send only lastMessage (not full history)
- Update memoryDiagnostics with process-tree RSS measurement
* feat(core): add runtimeDiagnostics utility for heap/memory instrumentation
Required by content generators (anthropic, openai, logging) which import
runtimeDiagnostics for optional heap-pressure telemetry during streaming.
Gated by QWEN_CODE_PROFILE_RUNTIME=1 environment variable.
* fix(cli): update doctorCommand test mocks for new MemoryDiagnostics interface
Add missing maxRSSRaw, maxRSSUnit, and processTree fields to test fixtures
to match the updated MemoryResourceUsage and MemoryDiagnostics interfaces.
* fix(vscode-ide-companion): use public core imports
* fix: address review comments — type guards, dead fallbacks, and doc accuracy
Code:
- Fix unsound type guard: `'text' in part` → `typeof part.text === 'string'`
in geminiChat.ts and client.ts (Copilot + wenshao feedback)
- Remove unnecessary optional chaining and dead fallback chains in client.ts
(getHistoryShallow, peekLastHistoryEntry, getHistoryLength, etc. now call
GeminiChat methods directly)
- Add 5s timeout to `execFileAsync('ps', ...)` in memoryDiagnostics.ts
Docs:
- Fix GiB conversion accuracy and add single-run caveat to summary
- Add Node.js version to test environment table
- Fix auto-compaction attempt count (5→4) in OOM report
- Soften root-cause attribution certainty
- Add MCP child process context to investigation plan
- Clarify "Codex" reference (→ OpenAI Codex)
- Fix truncated MCP server name (chrome → chrome-devtools)
- Remove duplicate verification commands in benchmark table
- Clarify thread exhaustion vs V8 heap OOM distinction
- Add workload confound caveat to before/after comparison
- Fix SUMMARY_RESERVE "hard relationship" vs thinking budget contradiction
* fix(core): restore fallback chains in client.ts for mock compatibility
The previous commit removed optional chaining from client.ts wrapper
methods, but client.test.ts mocks getChat() with partial objects that
lack the new shallow methods. Restore ?. fallback chains so both
production (GeminiChat) and test (mock) paths work correctly.
* docs: clarify memory review follow-ups
* docs: fix runtime benchmark unit conversion
* docs: add default-heap OOM stress report
* fix: update copyright year to 2026 in new files [skip ci]
New files added in this PR had 2025 copyright headers. Updated to 2026
to reflect the current year.
* docs(worktree): update design doc — split Phase C/D, add Future section
- Phase C: session persistence + hooksPath + StatusLine + WorktreeExitDialog
- Phase D: --worktree CLI flag + symlinkDirectories
- Future: sparse checkout, .worktreeinclude, tmux, PR reference parsing
- Feature comparison table updated with Phase A/B completion status
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* docs(worktree): add Phase C implementation plan
8 tasks: WorktreeSession sidecar storage, hooksPath setup,
EnterWorktree/ExitWorktree session wiring, useWorktreeSession hook,
Footer display, --resume context injection, WorktreeExitDialog.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* docs(worktree): update Phase C plan after claude-code comparison
- WorktreeSession: add originalHeadCommit field
- hooksPath: add .husky/ detection + skip-if-already-set logic
- StatusLine payload: expand worktree field to match claude-code schema
- WorktreeExitDialog: load dirty state on mount, display counts in dialog
- UIState.activeWorktree: add originalCwd, originalBranch, originalHeadCommit
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* feat(worktree): add WorktreeSession sidecar storage
New worktreeSessionService.ts exposes read/write/clear functions for the
sidecar JSON file at <chatsDir>/<sessionId>.worktree.json. SessionService
gains getWorktreeSessionPath() so callers don't need to know the layout.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(worktree): configure core.hooksPath after worktree creation
createUserWorktree() now sets `core.hooksPath` inside the new worktree to
the main repo's hooks directory (.husky preferred, .git/hooks fallback) so
commits inside the worktree run the same pre-commit checks as the main
repo. Mirrors claude-code's performPostCreationSetup logic — skips the
subprocess when the value already matches to avoid ~14ms spawn overhead.
Failures are non-fatal: the worktree is still usable without hooks.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(worktree): persist WorktreeSession sidecar in EnterWorktreeTool
After creating a worktree, EnterWorktreeTool now writes a sidecar JSON
file at <chatsDir>/<sessionId>.worktree.json with the full session state
(slug, paths, branches, original HEAD SHA). --resume reads this in Phase
C task 7 to restore worktree context. Best-effort: write failures don't
abort the creation.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(worktree): clear WorktreeSession sidecar in ExitWorktreeTool
After successful keep or remove, ExitWorktreeTool now clears the sidecar
JSON file iff its slug matches the worktree being exited. The slug check
prevents wiping the sidecar when the user exits a worktree that isn't
currently tracked (multiple worktrees on disk, sidecar tracks one).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(worktree): expose active worktree via useWorktreeSession + UIState
New useWorktreeSession hook watches the sidecar JSON file (created by
EnterWorktreeTool, deleted by ExitWorktreeTool) and returns the current
WorktreeSession or null. AppContainer wires it into a new
UIState.activeWorktree field consumed by Footer (Task 6) and
WorktreeExitDialog (Task 8).
A showWorktreeExitDialog state placeholder is added too, hardcoded false
until Task 8 wires the dialog trigger.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(worktree): show active worktree in Footer + StatusLine payload
Footer renders `⎇ <branch> (<slug>)` when activeWorktree != null, but
only when the user has no custom statusline (their script likely
handles it from the stdin payload itself).
useStatusLine's StatusLineCommandInput gains a `worktree` field with
{name, path, branch, original_cwd, original_branch} — matches claude-code's
schema so statusline scripts can be shared across both CLIs.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(worktree): inject context hint on --resume when worktree is active
On --resume, if the session has a WorktreeSession sidecar, append an
INFO history item pointing the model at the worktree path so it
continues using it for file operations. Stale sidecars (worktree dir
deleted out-of-band) are cleaned up so the Footer indicator doesn't
go stale.
qwen-code can't process.chdir() the way claude-code does because
Config.targetDir is immutable; the context hint is the equivalent
behavioral cue.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(worktree): add WorktreeExitDialog with dirty-state inspection
WorktreeExitDialog renders when the user double-presses Ctrl+C inside a
worktree. On mount it runs `git status --porcelain` and
`git rev-list --count <originalHeadCommit>..HEAD` to show how many
uncommitted files and new commits the user would discard by choosing
"Remove". The dialog never auto-removes — every exit goes through
explicit user confirmation per requirements.
handleExit in AppContainer intercepts the second-press quit when
activeWorktree is set and shows the dialog instead. A new UIAction
handleWorktreeExit(choice) routes the user's choice through removal
(via GitWorktreeService.removeUserWorktree) + sidecar cleanup + /quit.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* docs(worktree): add Phase C E2E test plan
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* docs(worktree): fix E2E test plan sidecar path + jq selector
- sidecar lives at ~/.qwen/projects/<sanitized-cwd>/chats/, not ~/.qwen/tmp/<hash>/
- qwen --output-format json emits a JSON array, not NDJSON — jq needs .[]
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): add showWorktreeExitDialog to dialogsVisible
Phase C task 8 introduced showWorktreeExitDialog state and the dialog
render in DialogManager, but missed adding the flag to the dialogsVisible
OR expression. DefaultAppLayout only renders DialogManager when
dialogsVisible is true, so the dialog was never shown — second Ctrl+C
in a worktree silently absorbed instead of triggering the prompt.
Caught by Group E E2E tests.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* feat(worktree): extend --resume context restore to headless + ACP modes
Phase C task 7 originally placed the worktree-restore logic in
AppContainer.tsx (TUI only). E2E Group C exposed that headless and ACP
modes never run AppContainer, so stale sidecars accumulate and the model
loses worktree context after --resume.
Refactor to a shared `restoreWorktreeContext` helper in core, then wire
the three entry points:
- TUI (AppContainer): keep historyManager.addItem(INFO) UX, route via
the helper.
- Headless (nonInteractiveCli): prepend the notice as a system-reminder
block on the user prompt; emit a `worktree_restored` system message to
the JSON adapter so SDK consumers can react.
- ACP (Session.pendingWorktreeNotice): set by acpAgent.loadSession on
resume, consumed and cleared exactly once on the next #executePrompt.
All three modes call the same helper, so stale-sidecar cleanup is
consistent. Helper covers: missing sidecar, live worktree dir,
deleted worktree dir, regular file at worktreePath, malformed JSON.
5 new unit tests for restoreWorktreeContext (13/13 pass total).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* test(worktree): add ACP-mode integration tests for --resume context
Covers:
- acpAgent.worktree.test.ts (3 tests): loadSession sets
pendingWorktreeNotice only when worktree dir is live, clears
stale sidecar otherwise, swallows restoreWorktreeContext errors.
- Session.worktree.test.ts (4 tests): #executePrompt prepends the
system-reminder block exactly once on first prompt, clears the
pending notice, second prompt sees no leakage, no-op when nothing
was set.
E2E via real ACP protocol is impractical without a Zed client; these
tests cover the integration boundaries directly.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* docs(worktree): clarify hooksPath comment + pendingWorktreeNotice one-shot rationale
Two doc-only fixes from PR #4174 review:
- gitWorktreeService.ts: previous hooksPath comment overstated the
optimization (claimed claude-code's ~14ms saving but we still do a
read subprocess). Rewrite to be explicit: write-skip only, read
retained, parseGitConfigValue's full optimization deliberately not
ported because the read happens once per worktree creation.
- Session.ts: pendingWorktreeNotice doc now explains why it's one-shot
(after the first prompt the worktree path is already in conversation
context; re-injecting would clutter history without adding signal).
No behavior change.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(test): add getResumedSessionData to nonInteractiveCli mock Config
CI surfaced TypeError: config.getResumedSessionData is not a function
across 12 tests in nonInteractiveCli.test.ts. The Phase C ada0837e2
commit added a worktree-restore call in the headless path that probes
config.getResumedSessionData(); the mock Config never had that method.
Return undefined to short-circuit the restore block — these tests
don't exercise --resume.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address PR #4174 reviewer findings
Bundled response to the two review rounds. Per-thread replies follow.
CORE — worktree sidecar robustness (Findings 3252368644, 3252368651, 3255171690):
- atomicWriteJSON instead of fs.writeFile (no more half-written sidecar after a crash)
- readWorktreeSession now schema-validates the parsed object and returns null
on missing/wrong-type fields instead of propagating undefined into consumers
- restoreWorktreeContext clears the sidecar on JSON parse failure / read I/O
error so a corrupted file doesn't block every subsequent --resume
CORE — hooksPath setup (Finding 3252368645):
- configureHooksPath distinguishes ENOENT (benign "candidate not present")
from real stat errors (EACCES/EIO/ENOTDIR); the latter are warn-logged
so a silently-degraded hooksPath is visible to operators
CLI — handleWorktreeExit Remove path (Findings 3252368637, 3252368640 a+b):
- Anchor GitWorktreeService at activeWorktree.originalCwd (the captured
repo root), not config.getTargetDir() — fixes monorepo-subdirectory
launches where the worktree lives under the repo root but getTargetDir
points at a subpackage
- Check removeUserWorktree return value; on failure, leave the sidecar
intact so --resume can recover (previous code cleared it regardless)
- Pass forceDeleteBranch:true to honour the dialog's "discards N commits"
label — without it `git branch -d` refused unmerged commits and the
branch was silently preserved
CLI — useWorktreeSession watcher (Finding 3252368648):
- Normalize fs.watch filename via toString() so the Linux-Buffer code
path triggers reloads (previous comparison silently never matched)
- Treat null filename as "unknown, reload to be safe" (recursive watchers
on some platforms emit events without a payload)
CLI — WorktreeExitDialog (Findings 3252368650, 3255171694):
- execGit now correctly reads numeric exit codes from .code/.status
(NodeJS.ErrnoException.code is a string for spawn errors, number for
subprocess exits); previous typeof === 'number' check always missed
- Dialog body shows an "⚠ Could not measure worktree state (...)" banner
when git status / rev-list failed, so the user doesn't see a misleading
"0 files, 0 commits" before choosing Remove
CLI — closeAnyOpenDialog (Round 2 review body):
- Wire WorktreeExitDialog into the standard dialog-dismissal path so
Ctrl+C dismisses it the same way it dismisses every other dialog
TEST FIXES — vitest timeouts:
- Real git invocations + user-global hooks (e.g. trustup post-commit
webhooks) can take 10–20s per setUp on CI. Bump testTimeout +
hookTimeout to 30s for the three integ test suites that spawn git
(Phase B/C worktree integ tests) so the suite isn't flaky.
NEW TESTS:
- worktreeSessionService.test: 3 new cases covering malformed JSON,
missing required fields, wrong-type fields, malformed sidecar cleanup,
partial sidecar cleanup (16 total, up from 13).
- useWorktreeSession.test.tsx: 4 new cases — null when no sidecar,
parsed sidecar at mount, reacts to delete, reacts to creation.
- WorktreeExitDialog.test.tsx: 1 new case — loading frame renders before
git probes resolve. (Async dialog states tested via E2E — vi.mock of
execFile in ink-testing-library doesn't fire mock impl reliably.)
- nonInteractiveCli.test: 3 new "Phase C --resume" cases — system-reminder
injection on live worktree, no injection when sidecar absent, stale
sidecar cleanup when worktree dir is gone.
DECLINED FINDINGS (replied on threads):
- 3252368642 (Dialog Keep clears sidecar) — declined-design. Dialog
Keep = "exit app, keep worktree for next --resume"; tool Keep =
"I'm done with this worktree". Intentionally different semantics.
- 3252368643 (originalHeadCommit base branch) — false-positive. There
is no base_branch parameter; getCurrentCommitHash() returns HEAD which
equals the tip of the current branch (== baseBranch in createUserWorktree).
- 3252368640 part c (bypass safety guards) — declined-design. The
dialog IS the safety affordance for this path — it shows dirty-state
counts and asks for explicit user confirmation before removal.
- 3255171696 (DialogManager async fire-and-forget) — false-positive.
handleSlashCommand('/quit') is inside the await chain in
handleWorktreeExit, so the described race ("process.exit before remove
completes") cannot occur.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(test): correct linter-mangled imports in useWorktreeSession.test
Pre-commit hook auto-fixed imports collapsed value imports
(writeWorktreeSession, clearWorktreeSession) into an `import type`
block, breaking runtime resolution. Split back into value + type imports.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(test): normalize path separators for Windows in worktree session integ
Windows CI failure: `repoRoot` from Node's `fs.mkdtemp` returns
backslash-separated paths (`C:\Users\runneradmin\…`), but
`originalCwd` in the sidecar comes from `getRepoTopLevel()` which
delegates to `git rev-parse --show-toplevel` — git on Windows
returns forward slashes (`C:/Users/runneradmin/…`).
The Windows-only assertion `expect(originalCwd).toBe(repoRoot)` was
comparing two different representations of the same canonical path
and rightly failed on `Object.is` equality. Compare via path.normalize
on both sides so the assertion holds across platforms without
changing the runtime path (originalCwd still records git's output
verbatim, which is what consumers expect since other places in the
codebase that read `getRepoTopLevel()` also work with that shape).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address PR #4174 round 4 findings
Finding #3256237933 (Critical, follow-up to #3252368640 part 1):
handleWorktreeExit silently /quit'd when removeUserWorktree returned
{success:false}, contradicting the user's intent after they clicked
"Remove worktree and branch (discards N commits, M files)". Now
surfaces an ERROR history item with the underlying error message
and STAYS in the session so the user can decide what to do
(retry via exit_worktree, fix the lock/permission/corruption issue,
or quit anyway). Same treatment applied to the hard-failure catch
block — previously it caught the throw and proceeded to /quit with
no log; now it emits the error and stays alive.
Finding #3256236050 (Nit): originalCwd field name implies "user's
launch cwd" but actually stores `getRepoTopLevel()` (different in
monorepo subdir launches — the gap closed by #3252368637). Renaming
the field would force on-disk migration of every existing sidecar
(every active --resume breaks until users wipe the old file).
Doc-only fix: WorktreeSession.originalCwd now carries an explicit
JSDoc explaining the semantics and warning consumers expecting
process.cwd() to NOT use this field.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address PR #4174 round 5 findings
Finding #3256241831 (Nit, but awareness UX): the built-in `⎇`
indicator used to disappear whenever `statusLineLines.length > 0`,
on the assumption that the user's custom statusline rendered worktree
itself. That assumption is unsafe — scripts written before Phase C
don't know about `payload.worktree`, scripts can deliberately ignore
the field, and partial scripts may render some fields but not
worktree. In any of those cases the user sees no worktree UI while
having an active worktree, risking destructive operations in the
wrong cwd. New behavior: indicator shows by default regardless of
statusline. Added an opt-out setting `ui.hideBuiltinWorktreeIndicator`
(default false) for users whose custom statusline already renders
worktree and want to avoid duplication.
Finding #3256239608 (Nit): `fs.watch` in useWorktreeSession holds
an inode handle to `chatsDir` at mount time. If the directory is
deleted out-of-band (manual cleanup, antivirus quarantine, reset
scripts) and recreated, the watcher does NOT re-attach to the new
inode and the Footer indicator stops reacting to sidecar changes.
Reviewer explicitly accepted this as a documented limitation rather
than adding polling-fallback or error-event-handler complexity for
an edge case that doesn't arise in normal use. Added a JSDoc block
on the hook explaining the limitation and pointing to the future
fix shapes.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* chore(worktree): regenerate settings.schema.json for hideBuiltinWorktreeIndicator
CI Lint step caught that the JSON schema mirror in
packages/vscode-ide-companion was out of date after adding the new
ui.hideBuiltinWorktreeIndicator setting in 80f9cb495. Regenerated
via `npm run generate:settings-schema`.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address PR #4174 round 6 findings
Critical fixes:
- #3259975247: TUI dialog Remove now reads the in-worktree session
marker and refuses to delete a worktree owned by a different
session — same ownership guard ExitWorktreeTool already applies.
Stale/copied sidecars can no longer destroy another session's work.
- #3259975249: TUI --resume queues a one-shot pendingWorktreeNotice
ref consumed by handleFinalSubmit; the user's first prompt is
prefixed with the same <system-reminder> block headless/ACP use.
Previously only the INFO history item showed in the transcript
(UI-only), so resumed models could silently edit the parent
checkout.
- #3259975245: exit_worktree action='keep' no longer clears the
sidecar. `keep` means "preserve the worktree for later"; clearing
the persisted binding broke --resume / Footer / WorktreeExitDialog
for kept worktrees. Now matches the Dialog keep semantics. Test
updated to assert preservation instead of clearing.
- ACP unstable_resumeSession parity: factored the worktree restore
block into #restoreWorktreeOnResume() and called from both
loadSession() and unstable_resumeSession(). ACP clients using
resume no longer miss the worktree context.
Suggestion-level fixes:
- #3259975237: configureHooksPath now resolves the canonical hooks
dir via `git rev-parse --git-common-dir` instead of constructing
`<sourceRepoPath>/.git/hooks`. The construction assumed .git is a
directory, but when Qwen runs from a linked worktree it's a file
pointing at the real gitdir → ENOTDIR → silent no-hooks worktree.
- #3259975242: only writes core.hooksPath when the key is unset.
A non-empty inherited or user-configured value is preserved
instead of being silently replaced.
- #3256839787: restoreWorktreeContext adds a structural invariant
check — worktreePath must live under <originalCwd>/.qwen/worktrees/.
A tampered/copied sidecar pointing at an arbitrary existing dir
is rejected and cleared so the model can't be redirected.
Tests:
- worktreeSessionService.test: 17/17 (added prefix-escape rejection
case + restructured the existing live-worktree case to satisfy
the new structural invariant).
- exit-worktree.session.integ.test: rewrote keep test to assert
preservation (matches new behavior).
- nonInteractiveCli.test: updated fixture worktreeDir to live
under <originalCwd>/.qwen/worktrees/ for the prefix invariant.
- All other suites pass without modification.
Test coverage gap acknowledgement (no comment_id reply): per-handler
unit tests for handleWorktreeExit + dialog post-load states remain
covered by the E2E Group E suite in docs/e2e-tests/worktree-phase-c.md.
The execFile mock path in ink-testing-library still doesn't deliver
async useEffect state transitions reliably, so unit testing those
states adds more harness than signal; deferring.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
* docs: add async memory recall design spec and implementation plan
* refactor(core): introduce MemoryPrefetchHandle, replace pendingRecallAbortController field
* refactor(core): fire memory recall as non-blocking prefetch with settledAt flag
* refactor(core): replace blocking await with zero-wait settledAt poll at UserQuery consume point
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* feat(core): inject recalled memory on first ToolResult when UserQuery consume point misses
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* refactor(core): replace pendingRecallAbortController with pendingMemoryPrefetch in all cleanup paths
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* refactor(memory): remove 1s AbortSignal.timeout from relevanceSelector — caller controls lifetime
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* test(core): update auto-memory tests for async prefetch pattern — drop fake timers and deadline references
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* test(core): add ToolResult inject test — memory injected on first ToolResult when recall settles after UserQuery
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* fix(core): address codex review findings on async memory recall
Three findings fixed:
1. Abort previous prefetch before installing a new one (line 1059):
A new UserQuery/Cron used to overwrite pendingMemoryPrefetch without
aborting the old controller, leaking an unbounded background recall now
that the 1s side-query timeout is gone.
2. Move the UserQuery consume poll AFTER the async reminder setup:
ensureTool + listSubagents are awaited between the old poll location and
the final assembly, so recalls that settled during those awaits used to
be missed (and a tool-less turn never got a ToolResult retry). The poll
now runs immediately before requestToSend assembly, and unshifts memory
to the front of systemReminders to preserve ordering.
3. Append memory after functionResponse on ToolResult turns:
The Qwen API requires the functionResponse part to immediately follow
the model's functionCall (see lines 1209-1213). Prepending memory text
risked breaking that pairing on the native Gemini path. Appending keeps
the pair intact on Gemini and produces the same OpenAI output (text
becomes a separate user message after the tool messages).
Tests:
- Updated ToolResult inject test to assert memory index > functionResponse
- Added abort-previous-prefetch test (mid-flight UserQuery aborts old handle)
224/224 tests pass; tsc clean on changed files.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* docs(core): add JSDoc + clarifying comments per review feedback
Annotations only, no behavior change:
- MemoryPrefetchHandle: full JSDoc covering lifecycle (create → consume → discard)
- UserQuery consume site: explain why we unshift (front of systemReminders)
- ToolResult inject site: reference hasPendingToolCall pattern instead of
brittle line numbers when citing the Qwen functionCall/Response constraint
- relevanceSelector.ts: explain why the side-query has no inline timeout
(caller controls lifetime via MemoryPrefetchHandle.controller)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* fix(core): bridge caller abort signal into memory prefetch + doc accuracy fixes
Behavior fix (addresses copilot review on client.ts:1071):
- When the parent sendMessageStream signal aborts (user Ctrl-C / Esc),
the prefetch controller now aborts too. Previously the recall side-query
would keep running until a later cleanup (next UserQuery / /clear / etc),
wasting fast-model tokens on work whose result no one would consume.
- Listener uses { once: true } and is also removed in the promise's
finally() so a long-lived parent signal doesn't accumulate listeners
across many turns under normal completion.
- Edge case: if signal is already aborted when fire runs, abort the
controller synchronously instead of attaching a listener.
Test:
- New regression guard: "should abort the pending prefetch when the caller
signal aborts" — verifies the abort handler installed on the recall side
fires once the parent signal aborts.
Doc accuracy (addresses copilot review on the design spec):
- ToolResult inject: was documented as "prepend", actual implementation
appends to preserve functionCall/functionResponse pairing. Updated both
the prose summary and the code sample.
- Cleanup section: was documented as 6 abort-locations including the
"post-consume clear"; the consume sites don't actually abort (the promise
has already settled). Reorganized as 5 abort-and-clear sites + 2
clear-only sites with the distinction made explicit.
- Fire path snippet: added the abort-previous-prefetch line and the
caller-signal bridge so the spec matches the current implementation.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* refactor(core): consolidate memory-prefetch lifecycle + safety nets per round-3 review
Architectural (root-cause fix for cleanup-path sibling drift):
- New private cancelPendingMemoryPrefetch() consolidates the abort+clear
idiom (was duplicated across 6 sites). Logs at debug when discarding a
settled-but-unconsumed handle so missing-memory scenarios are diagnosable.
- New private tryConsumeMemoryPrefetch() consolidates the
consume-and-mark-consumed dance (was duplicated UserQuery + ToolResult).
- All existing cleanup sites + the two newly-flagged early-return sites
(LoopDetected, Error) now use the helper; future early-returns can rely
on the finally-block safety net.
- sendMessageStream try-finally now uses a `normalCompletion` flag:
only the bottom-of-try return path preserves the prefetch (intentional
— next ToolResult turn may consume it); every other exit (uncaught
exception, abnormal early-return) goes through cancelPendingMemoryPrefetch
in finally.
Diagnostics:
- Restored AbortError debug log in fire-path catch (was silent after
removing the deadline mechanism; aborts now come from 4+ sources so a
trace is valuable).
- Updated stale "deadline" log in recall.ts to reflect current abort
sources (caller signal / new UserQuery / cleanup / 30 s safety timeout).
Safety net:
- Added 30 s ceiling in relevanceSelector via AbortSignal.any(...).
Generous enough that normal ~1 s recalls don't trip it; bounds zombie
side-queries if the model API hangs and the caller never aborts.
Replaces the uncancellable `new AbortController().signal` fallback that
would have left callerless invocations running indefinitely.
Doc sync:
- Design doc updated: UserQuery consume code sample now shows `unshift`
(matches implementation) with an inline note on the prepend-vs-append
contrast.
Tests:
- New regression guard: resetChat aborts pending prefetch and clears the
handle.
- New regression guard: LoopDetected mid-stream aborts pending prefetch
and clears the handle (catches the sibling-drift bug this round caught).
227/227 tests pass; tsc clean on changed files.
Declined from this round:
- `await Promise.resolve()` after fire path: defensive — current code has
multiple natural microtask drains before consume point. Added comment
documenting the dependency instead.
- Renaming `settledAt: number | null` to `settled: boolean`: timestamp
has diagnostic value for future instrumentation; current consumers'
null-check usage is documented in the JSDoc.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* fix(test): correct getLastLoopType mock return type — null, not undefined
CI tsc --build (stricter than --noEmit) caught:
src/core/client.test.ts(2996,65): error TS2345: Argument of type
'undefined' is not assignable to parameter of type 'LoopType | null'.
getLastLoopType()'s contract returns LoopType | null; the test mock was
returning undefined. Switched to null to match the type.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
* fix(core): preserve memory prefetch across hook/next-speaker continuations + accurate recall abort log
Round-4 review findings (self-inflicted regression from round-3):
1. Preserve pending prefetch on `return hookTurn` (Stop-hook continuation)
and `return continueTurn` (next-speaker continuation). The round-3
`normalCompletion = true` was only set at the bottom-of-try `return turn`,
leaving these two recursive-yield paths to trip the finally cleanup.
When the inner Hook turn produced tool calls, the subsequent ToolResult
turn found `pendingMemoryPrefetch === undefined` and memory was silently
dropped.
2. recall.ts catch log distinguishes caller-driven aborts (heuristic
genuinely skipped below) from the 30s safety-net timeout in
relevanceSelector (the caller's signal is NOT aborted by that path,
so the heuristic fallback actually runs).
Regression guard added:
- "should PRESERVE the pending prefetch when next-speaker continueTurn
returns" — was red before this commit, green after.
258/258 tests pass; tsc --build clean.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---------
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
* docs: add user + design docs for --json-schema structured output
Follows up #3598 (cli/core feature shipped to main, no docs).
**User doc** `docs/users/features/structured-output.md` — covers
quick-start, schema input forms (inline + `@path`), output shapes per
`--output-format`, parse-time restrictions, retry/failure modes,
privacy redaction, permission gating, MCP shadow-tool handling, and a
worked `jq`-piped pipeline example. Registered under the existing
`features/_meta.ts` so it shows up in the docs sidebar between
"Headless Mode" and "Dual Output".
**Design doc** `docs/design/structured-output/structured-output.md` —
why the synthetic-tool-whose-param-schema-is-the-user-schema approach,
the four-stage parse-time validation pipeline,
`schemaRootAcceptsObject`'s decided-vs-deferred boundaries, main-turn
vs drain-turn parity via `processToolCallBatch`, the structured-
success terminal block, the cross-surface privacy redaction sharing
`STRUCTURED_OUTPUT_REDACTED_ARGS`, subagent context handling
(`forSubAgent`), MCP shadow-tool guard, the compatibility surface,
alternatives considered (and why rejected), and a file-by-file index.
Both docs are English-only — repo convention is English-only for
both `docs/users/features/` (zero zh-CN siblings) and `docs/design/`
(only `customize-banner-area/` has a zh-CN twin). Open to adding
zh-CN translations as a separate PR if there's demand.
* docs(structured-output): address PR review feedback
User doc:
- explicit stdout-vs-stderr contract and `{}`-schema behavior.
- 500 ms shutdown-holdback latency note.
- ReDoS warning for user-supplied `pattern` keywords.
- root `$ref` rejection + `allOf` workaround.
- per-retry token cost note.
- sibling-suppression success vs retry paths split out.
- numeric exit codes (1 / 53 / 130) for every failure mode.
- new "Session resumption" section for --continue / --resume.
Design doc:
- gloss the ToolSearch on-demand-loading reference.
- `not` row: drop the array-indexing-lookalike `[…]`.
- 500 ms holdback is best-effort, not guaranteed.
- redaction rationale extends to validation-failure retries.
- `CORE_TOOLS` phrasing: structured_output is excluded FROM the set;
skill is in a separate dynamically-discovered category.
- subagent suppression maintainer note (single brittle call path).
- `--bare` parenthetical lists the three retained core tools.
- PR #4001 status (closed 2026-05-11, superseded).
* docs(structured-output): correct empty-schema / holdback / SIGINT claims
Three doc claims were stronger than the actual code behaviour:
- **Empty schema produces `{}`, not `null`.** `turn.ts` normalises
the tool args via `(fnCall.args || {})` before they land in
`structuredSubmission`, so a zero-arg call against `{}` is emitted
as `{}` on stdout. The `?? null` in the adapter is defence-in-depth
for the strictly-undefined case, which the upstream path doesn't
produce.
- **Holdback is a cap, not a fixed wait.** The loop guard is
`Date.now() < deadline && registry.hasUnfinalizedTasks()`, so it
exits immediately when nothing is in flight. Reword as "capped at
~500 ms" with an early-exit note.
- **SIGINT can still flush a captured result.** The holdback loop
does not poll the abort signal, so a SIGINT after the structured
call is captured but before `adapter.emitResult` finishes may
still land on stdout. Treat exit code 130 as the source of truth.
Also addresses the new auto-review summary suggestion about per-turn
schema cost: pull the cost callout up out of the bullet list (so it
covers both retry cost and schema-embedded-every-turn cost), since
the schema-embedding cost isn't retry-specific.
* docs(structured-output): correct stdout/stderr + json-mode envelope claims
Two doc claims didn't match `JsonOutputAdapter.emitResult`:
- **Model prose doesn't go to stderr in text mode.** Only error
messages and log lines do. Successful runs emit just the
JSON-stringified payload on stdout; accumulated assistant prose
is discarded entirely (not mirrored to stderr). Point users at
`--output-format json` / `stream-json` when they need the prose.
- **`--output-format json` emits a JSON array, not a single
document with top-level fields.** The adapter calls
`JSON.stringify(this.messages)` where `messages` is an array of
message objects. `structured_result` lives on the final
`type: "result"` element of that array, not at the document
root, so consumers must read `.[-1].structured_result` rather
than `.structured_result`.
* docs(structured-output): note schema-itself reaches the provider
The Privacy section so far only described `structured_output` *args*
being redacted from local on-device surfaces (telemetry + chat
recording). The schema body is a separate exposure surface — it
ships as the function declaration's `parameters` block on every
model request, so `enum`, `const`, `default`, `examples`,
`description`, `$comment`, etc. travel to the provider in
cleartext. Users defaulting to "redaction covers everything"
could legitimately leak secrets via schema-literal fields.
Add a callout in the user doc, plus a parallel paragraph in the
design doc explaining why the redaction stops at on-device
surfaces (the model needs the schema to satisfy the tool-call
contract, so provider-side redaction isn't possible).
* docs(structured-output): correct stdout-on-failure / ReDoS example / hooks / --bare deny / typo
Five issues from the latest /qreview pass:
- **stdout-vs-stderr is text-mode only.** In `--output-format json`
and `stream-json`, the failure result message is emitted on
stdout (final element of the JSON array, or the terminating
`result` line on the JSONL stream). Wrappers in those modes must
switch on `is_error`, not on whether stdout is empty.
- **ReDoS example didn't actually demonstrate the threat.** JSON
Schema `pattern` only fires on string instances, and tool args
are always objects, so the bare `{"pattern": "(a+)+b"}` schema
doesn't constrain anything the model can supply. Move the
pattern inside a string-typed property.
- **Hooks see raw `tool_input`.** `PreToolUse` / `PostToolUse` /
`PostToolUseFailure` receive the unredacted args — including
HTTP hooks that can forward off-device. Call this out
explicitly so users with audit-style catch-all hooks know to
filter or add hook-side redaction.
- **`--bare` drops settings-level deny.** Bare mode builds
`mergedDeny` as `[...(bareMode ? [] : settings.permissions.deny), …]`
— settings-level denies are skipped while the synthetic tool
stays registered. Argv-level `--exclude-tools` still applies.
Document this exception in the user doc and the design doc.
- **`maxSessionTurns` hint typo.** The hint points at "schema is
unsatisfiable" — the original text inverted the polarity.
* feat(core): PR-2.5 — post-promote stream redirect + natural-exit registry settle
Closes the two limitations PR-2 (#3894) deferred for the Phase D part
(b) Ctrl+B promote flow (#3831):
1. **Post-promote stream redirect**: today the `bg_xxx.output` file
is frozen at promote time because `ShellExecutionService` detaches
its data listener as part of PR-1's ownership-transfer contract.
PR-2.5 wires a caller-side `onPostPromoteData` callback so bytes
from the still-running child append to the file via an
`fs.createWriteStream` opened in `handlePromotedForeground`.
2. **Natural-exit registry settle**: today the registry entry stays
`'running'` until `task_stop` / session-end `abortAll` fires its
abort listener. PR-2.5 wires `onPostPromoteSettle` so natural
child exit transitions the entry to `'completed'` / `'failed'`
with the right exitCode / signal / error message.
## Service (`shellExecutionService.ts`)
- New exported types: `ShellExecuteOptions`, `ShellPostPromoteHandlers`,
`ShellPostPromoteSettleInfo`.
- `execute()` options bag now accepts `postPromote?: { onData, onSettle }`.
Threaded through to both `executeWithPty` and `childProcessFallback`.
- PTY's `performBackgroundPromote` (line ~1159): after disposing
the foreground data + exit + error listeners, RE-ATTACH minimal
forwarders that call `postPromote.onData` / `postPromote.onSettle`
when the caller opted in. Backwards compat: when `postPromote` is
unset the PR-2 detach-everything contract is preserved (the
re-attach is gated on each callback being defined).
- `childProcessFallback`'s `performBackgroundPromote` (line ~706):
same pattern — re-attach `stdout.on('data', ...)`, `stderr.on('data',
...)`, `child.once('exit', ...)`, `child.once('error', ...)` when
the caller opted in. `error` listener routes through `onSettle`
with `error` populated, so spawn-side errors after the foreground
errorHandler detached don't crash the daemon via the default
unhandled `'error'` event.
- Both paths wrap caller callbacks in try/catch so a thrown handler
doesn't crash the child's data loop / unhandled-rejection the
service.
## Shell tool (`shell.ts`)
- New `PromoteArtifacts` type — slots shared between the foreground
`execute()` postPromote handlers (which fire on the service side
as soon as promote happens) and the post-resolve
`handlePromotedForeground` finalizer (which runs after
`await resultPromise` returns). The two race; the buffer +
settle-queue absorb that race so neither chunks nor the eventual
exit info are lost.
- `executeForeground` wires `postPromote` handlers that route data
to either `promoteArtifacts.stream` (if open) or
`promoteArtifacts.buffer` (drained when the stream opens), and
queue settle info if the wired handler isn't yet installed.
- `handlePromotedForeground` opens `fs.createWriteStream(outputPath,
{ flags: 'w' })`, writes the initial snapshot first, drains the
buffer, then registers the entry and wires `onSettleWired` with
the full registry decision table:
- `error` set → `registry.fail(shellId, error.message, endTime)`
- `exitCode === 0` → `registry.complete(shellId, 0, endTime)`
- non-zero exitCode → `registry.fail(shellId, "Exited with code N", endTime)`
- signal !== null → `registry.fail(shellId, "Terminated by signal N", endTime)`
- all-null fallback → `registry.fail(shellId, "Exited with unknown status", endTime)`
- Fires queued settle synchronously after wiring so a fast command
that exits between promote and finalizer doesn't get lost.
- Self-audit catch: closes the output stream on the
`registry.register` throw path so the FD doesn't leak past the
orphan-child kill.
## Tests
- 3 new in `shellExecutionService.test.ts`:
- `post-promote bytes route to postPromote.onData when callback provided`
- `postPromote.onSettle fires on natural child exit after promote`
- `backwards compat: without postPromote, listeners stay fully detached`
- 3 new in `shell.test.ts` under a `foreground → background promote
PR-2.5` describe block:
- `post-promote bytes APPEND to bg_xxx.output via write stream`
- `natural child exit transitions registry entry to "completed"`
- `non-zero exit / signal / error → "failed" with descriptive message`
- Bulk-replaced 50 prior `{},` (empty 6th-arg shellExecutionConfig)
with `expect.objectContaining({}),` + added `expect.objectContaining({
postPromote: expect.any(Object) }),` as the 7th-arg expectation for
the foreground execute call.
- Updated the existing `registers a bg_xxx entry on result.promoted`
test to assert on `fs.createWriteStream` + `stream.write` instead
of the now-removed `fs.writeFileSync` snapshot path.
182/182 shell.test.ts pass + 73/73 shellExecutionService.test.ts pass
+ 111/111 coreToolScheduler.test.ts pass + 60/60 AppContainer.test.tsx
pass; tsc + ESLint clean.
Self-audit: 3 rounds (positive / reverse / cross-file) found one
issue — output stream FD leak on `registry.register` throw — and
fixed it before flagging complete. All flagged edge cases (stream
errors, child-exits-before-wire-up race, task_stop during natural-
exit window, promote-never-happens cleanup, backwards compat
without callbacks) have explicit handling and / or test pinning.
* fix(core): #4102 review wave — 3 Critical + UTF-8 + tests
3 Critical race/correctness issues + 1 multibyte-corruption suggestion
+ 3 test coverage gaps addressed:
**Critical 1 — child_process late-chunk drop (service)**
Settle was fired on 'exit', but stdout/stderr can emit buffered data
between 'exit' and 'close'. Late chunks landed in
`promoteArtifacts.buffer` after shell.ts had already closed the
stream + transitioned the registry → silently dropped → truncated
`bg_xxx.output`. Switched to listening on 'close' which guarantees
all stdio is fully drained. (code, signal) payload is identical to
'exit', just with proper ordering.
**Critical 2 — stream-flush wait before registry transition (shell)**
`stream.end()` is asynchronous; pending writes can still be in the
libuv queue when it returns. The old code transitioned the registry
immediately after `.end()`, so a /tasks consumer could observe a
`completed` entry and read the output file BEFORE the trailing
bytes were on disk. Fixed: wired settle now `stream.once('finish',
...)` BEFORE calling `registry.complete/fail`. `error` event also
short-circuits to the transition so a late ENOSPC doesn't hang the
settle path forever.
**Critical 3 — stream-open-fail buffer leak (shell)**
If `fs.createWriteStream` threw, the catch path set `stream = null`
but the foreground `onData` handler would still take the
`stream === null` branch and push chunks into `promoteArtifacts.buffer`
— unbounded growth under a sustained child whose output file
couldn't be opened. Added a `streamFailed: boolean` latch on
`PromoteArtifacts`. When set, `onData` drops chunks (with a debug
log) instead of buffering. The catch branch sets the latch.
**Suggestion — shared TextDecoder corrupts multibyte UTF-8 (service)**
child_process post-promote used ONE TextDecoder for both stdout AND
stderr. The decoder's continuation-byte state machine assumes one
byte source; interleaved multibyte chunks corrupted. Now uses
separate decoders + flushes both with `decode()` (no `stream: true`)
on settle so trailing bytes surface as their final characters.
**Suggestion — llmContent reflects already-settled status (shell)**
When the queued-settle drain transitions the registry synchronously
(fast-exit race), the model-facing copy was still saying "Status:
running. … task_stop({...})". Updated to branch on
`postPromoteAlreadySettled` / `postPromoteFinalStatus` — when the
process is already gone, the copy says "Status: completed/failed"
and replaces the `task_stop` suggestion with "Process has already
exited; no `task_stop` needed".
**Suggestion — test coverage gaps**
Added: (a) `queued-settle race: onSettle BEFORE
handlePromotedForeground completes` — custom service impl fires
onSettle synchronously before resolving the promote promise, pins
the drain path. (b) child_process post-promote tests for stdout/stderr
forwarding + 'close'-not-'exit' settle + spawn-error settle.
**Self-audit**: Round 1 + reverse audit. Stream.once mock added to
fire 'finish' synchronously so existing tests don't hang on the new
flush wait. 76/76 shellExecutionService.test.ts (+3) + 183/183
shell.test.ts (+1) pass; tsc + ESLint clean.
* fix(core): #4102 review wave-2 — 3 more from gpt-5.5
C1 (shell.ts:2227): the WriteStream `'error'` event handler only
logged. `fs.createWriteStream` reports common open failures
(ENOENT / EACCES / ENOSPC) asynchronously via that event rather
than throwing. Result: `promoteArtifacts.stream` kept pointing at
the failed stream; `onSettleWired` attached a `.once('finish')`
listener that would never fire → registry stuck on `running`
forever. Latch the failure (null the shared `stream` slot,
set `streamFailed`); `onSettleWired`'s existing `if (!stream)`
branch then transitions the registry immediately.
C2 (shellExecutionService.ts:1468): the promote handoff removes the
foreground `ptyErrorHandler` and only re-attaches data + exit
listeners. A subsequent PTY `error` event had no listener — Node
treats an unhandled `error` from an EventEmitter as a fatal
exception that takes the whole CLI down. Attach a post-promote
forwarder that ignores expected PTY read-exit codes (EIO / EAGAIN,
same filter the foreground handler uses) and routes unexpected
errors through `postPromote.onSettle` with `error` populated.
Single-fire latch shared with `onExit` so settle never fires twice.
C3 (shell.ts:2503): `onSettleWired` waits for the stream's
asynchronous `'finish'` event before flipping
`postPromoteAlreadySettled`, but the model-facing `statusLine` was
built immediately after invoking `onSettleWired` on the queued
settle. A fast-exited promoted command could therefore land
"Status: running" + a `task_stop` instruction in production even
though settle was already observed. Split into two flags:
`postPromoteSettleObserved` (set synchronously when settle is
classified) drives the model copy; the registry transition stays
behind the stream flush.
Tests: +1 PR-2.5 wave-2 PTY error-routing test; +2 shell.ts tests
(stream open async error → registry still transitions; async
`'finish'` after queued-settle drain → llmContent says 'completed'
before registry transition fires).
* fix(core): #4102 review wave-3 — 4 actionable from deepseek-v4-pro
T2 (shell.ts:2456) — Critical buffer-leak race
`onSettleWired` previously set `promoteArtifacts.stream = null`
BEFORE calling `stream.end()`. Any `postPromote.onData` chunk that
landed between that null assignment and the actual flush completing
saw `stream === null && streamFailed === false` and pushed into
`promoteArtifacts.buffer` — a buffer that has no further drain path
(the foreground finalizer has already returned). Result: chunks
stranded indefinitely; PTY mode in particular hits this because
`onExit` can fire while kernel buffers still hold data. Fix drains
the pre-settle buffer to the stream BEFORE nulling AND latches
`streamFailed = true` so any subsequent chunk drops via the
existing `else if (streamFailed)` arm in `onData` instead of
leaking. Updates the `streamFailed` doc to cover both setters
(open-fail and settle-done) so the dual semantic is explicit.
T3 (shell.ts:2262) — silent chunk-drop in catch path
When `fs.createWriteStream` throws synchronously (rare: ENOENT on
a vanished tmpdir), chunks already in `promoteArtifacts.buffer`
were silently lost with no observability — oncall reading a
truncated `bg_xxx.output` had no way to distinguish "stream open
failed" from "child produced nothing." Logs the dropped chunk
count and empties the buffer.
T5 (shell.ts:2443) — opaque all-null fallback
The "Exited with unknown status" fallback fired the registry to
'failed' without any context about which fields were null. This
branch is meant to be unreachable; hitting it indicates the
service emitted a defective settle info object. Includes the
field values in both the fail message and a warn log so the
oncall engineer can tell this path apart from the other "failed"
branches.
T6 (shellExecutionService.ts:1452) — leaked PTY post-promote listeners
`ptyProcess.onData(...)` returns an `IDisposable` that was being
discarded; same for `onExit`. The `'error'` listener function was
also not captured (no way to `removeListener` it). EventEmitter
holds refs to listener closures, which transitively hold refs to
`onPostData` / `onPostSettle` / the caller's `promoteArtifacts`.
While bounded by the PTY's lifetime, the closures keep the
caller's state pinned for the post-settle delay window. Captures
all three handles into `postPromoteDataDisposable` /
`postPromoteExitDisposable` / `postPromoteErrorListener`, then
releases them via a shared `disposePostPromoteListeners()` call
from `firePostSettle` (idempotent — each slot null-checked and
nulled after disposal).
Tests: +1 service test for IDisposable + error-listener cleanup;
+2 shell.ts tests for buffer drain race and catch-path snapshot
fallback. Existing tests stay green (262 → 265 in the touched
suites; 7819 → 7822 across the core package).
* fix(core/test): drop unused 'registry' in wave-3 T2 test (TS6133)
CI build failed across all platforms with src/tools/shell.test.ts(4395,15): error TS6133. The variable was a leftover from copying the queued-settle test pattern; the wave-3 T2 test inspects writeStreamMock.write call history directly and never reads the registry, so the assignment is dead code. Drop it.
* fix(core): #4102 review wave-4 — 6 actionable from gpt-5.5 + deepseek-v4-pro
T1 (Critical, shellExecutionService.ts:860 child_process onSettle
exactly-once)
The PTY path used a `firePostSettle` latch but child_process wired
`close` and `error` independently to `onPostSettle`. A spawn-side
error followed by Node's auto-emitted `'close'` would call the
caller's settle TWICE, racing the registry transition. Added the
same single-fire latch on the child_process path.
T2 (Critical, shell.ts:2264 handoff race reorder)
Original order was `write(snapshot) -> drain buffer -> assign stream`.
Synchronous today (no race in current code), but assign-after-drain
leaves a hazard for any future refactor that adds an `await` inside
the drain loop — a chunk arriving in that window would land in
`promoteArtifacts.buffer`, then post-assign chunks would write to
the stream first, producing out-of-order bytes until the settle
drain. Reordered to `write(snapshot) -> assign stream -> drain
buffer`, which closes the hazard regardless of future async
additions.
T3 (Suggestion, shellExecutionService.ts:816 decoder flush gated
on onSettle)
The trailing-multibyte flush ran inside the `child.once('close', ...)`
handler, which was only installed when `onSettle` was set. An
`onData`-only caller (no onSettle) lost trailing continuation
bytes silently. Hoisted flush into `flushPostPromoteDecoders`
called from `firePostSettle`, and made `firePostSettle` available
on the `'close'` path independent of onSettle (T6 install).
T4 (Suggestion, shell.ts:1700 promoted ANSI passthrough)
The regular `executeBackground` path strips ANSI before writing to
`bg_xxx.output`; the promoted-foreground onData path appended raw
chunks. Reading `bg_xxx.output` after Ctrl+B showed plain text up
to the snapshot then raw `\x1b[31m` / cursor-move / clear-screen
sequences for the post-promote tail — unreadable. Apply
`stripAnsi(rawChunk)` before write/buffer, matching the
executeBackground contract.
T5 (Suggestion, shellExecutionService.ts:786 UTF-8 hardcoded)
The post-promote child_process decoders were hard-coded to
`new TextDecoder('utf-8')`, but the foreground decoder runs
encoding detection via `getCachedEncodingForBuffer`. On a non-UTF-8
child (e.g. GBK on a Chinese Windows shell), the snapshot decoded
correctly but the post-promote tail was mojibake. Capture the
foreground decoder's `.encoding` property and reuse it for
post-promote (with utf-8 fallback if foreground hadn't seen any
bytes yet, and a try/catch around `new TextDecoder` for the rare
unsupported-encoding case).
T6 (Suggestion, shellExecutionService.ts:1540 `error` listener
gated on onSettle)
The post-promote `error` listener was attached only when `onSettle`
was set. An `onData`-only caller still had the foreground
errorHandler detached; a post-promote spawn error would then crash
the CLI via Node's unhandled-error default. Hoisted the close +
error listeners into `if (postPromote)` so any caller opting into
post-promote gets crash protection; if `onSettle` is absent the
listeners log + drop instead of routing.
T7 (Suggestion, shellExecutionService.ts:791 onSettle-only
pipe-block deadlock)
Same root cause as T6: when only `onSettle` is set, the foreground
`stdout`/`stderr` 'data' listeners are detached and no post-promote
listener replaces them. The Readables stay paused, the OS pipe
buffer fills (~64KB on Linux), the child blocks on `stdout.write`,
'close' never fires, onSettle never fires. Added `child.stdout?.resume()`
and `child.stderr?.resume()` in the no-onData branch so the child
can drain its pipes and reach exit.
T8 (Suggestion, shell.ts:2614 dead inspectLine ternary)
`inspectLine`'s ternary returned the same string on both sides —
copy-paste leftover from when the other two adjacent ternaries
(statusLine / stopLine) were correctly varied. Collapsed to a
single string assignment.
Tests: +5 regression tests (4 child_process: T1 double-fire latch,
T3 onData-only flush, T6 onData-only error survives, T7 onSettle-
only resume; +1 shell.ts: T4 ANSI strip).
265 -> 270 in the touched suites; 7822 -> 7827 across the core
package; full suite green.
* fix(core/test): use ShellOutputEvent type in wave-4 onData callbacks (TS2345)
CI lint failed on the wave-4 (T3 / T6) tests with TS2345: pushing
ShellOutputEvent into Array<{type:string;chunk:unknown}> narrows
incompatibly. Switch to ShellOutputEvent[] (matches earlier helpers
at lines 758/966) and discriminate the union via .type === 'data'
when reading .chunk so the narrowed multibyte assertion still
type-checks.
* docs(structured-output): address doudouOUC's four review findings
- Tighten JSON/stream-json paragraph: not all failures emit a result
to stdout (exit 53 / exit 130 are stderr-only); check exit code first
- Fix suppressed-sibling retry guidance: re-issue in a separate turn
that does not include structured_output (avoids re-suppression)
- Distinguish settings-deny (exit 53) from --exclude-tools (exit 1)
in Permission gating section
- Replace <projectDir> placeholder with actual path
~/.qwen/projects/<sanitized-cwd>/chats/<sessionId>.jsonl in both docs
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* docs(structured-output): fix Permission gating — both deny paths strip registration
Forward audit against source code found that the Permission gating
section incorrectly distinguished settings.permissions.deny (claiming
tool stays visible, exit 53) from --exclude-tools (claiming
declaration stripped, exit 1). Both go through the same mergedDeny →
isToolEnabled path and both prevent registration — the model never
sees the tool. Corrected both docs to reflect the actual mechanism:
typical outcome is plain text (exit 1), with maxSessionTurns (exit 53)
as the fallback if the model loops through other tools.
* docs(structured-output): address doudouOUC's May 17 review (5 items)
- Clarify validation is client-side Ajv, not provider-side
- Qualify "same way" with DeclarativeTool abstraction parenthetical
- Match symptom→cause structure for maxSessionTurns hint
- Expand $ref workaround with concrete $defs example
- Clarify Dual Output See Also doesn't require --json-schema
* docs(structured-output): address 2 unresolved design-doc suggestions
1. Privacy/redaction section: note hooks as intentionally non-redacted
surface (matches user-doc "Hooks see raw args" callout).
2. Dual call-site section: clarify differing post-helper termination
flow between main-turn (direct return) and drain-turn (sentinel hop).
* docs(structured-output): address doudouOUC's May 17 review (2 nits)
1. Failure-paths table: align "three common causes" cell with the
symptom→cause framing already used at parse-time validation pipeline
section ("common stuck-run symptom and its two likely causes").
2. Dual call-site section: fix factual inaccuracy from prior commit —
`drainOneItem` is `async (): Promise<void>` and returns nothing.
The two-hop termination is via closure-mutated `structuredSubmission`
(set by `processToolCallBatch`, checked by `drainLocalQueue` and the
holdback loop), not a return-value sentinel.
---------
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
* feat(telemetry): unify span creation paths for hierarchical trace tree (#3731 P3 Phase 1)
Replace disconnected withSpan/startSpanWithContext calls in runtime with
session-tracing typed helpers so LLM and tool spans become children of
the interaction span instead of siblings under the session root.
- Add toolContext ALS with runInToolSpanContext() for concurrent-safe
tool span scoping (uses AsyncLocalStorage.run, not enterWith)
- Wire startLLMRequestSpan/endLLMRequestSpan in loggingContentGenerator
for both streaming and non-streaming paths
- Wire startToolSpan/endToolSpan + startToolExecutionSpan/endToolExecutionSpan
in coreToolScheduler with proper try/finally lifecycle
- Remove redundant withSpan('client.generateContent') wrapper from client.ts
- Fix endToolSpan to not override pre-set status when metadata is omitted
- Change startToolExecutionSpan to read parent from toolContext ALS
- Update tests for new span creation APIs and remove dead test infrastructure
* fix(telemetry): address CI build errors in session-tracing tests
- Remove unused _toolSpan variable (TS6133)
- Use bracket notation for index signature property access (TS4111)
* fix(telemetry): update coreToolScheduler and loggingContentGenerator test mocks
- coreToolScheduler.test.ts: mock startToolSpan/endToolSpan/runInToolSpanContext
instead of withSpan; update cancellation tests for restored safeSetStatus call
- loggingContentGenerator.test.ts: fix attribute keys in mock, add try/catch in
endLLMRequestSpan mock to match production best-effort behavior
* fix(telemetry): address review feedback from wenshao
- Add debugLogger.warn in catch blocks of endLLMRequestSpan/endToolSpan/
endToolExecutionSpan instead of silent swallowing
- Add JSDoc on endToolSpan documenting intentional no-metadata-no-status
contract with setToolSpanFailure/setToolSpanCancelled
- Add warning in startToolExecutionSpan when called outside
runInToolSpanContext (no active toolContext)
- Sanitize error message in endToolExecutionSpan: use constant
TOOL_SPAN_STATUS_TOOL_EXCEPTION instead of raw error message
* fix(telemetry): use partial mock for telemetry/index.js in coreToolScheduler tests
The full mock shadowed all re-exports (logToolCall, etc.) causing 49 test
failures. Use importActual to preserve other exports, only override span
functions.
* fix(telemetry): getLastToolSpan must skip tool.execution sub-spans
startToolExecutionSpan mock also pushes to toolSpanRecords, so at(-1)
returns the execution sub-span instead of the tool span. Use findLast
to filter by name.
* fix(telemetry): address second round review feedback
- Remove redundant safeSetStatus(span, OK) on success path — endToolSpan
in finally already sets OK via metadata
- Add llm_request.stream attribute (true/false) to distinguish streaming
vs non-streaming LLM requests in trace backends
* fix(telemetry): endToolSpan mock writes to record directly
Bypass span.setStatus() in mock to avoid potential interference from
vitest module resolution. Write to statusCalls/ended directly on the
ToolSpanRecord.
* fix(telemetry): mock session-tracing.js directly instead of telemetry/index.js
Mocking the barrel re-export (telemetry/index.js) with importActual was
unreliable — vitest's module resolution could bind production code to the
real endToolSpan before the mock override took effect. Mock the source
module (session-tracing.js) directly to guarantee interception.
* fix(telemetry): fix endToolSpan status on success — toolCalls is empty in finally
Root cause: checkAndNotifyCompletion clears this.toolCalls before the
finally block in executeSingleToolCall runs, so the tc lookup always
returns undefined.
Fix: set OK status explicitly in _executeToolCallBody's success path
via safeSetStatus(span, OK), and call endToolSpan() without metadata
in finally (just ends the span, preserves pre-set status from any path).
* fix(telemetry): address Codex review — activate OTel context, end span on failure
- Wrap non-stream generateContent API call + logging in context.with(spanContext)
so nested OTel spans (HTTP instrumentation, log-bridge spans) parent to
qwen-code.llm_request instead of session root (matches streaming path).
- runInToolSpanContext now also activates OTel context via otelContext.with,
not just the custom toolContext ALS. Hooks/HTTP/IO during tool execution
now correctly parent to qwen-code.tool span.
- Split end*Span helpers: span.end() runs in its own try/catch so a throwing
setAttributes/setStatus can't leak unended spans.
* fix(telemetry): address Codex review v2 — session-root fallback + execution span timing
- start{LLMRequest,Tool,ToolExecution}Span now fall back to getSessionContext()
when no parent context, instead of otelContext.active(). Side-query LLM calls
(auto-title, recap) now stay in the session trace instead of starting a new
detached trace.
- Move startToolExecutionSpan() to BEFORE invocation.execute(), matching
claude-code. Previously the synchronous setup inside execute (shell command
preprocessing, child_process.spawn) ran outside the execution span.
* fix(telemetry): address Codex review v3 — sync throw, idle timeout race, test coverage
- coreToolScheduler.executeSingleToolCall: move try-block to wrap
invocation.execute() so synchronous throws (e.g. shell setup failure)
flow into the same catch path as async rejections. Previously a sync
throw would leak the execution span and skip failure hooks.
- loggingStreamWrapper: track spanEndedByTimeout flag so a stream that
resumes after the 5-min idle timeout does not run the final
endLLMRequestSpan (which would no-op anyway, but the flag also stops
resetSpanTimeout from queuing further timer callbacks).
- coreToolScheduler.test: add execution sub-span assertions for success,
ToolResult.error, thrown invocation exceptions, and pre-hook denial.
- loggingContentGenerator.test: capture setAttribute calls into the mock
span attributes record; assert llm_request.stream is false for non-stream
and true for stream paths.
* fix(telemetry): address Codex review v4 — consistency + test coverage gaps
- endLLMRequestSpan now uses spanCtx.span for mutations (matches
endToolSpan/endToolExecutionSpan pattern). Same object, but consistent
lookup pattern prevents future drift.
- Mocks capture endLLMRequestSpan and endToolSpan/endToolExecutionSpan
metadata so tests can assert token counts, durationMs, success, error
are forwarded correctly. Add assertions on:
* Non-stream LLM: inputTokens, outputTokens, success on response path
* Non-stream LLM: success: false + sanitized error on rejection
* Stream LLM: final lastUsageMetadata reaches endLLMRequestSpan
* Tool execution sub-span: success: true on happy path
* Tool execution sub-span: success: false on ToolResult.error
* Tool execution sub-span: success: false + sanitized error on throw
- Add OTel error resilience tests: when setAttributes or setStatus throws,
span.end() must still run and the span must be removed from activeSpans.
Covered for endLLMRequestSpan, endToolSpan, endToolExecutionSpan.
* fix(telemetry): address Codex review v5 — abort distinction + API symmetry
- session-tracing.ts SpanContext.type: comment 'tool.blocked_on_user' |
'hook' as Phase 2 forward-declarations (no helpers wired yet).
- endToolExecutionSpan: align no-metadata-no-status behavior with
endToolSpan. Currently no caller omits metadata, but the asymmetric
default (OK vs preserve-pre-set) was a maintenance trap.
- loggingContentGenerator generateContent (non-stream) catch block:
call endLLMRequestSpan BEFORE the logging block, mirroring the
streaming path. Defense-in-depth against logging-side rejections.
- loggingContentGenerator: restore abort-specific span status message.
All three LLM error paths (non-stream catch, stream eager-error catch,
stream loggingStreamWrapper finally) now use
API_CALL_ABORTED_SPAN_STATUS_MESSAGE when req.config.abortSignal.aborted,
matching the original withSpan('client.generateContent') behavior.
Trace backends can now distinguish cancellations from real failures.
- coreToolScheduler _executeToolCallBody catch: distinguish abort vs
exception in execSpan error message. New constant
TOOL_SPAN_STATUS_TOOL_CANCELLED prevents operators filtering exec
spans for errors from seeing cancellation false positives.
- New test asserting exec span uses cancelled-by-user message when the
invocation throws after abort.
* fix(telemetry): always write 'success' attribute on tool spans
E2E review found qwen-code.tool spans never carry the `success` boolean
attribute (the helper only writes it when metadata is passed, and the
finally block calls endToolSpan(toolSpan) without metadata). This breaks
the most common observability query — filtering tool failures with
`success = false` — because tool spans don't have that field at all.
Fix: setToolSpanFailure / setToolSpanCancelled now also call
span.setAttribute('success', false); the success path in
_executeToolCallBody adds span.setAttribute('success', true) after
safeSetStatus(span, OK). Mirrors the unconditional `success` attribute
on llm_request spans, so backends can use one query for both span types.
Add 4 scheduler-level tests asserting the success attribute on:
- success path
- ToolResult.error path
- thrown invocation path
- cancellation path
* feat(tools): add generic worktree support (Phase A + B of #4056)
Adds first-class git worktree as a general-purpose capability:
Phase A — User-facing tools
- enter_worktree: creates `<projectRoot>/.qwen/worktrees/<slug>` on a
`worktree-<slug>` branch and returns the absolute path. Slug auto-generated
when omitted; validated against path traversal and disallowed characters.
- exit_worktree: keeps or removes the worktree (and its branch). Refuses to
remove a worktree with uncommitted tracked changes or untracked files
unless `discard_changes: true` is set.
Phase B — Agent isolation
- Agent tool gains an `isolation: 'worktree'` parameter that provisions a
temporary `agent-<7hex>` worktree, prepends a worktree notice to the task
prompt, and on completion either removes the worktree (no changes) or
preserves it and reports its path/branch in the result. Background and
foreground execution paths both wired up; rejected for fork agents.
- worktreeCleanup.cleanupStaleAgentWorktrees: fail-closed sweep for
ephemeral `agent-<7hex>` worktrees older than 30 days with no tracked
changes and no unpushed commits. User-named worktrees are never swept.
- buildWorktreeNotice helper for fork subagents (parity with claude-code).
Arena compatibility
- The existing Arena worktree implementation (GitWorktreeService.setupWorktrees,
ArenaManager, agents.arena.worktreeBaseDir) is untouched. Arena uses its
own batch APIs and `~/.qwen/arena` base dir; the new general-purpose APIs
live alongside under `<projectRoot>/.qwen/worktrees/`.
Subagent safety
- enter_worktree / exit_worktree are added to EXCLUDED_TOOLS_FOR_SUBAGENTS
so a subagent cannot mutate the parent session's worktree state.
Refs #4056
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* test(worktree): use path.join in expected paths so the test passes on Windows
The Windows CI run reported `enter-worktree.test.ts` failing because the
expected string was hardcoded with `/` while `getUserWorktreesDir()` uses
`path.join`, which returns `\\` on Windows. Build the expected path via
`path.join` so the platform-correct separator is compared.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(enter-worktree): treat empty name as auto-generate
Some models pass `{ "name": "" }` when calling EnterWorktree, because the
schema marks `name` as optional and they emit an empty placeholder. The
previous validation rejected the empty string with "Worktree name must be
a non-empty string", which surprised users running the auto-slug path.
Now both `validateToolParams` and `execute` treat `name: ""` as equivalent
to `name: undefined` and fall back to the auto-generated `{adj}-{noun}-{4hex}`
slug. Explicit invalid slugs (`'../etc'`, `'a/b'`, etc.) are still rejected
as before.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address review findings 1-6 from PR #4073
Six issues raised on the initial review; each addressed with a verifiable
guarantee.
1. Real isolation for `agent isolation: 'worktree'`
Before: subagent's Config still resolved `getTargetDir()` to the parent
project root, so Edit/Write/Read workspace checks and Shell's default cwd
silently operated on the parent tree. The cleanup helper then saw a
"clean" worktree and removed it — destroying the evidence.
After: the worktree is provisioned BEFORE `createApprovalModeOverride`,
and the resulting agent Config has `getTargetDir`/`getCwd`/`getWorkingDir`
rebound to the worktree path. Relative paths, unqualified shell
commands, and glob/grep roots all confine to the worktree.
2. `exit_worktree action='remove'` now prompts in default/auto-edit modes
Added `getDefaultPermission()` on the invocation: `'ask'` when action is
`remove`, `'allow'` when `keep`. Brings it in line with edit, write_file,
and run_shell_command.
3. Force-delete no longer silently destroys unpushed commits
`removeUserWorktree` now uses `git branch -d` (refuses unmerged) by
default and surfaces `branchPreserved: true` when git refuses. Added
`hasUnmergedWorktreeCommits` (checks if branch tip is reachable from any
other local branch or remote ref). Both the agent isolation cleanup and
`exit_worktree action='remove'` use this check: if the branch has work
not covered elsewhere, the worktree+branch are preserved even when
`discard_changes: true` is set (there is no `discard_commits` flag —
committed work is rarely what `remove` means to discard).
4. Both new tools are now deferred behind ToolSearch
`shouldDefer: true` + `searchHint` on both. Verified via openai-logging:
`enter_worktree` and `exit_worktree` no longer appear in the function-
declaration list sent on every API request.
5. Stale-worktree cleanup is wired in
`Config.initialize()` fires `cleanupStaleAgentWorktrees(targetDir)` as a
non-awaited startup sweep (skipped in bare mode). Picks up orphaned
`agent-<7hex>` worktrees left by crashed runs.
6. Foreground isolation no longer leaks on uncaught throw
The foreground try block tracks whether the cleanup helper ran on the
success path; the finally block invokes it as a fallback when the try
bailed early. Mirrors the background path's pattern.
Verification:
- Unit tests: 83 passed (16 worktree + 64 existing agent + 3 cleanup) — no
regressions.
- E2E #1: agent told to write `hello.txt` via RELATIVE path — file landed
at `.qwen/worktrees/agent-XXXXXXX/hello.txt`, NOT at the parent root.
- E2E #3: created worktree, committed work inside it, called exit_worktree
with `discard_changes=true` — refused with clear message; worktree and
branch both preserved.
- E2E #4: openai-logging confirms worktree tools absent from API tool list
(7 tools sent instead of 9).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address review round 2 findings (1 from tanzhenxin, 7+8 from wenshao)
The first round closed the data-loss-class issues. This round addresses
follow-ups from a deeper audit:
1. Stale-worktree sweep was inert on common-case repos
`cleanupStaleAgentWorktrees` previously ran `git log --branches --not
--remotes --oneline` from each worktree's directory — that lists
unpushed commits across EVERY local branch, not just the worktree's
own branch. On any repo with no remote configured (or with stray
unpushed branches), the sweep refused to remove every candidate.
Replaced with `service.hasUnmergedWorktreeCommits(slug)` which scopes
the check to the worktree branch via `for-each-ref --contains <tip>`.
Also added the `branchPreserved` warn log requested in M7 and an
`fs.access` shortcut for the empty-worktrees-dir case (M8).
2. `cleanupWorktreeIsolation` and `worktreeIsolation` were inside the
inner try (~660 lines from the outer catch). Hoisted both to the top
of `execute()` so the outer catch can reap or preserve the worktree
when anything between provisioning and the inner try throws (e.g.
`createApprovalModeOverride`, agent creation). Closure carries the
resolved `repoRoot` so cleanup never has to re-resolve.
3. Background error path discarded the cleanup result. Now captures
`formatWorktreeSuffix(...)` and appends it to the registry's failure
/cancel message, so users see the preserved path/branch even when
the agent crashed before reporting.
4. `cleanupWorktreeIsolation` now treats `result.success === false` as
"worktree still on disk" and surfaces it as preserved instead of
silently dropping it from the result.
5. Override was incomplete. Several Config methods read `this.targetDir`
directly (`getProjectRoot`, `getFileService`, etc.) — own-property
getter overrides did not redirect them. Now also shadows `targetDir`
and `cwd` as own properties on the agent's Config override, swaps in
a `FileDiscoveryService` rooted at the worktree, and rebuilds
`WorkspaceContext` to point at the worktree only. Verified
end-to-end: shell `pwd > pwd-record.txt` (no directory arg) lands at
`.qwen/worktrees/agent-<7hex>/pwd-record.txt`, not the parent root.
6. monorepo subdir issue. Both `enter_worktree` and the agent isolation
path now resolve `git rev-parse --show-toplevel` first and anchor
`.qwen/worktrees/<slug>` at the repo root. Worktrees created from
any subdirectory now end up where the startup sweep can find them.
7. Replaced `git worktree add -B` (silent force-reset of pre-existing
branches) with `git worktree add -b` plus an explicit existence
check via `git for-each-ref` (NOT `show-ref --quiet`, which
simple-git swallows). Pre-existing `worktree-<slug>` branches now
trigger a clear error instead of clobbering committed work.
8. First worktree creation in a repo writes `<projectRoot>/.qwen/.gitignore`
with `worktrees/` so worktree contents stay out of the parent's
`git status`, glob/grep results, and bundle tools. Idempotent: never
overwrites an existing file.
9. Logging across the failure paths (`enter_worktree` errors,
`agent.ts:failWorktreeProvisioning`, `cleanupWorktreeIsolation`,
`hasUnmergedWorktreeCommits` swallowed errors,
`cleanupStaleAgentWorktrees`'s `branchPreserved` race).
10. `exit_worktree` no longer suggests `discard_changes: true` when the
git status check itself fails — that would be advising the user to
bypass a safety check whose precondition is unknown. Now points at
the underlying repo problem.
11. `generateAutoSlug` switched from `Math.random()` (4 hex, weak RNG,
one-in-65k collision) to `randomBytes` (6 hex, ~16M combinations).
Two RNG sources in this file collapsed to one.
Pushed back: the TOCTOU swap in `removeUserWorktree` (S6 round 1) is
left as-is — `git branch -d` is the real safety, and reordering does
not eliminate the window. Windows reserved-name validation (M5 round 2)
deferred to a follow-up; the current allowlist already rejects path
separators, `..`, leading dot/dash, and the >64-char case.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): use randomInt to silence CodeQL biased-modulo finding
CodeQL's `js/biased-cryptographic-random` flagged
`randomBytes(4)[i] % ARRAY.length` in `generateAutoSlug`. The math is
actually exact for the current word-list lengths (256 % 8 == 0), but
the lint rule does not know that — and a future contributor changing
the list to a non-power-of-two length would silently introduce bias.
Switched the index lookups to `crypto.randomInt(0, length)`, which uses
rejection sampling and is uniform by construction. Suffix still uses
`randomBytes(3).toString('hex')` since hex encoding is unbiased.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address review round 3 findings 1-6 from PR #4073
The previous round added `getRepoTopLevel` for `enter_worktree`'s
provisioning, but missed three sibling call sites that still used the
raw cwd. The double-cleanup race in the foreground path also leaked
stale `[worktree preserved]` suffixes on rejected promises. All six
findings from the deeper audit are addressed:
1. exit_worktree now resolves through `getRepoTopLevel()` before
building its `GitWorktreeService`, mirroring `enter_worktree`. Without
this, launching `qwen` from a monorepo subdirectory created the
worktree under the repo root but exit_worktree looked under the
subdir's `.qwen/worktrees/` and always returned "Worktree not found".
Verified end-to-end: enter + exit from `packages/core/` works.
2. agent.ts cleanup helper now nulls `worktreeIsolation` immediately
after capturing the closure value. The previous structure could
reach the helper twice — once in the foreground try's success path
and once in the foreground finally fallback (or once in the inner
try and once in the outer catch on a thrown rejection). The second
call would `hasWorktreeChanges()` against a directory the first
call already removed, fail-closed, and emit a bogus
`[worktree preserved: <missing path>]` suffix.
3. Config.initialize's startup sweep now resolves `getRepoTopLevel()`
before invoking `cleanupStaleAgentWorktrees`. Without this, every
subdir launch scanned a non-existent `<subdir>/.qwen/worktrees/`
and the 30-day expiry sweep was permanently a no-op.
4. agent.ts's `buildWorktreeNotice` now passes
`worktreeIsolation.repoRoot` as `parentCwd` instead of
`this.config.getTargetDir()`. The notice's path-translation
guidance (≈ "translate paths from <parent> to <worktree>") would
otherwise misdirect the subagent in a monorepo subdir launch.
5. Removed dead method `GitWorktreeService.listUserWorktrees`. It had
no callers anywhere in the codebase and used `execSync` in a loop
(would have blocked the event loop if anyone wired it up).
6. `localBranchExists` no longer swallows git failures silently. The
defensive `false` default is preserved (so `git worktree add -b`
itself surfaces the conflict if the check missed an existing
branch), but the catch now logs via `debugLogger.warn` so disk-full
/ permission / ref-store-corruption cases are visible in debug
output instead of being invisible.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address review round 4 findings (data-loss + visibility)
Seven actionable findings from a deeper audit, all closed:
1. User worktree slugs could collide with ephemeral-agent shape
`validateUserWorktreeSlug` did not reject names starting with
`agent-`, so a user-named `agent-1234567` matched the cleanup regex
`/^agent-[0-9a-f]{7}$/` and would be silently swept after 30 days
along with whatever work was in it. Now reserved — clear error
message points users at the cause.
2. Slug producer and consumer were string-coupled across files
`agent.ts` hardcoded `agent-${hex(7)}` and `worktreeCleanup.ts`
independently hardcoded `/^agent-[0-9a-f]{7}$/`. Future change to
hex length on one side would silently break the other. Lifted
`AGENT_WORKTREE_PREFIX`, `AGENT_WORKTREE_HEX_LENGTH`,
`AGENT_WORKTREE_SLUG_PATTERN`, and `generateAgentWorktreeSlug()` to
`gitWorktreeService.ts`; both call sites import them.
3. Startup sweep was invisible at default log level
Fire-and-forget sweep used `debug` for errors and discarded the
success count. A leak-chasing operator had no log breadcrumb.
Errors promoted to `warn`; successful removals (count > 0) logged
at `info`.
4. `getRepoTopLevel()` silent catch
Returned `null` on any git failure with no log. Combined with
`?? cwd` fallback in callers, a flaky git would have made worktree
creators and the startup sweep disagree silently about which dir to
use. Now logs the underlying error.
5. `hasTrackedChanges()` silent catch
Cleanup's fail-closed `return true` had no log. Couldn't tell
"has real changes — leave alone" from "git index unreadable — repo
may be corrupt". Now logs.
6. `cleanupWorktreeIsolation` claimed `preservedPath` for a removed dir
When `removeUserWorktree` returns `{ success: true, branchPreserved:
true }` it has already deleted the directory and failed only on
`git branch -d`. The helper still reported the (now non-existent)
path as preserved. Now returns only `preservedBranch` for that
case; `formatWorktreeSuffix` emits a distinct message instructing
recovery via `git worktree add <new-path> <branch>`.
7. `removeUserWorktree` swallowed branch-delete failures
Both `-d` and `-D` catch blocks were empty. Locked refs, perms,
disk full all looked identical to "unmerged commits". Both now
`debugLogger.warn` with the underlying error.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* refactor(worktree): self-review pass — reuse, parallelism, dead code
Self-review caught a handful of issues across three categories:
Reuse:
- `pathExists` in the new code now uses the existing `fileExists` from
`utils/fileUtils.ts` instead of duplicating an `fs.access` wrapper.
- `worktree-` branch prefix was string-literalled in five places. Added
`WORKTREE_BRANCH_PREFIX` and `worktreeBranchForSlug(slug)` exports in
`gitWorktreeService.ts`; updated `gitWorktreeService.ts`,
`worktreeCleanup.ts`, and `exit-worktree.ts` to use them. Future
prefix changes are a single edit.
Efficiency:
- `Config.initialize` used two `await import(...)` calls inside the
startup-sweep IIFE, paying that cost on every CLI start. Switched to
static imports at the top of `config.ts` — the modules are tiny and
the dynamic indirection bought nothing.
- `cleanupWorktreeIsolation` in `agent.ts` ran `hasWorktreeChanges` and
`hasUnmergedWorktreeCommits` sequentially. They have no data
dependency on each other and each spawns its own `git` invocation;
`Promise.all` halves the cleanup wall-clock on the common path.
Same fix in `worktreeCleanup.ts`'s per-entry loop.
- `ensureWorktreesGitignored` used `fs.access` then `fs.writeFile`, a
TOCTOU race when two agent invocations created worktrees concurrently
(both could pass the `access` check and the second would clobber the
first's `.gitignore`). Now writes with `flag: 'wx'` and treats
`EEXIST` as the no-op case — atomic in one syscall.
Quality:
- Dropped the `worktreeCleanupRan` boolean in the foreground execution
path. `cleanupWorktreeIsolation` already nulls its closure variable
at the top of every call (see the comment at its definition), so
re-entries are no-ops. The boolean and its tracking were dead weight
that obscured the real guard.
- Trimmed the Phase-2 override comment block to drop the WHAT-stating
enumerations (items 3 and 4 just narrated the lines below) and
removed a navigation comment about hoisted helpers — the helpers are
visible at the top of the same method.
84 unit tests pass; typecheck clean.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address review round 5 — design-doc commitments + correctness
Five critical findings + four suggestions, all closed.
Critical:
1. Wrong base branch for agent isolation. `createUserWorktree(slug)` with
no `baseBranch` arg fell back to `getCurrentBranch()` on the **main**
working tree, returning `main` regardless of which branch the user
was actually on. A subagent invoked from `feature-x` would silently
start from `main` and produce diffs against the wrong baseline.
`enter_worktree` had the same bug. Both now resolve the parent's
current branch first and pass it explicitly. Verified end-to-end:
`git checkout feature-x` → `enter_worktree` → worktree HEAD includes
the feature-x commit.
2. `countWorktreeChanges` (used by `exit_worktree`'s dirty-state guard)
missed `status.conflicted[]`. In simple-git that array is mutually
exclusive with the staged/modified/etc. arrays, so a worktree
mid-merge with only conflicts looked `{tracked: 0, untracked: 0}`
to the guard and `action='remove'` would proceed without
`discard_changes: true`. Added `+ status.conflicted.length`.
3. `exit_worktree` had no session-ownership check, contradicting the
design doc's "only operates on worktrees created by THIS session".
In yolo mode a prompt injection could enumerate `.qwen/worktrees/`
and pass any name to drop another session's work. Now:
`enter_worktree` and agent isolation write a `.qwen-session`
marker into the worktree at provisioning time; `exit_worktree
action='remove'` reads it and refuses if it does not match the
current `Config.getSessionId()`. Worktrees from before this guard
(no marker file) are treated as "owner unknown" — allowed with a
warn log so the change is observable.
4. `enter_worktree` did not refuse nested invocations from inside an
existing worktree, contradicting the design doc. Now rejects any
cwd containing `.qwen/worktrees/` as a path component, with a
clear "Already inside a git worktree…" message. Verified: enter
from inside a worktree returns is_error with that text.
6. `hasTrackedChanges` (cleanup sweep) had the same `conflicted[]`
gap. Rewrote to use raw `git status --porcelain --untracked-files=no`
which lists every tracked change including `UU` conflict markers
in a single git call and explicitly skips the untracked walk
(the prior comment claimed to skip it, but `status()` always
does the scan).
Suggestion:
7. `buildWorktreeNotice` now receives the parent agent's actual
`getTargetDir()` again (was switched to `repoRoot` in round 3 on
a different reviewer's suggestion; round-5 caught that the model's
inherited paths reference the parent's cwd, not necessarily the
repo root, so the prior behaviour was correct).
8. Startup sweep now does `fs.access(<targetDir>/.qwen/worktrees)`
*before* importing GitWorktreeService and spawning `git
rev-parse --show-toplevel`. The git probe is reserved for users
who actually have a worktrees directory locally — 99% of users
pay only one syscall on startup.
9. Tests:
- New `exit-worktree.test.ts` covers metadata, validation,
`getDefaultPermission` (ask vs allow), and getDescription.
- `agent.test.ts` adds three `validateToolParams` cases for the
`isolation` parameter (accepted with subagent_type, rejected
without, rejected for non-"worktree" values).
- `enter-worktree.test.ts` adds round-trip tests for
`writeWorktreeSessionMarker` / `readWorktreeSessionMarker` plus
a `worktreeBranchForSlug` sanity check.
- Total: 101 tests pass (was 86 → +15).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(test): drop unused @ts-expect-error in exit-worktree.test.ts
Empty string `''` is a valid `string` type, so the @ts-expect-error
directive on `validateToolParams({ name: '', action: 'keep' })` did
nothing — TypeScript correctly accepted the line, and `tsc --build`
in CI reported TS2578 ("Unused '@ts-expect-error' directive"). The
runtime assertion already covers the case; the directive was leftover
from an earlier draft.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(test): use importActual in ArenaManager mock to preserve new exports
The Arena test mocks `gitWorktreeService.js` with a factory that
returns only `{ GitWorktreeService }`. PR #4073 added several other
exports to that module (`AGENT_WORKTREE_SLUG_PATTERN`,
`WORKTREE_BRANCH_PREFIX`, `worktreeBranchForSlug`,
`generateAgentWorktreeSlug`, `writeWorktreeSessionMarker`,
`readWorktreeSessionMarker`, `WORKTREE_SESSION_FILE`).
Other modules in the dep graph reach the mocked surface — most
notably `worktreeCleanup.ts` imports `AGENT_WORKTREE_SLUG_PATTERN`
and `worktreeBranchForSlug`, and now reaches the mock via the static
`config.ts` → `worktreeCleanup.ts` import chain added in the
self-review pass. The Arena test failed at module-load with:
Caused by: Error: [vitest] No "AGENT_WORKTREE_SLUG_PATTERN" export
is defined on the "../../services/gitWorktreeService.js" mock. Did
you forget to return it from "vi.mock"?
Use `importOriginal` to capture every real export, spread it into
the return object, and only replace `GitWorktreeService` (the class
the test actually needs to mock). The class-level mock keeps its
existing static-method shims.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): address review round 6 (5 critical + 6 suggestions)
The biggest item — #1 — is a self-inflicted regression from round 5:
the new agent- prefix reservation in `validateUserWorktreeSlug`
rejected EVERY slug that `generateAgentWorktreeSlug` produces, since
that helper emits exactly `agent-<7hex>`. Net effect: every
`AgentTool isolation: 'worktree'` invocation failed at validation.
The reservation now allows the canonical pattern through (everything
the helper can produce) and only rejects user-chosen `agent-*` names
that don't match it. Added a round-trip regression guard: 50
`generateAgentWorktreeSlug()` outputs are fed back through
`validateUserWorktreeSlug` and must all pass.
Other critical fixes:
2. `hasWorktreeChanges` (used by agent isolation cleanup) was the
one remaining caller relying solely on `status.isClean()`.
Defensive `|| status.conflicted.length > 0` so a future simple-git
bookkeeping change can't let a mid-merge worktree appear clean and
get auto-deleted.
3. `readWorktreeSessionMarker` swallowed every I/O error as "marker
missing", which let a disk error / EACCES silently bypass the
session-ownership guard. ENOENT is still treated as missing
(legitimate); every other code now logs.
4. `exit_worktree` `fs.stat` catch was the same shape — every error
collapsed to "Worktree not found". ENOENT → not found; everything
else logs and returns a distinct "cannot access" error.
5. `cleanupStaleAgentWorktrees` `fs.stat` catch was again the same.
ENOENT → silently skip (entry vanished between readdir and stat);
everything else logs.
Suggestions:
6. Startup sweep fast-bail was running BEFORE resolving the repo
top-level. For monorepo subdir launches, `targetDir/.qwen/worktrees`
never exists and the sweep early-returned — permanently a no-op.
Now resolves the root first, then fast-bails against the resolved
`<root>/.qwen/worktrees`. Also logs the skip case so operators can
tell "skipped" from "ran, found nothing".
7. `.qwen-session` marker was visible to `git add -A` inside the
worktree. Now writes a `.git/info/exclude` rule (resolved via
`git rev-parse --git-dir`, since worktree `.git` is a file
pointing at the parent repo's `.git/worktrees/<name>/`).
Best-effort: failure to write the rule does not abort
provisioning.
8. Agent isolation now refuses to provision when the parent's cwd is
already inside a worktree — same regex guard as `enter_worktree`.
9. `exit_worktree`'s wrapper around `hasUnmergedWorktreeCommits` now
logs at the call site so the chain (caller → reason it asked →
underlying git error) is complete in operator logs.
10. Sweep now logs unconditionally at `info`. Three distinct messages:
"skipped (no worktrees dir)", "ran, nothing to remove", "removed N".
Tests:
11. New `execute()` coverage:
• exit-worktree: session-ownership refusal, keep happy path,
legacy/no-marker fallthrough with warn log, missing-worktree
error, unmerged-commits guard with `discard_changes: true`,
`writeWorktreeSessionMarker` round-trip.
• enter-worktree: nested-guard rejection, non-git-repo error.
These spin up real temp git repos (no filesystem mocking) and
drive the actual tool invocation pipeline.
Total: 135 tests pass (was 101 → +34).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* refactor(worktree): demote noise startup-sweep logs to debug
Self-review pass applying the round-6 review-triage framework
(filter #5: "If a log only fires on the happy path, it's noise.")
to my own round-6 changes:
- "Stale worktree sweep skipped: <dir> does not exist" — fires on
every CLI start for ~99% of users who never use worktrees.
- "Stale worktree sweep ran under <root>: nothing to remove" —
fires on every CLI start for users who have any worktrees but
no stale ones at the moment.
Both are happy-path noise at `info`. Demoted to `debug` so an
operator can opt in via `--debug` when they want to confirm the
sweep is wired up, but normal output stays clean.
Only the actually-actionable case ("removed N worktrees") stays at
`info` — that's the signal someone chasing a worktree leak would
grep for.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
* fix(worktree): close AUTO_EDIT bypass + parent-dirty stale-code hazard
Round-7 review caught two correctness gaps:
1. exit_worktree action='remove' was still auto-approved in AUTO_EDIT
`getDefaultPermission` returning 'ask' is necessary but not
sufficient. `permissionFlow.isAutoEditApproved` auto-approves any
tool whose `confirmationDetails.type` is 'edit' OR 'info', and
`BaseToolInvocation` returns 'info' by default. So a session in
AUTO_EDIT could silently destroy a worktree (with branch deletion)
without a confirmation prompt — the data-loss path the round-1
`'ask'` switch was meant to close. Now overrides
`getConfirmationDetails` to return `type: 'exec'` for action=remove,
which keeps the prompt in AUTO_EDIT. The `keep` action still falls
through to the base info-type since it is non-destructive.
Regression-guard test asserts the type is 'exec' (not 'info') for
remove and that the command field describes both the worktree-remove
and branch-delete operations.
2. Agent isolation worktrees ran against parent's HEAD, not its
working tree
`git worktree add -b <branch> <path> <base>` only checks out the
base ref's tip — uncommitted edits in the parent's working tree do
NOT propagate. The "edit code → ask review/test agent before
committing" workflow silently ran the subagent against the
pre-edit HEAD and returned results that looked authoritative but
reflected stale code.
Reviewer offered two options: overlay parent's dirty state à la
Arena (~50 LOC, edge cases), or refuse isolation when parent is
dirty (~10 LOC, clear UX). Chose the latter for Phase B scope —
simpler, decisive, and matches the design-doc's explicit
commitment that dirty-state overlay is Arena-specific. Users can
commit/stash before re-invoking agent isolation; overlay can be a
follow-up if users complain about the friction.
Fail-closed on the dirty-check itself (assume dirty rather than
silently launch on a possibly-stale tree).
Test exercises both "dirty parent → guard fires" and
"clean parent → guard passes" against real temp git repos.
139 unit tests pass (was 135, +4 regression guards).
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
* feat(core): strip inline media before chat compaction summary
Compaction's side-query previously shipped historyToCompress verbatim.
Two related issues degraded summary quality and accuracy:
- Inline image / document bytes (from MCP tool results) leaked into the
summary model's prompt where they could not be interpreted and merely
inflated payload.
- findCompressSplitPoint apportioned chars via JSON.stringify(content),
so a single 1 MB base64 image looked like ~350K tokens and biased
the split point. Real Qwen-VL token cost is at most a few thousand.
This change adds a new compactionInputSlimming module that replaces
inlineData / fileData parts with short [image: <mime>] / [document:
<mime>] placeholders before the side-query, leaving live history
unchanged. The same constant feeds estimateContentChars so the
split-point algorithm sees the budget the summary model actually
consumes downstream. Microcompact is also extended to clear stale
inline images alongside old tool results.
A previous draft of the design also externalized large pastes to a
content-addressable on-disk cache, but it was withdrawn after surveying
claude-code's 2026-03 to 2026-05 releases - upstream consensus is to
keep user input visible to the model and amortize cost via prompt
caching rather than externalize. See the Out-of-scope section of the
design doc for the full rationale.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
* fix(core): recurse into functionResponse.parts when stripping media
E2E exposed that `read_file` (and any tool that surfaces an image)
wraps the result in `functionResponse.parts` via
`coreToolScheduler.createFunctionResponsePart`. The slimming module
only walked top-level `part.inlineData` / `part.fileData`, so the
nested base64 bytes leaked into the compaction side-query payload.
The previous design doc incorrectly claimed that no recursive walk
was needed.
Three changes:
- `slimCompactionInput.transformPart` recurses into the nested
`functionResponse.parts` array and replaces each entry via the
same image/document placeholder logic.
- `estimatePartChars` walks the nested array too, so the split-point
algorithm doesn't fall back to `JSON.stringify` and over-count the
base64 bytes.
- `microcompactHistory` drops `functionResponse.parts` when clearing
an old tool result; the previous spread of `...part.functionResponse`
silently carried the original media through.
New unit tests cover (a) nested image / document stripping, (b) the
estimator no longer being skewed by nested base64. The previously
failing E2E now PASSES: side-query payload contains zero `data:image/`
occurrences, zero long base64 runs, and exactly one
`[image: image/png]` placeholder.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
* fix(core): address review findings on compaction image stripping
Addresses 8 valid findings from PR review:
- [Critical] estimatePartTokens now handles `fileData` parts (both
top-level and nested under functionResponse.parts). Without this,
microcompact's `tokensSaved === 0` short-circuit silently discarded
every fileData clear.
- estimatePartTokens for binary parts now uses a fixed
MEDIA_PART_TOKEN_ESTIMATE constant (1,600) instead of base64-length
divided by 4. The old formula billed a 1 MB image as ~250K tokens
rather than its actual ~1,280 visual tokens on Qwen-VL, inflating
the saved-token metric by orders of magnitude.
- mimeType values from MCP tool servers are now run through
sanitizeMimeForPlaceholder before being embedded in `[image: …]` /
`[document: …]` placeholders. An adversarial server could otherwise
craft `image/png]\n\n[SYSTEM: …` and inject instructions into the
summary side-query.
- collectCompactablePartRefs now recognizes a third 'nested-media'
kind: functionResponse parts from non-compactable tools (e.g. MCP
screenshots whose names aren't in COMPACTABLE_TOOLS) that carry
images on functionResponse.parts. The nested media is dropped while
the tool's text output is preserved. Previously such media
accumulated forever in live history.
- keepRecent budgets are now per-kind (tool / media / nested-media).
Setting `toolResultsNumToKeep: 1` keeps 1 of each kind rather than 1
entry total across the merged list — matches the natural reading of
the setting name.
- findCompressSplitPoint's `precomputedCharCounts` fallback path is
now documented as test-only; production callers MUST pass the
precomputed array.
- The text-based branch of isAlreadyCleared is gone: with the new
nested-media handling (drops `parts`) and existing media handling
(replaces with `{ text: … }` that is no longer collected) it was
unreachable.
- OpenAI converter (createToolMessage) now passes text parts inside
functionResponse.parts through as text content. The slimmer writes
`{ text: '[image: image/png]' }` placeholders into the nested array;
without this fix the converter dropped them when serializing to the
OpenAI wire format, leaving the summary model with empty tool
responses instead of the placeholder.
Two findings deferred with rationale (see design doc Open Questions):
MIN_COMPRESSION_FRACTION still uses pre-slim counts (acceptable —
"user shared an image" is itself worth summarizing); SlimResult is not
re-exported (round-3 simplify decided to keep core's public surface
minimal).
E2E re-verified end-to-end: side-query payload contains 0 data:image/
occurrences, 0 long base64 runs, and 1 `[image: image/png]` placeholder
in the expected position. 185/185 collocated unit tests pass.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
* chore(core): tidy compaction slimming after self-review
Three small polishes from a follow-up code review pass:
- `stripNestedMedia` no longer re-casts its return value: after
destructuring `parts` out of the widened input type, TypeScript
infers the original `FunctionResponse` shape without help.
- `isAlreadyCleared` shed a 10-line comment block — the body is now
one line, so one descriptive line above it is enough.
- OpenAI converter's nested-part text check switched from
`(part as { text?: unknown }).text` to
`'text' in part && typeof part.text === 'string'`, dropping the
cast and letting `in` narrow the type.
No behavior change. 185/185 unit tests still pass.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
* fix(core): wire slim stats to debug log; split MicrocompactMeta tools vs media
Addresses two follow-up review suggestions:
- `slimCompactionInput` returned `stats.imagesStripped` and
`stats.documentsStripped` but the orchestrator never consumed them.
Now logged at debug level whenever non-zero so operators can confirm
the slimming pipeline actually fires on image-heavy compactions.
- `MicrocompactMeta.toolsCleared` lost meaning after the recent
refactor: it had grown to count both tool-result clears AND
inline-media / nested-media clears. Renamed:
- `toolsCleared` → only `tool`-kind clears (compactable tool output)
- `mediaCleared` → `media` + `nested-media` clears (new)
- `toolsKept` / `mediaKept` mirror the split, replacing the prior
`toolsKept` that was actually a combined count.
The single non-test consumer (`client.ts` debug log) updated to use
both fields.
185/185 unit tests pass.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
The `qwen auth` CLI subcommand (with subcommands like qwen-oauth,
coding-plan, api-key, openrouter, status) has been superseded by the
richer /auth TUI dialog introduced in the provider-first auth registry
(#3864). Running `qwen auth` now prints a deprecation notice pointing
users to the /auth TUI dialog (interactive), env vars (CI/headless),
or /doctor (status check).
Changes:
- Replace auth.ts with a stub that prints a removal notice and exits
- Delete handler.ts (734 lines), interactiveSelector.ts, and their
tests (interactiveSelector.test.ts, openrouter.test.ts, status.test.ts)
- Update /auth slash command to handle non-interactive/ACP modes gracefully
- Enrich /doctor auth check with provider-aware diagnostics using
findProviderByCredentials
- Mark `auth` as a subcommand that handles its own exit in config.ts
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(cli): improve slash command discovery
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* test(cli): update input prompt completion expectations
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): address review feedback on slash command phase 3
- Fix getBestSlashCommandMatch sort order: completionPriority first,
recentOrder second — consistent with compareRankedCommandMatches in
useSlashCompletion.ts so ghost text and dropdown agree on best match
- Fix findSlashCommandTokens to index altNames into commandMap so alias
tokens (e.g. /usage for /stats) are highlighted as valid instead of
being marked invalid
- Fix getRecentScore decay formula: 10 * Math.max(0, 1 - ageMs /
RECENT_DECAY_MS) so the recent boost truly decays to 0 within the
10-minute window named by RECENT_DECAY_MS
- Fix Help.tsx CommandsHelp scroll indicator to show command count
range (e.g. 1-12/49) instead of raw line count (18/108), which was
confusing because each command expands into 2-3 render lines
- Fix Help.tsx CommandLine key prop: use stable type:text:index key
instead of scrollOffset-index to avoid remounting every line on scroll
- Internationalize Help.tsx tab labels via t() instead of hardcoded
English strings
- Add Tab/Shift+Tab to switch tabs hint in Help footer alongside Esc
- Add commandMetadata.test.ts with full branch coverage for all 6
exported functions (getCommandSourceBadge, getCommandSourceGroup,
formatSupportedModes, getCommandDisplayName, getCommandSubcommandNames,
formatCommandSourceLabel)
- Add direct unit tests for getBestSlashCommandMatch covering: null on
empty input, null on no match, null for non-modelInvocable commands,
completionPriority ordering, recentCommands tie-breaking, argumentHint
return path, exact-match exclusion without hint, inclusion with hint
- Update Session.test.ts expectation for sendAvailableCommandsUpdate to
include _meta field that was added in this PR
* test(cli): add missing test coverage for slash completion
- Add test: midInputGhostText is null when only non-modelInvocable commands match
- Add test: recentCommands boosts non-root prefix suggestions via recentScore
Both tests address coverage gaps identified in code review.
---------
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(memory): add autoSkill background project skill extraction
* fix(test): add missing mock methods for autoSkill (getAutoSkillEnabled, recordCompletedToolCall, consumePendingMemoryTaskPromises)
* fix(test): fix cross-platform path comparison in skillReviewNudge integration test
* fix(autoSkill): address critical review comments
- Fix merged_with_extract silent drop: remove broken merge optimization
in scheduleSkillReview(). When an extract task is pending/running,
skill review is now scheduled independently instead of recording
metadata that no production code ever reads.
- Fix SKILL_MANAGE blocked from skill review agent: prepareTools() now
only enforces the recursion guard (AGENT tool) when the agent has an
explicit tools list. Wildcard/inherit subagents still get the full
EXCLUDED_TOOLS_FOR_SUBAGENTS filter, preventing task subagents from
calling skill_manage. The dedicated skill review agent can now receive
the skill_manage tool it requires.
- Update manager.test.ts: replace merged_with_extract tests with
concurrent-extract independent-scheduling tests.
- Update skill-manage.test.ts: clarify test description to reflect
wildcard-only exclusion semantics.
* fix(autoSkill): reject symlink traversal in skill_manage path guard
assertProjectSkillPath() uses path.resolve() which is purely lexical and
does not dereference symlinks. If any path component inside .qwen/skills/
is a symlink pointing outside the project, fs.writeFile/readFile/rm would
follow the link and mutate files outside the advertised write boundary.
Add assertRealProjectSkillPath() (async) in skill-paths.ts that:
- Resolves the real path of the skills root via fs.realpath()
- Walks up from targetPath to find the nearest existing ancestor
- Resolves that ancestor to its real filesystem path
- Rejects if the real path falls outside the real skills root
skill-manage.ts execute() now calls both the cheap lexical check (fast
fail for obviously wrong paths) and the async real-path check before any
fs.writeFile / fs.rm mutation.
Add three symlink-specific tests in skill-paths.test.ts covering:
- Legitimate path accepted
- Symlinked directory pointing outside skills root rejected
- Skills root itself being a symlink (safe target) accepted
* refactor(autoSkill): remove skill_manage tool, use path-based skill write detection
Address reviewer feedback: instead of keeping skill_manage as the sole
write gate (which still had symlink bypass risk via generic tools), remove
the dedicated tool entirely and replace with a two-layer protection:
1. skillsModifiedInSession (client.ts): detects writes to .qwen/skills/
by inspecting the file_path arg of every completed tool call, replacing
the fragile historyCallsSkillManage() history scan.
2. hasAutoSkillSource + evaluateScopedDecision (skillReviewAgentPlanner.ts):
the review agent's permission sandbox now verifies BOTH that the target
path is inside the skills directory AND that the existing file already
contains 'source: auto-skill' in its frontmatter before allowing edits,
preventing the agent from overwriting user-managed skills.
Changes:
- Delete skill-manage.ts and skill-manage.test.ts
- Remove SKILL_MANAGE from ToolNames, ToolDisplayNames, config registerLazy,
agent-core EXCLUDED_TOOLS comment, and agent.ts comment
- Replace historyCallsSkillManage() with skillsModified: boolean param in
scheduleSkillReview; skip reason renamed skills_modified_in_session
- recordCompletedToolCall(name, filePath?) detects .qwen/skills/ writes;
CLI layers pass file_path arg from tool call request
- Fix buildTaskPrompt frontmatter template to use top-level source: auto-skill
- Update skill-paths.ts error messages to remove skill_manage references
- Update all unit/integration tests accordingly
* fix(autoSkill): deduplicate concurrent skill-review tasks per projectRoot
scheduleSkillReview() was launching a new background task every time the
threshold was reached for the same project, with no guard against multiple
in-flight reviews running concurrently.
Fix: add skillReviewInFlightByProject Map that tracks the taskId of any
running review per projectRoot. A second call while one is in-flight returns
{ status: 'skipped', skippedReason: 'already_running', taskId: <existing> }.
The map entry is cleared in a finally block inside runSkillReview() so the
next session can schedule a fresh review after the current one completes.
Also extend SkillReviewScheduleResult.skippedReason union to include
'already_running', and add a unit test covering the full lifecycle:
first call schedules, second call is skipped with existing taskId, and a
third call after completion schedules a new task.
* fix(autoSkill): address all critical review comments
1. hasAutoSkillSource: narrow catch to ENOENT only (EISDIR/EACCES etc.
return false to deny); tighten frontmatter regex to match opening block only.
2. evaluateScopedDecision: add explicit allow for READ_FILE and LS so they
don't fall to 'default' which the base PermissionManager might widen;
EDIT/WRITE_FILE now call assertRealProjectSkillPath() (async realpath guard)
in addition to the lexical check, closing the symlink traversal hole.
3. isScopedTool / getScopedDenyRule: cover READ_FILE and LS so hasRelevantRules
returns true and findMatchingDenyRule is correctly consulted for them.
4. recordCompletedToolCall (client.ts): broaden tool name set to match
WRITE_TOOL_NAMES in manager.ts (write_file, edit, replace, create_file) and
inspect all three arg keys (file_path, path, target_file). Signature changed
from (name, filePath?) to (name, args?) to carry all args through.
5. client.ts hardcoded literals: replace threshold/maxTurns/timeoutMs with the
named constants AUTO_SKILL_THRESHOLD / DEFAULT_AUTO_SKILL_MAX_TURNS /
DEFAULT_AUTO_SKILL_TIMEOUT_MS imported from manager.ts and
skillReviewAgentPlanner.ts.
6. toolCallCount / skillsModifiedInSession reset: only reset when skill review
is actually scheduled (status === 'scheduled'), not every turn, so the
counter correctly accumulates across turns within a session as per design doc.
7. runSkillReview (manager.ts): rethrow after marking record failed, consistent
with runExtract behavior.
8. skillReviewNudge.integration.test.ts test 5: rewrite to reflect the
in-flight dedup contract (second same-project call returns already_running
with existing taskId; third call after completion gets a new task). Add
vi.mock for runSkillReviewByAgent so the test does not need a full Config.
* fix(autoSkill): address all review comments
- skill-paths: detect dangling symlinks with lstat before treating ENOENT as safe
- skill-paths: fix isProjectSkillPath relative path resolution to use projectRoot
- skillReviewAgentPlanner: restrict READ_FILE/LS to project root only
- skillReviewAgentPlanner: remove SHELL tool from review agent tool list
- skillReviewAgentPlanner: add path import; remove unused shell imports
- skillReviewAgentPlanner: add comment for buildAgentHistory trailing user message
- client: fix runManagedAutoMemoryBackgroundTasks gate widening
- client: fix skillsModifiedInSession deadlock
- client: add .catch() to skill review promise
- client: hoist SKILL_WRITE_TOOL_NAMES to module-level ReadonlySet
- agent-core: use full EXCLUDED_TOOLS_FOR_SUBAGENTS for explicit tool list subagents
- manager: extend notify() signature to accept 'skill-review' taskType
- config: fix JSDoc default value comment (false, not true)
* fix(autoSkill): address second round review comments
- client: reset toolCallCount when scheduleSkillReview returns already_running
and count >= threshold, preventing immediate cascade after in-flight review
- client.test: add autoSkill branch tests (scheduled/already_running/skills_modified)
- client.test: add full recordCompletedToolCall unit tests (skillsModifiedInSession,
toolCallCount increment, skill path detection for write_file/edit/read_file)
- client.test: add scheduleSkillReview mock to mockMemoryManager
- nonInteractiveCli.test: add assertions for recordCompletedToolCall and
consumePendingMemoryTaskPromises in tool-call integration test
* fix(cli): refresh static header on model switch
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(cli): simplify api key provider registry
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(cli): split Alibaba auth providers
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* polish(cli): refine auth provider onboarding
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): update OpenRouter free defaults
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): restrict token plan models
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* chore(cli): remove unused third-party providers
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(cli): add regional third-party providers
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(cli): simplify api key provider endpoints
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(cli): split auth dialog flows
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(cli): unify auth around declarative provider config
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
Introduce ProviderConfig abstraction (providerConfig.ts) and a central provider registry (allProviders.ts), replacing the per-flow UI components (AlibabaModelStudioFlow, CustomProviderFlow, OAuthFlow, ThirdPartyProvidersFlow, etc.) with unified ProviderSetupSteps and useProviderSetupFlow.
Key changes:
- Remove setupMethods/apiKey/ directory entirely
- Collapse flow-specific hooks/components into a single generic provider setup flow
- Simplify each provider file to export only a ProviderConfig descriptor
- Add alibabaStandard provider alongside codingPlan/tokenPlan
- Move all baseUrl resolution, install plan building, and settings writing into providerConfig
- Update useAuth, AuthDialog, command handler, and upstream consumers to use the new registry
* refactor(cli): simplify provider setup input flow
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(cli): remove toLlmProvider and legacy auth wrappers
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(cli): flatten auth flow files and simplify ProviderSetupSteps props
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(cli): prefill API key from existing env settings in provider setup flow
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): correct third-party provider context windows
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): harden provider auth setup
* feat(cli): support provider modality and context settings
* feat: eable modelsEditable for coding plan
* refactor(cli): auto-derive provider metadata key and state
Move metadataKey and getProviderState from per-provider config to
auto-derived helpers (resolveMetadataKey, resolveProviderState) in
providerConfig.ts. This centralizes version tracking logic and reduces
boilerplate in individual provider definitions.
Add useProviderUpdates hook that detects model template changes across
all version-tracked providers and surfaces update/ignore choices.
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
Closes: OSS-1730, OSS-1729
* refactor(cli): namespace provider metadata under providerMetadata key
Introduce PROVIDER_METADATA_NS ('providerMetadata') to avoid top-level
settings key collisions. Provider metadata now lives under
e.g. providerMetadata.coding-plan.version instead of codingPlan.version.
Add migration logic (migrateProviderMetadata) to automatically move
legacy top-level keys (codingPlan, tokenPlan) into the new namespace
on first run.
Update auth handler, useProviderUpdates hook, and all related tests
to use the new namespace structure.
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
[skip ci]
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): polish ProviderUpdatePrompt styling and test coverage [skip ci]
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(auth): simplify auth flows around provider abstraction [skip ci]
- Rewrite motivation.md to document provider-centric architecture
- Remove Alibaba Standard API Key and Coding Plan UI flows from handler
- Update status tests to use providerMetadata instead of codingPlan settings
- Streamline API key auth to show docs link only
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(auth): update provider models and refine auth infrastructure
- Bump model versions (qwen3.6-plus, glm-5.1) and add deepseek-v4-pro/flash
with modalities to Alibaba Standard provider
- Reorder DeepSeek models, add thinking+image/video modalities to v4-pro,
fix v4-flash context window
- Enhance auth tests with provider metadata setValue assertions
- Switch env key generation from hash-based to URL-based with
trailing-slash normalization
- Remove deprecated codingPlan section from settings schema
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(i18n): add missing zh-TW translations for token plan and subscription providers
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(auth): improve provider install error recovery and AuthDialog state init
- Restore settings from backup on provider install plan failure
- Fix AuthDialog mainIndex state to null (was 0), preventing stale selection
- Remove ownsModel from customProvider; fall back to id-based filtering
- Change provider migration log from console.error to console.log
- Add sync reminder comments between CLI and VSCode subscription models
- Expand handleApiKeyAuth JSDoc explaining its role as lightweight fallback
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(auth): i18n for step labels, lazy preview JSON, and accurate header label
- Wrap getStepLabel() strings and PROTOCOL_ITEMS in t() for i18n
- Only compute previewJson when on the review step
- Return matched provider's own label in getAuthDisplayType instead
of hardcoding CODING_PLAN for all managed providers
* fix(auth): address round-3 review blockers
- Fix CI: add missing useProviderUpdates mock in AppContainer.test.tsx
that caused TypeError breaking React effects (title/height tests)
- Fix half-rollback: snapshot settings + modelProviders before install,
restore in-memory state (not just disk) on refreshAuth failure
- Fix .orig backup reuse: always create fresh backup (overwrite stale),
cleanup on success, unlink after restore to prevent data loss
- Fix cross-package key consistency: VS Code settingsWriter now writes
to providerMetadata namespace matching CLI's new structure
- Fix validateApiKey: remove baseUrl guard so sk-sp- prefix check
applies to both China and Global Coding Plan endpoints
* fix(cli): stabilize AuthDialog tests for slower CI environments
Increase vi.waitFor timeouts from default 1000ms to 5000ms and replace
unreliable fixed-delay waits with proper render-completion assertions,
preventing flaky failures on Linux/Windows CI runners with Node 22/24.
* fix(core): use id+baseUrl composite key for model identity
Custom provider installs previously used model id alone to determine
ownership, causing the second install to remove the first backend's
model entry when both expose the same model id (e.g. gpt-4o) with
different baseUrls. Use id+baseUrl as the composite identity key
throughout the model registry, ModelDialog, and modelsConfig to
prevent cross-provider model collisions.
* fix(cli): update ModelDialog tests for composite-key model identity
Add missing getModelsConfig and getActiveRuntimeModelSnapshot mocks,
and update switchModel assertion to expect the new { baseUrl } options
object introduced in 4c4ebb81c.
* fix(cli): skip flaky TUI input tests on all CI environments
Multi-step TUI navigation tests exceed 5s timeout on CI runners
regardless of Node version. Extend skip condition from only Node 20
to all CI environments where input simulation is unreliable.
* fix(cli): improve auth/provider edge cases and UX
- Add fallback to non-free models in OpenRouter OAuth when no free models available
- Validate non-empty models list when building install plan
- Fix auth status to use activeConfig instead of iterating all providers
- Clear API key input when switching auth protocol
- Skip unnecessary auth refresh when applying provider updates
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* test(cli): update tests for empty model validation and skip auth refresh
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): skip remaining flaky TUI input AuthDialog tests on CI
8558c49bc only converted part of the tests to itWhenTuiInputReliable,
leaving 9 multi-step keyboard-navigation tests still using bare it().
These tests reliably time out on Linux/Windows CI runners where stdin
simulation timing is unpredictable.
Convert all remaining it() → itWhenTuiInputReliable() so CI skips them,
and add a comment block to clearly demarcate the TUI input section.
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
---------
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* docs(design): add banner customization design (#3005)
Document the design for issue #3005 (customize CLI banner area). Covers
the banner region taxonomy and what is replaceable vs. locked, the three
proposed settings (`ui.hideBanner`, `ui.customBannerTitle`,
`ui.customAsciiArt`) and their resolution pipeline, the schema additions
and wiring touch points, five alternative shapes considered, and the
security / failure-handling guards. Mirrored EN + zh-CN under
`docs/design/customize-banner-area/`. No code changes in this commit;
implementation lands in a follow-up PR.
Generated with AI
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(cli): customize banner area (logo, title, hide)
Adds three opt-in `ui.*` settings that let users replace brand chrome on
startup while keeping the operational lines (version, auth, model, path)
locked: `hideBanner`, `customBannerTitle`, `customAsciiArt` (string,
{path}, or {small,large}).
A new resolver in `packages/cli/src/ui/utils/customBanner.ts` walks the
loaded settings, normalizes each tier per scope (so {path} resolves
against the file that declared it), reads the file with O_NOFOLLOW and a
64 KB cap on POSIX, sanitizes via a banner-specific stripper that drops
OSC/CSI/SS2/SS3 sequences while preserving newlines, and caps art at 200
lines × 200 cols and titles at 80 chars. Every soft failure logs a
`[BANNER]` warn and falls through to the bundled QWEN logo or default
brand title — banner config can never crash the CLI.
`<Header />` now picks the widest custom tier that fits via a shared
`pickAsciiArtTier` helper and falls back to `shortAsciiLogo` otherwise;
`<AppHeader />` extends the existing `showBanner` gate to honor
`hideBanner` alongside the screen-reader fallback.
Tracks #3005 and the design merged in #3671.
* docs(design): apply prettier to banner customization design
Reformats the EN and zh-CN design docs in
`docs/design/customize-banner-area/` to satisfy `npx prettier --check`:
table column alignment and trailing commas in `jsonc` examples. No
content changes — the words, tables, and code blocks all say the same
thing as before.
Carries forward the only actionable feedback from the now-closed
docs-only PR #3671, where the prettier check was the sole change
requested.
* fix(cli): address banner audit findings
Three audit-driven fixes for the banner customization feature:
1. **VSCode JSON schema accepts every documented shape.** The
`ui.customAsciiArt` entry in
`packages/vscode-ide-companion/schemas/settings.schema.json` was
declared as `type: object`, which made VSCode flag the inline-string
form (`"customAsciiArt": " ___"`) — a shape the runtime accepts and
the design doc recommends — as a schema violation. Replaced with a
`oneOf` covering string, `{path}`, and `{small,large}` (with each
tier itself string-or-`{path}`).
2. **Narrow terminals no longer leak the QWEN logo over a white-label
deployment.** When a user supplied custom ASCII art but neither tier
fit the terminal, `Header.tsx` previously fell back to the bundled
`shortAsciiLogo` — silently undoing the white-label intent on small
windows. The fallback now distinguishes "user supplied custom art"
from "no custom art at all": in the first case the logo column is
hidden entirely (info panel still renders); in the second case the
default logo shows as before. Soft-failure paths (missing file,
sanitization rejection) still fall through to `shortAsciiLogo`.
3. **Sanitizer strips C1 control bytes (0x80-0x9F).** The art and title
strippers previously stopped at 0x7F, leaving single-byte CSI
(`0x9B`), DCS (`0x90`), ST (`0x9C`) and other C1 controls intact —
which legacy 8-bit terminals would still interpret. Aligned the
ranges with the repo's existing `stripUnsafeCharacters` (in
`textUtils.ts`) so banner content can't carry interpreted control
bytes through.
New tests cover: C1 strip in art and title, absolute path reads,
symlink rejection on POSIX, narrow-terminal hide-on-custom-art, and
end-to-end `<AppHeader />` rendering through `resolveCustomBanner`.
The full banner suite is 48 tests (was 42).
* docs(design): clarify cross-scope tier merge and white-label fallback
Two clarifications surfaced by the audit on the implementation PR:
1. The design said `customAsciiArt` follows standard merge precedence,
but the resolver actually walks scopes per-tier so workspace can
override only `large` while user keeps `small`. Document that this
per-tier walk is intentional — both because each `{path}` has to
resolve against the file that declared it (the merged view loses
that information) and because it lets users keep a personal default
tier and override the other one per-workspace.
2. The render-time tier-selection step now distinguishes "user
supplied custom art but neither tier fits" (hide the logo column
entirely; falling back to `shortAsciiLogo` would silently undo a
white-label deployment on narrow terminals) from "user supplied no
custom art at all" (fall through to `shortAsciiLogo` and let the
default-logo width gate decide). Step 5's pure soft-failure
fallback (missing file, sanitization rejection) is unchanged —
still `shortAsciiLogo`.
Mirrored both edits in the zh-CN translation.
Generated with AI
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* docs(design): add size budget section to banner customization
Question raised on the implementation PR: "why is the test logo `CCA`
instead of the full `Custom Code Agent` — is there a character limit?"
There is no character-count limit on titles or art. There is a
**width budget** driven by terminal columns, plus an absolute
hard cap (200×200 art, 80-char title) to keep malformed input from
freezing layout. The existing user-facing guide didn't quantify the
budget anywhere, so users were guessing why long inline names didn't
render.
Add a "How wide can the logo be? — the size budget" subsection that
spells out the formula
(`availableLogoWidth = terminalCols − 4 − 2 − 44`), tabulates it at
80 / 100 / 120 / 200 cols, calls out that a 17-char brand like
"Custom Code Agent" can't render as a single ANSI Shadow line on most
terminals (~120 cols of art), and shows the stacked-words
`{ small, large }` recipe — including the `figlet` one-liner that
generates the corresponding `banner-large.txt`.
Mirrored in the zh-CN translation.
Generated with AI
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* docs(design): add limits-at-a-glance table; switch demo to Custom Agent
The banner-customization design now has the size budget written down,
but the per-cap limits (80-char title, 200×200 art, 64 KB file) were
buried inside the size-budget formula table. Surface them as their own
"Limits at a glance" subsection at the top of the user-configuration
guide so users see the hard caps before they start hand-crafting art.
Also switch the running example from "Custom Code Agent" (17 chars,
~120 cols of ANSI Shadow art on one line — too wide for any common
terminal) to "Custom Agent" (12 chars, two-word stack at ~54 cols ×
12 lines, fits any terminal ≥ 104 cols). The figlet recipe is now a
two-word pipeline so a copy-paste run produces art the size the doc
claims.
Mirrored both changes in the zh-CN translation. The implementation
itself is unchanged.
Generated with AI
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): address PR review + CI Lint failure
Two reviewer findings on PR #3710 (and the Lint job that fails for the
same root cause):
1. **Schema regen now reproduces the committed JSON Schema.** The CI
Lint step runs `npm run generate:settings-schema` and fails when
the worktree dirties — my earlier hand-authored `oneOf` got blown
away because `customAsciiArt` is `type: 'object'` in the source
schema and the generator had no way to emit a union.
Add a `jsonSchemaOverride` escape-hatch field on `SettingDefinition`:
when set, the generator emits the override verbatim (description
carried forward) instead of the type-driven shape. Set it on
`customAsciiArt` to express the runtime union (string | {path} |
{small,large} where each tier is itself string-or-{path}). The
committed schema is now regenerated from source and CI's
regenerate-and-diff check passes; two back-to-back regens produce
identical output.
2. **Untrusted workspace settings no longer influence the banner.**
`collectScopedTiers()` walked `settings.workspace` directly because
per-scope file paths are needed to resolve relative `{path}`
entries — but that bypassed the trust gate that
`settings.merged` enforces. An untrusted checkout could therefore
render its own ASCII art and trigger local file reads through a
`{path}` entry before the user trusts the folder. Skip
`settings.workspace` entirely when `settings.isTrusted` is false.
Two regression tests cover the gate (untrusted = workspace
silenced, falls through to user; trusted = workspace honored).
Test suite for the banner is now 30 resolver tests + the existing
Header / AppHeader / settingsSchema tests = 66 total, all green.
* feat(cli): add ui.customBannerSubtitle for the spacer row
Adds a fourth opt-in setting to the banner customization surface.
The info panel renders four rows (title, subtitle/spacer, status,
path); the second row was a hard-coded single-space spacer up to
now. With this change a fork or white-label deployment can set
`ui.customBannerSubtitle` to a one-line subtitle (e.g. "Built-in
DataWorks Official Skills") and have it render in the secondary
text color in place of the spacer. Empty/unset preserves the
previous blank-spacer layout, so the change is back-compat.
The subtitle is sanitized through the same
`sanitizeSingleLine` helper as the title (now factored out): OSC /
CSI / SS2 / SS3 leaders dropped, every other C0/C1 control byte
replaced with a space, internal whitespace collapsed, ends
trimmed. Capped at 160 characters — looser than the title's 80
because tagline / "powered by" copy commonly runs longer — with
the same `[BANNER]` warn on truncation.
Wiring:
- `settingsSchema.ts` — new `customBannerSubtitle` entry next to
`customBannerTitle`, `showInDialog: false` (free-form text in
the TUI dialog isn't worth its own picker).
- `customBanner.ts` — `ResolvedBanner.subtitle` field;
`resolveCustomBanner` populates it; `sanitizeTitle` and the new
`sanitizeSubtitle` share the same helper.
- `Header.tsx` — when `customBannerSubtitle` is truthy the spacer
row renders the string (secondary color, single line) instead
of `<Text> </Text>`. Auth/model and path still sit at their
usual positions.
- `AppHeader.tsx` — pipes `resolvedBanner.subtitle` through.
- VSCode JSON schema regenerated from source (idempotent).
Tests: 5 new resolver tests (default, sanitize, length cap,
empty, newline + C1 strip), 2 new Header tests (renders subtitle
between title and auth; spacer preserved when unset), 1 new
AppHeader integration test (end-to-end through resolver). Banner
suite is now 35 + 17 + 6 + 16 = 74 tests, all green.
Design docs (EN + zh-CN) updated: region taxonomy now lists four
B-rows; "Limits at a glance" table grows a subtitle row;
"Customization rules" matrix and "How to modify" section gain a
"Add a brand subtitle" example with a rendered four-row preview.
* docs(design): sweep stale 3-setting references after subtitle add
Self-review found several sections of the banner customization design
doc still framed for the original three settings; bring them in line
with the four-setting reality landed in c7aa4a401:
- Region taxonomy ASCII diagram now shows four B-rows
(① title, ② subtitle, ③ status, ④ path).
- Resolution-pipeline ASCII diagram and step list pick up
customBannerSubtitle on the input side and the title/subtitle
sanitize step on the resolver side.
- "Settings schema additions" section lists the fourth entry,
customBannerSubtitle, and notes the customAsciiArt
jsonSchemaOverride that landed for VS Code schema reproducibility.
- "Wiring changes" section updates the Header prop list and the
HeaderProps interface, replaces the brittle line-number anchors
with file-level anchors, drops the obsolete `paths` second arg
from resolveCustomBanner, and adds the trust-gate sentence.
- "Security & failure handling" table replaces the
stripTerminalControlSequences shorthand with the actual
banner-specific stripper, splits the title/subtitle row to cover
both, and adds the untrusted-workspace gate as its own row.
- "Verification plan" gains two scenarios: the subtitle row, and
the untrusted-workspace check that the Critical reviewer comment
on the impl PR explicitly asked us to lock down.
Mirrored every edit in the zh-CN translation. The implementation
itself is unchanged.
Generated with AI
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): address banner re-review (FIFO, mutex schema, display width, regex dedupe)
Addresses the five findings on PR #3710 from the latest re-review:
1. **[Critical] FIFO/pipe at `customAsciiArt.path` no longer hangs
startup.** The resolver was calling `openSync(path, O_NOFOLLOW)`
*before* the `fstatSync(...).isFile()` check; on POSIX, opening a
FIFO read-only blocks until a writer connects, and `O_NOFOLLOW`
doesn't help — it only refuses symlinks at the final path
component. `readArtFile` now `lstatSync()`s first and refuses
non-regular files (FIFO / socket / device / symlink) before the
open, while keeping the post-open `fstatSync` check for TOCTOU
safety against a swap between the lstat and the open. New
POSIX-only regression test `mkfifo`s a named pipe and asserts the
resolver soft-fails inside 1 s; if the open ever regresses to
blocking, the test will hang past the timeout and the assertion
will catch it.
2. **[Suggestion] `{path}` and `{small,large}` are now mutually
exclusive in both schema and runtime.** The `jsonSchemaOverride`
on `ui.customAsciiArt` is split into three branches (string,
`{path}`, `{small?, large?}`); none of them allow `path` and tier
keys to co-exist. `normalizeTiers()` mirrors that — an object
carrying both kinds of keys is now soft-rejected with a `[BANNER]`
warn rather than letting `path` silently win and dropping the
tier values. New regression test pins the runtime side.
3. **[Suggestion] Column cap and tier-fit selection now measure in
terminal cells.** `getAsciiArtWidth` (in `textUtils.ts`) and the
`MAX_ART_COLS` cap in `customBanner.ts` were both using UTF-16
`.length`, so 200 CJK fullwidth characters would slip the cap and
render at ~400 cells, and `pickAsciiArtTier`'s width-fit check
was wrong for any non-ASCII art. Switched both to
`getCachedStringWidth` (string-width semantics, already in the
repo); art truncation walks code points until adding another
would push the cell width past the cap, so we never split a
fullwidth code point or surrogate pair down the middle. New
regression test exercises the CJK fullwidth case.
4. **[Suggestion] `collectScopedTiers()` no longer drops a whole
scope just because it has no `file.path`.** Inline-string tiers
don't need an owning settings directory; only `{path}` tiers do.
The path-presence check was moved into the `{path}` branch, so a
path-less scope (e.g. `systemDefaults`, future SDK-injected
scopes) can still contribute inline art. `{path}` entries in such
a scope soft-fail with a tier-specific `[BANNER]` warn rather
than killing the whole scope. Two regression tests cover both
sides.
5. **[Suggestion] OSC / CSI / SS2-3 regex are now authored once.**
Extracted `TERMINAL_OSC_REGEX`, `TERMINAL_CSI_REGEX`,
`TERMINAL_SHIFT_DCS_REGEX` from `stripTerminalControlSequences`
in `@qwen-code/qwen-code-core` and re-export them from the
package index. `customBanner.ts` reuses the constants for
`sanitizeArt` (which still has to preserve `\n` / `\t`) and
delegates the title/subtitle pipeline directly to
`stripTerminalControlSequences`. Also backported the C1 control
strip (0x80-0x9F) into the core helper so all callers
(session-title, etc.) benefit from the same coverage; banner
sanitizer was the only place catching single-byte CSI / DCS / ST.
Banner suite is now 40 + 17 + 6 + 16 = 79 tests, all green. Schema
regen is still byte-for-byte idempotent. `npm run typecheck` and
prettier clean on touched files.
* fix(cli): replace require() with ES6 import in FIFO test (lint)
The FIFO regression test in 7ccbfaeb1 used a synchronous `require()` to
pull in `node:child_process` so the test could lazy-load `execFileSync`
only when needed. CI Lint flagged it under `no-restricted-syntax` —
the repo enforces ES6 imports throughout, including in tests, with no
exception for `require()`.
Move the import to the top of the file alongside the other `node:` /
vitest imports. The `try/catch` around `execFileSync('mkfifo', ...)`
still gates the test on `mkfifo` being available (rare on a fresh
container, so we skip rather than fail). 40 / 40 tests still pass and
ESLint is clean on the touched file.
---------
Co-authored-by: 秦奇 <gary.gq@alibaba-inc.com>
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): add "API Key" option to `qwen auth` interactive menu
The `qwen auth` CLI command only showed 2 options (Coding Plan, Qwen OAuth),
while the interactive `/auth` dialog showed 3 (Coding Plan, API Key, Qwen OAuth).
Users following the README instructions to configure OpenRouter/Fireworks via
`qwen auth` had no API Key entry point.
- Add "API Key" option to the `runInteractiveAuth` menu with two sub-paths:
"Alibaba Cloud ModelStudio Standard API Key" (guided flow) and
"Custom API Key" (prints docs link)
- Add `qwen auth api-key` yargs subcommand for direct access
- Extract `createMinimalArgv` / `loadAuthConfig` helpers to eliminate duplicated
CliArgs boilerplate
- Extract `promptForInput` to share raw-mode stdin logic between `promptForKey`
and `promptForModelIds`
- Improve `showAuthStatus` to distinguish Coding Plan, Standard API Key, and
generic OpenAI-compatible configurations
- Align menu labels and descriptions with the interactive `/auth` dialog
Closes#3413
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* docs: add `qwen auth api-key` to auth subcommand tables
Update documentation to reflect the new `qwen auth api-key` subcommand:
- auth.md: add to subcommands table, examples, and interactive menu display
- commands.md: add to CLI Auth Subcommands table
- quickstart.md: add to quick-reference command table
* fix(cli): restore incomplete Coding Plan warning in showAuthStatus
When selectedType is USE_OPENAI and Coding Plan metadata exists but
the API key is missing, show the incomplete warning instead of falling
through to the generic "OpenAI-compatible" status.
* refactor(cli): use endpoint constants in region selector and fix status formatting
- Use ALIBABA_STANDARD_API_KEY_ENDPOINTS constants for region
descriptions instead of hardcoded URLs
- Restore trailing newline in showAuthStatus "no auth" command list
for consistent spacing
* fix(cli): determine active auth method from model config in showAuthStatus
Previously showAuthStatus checked which env keys exist to determine
the auth method, causing false reports when users switch providers
(e.g., Coding Plan key still present after switching to Standard API Key).
Now it inspects the active model's provider config (baseUrl/envKey) to
determine the actual method, and validates the corresponding key exists:
- Coding Plan: check via isCodingPlanConfig + CODING_PLAN_ENV_KEY
- Standard API Key: check via DASHSCOPE_STANDARD_API_KEY_ENV_KEY + endpoints
- Generic OpenAI-compatible: check if the model's envKey is set
Also clear stale Coding Plan metadata (codingPlan.region/version and
process.env) when switching to Standard API Key.
* fix(cli): add legacy fallback in showAuthStatus and clear persisted Coding Plan env
- When no active model config is found (legacy setups without
modelProviders), fall back to env key / metadata checks for
Coding Plan status detection. Fixes CI test failures.
- When activeConfig exists but has no envKey, report incomplete
status instead of false positive "Configured".
- Clear persisted env.BAILIAN_CODING_PLAN_API_KEY from settings
when switching to Standard API Key, not just process.env.
* fix(cli): also remove Coding Plan model entries when switching to Standard API Key
When switching to Standard API Key, filter out existing Coding Plan
model entries from modelProviders.openai in addition to old Standard
entries. Previously these were preserved but their credential source
(BAILIAN_CODING_PLAN_API_KEY) was cleared, leaving broken model
entries visible in /model.
---------
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(cli,core): generate tool-use summaries for compact mode
After each tool batch completes, fire a parallel fast-model call to
generate a short git-commit-subject-style label summarizing what the
batch accomplished (e.g. "Read txt files", "Searched in auth/"). In
compact mode the label replaces the generic "Tool × N" header so N
parallel tool calls collapse to a single semantic row.
The fast-model call (~1s) runs fire-and-forget, overlapped with the
next turn's API stream, so there is no perceived latency. Missing
fast model, aborted turns, and model failures all degrade silently to
the existing rendering.
The summary is also emitted as a `tool_use_summary` history entry
with `precedingToolUseIds`, keeping the shape compatible with SDK
clients that want to render collapsed tool views on their own.
Gated by `experimental.emitToolUseSummaries` (default on). Can be
overridden per-session with `QWEN_CODE_EMIT_TOOL_USE_SUMMARIES=0|1`.
The system prompt and truncation rules (300 chars per tool field,
200 chars of trailing assistant text as intent prefix) match the
existing behavior seen in other tools that emit the same message
type, so SDK consumers see a consistent shape across clients.
* fix(core): bound cleanSummary quote-strip regex to avoid ReDoS
CodeQL js/polynomial-redos flagged the /^["'`]+|["'`]+$/g pattern in
cleanSummary because its input comes from an LLM (treated as
uncontrolled). The original regex is anchored and linear in practice,
but tightening the quantifier to {1,10} both satisfies the static
check and caps engine work on pathological model output with a long
run of quotes. Ten opening/closing quotes is well past anything a real
label would produce.
* fix(cli): render tool_use_summary inline so full mode also shows the label
The summary was only visible in compact mode because the full-mode
ToolGroupMessage ignored the compactLabel prop. Compact mode got away
with this because mergeCompactToolGroups triggers refreshStatic(),
which re-renders the merged tool_group with its newly-looked-up
label. Full mode has no such refresh path, so when the fast-model
call resolves *after* the tool_group has been committed to the
append-only <Static>, there is no way to retroactively decorate it.
Switch to rendering `tool_use_summary` as its own inline history item
(a single dim `● <label>` line). New items append cleanly to <Static>,
so the summary flows in naturally once the fast-model call resolves.
Compact mode still replaces the merged tool_group header with the
label and hides the standalone summary line via the `compactMode`
guard.
With this, the feature works under the default `ui.compactMode: false`
— not just the opt-in compact view.
* docs: tool-use-summaries feature guide, settings entry, and design doc
Three new docs matching the existing fast-model feature docs layout:
- docs/users/features/tool-use-summaries.md — user-facing guide
covering full + compact rendering, configuration (settings + env),
failure modes, cost, and cross-links to followup-suggestions.
- docs/users/configuration/settings.md — register the new
experimental.emitToolUseSummaries setting next to the other
fast-model-driven UI settings.
- docs/design/tool-use-summary/tool-use-summary-design.md — deep dive
matching the compact-mode-design.md competitive-analysis style.
Documents the Claude Code port (prompt, truncation, timing, gate),
the deviations (settings layer, default on, cleanSummary, dual
render paths), and the Ink <Static> append-only rationale that
drove the inline full-mode render vs header-replacement split.
* docs: add Recommended pairing section to tool-use-summaries
Full-mode rendering of the summary works, but for small same-type
batches (Read × 3 and similar) the label visibly restates what the
tool lines already show. Pairing with ui.compactMode: true folds
the whole batch into a single labeled row, which is the cleanest
transcript shape once the label is available.
Adds a dedicated section showing the paired settings.json snippet
and explicitly calling out when each mode wins (and when to turn
the feature off instead).
* fix: address review feedback on tool-use summary generation
Addresses multiple issues from @chiga0's review:
Blocking — compact-mode label invisible for single-batch turns.
mergeCompactToolGroups's adjacency-only gating left a trailing
tool_use_summary in the merged result whenever there was no second
batch to merge across. That pushed mergedHistory.length lock-step
with history.length and MainContent's refreshStatic heuristic
(currMLen <= prevMLen) never fired, so Ink's append-only <Static>
never repainted the tool_group with its newly-looked-up label.
Drop tool_use_summary items unconditionally now; gemini_thought
still survives to avoid unnecessary repaints. New tests cover
the single-batch case and the summary-before-user-message case.
Blocking — stale summary appears after Ctrl+C on the next turn.
summarySignal captured the CURRENT turn's AbortController, but the
summary resolves during the NEXT turn's streaming window. The next
turn's submitQuery allocates a fresh controller, so the captured
signal was never aborted — Ctrl+C during the new turn used to let
the previous turn's summary land in the transcript seconds later.
Fix: dedicated per-batch AbortController tracked in a ref set,
aborted eagerly from cancelOngoingRequest; resolve-time check reads
the live abort state and turnCancelledRef.
High — summarizer input pollution.
geminiTools contained error/cancelled tools; retry-loop warnings
and "Cancelled by user" strings were feeding the fast model.
cleanSummary can only reject error-shaped output, not prevent the
model from hallucinating a plausible label from bad input (the PR's
own tmux screenshot showed "Read txt files · 5 tools" where 4 of
the 5 were prior-retry failures). Filter to status === 'success'
before building the prompt; skip the call entirely if nothing's
left.
High — unstable label on merged groups.
getCompactLabel iterated all callIds and returned the first hit,
so asynchronous resolution order made the header visibly flip
from SB to SA when batch A resolved after batch B. Lock onto
item.tools[0].callId to keep stable "leading batch governs"
semantics.
High — force-expanded groups in compact mode had no label at all.
Compact mode routes non-force-expand groups through
CompactToolGroupDisplay (consumes compactLabel) and force-expand
groups through the full ToolGroupMessage (ignores compactLabel);
the standalone ● line was gated on !compactMode, creating a dead
zone — exactly the diagnostically valuable case. MainContent now
computes absorbedCallIds (which groups actually consume the
header replacement) and passes summaryAbsorbed to
HistoryItemDisplay; force-expand groups in compact mode get the
standalone line as the label's only path to the screen.
Medium — cleanSummary robustness.
Extend quote-strip to Unicode curly + CJK corner brackets; strip
markdown emphasis (**bold**, _italic_); broaden refusal-prefix
rejection to curly-apostrophe "I can't", Chinese "我无法 / 我不能 /
抱歉 / 无法", and "Failed to / Sorry, / Request failed". 7 new
cleanSummary tests cover the added cases.
Low — concurrent-rendering safety.
Move historyRef.current = history from render phase into
useLayoutEffect so bailed renders can't leave a dropped value.
Low — CompactToolGroupDisplay readability.
Extract renderSummaryHeader / renderDefaultHeader helpers and
document the toolCalls.length > 1 count-suffix guard so a future
"fix" to >= 1 doesn't reintroduce "Read config.json · 1 tools".
Docs — add Scope & Lifecycle section to tool-use-summaries.md
covering (1) one generation per batch shared by both modes,
(2) no backfill on toggle / session resume, (3) main-agent batches
only with the Task-tool clarification.
* fix: address second-round review feedback on tool-use summaries
Critical — force-expand groups lost their summary entirely.
Previous round's "drop tool_use_summary unconditionally" merge fix
also stripped summaries for force-expanded groups, defeating the
exact case (errors, confirmations, focused shell) where the
standalone ● label is the label's only path to the screen. The
merge function now takes an absorbedCallIds set: summaries whose
preceding callIds are all absorbed by a compact tool_group header
are dropped (so refreshStatic still fires), but force-expanded
summaries pass through to be rendered standalone by
HistoryItemDisplay. MainContent computes absorbedCallIds from raw
history and passes it in. New tests cover both the absorbed-drop
and the force-expand-preserve cases plus the empty-set default
for callers that don't compute absorption.
Suggestion — late-arriving summaries could land out of order.
A slow fast-model call could resolve after the next turn's
content was committed, planting the ● label between later items
in full mode. The resolve callback now captures the first batch
callId, locates the corresponding tool_group at resolve time,
and drops the summary if a newer tool_group has already appeared
in history. New test exercises this with a manually-resolved
fast-model promise.
Suggestion — truncateJson allocated full JSON for large strings.
A 10MB ReadFile result was being JSON.stringify'd in full only to
be sliced down to 300 chars. Added preTruncate that walks the
value (depth-bounded to 4) and slices string leaves to maxLength
before serialization. Tests verify the input never reaches its
full pre-cap form.
Suggestion — settings description over-claimed SDK emission.
The description said summaries are emitted to SDK clients as a
tool_use_summary message; the SDK plumbing isn't actually wired
in this PR (the factory is exported for follow-up). Updated
settings.json description and regenerated the vscode schema to
state CLI-only scope explicitly.
Suggestion — fastModel data-boundary not documented.
When fastModel uses a different provider than the main session
model, tool inputs/outputs cross a new auth boundary that users
may not expect. Added "Data flow & privacy" section to the user
feature doc spelling out: same-provider fast model = no scope
change; different-provider = strictly larger sharing scope; two
escape hatches (same-provider fast model OR feature off).
Code-level mitigation (metadata-only mode) deferred.
* feat(cli): add OpenRouter auth flow
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(cli): add OpenRouter model management UI
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): align OpenRouter OAuth fallback session
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(cli): unify OpenRouter model setup flow
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(auth): update OAuth description with provider examples and i18n support
- Updated OAuth option description to include provider examples (OpenRouter, ModelScope)
- Added internationalization support for new description text
- Updated all language files (en, zh, de, fr, ja, pt, ru) with translations
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* docs: simplify OpenRouter design docs
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* test(auth): fix OpenRouter OAuth mock typing
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* test(auth): sync AuthDialog tests with new three-option main menu layout
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
Update assertions that referenced removed 'Qwen OAuth' and 'OpenRouter' options in the main/API-key views to match the refactored OAUTH / CODING_PLAN / API_KEY structure.
* fix(i18n): add missing zh-TW translation for browser-based auth key
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
zh-TW.js was generated from main's en.js which had already removed this key, but the PR re-adds it in en.js. Sync zh-TW with the new translation.
* feat(cli): Improve custom auth wizard with step indicators and cleaner advanced config (#3607)
* feat(cli): Add custom API key auth wizard with 6-step setup flow
Replace the documentation-only
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>"Custom API Key" screen with an
in-terminal wizard: Protocol select → Base URL input → API Key input →
Model ID input → JSON review → Save.
- Add 5 new ViewLevels and render functions in AuthDialog
- Implement utility functions: generateCustomApiKeyEnvKey (normalization),
normalizeCustomModelIds (split/trim/dedupe), maskApiKey (display)
- Implement handleCustomApiKeySubmit in useAuth with backup, env key
generation, modelProviders merge, auth refresh, and user feedback
- Wire handler through UIActionsContext and AppContainer
- Add 18 unit tests for utilities, 4 wizard flow integration tests
* feat(cli): Improve custom auth wizard with step indicators and cleaner advanced config
- Add step indicators (Step 1/6 · Protocol) to each wizard screen
- Remove redundant Protocol/Endpoint context from each step for focus
- Redesign advanced config: add descriptions to thinking/modality toggles
- Remove max tokens option; keep only thinking and modality settings
- Add ↑↓ arrow navigation with Space toggle and Enter to continue
- Generation config flows through review JSON and final submit
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* test: Fix Windows CI failures in fileUtils and AuthDialog tests
- fileUtils.test.ts: Mock node:child_process execFile to prevent
pdftotext spawn that times out on Windows (ENOENT, 5s timeout)
- AuthDialog.test.tsx: Add char-by-char typeText() helper to work
around Node 24.x + ink TextInput compatibility issue on Windows
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): Reset advanced wizard state and use JSON.stringify for settings preview
- Reset advancedThinkingEnabled, advancedModalityEnabled, and
focusedConfigIndex when re-entering custom wizard to prevent
state leakage between configurations
- Replace hand-rolled JSON string concatenation with
JSON.stringify for settings.json preview to properly escape
special characters in model IDs and base URLs
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
---------
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(cli): harden OpenRouter OAuth callback handling
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* test(cli): stabilize OpenRouter state mismatch test
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* test(cli): stabilize custom auth wizard navigation
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
---------
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* feat(session): auto-title sessions via fast model, add /rename --auto
The /rename work in #3093 generates kebab-case titles only when the user
explicitly runs `/rename` with no args; until they do, the session picker
shows the first user prompt (often truncated or misleading). This change
adds a sentence-case auto-title that fires once per session after the
first assistant turn, using the configured fast model.
New service: `packages/core/src/services/sessionTitle.ts` —
`tryGenerateSessionTitle(config, signal)` returns a discriminated outcome
(`{ok: true, title, modelUsed}` | `{ok: false, reason}`) so callers can
either handle failures generically or map reasons to actionable messages.
Prompt shape: 3-7 words, sentence case, good/bad examples including a
CJK row, JSON schema enforced via `baseLlmClient.generateJson`.
`maxAttempts: 1` — titles are cosmetic metadata and shouldn't fight
rate limits.
Trigger point: `ChatRecordingService.maybeTriggerAutoTitle` runs after
`recordAssistantTurn`. Fire-and-forget promise, guarded by:
- `currentCustomTitle` — don't overwrite any existing title.
- `autoTitleController` doubles as in-flight flag; a second turn while
the first is still pending is a no-op.
- `autoTitleAttempts` cap of 3 — the first assistant turn may be a
pure tool-call with no user-visible text; retry for a handful of
turns until a title lands. Cap bounds total waste.
- `!config.isInteractive()` — headless CLI (`qwen -p`, CI) never auto-
titles; spending fast-model tokens on a one-shot session is waste.
- `autoTitleDisabledByEnv()` — `QWEN_DISABLE_AUTO_TITLE=1` opt-out.
- `config.getFastModel()` falsy — skip entirely rather than falling
back to the main model; auto-titling on main-model tokens is too
expensive to be silent.
Persistence: `CustomTitleRecordPayload` grows a `titleSource: 'auto' |
'manual'` field. Absent on pre-change records (treated as `undefined`
→ manual, safe default so a user's pre-upgrade `/rename` is never
silently reclassified). `SessionPicker` renders `titleSource === 'auto'`
titles in dim (secondary) color; manual stays full contrast. On resume,
the persisted source is rehydrated into `currentTitleSource` — without
this, finalize's re-append would rewrite an auto title as manual on
every resume cycle.
Cross-process manual-rename guard: when two CLI tabs target the same
JSONL, in-memory state can diverge. Before writing an auto record, the
IIFE re-reads the file via `sessionService.getSessionTitleInfo`. If a
`/rename` from another process landed as manual, bail and sync local
state — never clobber a deliberately-chosen manual title with a model
guess. Cost is one 64KB tail read per successful generation.
`finalize()` aborts the in-flight controller before re-appending the
title record. Session switch / shutdown doesn't have to wait on a slow
fast-model call.
New user-facing command: `/rename --auto` regenerates via the same
generator — explicit user trigger, overwrites whatever's there (manual
or auto) because the user asked. Errors route through
`autoFailureMessage(reason)` so `empty_history`, `model_error`,
`aborted`, etc. each get actionable guidance rather than a generic
"could not generate". `/rename -- --literal-name` is the sentinel for
titles that start with `--`; unknown `--flag` tokens error with a hint
pointing at the sentinel. Existing `/rename <name>` and bare `/rename`
(kebab-case via existing path) are unchanged, except the kebab path now
prefers fast model when available and runs its output through
`stripTerminalControlSequences` (same ANSI/OSC-8 hardening as the
sentence-case path).
New shared util: `packages/core/src/utils/terminalSafe.ts` —
`stripTerminalControlSequences(s)` strips OSC (\x1b]...\x07|\x1b\\), CSI
(\x1b[...[a-zA-Z]), SS2/SS3 leaders, and C0/C1/DEL as a backstop. A
model-returned `\x1b[2J` or OSC-8 hyperlink escape would otherwise
execute on every SessionPicker render; both sentence-case and kebab
paths now route titles through the helper before they reach the JSONL
or the UI.
Tail-read extractor: `extractLastJsonStringFields(text, primaryKey,
otherKeys, lineContains)` reads multiple fields from the same matching
line in a single pass. Two separate tail scans could return a mismatched
pair (primary from a newer record, secondary from an older one with only
the primary set); the new helper guarantees the pair is atomic. Validates
a proper closing quote on the primary value so a crash-truncated trailing
record can't win the latest-match race. `readLastJsonStringFieldsSync`
is its file-reading wrapper — same tail-window fast path and full-file
fallback as the single-field version, plus a `MAX_FULL_SCAN_BYTES = 64MB`
cap so a corrupt multi-GB session file can't freeze the picker. Session
reads now open with `O_NOFOLLOW` (falls back to plain RDONLY on Windows
where the constant isn't exposed) — defense in depth against a symlink
planted in `~/.qwen/projects/<proj>/chats/`.
Character handling: `flattenToTail` on the LLM prompt drops a dangling
low surrogate after `slice(-1000)` — otherwise a CJK supplementary char
or emoji cut mid-pair produces invalid UTF-16 that some providers 400.
`sanitizeTitle` applies the same surrogate scrub after max-length trim,
and strips paired CJK brackets (`「」 『』 【】 〈〉 《》`) as whole units so
a `【Draft】 Fix login` doesn't leave a dangling `】` after leading-char
strip. `lineContains` in the title reader is tightened from the loose
substring `'custom_title'` to `'"subtype":"custom_title"'` so user text
containing the literal `custom_title` can't shadow a real record.
Tests: 46 new unit tests across
- `sessionTitle.test.ts` (22): success/all-failure-reasons, tool-call
filter, tail-slice, surrogate scrub, ANSI/OSC-8 strip, CJK brackets.
- `chatRecordingService.autoTitle.test.ts` (15): trigger/skip matrix,
in-flight guard, abort propagation on finalize, manual/auto/legacy
resume symmetry, cross-process race, env opt-out, retry-after-
transient.
- `sessionStorageUtils.test.ts` (13): single-pass extractor, straddle
boundary, truncated trailing record, lineContains, multi-field atom.
- `renameCommand.test.ts` (8): `--auto` success, all reasons, sentinel,
unknown-flag hint, positional rejection, manual/SessionService
fallbacks.
* docs(session): design doc for auto session titles
Matches the session-recap design doc shape (Overview / Triggers /
Architecture / Prompt Design / History Filtering / Persistence /
Concurrency / Configuration / Observability / Out of Scope) and adds a
Security Hardening section unique to the title path — titles render
directly in the picker and persist in user-readable JSONL, so
LLM-returned control sequences are an attack surface the recap path
doesn't have.
Captures decisions a code-only reader has to reverse-engineer:
- Why `maxAttempts: 1` (best-effort cosmetic metadata; no retry loop).
- Why `autoTitleAttempts` cap is 3 (first turn can be pure tool-call).
- Why the auto trigger does NOT fall back to the main model but
session-recap does (auto-title fires on every turn; silently charging
main-model tokens is a bill surprise).
- Why `titleSource: undefined` stays unwritten on legacy records (no
rewrite risks silently reclassifying user intent).
- Why the cross-process re-read sits between the LLM await and the
append (manual wins at both in-process and on-disk layers).
- Why `finalize()`'s abort tolerates a controller swap (in-flight
identity check).
- Why JSON-schema function calling instead of tag extraction (avoid
reasoning preamble bleed; cross-provider reliability).
Placed at docs/design/session-title/ alongside session-recap,
compact-mode, fork-subagent, and other per-feature design docs. No
sidebar index update required — the design folder is unindexed.
* test(rename): pin model choice in bare /rename kebab path
Addresses reviewer feedback: the bare `/rename` model selection
(`config.getFastModel() ?? config.getModel()`) had no test pinning
it either way. Previous tests mocked `getHistory: []`, which exits
the function before the model is ever chosen, so a silent regression
to either direction (always-main or always-fast) would pass CI.
Two explicit cases now:
- fastModel set → `generateContent` called with `model: 'qwen-turbo'`.
- fastModel unset → `generateContent` called with `model: 'main-model'`.
The tests intentionally mock a non-empty history so the kebab path
reaches the generateContent call site instead of bailing on empty input.
* refactor(cli): replace slash command whitelist with capability-based filtering (Phase 1)
## Summary
Replace the hardcoded ALLOWED_BUILTIN_COMMANDS_NON_INTERACTIVE whitelist with a
unified, capability-based command metadata model. This is Phase 1 of the slash
command architecture refactor described in docs/design/slash-command/.
## Key changes
### New types (types.ts)
- Add ExecutionMode ('interactive' | 'non_interactive' | 'acp')
- Add CommandSource ('builtin-command' | 'bundled-skill' | 'skill-dir-command' |
'plugin-command' | 'mcp-prompt')
- Add CommandType ('prompt' | 'local' | 'local-jsx')
- Extend SlashCommand interface with: source, sourceLabel, commandType,
supportedModes, userInvocable, modelInvocable, argumentHint, whenToUse,
examples (all optional, backward-compatible)
### New module (commandUtils.ts + commandUtils.test.ts)
- getEffectiveSupportedModes(): 3-priority inference
(explicit supportedModes > commandType > CommandKind fallback)
- filterCommandsForMode(): replaces filterCommandsForNonInteractive()
- 18 unit tests
### Whitelist removal (nonInteractiveCliCommands.ts)
- Remove ALLOWED_BUILTIN_COMMANDS_NON_INTERACTIVE constant
- Remove filterCommandsForNonInteractive() function
- Replace with CommandService.getCommandsForMode(mode)
### CommandService enhancements (CommandService.ts)
- Add getCommandsForMode(mode: ExecutionMode): filters by mode, excludes hidden
- Add getModelInvocableCommands(): reserved for Phase 3 model tool-call use
### Built-in command annotations (41 files)
Annotate every built-in command with commandType:
- commandType='local' + supportedModes all-modes: btw, bug, compress, context,
init, summary (replaces the 6-command whitelist)
- commandType='local' interactive-only: export, memory, plan, insight
- commandType='local-jsx' interactive-only: all remaining ~31 commands
### Loader metadata injection (4 files)
Each loader stamps source/sourceLabel/commandType/modelInvocable on every
command it emits:
- BuiltinCommandLoader: source='builtin-command', modelInvocable=false
- BundledSkillLoader: source='bundled-skill', commandType='prompt',
modelInvocable=true
- command-factory (FileCommandLoader): source per extension/user origin,
commandType='prompt', modelInvocable=!extensionName
- McpPromptLoader: source='mcp-prompt', commandType='prompt', modelInvocable=true
### Bug fix
MCP_PROMPT commands were incorrectly excluded from non-interactive/ACP modes by
the old whitelist logic. commandType='prompt' now correctly allows them in all
modes.
### Session.ts / nonInteractiveHelpers.ts
- ACP session calls getAvailableCommands with explicit 'acp' mode
- Remove allowedBuiltinCommandNames parameter from buildSystemMessage() —
capability filtering is now self-contained in CommandService
* fix test ci
* feat(cli): Phase 2 slash command expansion + ACP fixes + UX improvements
Phase 2.1 - Command mode expansion:
- Extend 13 built-in commands to support non_interactive/acp modes
- A class: export, plan, statusline - supportedModes only
- A+ class: language, copy, restore - add non-interactive branches
- A' class: model, approvalMode - handle dialog paths in non-interactive
- B class: about, stats, insight, docs, clear - full non-interactive branches
- context: format output as readable Markdown instead of raw JSON
- export: use HTML as default format when no subcommand given
Phase 2.2 - SkillTool integration:
- SkillTool now consumes CommandService.getModelInvocableCommands()
Phase 2.3 - Mid-input slash ghost text:
- Replace mid-input dropdown completion with inline ghost text
- Match Claude Code behavior: gray dimmed completion hint in input box
- Tab accepts the ghost text completion
- Add findMidInputSlashCommand() and getBestSlashCommandMatch() utilities
ACP session bug fixes:
- Fix executionMode undefined in interactive mode (slashCommandProcessor)
- Fix slash command output not visible in Zed (use emitAgentMessage)
- Fix newline rendering in Zed (Markdown hard line-break)
- Fix history replay merging consecutive user messages (recordSlashCommand)
- Fix /clear not clearing model context (dynamic chat reference)
* feat: inline complete only for modelInvocable
* fix memory command
* fix: pass 'non_interactive' mode explicitly to getAvailableCommands
- Fix critical bug in nonInteractiveHelpers.ts: loadSlashCommandNames was
calling getAvailableCommands without specifying mode, causing it to default
to 'acp' instead of 'non_interactive'. Commands with supportedModes that
include 'non_interactive' but not 'acp' would be silently excluded.
- Apply the same fix in systemController.ts for the same reason.
- Update test mock to delegate filtering to production filterCommandsForMode()
instead of duplicating the logic inline, preventing divergence.
Fixes review comments by wenshao and tanzhenxin on PR #3283.
* fix: resolve TypeScript type error in nonInteractiveHelpers.test.ts
* fix test ci
* fix mcp prompt in skill manager
* revert pr#3345
* fix test ci
* feat(cli): adapt /insight for non_interactive mode with message return
- non_interactive: run generateStaticInsight() synchronously with no-op
progress callback, return { type: 'message' } with output path
- acp: keep existing stream_messages path with progress streaming
- interactive: unchanged
Add tests for non_interactive success and error paths.
Update phase2-technical-design.md and roadmap.md to reflect the
three-way mode split and clarify that MCP prompts do not need
modelInvocable (they are called via native MCP tool call mechanism).
* fix(cli): ghost text only shown when cursor is at end of slash token
Use strict equality (!==) instead of > in findMidInputSlashCommand so that
ghost text is only computed and Tab-accepted when the cursor sits exactly at
the trailing edge of the partial command token.
Previously, with the cursor inside an already-typed token (e.g. /re|view),
the ghost text suffix would still be shown and pressing Tab would insert it
at the cursor position, producing a duplicated tail. Using strict equality
makes ghost text disappear as soon as the cursor moves inside the token.
Add unit tests for findMidInputSlashCommand covering cursor-at-end,
cursor-inside-token, cursor-past-token, start-of-line, and
no-space-before-slash cases.
* fix(cli): support /model <model-id> in non-interactive and ACP modes
Previously, /model <model-id> (without --fast) fell through to the
non-interactive branch that only returned the current model info and
incorrectly told users to use --fast. Now:
- /model <model-id> → sets the main model via settings + config.setModel()
- /model → shows current model with correct usage hint
- /model --fast <id> → unchanged (sets fast model)
Fixes the inconsistency flagged in PR review: the help text said to use
'/model <model-id>' but the command returned a dialog action which is
unsupported in non-interactive mode.
* fix(cli): declare supportedModes on doctorCommand to enable non-interactive and ACP
The command's action already had non-interactive handling (returns a JSON
message with check results), but without supportedModes declared the
BUILT_IN fallback restricted it to interactive-only so it was never
registered in non_interactive or acp sessions.
* feat(skills): add SkillCommandLoader for user/project/extension skills as slash commands
- New SkillCommandLoader loads user, project, and extension level SKILL.md
files as slash commands (previously only bundled skills were slash-invocable)
- Extension skills follow plugin-command rules: modelInvocable only when
description or whenToUse is present
- User/project skills are always modelInvocable (matching bundled behavior)
- skill-manager now injects extensionName when loading extension-level skills
- Add when_to_use and disable-model-invocation frontmatter support to SKILL.md
and .md command files (SkillConfig, markdown-command-parser, command-factory,
BundledSkillLoader, FileCommandLoader)
- SkillTool filters out skills with disableModelInvocation and includes
whenToUse in the skill description shown to the model
- 16 unit tests for SkillCommandLoader covering all cases
* docs: update phase2 design doc to reflect final decisions on plan/statusline/copy/restore
These four commands are intentionally kept as interactive-only by design:
- /plan and /statusline: tightly coupled with interactive multi-turn UI
- /copy and /restore: clipboard and snapshot restore are inherently interactive
Update design doc classification table, section 4.2, 4.3, 5.2, 5.3,
file change summary, test requirements, behavior analysis table,
and implementation batch descriptions to reflect this decision.
* feat(cli): re-implement slashCommands.disabled denylist based on current refactored code
Adapts the feature originally introduced in pr#3445 to the current
CommandService / Phase-2 refactored code.
Sources (merged, de-duplicated, case-insensitive):
- settings key slashCommands.disabled (string[], UNION merge)
- --disabled-slash-commands CLI flag (comma-separated or repeated)
- QWEN_DISABLED_SLASH_COMMANDS environment variable
Enforcement points:
- CommandService.create() accepts optional disabledNames: ReadonlySet<string>
and removes matching commands post-rename, so disabled commands never appear
in autocomplete, mid-input ghost text, or model-invocable commands list.
- slashCommandProcessor (interactive TUI) passes the denylist to
CommandService.create so disabled commands are absent from dropdown/ghost text.
- nonInteractiveCliCommands.handleSlashCommand() keeps allCommands unfiltered
to distinguish disabled vs unknown; disabled commands return unsupported with
a "disabled by the current configuration" reason (not no_command).
- getAvailableCommands() (ACP) passes the denylist to CommandService.create.
Config plumbing:
- core/Config: ConfigParameters.disabledSlashCommands + getDisabledSlashCommands()
- cli/config: CliArgs.disabledSlashCommands + yargs option + loadCliConfig merge
- settingsSchema: slashCommands.disabled (MergeStrategy.UNION)
- settings.schema.json: regenerated
Tests: 28 pass (CommandService x4, nonInteractiveCliCommands x3 new cases)
* feat(cli): complete slashCommands.disabled coverage from pr#3445
Fill in the three items that were missing from the initial re-implementation:
- packages/cli/src/config/settings.test.ts: add UNION-merge test for
slashCommands.disabled across user and workspace scopes
- packages/cli/src/nonInteractiveCli.test.ts: add getDisabledSlashCommands
mock to the shared mockConfig fixture
- docs/users/configuration/settings.md: add slashCommands section (table +
example + note) and --disabled-slash-commands row in the CLI args table
* fix(cli): match disabled slash commands by alias as well as primary name
The denylist previously only checked cmd.name (the primary/canonical name),
so disabling a command by its alias (e.g. 'about' for the 'status' command)
had no effect. Fix both CommandService.create() and the isDisabled() helper
in nonInteractiveCliCommands.ts to also check altNames.
Also improve the user-facing error message to show the token the user actually
typed (e.g. /about) instead of always showing the primary name (/status).
* fix(core): recover from truncated tool calls via multi-turn continuation (#3049)
When large tool calls (e.g., WriteFile with big HTML) exceed the output
token limit, the model's response gets truncated and required parameters
like file_path are missing. Previously this surfaced as a confusing
"params must have required property" error.
Three-layer defense:
1. Escalate to model's actual output limit (not fixed 64K). Models with
128K output (Claude Opus, GPT-5) now use their full capacity.
2. Multi-turn recovery: if the escalated response is still truncated,
keep the partial response in history and inject a recovery message
("Resume directly — pick up mid-thought") so the model continues
from where it left off. Up to 3 recovery attempts before falling
back to the tool scheduler's guidance.
3. Stronger truncation guidance as fallback: "you MUST split" instead
of "consider splitting".
Also fixes:
- Clear toolCallRequests on RETRY to prevent duplicate tool execution
- Add isContinuation flag to RETRY events so the UI preserves text
buffers during recovery (continuation) but resets them during
escalation (fresh restart)
- Catch errors during recovery to prevent dangling history entries
* docs: update adaptive output token escalation design for recovery mechanism
Update the design doc to reflect:
- Escalation now targets model's actual output limit (64K floor)
- Multi-turn recovery loop after escalation (up to 3 attempts)
- isContinuation flag on RETRY events
- Recovery error handling (pop dangling message, break)
- Updated constants table and model-specific escalation limits
- New design decision: why multi-turn recovery over progressive escalation
* fix: remove competitor reference from code comment
* fix: address review feedback on recovery mechanism
Three correctness fixes from @tanzhenxin's review:
1. Partial text lost during continuation (useGeminiStream.ts):
On continuation RETRY, setPendingHistoryItem(null) cleared the pending
gemini item. The next Content event then saw a null pending item,
created a fresh one, and reset geminiMessageBuffer = eventValue —
discarding the preserved partial text. Now the pending item AND
buffers are kept on continuation, so the continuation appends.
2. Recovery on truncated tool-call turns (geminiChat.ts):
When the truncated turn already contains a complete functionCall,
appending a user recovery message produces model(functionCall) →
user(text) with no intervening functionResponse — an invalid API
sequence. Now recovery skips turns with functionCall parts and
defers to the tool scheduler's layer-3 fallback.
3. Recovery errors swallowed after partial chunks (geminiChat.ts):
If a recovery attempt yielded chunks then failed, the catch block
broke without emitting any terminal signal, leaving the UI with
partial text and no Finished event. Now emits a synthetic
finishReason=STOP chunk in the catch so the UI gets a proper
terminal signal.
* test: add coverage for output token recovery loop
Four targeted tests for the recovery mechanism introduced in the
truncated-tool-call-recovery PR:
1. Recovery loop fires when escalated response is also truncated:
initial MAX_TOKENS → escalation MAX_TOKENS → recovery STOP. Verifies
two RETRY events (one escalation, one continuation) and three API
calls.
2. Recovery is skipped when truncated turn contains a functionCall:
prevents the invalid model(functionCall) → user(text) sequence.
Verifies no continuation RETRY and history ends with the functionCall
intact.
3. Recovery attempts are capped at MAX_OUTPUT_RECOVERY_ATTEMPTS (3):
persistent MAX_TOKENS triggers exactly 5 API calls (1 initial + 1
escalation + 3 recovery).
4. Recovery catch block emits synthetic STOP chunk and pops dangling
user message: when a recovery attempt fails (empty stream →
InvalidStreamError), the UI gets a terminal signal and history
ends on the model turn, not a dangling user recovery message.
* test: cover cross-iteration functionCall detection in recovery loop
Existing tests cover the functionCall guard when both initial and
escalated responses have functionCall. This adds a test for the
cross-iteration case: iter 1 returns text (recovery proceeds), iter 2
returns functionCall (recovery must break before iter 3).
Verifies:
- API called exactly 4 times (1 initial + 1 escalation + 2 recovery)
- History ends with the functionCall model turn, not a dangling user
recovery message
- Iter 3's user recovery message is never pushed (guard fires at top
of loop before recoveryCount increment)
* fix(core): cast synthetic STOP chunk via unknown for TS2352
The object literal {candidates, content, parts} doesn't structurally
overlap enough with GenerateContentResponse for TypeScript's strict
narrow cast. Casting through 'unknown' is required per TS2352.
Build error from CI:
src/core/geminiChat.ts(651,24): error TS2352: Conversion of type '...'
to type 'GenerateContentResponse' may be a mistake because neither
type sufficiently overlaps with the other. If this was intentional,
convert the expression to 'unknown' first.
* test(core): tighten recovery history integrity assertions
Strengthen the "pop dangling recovery message" test to catch any
future regression that leaves consecutive same-role entries or an
empty last-model placeholder in history — conditions providers
reject on the next turn.
* fix(core): coalesce recovery pairs to avoid leaking control prompt
Previously every output-token recovery iteration left a (user, model)
pair in durable history where the user turn was the internal
OUTPUT_RECOVERY_MESSAGE control prompt. That prompt was then visible
to every later turn, biasing responses and polluting compression,
replay, and export.
Track successful recovery iterations and, after the recovery loop,
fold each completed pair back into the preceding model turn via a
new `coalesceRecoveryPairs` helper. Failed iterations already pop
their user turn in the catch block, so they need no coalescing.
Adds a targeted test that runs escalation + two successful recovery
iterations + a clean STOP, and asserts the merged history has
exactly one user turn and one model turn, no trace of the control
prompt text, and content ordered as B (escalation) + C + D.
* feat(cli): make recap away-threshold configurable
The 5-minute blur threshold was hard-coded. Confirmed from Claude
Code's own binary (v2.1.113) that 5 minutes is their default as well
(and that they shift to 60 minutes when 1h prompt-cache is active) —
so the default stays, but expose it as `general.sessionRecapAway
ThresholdMinutes` for users who briefly alt-tab often and don't want
recaps piling up, or who want to lower it for testing.
Non-positive / unset values fall back to the 5-minute default, so
dropping the key has the same behavior as before.
* fix(core): align recap prompt with Claude Code (1-2 sentences, ≤40 words)
The earlier "exactly one sentence, 80-char cap" was an over-correction
to a single in-the-moment ask. Going back to it: the natural shape of
"current task + next action" is two clauses, and forcing them into a
single sentence either crams them with a semicolon or drops the next
action entirely on complex sessions.
Adopt Claude Code's prompt verbatim (extracted from the v2.1.113
binary): "under 40 words, 1-2 plain sentences, no markdown. Lead with
the overall goal and current task, then the one next action. Skip
root-cause narrative, fix internals, secondary to-dos, and em-dash
tangents." Add a Chinese-budget note (~80 chars) and keep the
<recap>...</recap> wrapping that protects against reasoning-model
preambles leaking into the UI.
The sticky banner already re-measures controls height when the
recap toggles, so a 2-line render lays out cleanly.
Sweep "one-line" out of user-facing copy (settings description,
slash-command description, feature docs, design doc) so the
documentation matches the new shape.
* fix(cli): restore "one-line" in user-facing recap copy
Verified from the Claude Code v2.1.113 binary that the slash-command
description IS literally "Generate a one-line session recap now" even
though the underlying prompt allows 1-2 sentences. Claude Code is
deliberately setting a tighter user expectation than the prompt
guarantees, which keeps the surface feel "glanceable".
Mirror that asymmetry: keep the prompt at 1-2 sentences (the previous
commit) for behavioral parity, but put "one-line" back in the user-
visible copy (slash-command description, settings description, user
docs). Internal design doc keeps the accurate "1-2 sentence" wording.
* fix(cli): render recap inline in history to match Claude Code
Earlier I read the user's complaint that the recap "scrolled away" as
"the recap should be sticky above the input box," and built a sticky
banner accordingly. Disassembly of the Claude Code v2.1.113 binary
shows the actual behavior is the opposite: their away_summary is a
plain `type:"system", subtype:"away_summary"` message dispatched
through the standard message renderer (no Static, no anchor, no
flexbox pinning) — it scrolls with the conversation like every other
system message.
Tear out the sticky-banner machinery so recap matches that:
- Recap is back in the `HistoryItemWithoutId` union and `addItem`'d
into history (both from `/recap` and from auto-trigger), so it
serializes into session saves and behaves like every other history
item — no special clear paths, no resume-wrapper, no layout-effect
re-measure dance.
- `useAwaySummary` takes `addItem` again instead of a setter callback.
- `AwayRecapMessage` renders the way Claude Code does: a 2-column
gutter with `※`, then bold "recap: " and italic content, all in
dim color. Drop the prior `StatusMessage`-shaped layout that fused
prefix and label into "※ recap:".
- Remove the AppContainer plumbing, the slashCommandProcessor state,
the UIStateContext fields, the DefaultAppLayout / ScreenReader
placement blocks, the test-utils mocks, and the noninteractive
stub. Restore `useResumeCommand.handleResume` to a void return
since callers no longer need the success boolean.
Sweep the design doc so the architecture diagram, files table, and
hook deps reflect the inline-history flow.
* fix(cli): dedupe back-to-back auto-recaps with no new user turns between
Two consecutive blur cycles, each over the threshold but with no new
user activity in between, would each fire their own auto-recap and
add two near-duplicate entries to history (same task, slightly
different wording from temperature-driven LLM variance). Reported
case: leaving the terminal twice while a /review of one PR was
still on screen produced two recaps both about that same review.
Add a `shouldFireRecap` gate before kicking off the LLM call:
- Need at least 3 user messages in history total (don't fire on a
near-empty session).
- If a previous away_recap is already in history, need at least 2
new user messages since that one before another can fire.
Same shape as Claude Code's `Ic1` gate (`Sc1=3`, `Rc1=2`). Read
history through a ref so this isn't in the effect's deps and the
effect doesn't re-run on every message.
* fix(cli): type useResumeCommand.handleResume as Promise<void>
Per gemini review on #3482: the interface declared this as `() => void`
but the implementation is `async` and returns `Promise<void>`. The
mismatch silently lost the chainable promise — tests had to launder
it through `as unknown as Promise<void> | undefined` just to await.
Tighten the interface to `Promise<void>` and drop the cast in the
"closes the dialog immediately" test.
* fix(cli): persist auto-fired recap to chat recording so /resume keeps it
Per yiliang114 review on #3482: the manual `/recap` path persists across
`/resume` because the slash-command processor records every output
history item via `chatRecorder.recordSlashCommand({ phase: 'result',
outputHistoryItems })`, but the auto path called `addItem` directly
and bypassed that recorder. The result was an asymmetry where users
who triggered recap manually saw it after `/resume`, while users whose
recap fired automatically lost it.
Mirror the manual recording from useAwaySummary's `.then` callback —
record only the `result` phase (not invocation, since we don't want
a fake `> /recap` user line replayed) with the away-recap item as the
single output. Wrapped in try/catch because recap is best-effort and
must never surface a failure to the user.
Add useAwaySummary.test.ts covering:
- the recording path is taken on a successful auto-trigger
- the dedup gate (`shouldFireRecap`) suppresses the LLM call entirely,
including the recording, when no new user turns happened since the
last recap
* fix(cli): cast recap item via spread to satisfy strict tsc --build
CI's `tsc --build` (stricter than local `tsc --noEmit`) rejected the
direct `item as Record<string, unknown>` cast: HistoryItemAwayRecap's
literal `type: 'away_recap'` field doesn't overlap with `unknown`,
TS2352. Use the `{ ...item } as Record<string, unknown>` spread
pattern that the rest of the codebase (arenaCommand,
slashCommandProcessor's serializer) already uses for the same
SlashCommandRecordPayload field.
* fix(cli): pin /recap above input box and align defaults with fastModel
The recap rendered as a regular history item, so as soon as the model
streamed a new reply the "where you left off" reminder scrolled out of
view. Move it to a sticky banner anchored just above the Composer
(matching how btwItem is rendered) so it stays visible across turns.
While reworking the surface, also:
- Replace the chevron prefix with `※ recap:` so it reads as a labeled
recap line instead of a generic dim message.
- Mirror the placement in ScreenReaderAppLayout so screen-reader users
see it in the same logical position.
- Drop HistoryItemAwayRecap from the HistoryItemWithoutId union — it
is no longer addItem-able, and leaving it in invited silent no-op
bugs where addItem(awayRecap) would compile but render nothing.
- Clear the banner on /clear, /reset, /new and on /resume into a
different session, so a recap from a previous context doesn't bleed
into a freshly started one.
- Re-measure the controls box when the banner appears or disappears
(its height changes by a couple of lines) so the main content area
recomputes availableTerminalHeight and stays laid out correctly.
Auto-trigger now defaults to "on iff fastModel is configured" rather
than unconditionally on. Running an ambient background recap on the
main coding model is too costly and slow to be a sane default; tying
it to fastModel means the feature is silently opt-in for users who
have set up a cheap fast model. An explicit `general.showSessionRecap`
override still wins either way, and `/recap` itself is unaffected.
Sharpen the slash-command description to match the new behavior.
* fix(core): silence AbortSignal listener-leak warning in OpenAI pipeline
Every chat.completions.create call wires up an abort listener on the
incoming AbortSignal, and several layers — retryWithBackoff, the
LoggingContentGenerator wrapper, the SDK's own internal stream/fetch
plumbing — register their own listeners against the same signal. Five
retry attempts plus those layers comfortably exceed Node's default
10-listener cap and produce a MaxListenersExceededWarning. With
features that share or compose signals (e.g., recap + followup
speculation firing on the same response cycle), even a higher cap
gets blown past.
The signals here are per-request and short-lived, so the accumulation
is structural rather than a real memory leak — they get GC'd as soon
as the request settles. setMaxListeners(0, signal) at the SDK boundary
disables the warning for these specific signals only, without masking
any genuine leak elsewhere in the process. Idempotent and confined to
the one place where retry-bound API calls cross into the SDK.
* fix(core): tighten recap to a single sentence within 80 chars
The 1-3 sentence budget reliably wrapped onto two lines in the sticky
banner above the input box, which made it visually heavy for what is
supposed to be a glanceable reminder. Constrain the prompt to exactly
one sentence with a hard 80-char cap, and merge the "high-level task
+ next step" rule into a single sentence instead of two adjacent ones.
Also sweep the docs (settings, commands, design) so the user-facing
copy and the internal design notes match the new format.
* fix(cli): apply review feedback for recap PR
Two issues from review:
- The schema description for `general.showSessionRecap` still said
"1-3 sentence summary" while the prompt, docs, and slash-command
copy already say "one-line". Aligns the text in settingsSchema.ts
and the regenerated VSCode JSON schema.
- The /resume wrapper cleared the sticky recap synchronously, before
the inner handler had a chance to discover that no session data
was available. On a no-op resume the user would still lose the
current recap. Make `useResumeCommand.handleResume` return
Promise<boolean> reporting whether a session actually loaded, and
only clear the recap on a confirmed switch.
* fix(cli): default showSessionRecap to false and drop fastModel heuristic
The earlier "enabled iff fastModel is configured" default made it hard
for users to answer the simple question "is auto-recap on for me right
now?" — the answer depended on a setting from a different category,
and setting/unsetting fastModel silently changed recap behavior.
Revert to a plain boolean with a conservative off-by-default:
- Auto-trigger fires only when the user explicitly sets
`general.showSessionRecap: true`.
- Manual `/recap` keeps working regardless (that's a user-initiated
call, not an ambient one).
- Users never get ambient LLM calls billed to their main coding model
without having opted in.
Aligns settings.md, design doc, and the regenerated JSON schema.
* refactor(cli): replace slash command whitelist with capability-based filtering (Phase 1)
## Summary
Replace the hardcoded ALLOWED_BUILTIN_COMMANDS_NON_INTERACTIVE whitelist with a
unified, capability-based command metadata model. This is Phase 1 of the slash
command architecture refactor described in docs/design/slash-command/.
## Key changes
### New types (types.ts)
- Add ExecutionMode ('interactive' | 'non_interactive' | 'acp')
- Add CommandSource ('builtin-command' | 'bundled-skill' | 'skill-dir-command' |
'plugin-command' | 'mcp-prompt')
- Add CommandType ('prompt' | 'local' | 'local-jsx')
- Extend SlashCommand interface with: source, sourceLabel, commandType,
supportedModes, userInvocable, modelInvocable, argumentHint, whenToUse,
examples (all optional, backward-compatible)
### New module (commandUtils.ts + commandUtils.test.ts)
- getEffectiveSupportedModes(): 3-priority inference
(explicit supportedModes > commandType > CommandKind fallback)
- filterCommandsForMode(): replaces filterCommandsForNonInteractive()
- 18 unit tests
### Whitelist removal (nonInteractiveCliCommands.ts)
- Remove ALLOWED_BUILTIN_COMMANDS_NON_INTERACTIVE constant
- Remove filterCommandsForNonInteractive() function
- Replace with CommandService.getCommandsForMode(mode)
### CommandService enhancements (CommandService.ts)
- Add getCommandsForMode(mode: ExecutionMode): filters by mode, excludes hidden
- Add getModelInvocableCommands(): reserved for Phase 3 model tool-call use
### Built-in command annotations (41 files)
Annotate every built-in command with commandType:
- commandType='local' + supportedModes all-modes: btw, bug, compress, context,
init, summary (replaces the 6-command whitelist)
- commandType='local' interactive-only: export, memory, plan, insight
- commandType='local-jsx' interactive-only: all remaining ~31 commands
### Loader metadata injection (4 files)
Each loader stamps source/sourceLabel/commandType/modelInvocable on every
command it emits:
- BuiltinCommandLoader: source='builtin-command', modelInvocable=false
- BundledSkillLoader: source='bundled-skill', commandType='prompt',
modelInvocable=true
- command-factory (FileCommandLoader): source per extension/user origin,
commandType='prompt', modelInvocable=!extensionName
- McpPromptLoader: source='mcp-prompt', commandType='prompt', modelInvocable=true
### Bug fix
MCP_PROMPT commands were incorrectly excluded from non-interactive/ACP modes by
the old whitelist logic. commandType='prompt' now correctly allows them in all
modes.
### Session.ts / nonInteractiveHelpers.ts
- ACP session calls getAvailableCommands with explicit 'acp' mode
- Remove allowedBuiltinCommandNames parameter from buildSystemMessage() —
capability filtering is now self-contained in CommandService
* fix test ci
* fix memory command
* fix: pass 'non_interactive' mode explicitly to getAvailableCommands
- Fix critical bug in nonInteractiveHelpers.ts: loadSlashCommandNames was
calling getAvailableCommands without specifying mode, causing it to default
to 'acp' instead of 'non_interactive'. Commands with supportedModes that
include 'non_interactive' but not 'acp' would be silently excluded.
- Apply the same fix in systemController.ts for the same reason.
- Update test mock to delegate filtering to production filterCommandsForMode()
instead of duplicating the logic inline, preventing divergence.
Fixes review comments by wenshao and tanzhenxin on PR #3283.
* fix: resolve TypeScript type error in nonInteractiveHelpers.test.ts
* fix test ci
* feat(cli): add session recap with /recap and auto-show on return
Users often open an old session days later and need to scroll through
pages to remember where they left off. This change adds a short
"where did I leave off" recap — a 1-3 sentence summary generated by
the fast model — so they can resume without re-reading the history.
Two triggers:
- /recap: manual slash command.
- Auto: when the terminal has been blurred for 5+ minutes and gets
focused again (uses the existing DECSET 1004 focus protocol via
useFocus). Gated on streamingState === Idle so it never interrupts
an active turn. Only fires once per blur cycle.
The recap is rendered in dim color with a chevron prefix, visually
distinct from assistant replies. A new `general.showSessionRecap`
setting controls the auto-trigger (default on). /recap works
independent of the setting.
Implementation notes:
- generateSessionRecap uses fastModel (falls back to main model),
tools: [], maxOutputTokens: 300, and a tight system prompt. It
strips tool calls / responses from history before sending — tool
responses can hold 10K+ tokens of file content that drown the recap
in irrelevant detail. The 30-message window respects turn boundaries
(slice never starts on a dangling model/tool response).
- Output is wrapped in <recap>...</recap> tags; the extractor returns
empty (skips render) if the tag is missing, preventing model
reasoning from leaking into the UI.
- All failures are silent (return null) and logged via a scoped
debugLogger; recap is best-effort and must never break main flow.
- /recap refuses to run while a turn is pending.
* fix(cli): abort in-flight recap when showSessionRecap is disabled
If the user disables showSessionRecap while an auto-recap LLM call is
already in flight, the previous code returned early without aborting.
The pending .then would still pass its idle/abort guards and append the
recap, producing an unwanted message after the user has opted out.
Abort the controller and clear it eagerly so the resolved promise no
longer adds to history.
* fix(cli): gate /recap and auto-recap on streaming idle state
Two related issues from review:
1. /recap was only refusing when ui.pendingItem was set, but a normal
model reply runs with streamingState === Responding and a null
pendingItem. Invoking /recap mid-stream would generate a recap from
a partial conversation and insert it between the user prompt and
the assistant reply.
2. useAwaySummary cleared blurredAtRef before checking isIdle, so if
focus returned during a still-streaming turn (after a >5min blur)
the recap was permanently dropped — there was no later retry when
the turn became idle, because isIdle was not in the effect deps.
Fixes:
- Expose isIdleRef on CommandContext.ui (mirrors btwAbortControllerRef
pattern). Plumb it from AppContainer through useSlashCommandProcessor.
- recapCommand now refuses when isIdleRef.current is false OR
pendingItem is non-null.
- useAwaySummary preserves blurredAtRef on the !isIdle bail and adds
isIdle to the effect deps, so the trigger re-evaluates when the
current turn finishes.
- Brief blurs (< AWAY_THRESHOLD_MS) still reset blurredAtRef.
Also seeds isIdleRef in nonInteractiveUi and mockCommandContext so the
new field has a sensible default outside the interactive UI.
* docs: document /recap command, showSessionRecap setting, and design
- User docs: add /recap to the Session and Project Management table in
features/commands.md and a dedicated subsection covering manual use,
the auto-trigger, the dim-color rendering, and the fast-model tip.
- User docs: add general.showSessionRecap row to the configuration
settings reference.
- Design doc: docs/design/session-recap/session-recap-design.md covers
motivation, the two trigger paths, the per-file architecture, prompt
design with the <recap> tag and three-tier extractor, history
filtering rationale (functionResponse can be 10K+ tokens), the
useAwaySummary state machine, the isIdleRef gating for /recap, model
selection, observability, and out-of-scope items.
* fix(core): exclude thought parts from session recap context
filterToDialog kept any non-empty text part, but @google/genai's Part
type also marks model reasoning with part.thought / part.thoughtSignature.
That hidden chain-of-thought was being fed to the recap LLM and could
get summarized as if it were user-visible dialogue.
Drop parts where either flag is set. Update the design doc's
History 过滤 section to call this out alongside the existing
tool-call/response rationale.
* docs(session-recap): correct debug-logging guidance, fill in state machine, sharpen UX wording
Audit of the session recap docs against the implementation found three
issues worth fixing:
- Design doc claimed debug logs were enabled via a QWEN_CODE_DEBUG_LOGGING
env var. That var does not exist; debug logs are written to
~/.qwen/debug/<sessionId>.txt by default, gated by QWEN_DEBUG_LOG_FILE.
Replace with the accurate path + opt-out behavior, and tell the reader
to grep for the [SESSION_RECAP] tag.
- Design doc's useAwaySummary state machine table was missing the
isFocused && blurredAtRef === null path (taken on first render and
right after a brief-blur reset). Add the row.
- User doc's "Refuses to run ... failures are silent" line conflated the
inline-error refusal with silent generation failures, and "(when the
conversation is idle)" used internal jargon. Split the two cases and
spell out what "idle" means, including the wait-then-fire behavior
when focus returns mid-turn.
* docs(session-recap): correctly describe /recap vs auto-trigger failure modes
The previous wording said "Generation/network failures are silent — the
recap simply does not appear", but recapCommand returns a user-facing
info message ("Not enough conversation context for a recap yet.") in
exactly that path, and also returns inline messages for the
config-not-loaded and busy-turn guards.
Only the auto-trigger path is truly silent (it just skips addItem when
generateSessionRecap returns null). Split the two paths in the doc so
the manual command's "always responds with something" behavior is
distinguished from the auto-trigger's no-op-on-failure behavior.
* docs(session-recap): align prompt-rules section with the actual prompt
Two doc-vs-code mismatches in the design doc's "System Prompt" section,
caught with the same lens as yiliang114's failure-mode review:
- The bullet list claimed RECAP_SYSTEM_PROMPT forbids "推测用户意图"
and "用 'you' 称呼用户". Those rules existed in an early draft but
were dropped when the <recap> tag rules were added; the current
prompt has no such restrictions. Replace with the actual rules and
add a "与 RECAP_SYSTEM_PROMPT 一一对应" marker so future edits stay
in sync.
- The doc said systemInstruction "覆盖" the main agent prompt. True
for the agent prompt portion, but GeminiClient.generateContent
internally calls getCustomSystemPrompt which appends user memory
(QWEN.md / 自动 memory) as a suffix. Spell that out — the final
system prompt is recap prompt + user memory, which is actually
useful project context for the recap.
* docs(session-recap): translate design doc to English
The repo convention for docs/design is English (7 of 8 existing files;
auto-memory/memory-system.md is the only Chinese one). The first version
of this design doc followed the auto-memory example, which turned out
to be the wrong sample.
Translate to English while preserving the existing structure, the
state-machine table, the prompt-vs-doc 1:1 alignment, the
QWEN_DEBUG_LOG_FILE description, and the failure-mode notes added in
prior commits.
* fix(cli): drop empty info return from /recap interactive success path
The interactive success path inserts the away_recap history item
directly via ui.addItem and then returned `{type: 'message',
messageType: 'info', content: ''}`. The slash-command processor's
'message' case unconditionally calls addMessage, which adds another
HistoryItemInfo with empty text. The empty info renders as nothing
(StatusMessage early-returns null), but it still bloats the in-memory
history list and shows up in /export and saved sessions.
Return void on the interactive success path and on the abort path so
the processor's `if (result)` check skips the message-handler branch
entirely. Widen the action's return type to `void | SlashCommandActionReturn`
to match (same shape as btwCommand).
* docs: add auto-memory implementation log
* feat(core): add managed auto-memory storage scaffold
* feat(core): load managed auto-memory index
* feat(core): add managed auto-memory recall
* feat(core): add managed auto-memory extraction
* feat(cli): add managed auto-memory dream commands
* feat(core): add auxiliary side-query foundation
* feat(memory): add model-driven recall selection
* feat(memory): add model-driven extraction planner
* feat(core): add background task runtime foundation
* feat(memory): schedule auto dream in background
* feat(core): add background agent runner foundation
* feat(memory): add extraction agent planner
* feat(core): add dream agent planner
* feat(core): rebuild managed memory index
* feat(memory): add governance status commands
* feat(memory): add managed forget flow
* feat(core): harden background agent planning
* feat(memory): complete managed parity closure
* test(memory): add managed lifecycle integration coverage
* feat: same to cc
* feat(memory-ui): add memory saved notification and memory count badge
Feature 3 - Memory Saved Notification:
- Add HistoryItemMemorySaved type to types.ts
- Create MemorySavedMessage component for rendering '● Saved/Updated N memories'
- In useGeminiStream: detect in-turn memory writes via mapToDisplay's
memoryWriteCount field and emit 'memory_saved' history item after turn
- In client.ts: capture background dream/extract promises and expose
via consumePendingMemoryTaskPromises(); useGeminiStream listens
post-turn and emits 'Updated N memories' notification for background tasks
Feature 4 - Memory Count Badge:
- Add isMemoryOp field to IndividualToolCallDisplay
- Add memoryWriteCount/memoryReadCount to HistoryItemToolGroup
- Add detectMemoryOp() in useReactToolScheduler using isAutoMemPath
- ToolGroupMessage renders '● Recalled N memories, Wrote N memories' badge
at the top of tool groups that touch memory files
Fix: process.env bracket-access in paths.ts (noPropertyAccessFromIndexSignature)
Fix: MemoryDialog.test.tsx mock useSettings to satisfy SettingsProvider requirement
* fix(memory-ui): auto-approve memory writes, collapse memory tool groups, fix MEMORY.md path
Problem 1 - Auto-approve memory file operations:
- write-file.ts: getDefaultPermission() checks isAutoMemPath; returns 'allow'
for managed auto-memory files, 'ask' for all other files
- edit.ts: same pattern
Problem 2 - Feature 4 UX: collapse memory-only tool groups:
- ToolGroupMessage: detect when all tool calls have isMemoryOp set (pure memory
group) and all are complete; render compact '● Recalled/Wrote N memories
(ctrl+o to expand)' instead of individual tool call rows
- ctrl+o toggles expand/collapse when isFocused and group is memory-only
- Mixed groups (memory + other tools) keep badge-at-top behaviour
- Expanded state shows individual tool calls with '● Memory operations
(ctrl+o to collapse)' header
Problem 3 - MEMORY.md path mismatch:
- prompt.ts: Step 2 now references full absolute path ${memoryDir}/MEMORY.md
so the model writes to the correct location inside the memory directory,
not to the parent project directory
Fix tests:
- write-file.test.ts: add getProjectRoot to mockConfigInternal
- prompt.test.ts: update assertion to match full-path section header
* fix(memory-ui): fix duplicate notification, broken ctrl+o, and Edit tool detection
- Remove duplicate 'Saved N memories' notification: the tool group badge already
shows 'Wrote N memories'; the separate HistoryItemMemorySaved addItem after
onComplete was double-counting. Keep only the background-task path
(consumePendingMemoryTaskPromises).
- Remove ctrl+o expand: Ink's Static area freezes items on first render and
cannot respond to user input. useInput/useState(isExpanded) in a Static item
is a no-op. Removed the dead code; memory-only groups now always render as
the compact summary (no fake interactive hint).
- Fix Edit tool detection: detectMemoryOp was checking for 'edit_file' but the
real tool name constant is 'edit'. Also removed non-existent 'create_file'
(write_file covers all writes). Now editing MEMORY.md is correctly identified
as a memory write op, collapses to 'Wrote N memories', and is auto-approved.
* fix(dream): run /dream as a visible submit_prompt turn, not a silent background agent
The previous implementation ran an AgentHeadless background agent that could
take 5+ minutes with zero UI feedback — user saw a blank screen for the entire
duration and then at most one line of text.
Fix: /dream now returns submit_prompt with the consolidation task prompt so it
runs as a regular AI conversation turn. Tool calls (read_file, write_file, edit,
grep_search, list_directory, glob) are immediately visible as collapsed tool
groups as the model works through the memory files — identical UX to Claude Code.
Also export buildConsolidationTaskPrompt from dreamAgentPlanner so dreamCommand
can reuse the same detailed consolidation prompt that was already written.
* fix(memory): auto-allow ls/glob/grep on memory base directory
Add getMemoryBaseDir() to getDefaultPermission() allow list in ls.ts,
glob.ts, and grep.ts — mirrors the existing pattern in read-file.ts.
Without this, ListFiles/Glob/Grep on ~/.qwen/* would trigger an
approval dialog, blocking /dream at its very first step.
* fix(background): prevent permission prompt hangs in background agents
Match Claude Code's headless-agent intent: background memory agents must never
block on interactive permission prompts.
Wrap background runtime config so getApprovalMode() returns YOLO, ensuring any
ask decision is auto-approved instead of hanging forever. Add regression test
covering the wrapped approval mode.
* fix(memory): run auto extract through forked agent
Make managed auto-memory extraction follow the Claude Code architecture:
background extraction now uses a forked agent to read/write memory files
directly, instead of planning patches and applying them with a separate
filesystem pipeline.
Keep the old patch/model path only as fallback if the forked agent fails.
Add regression tests covering the new execution path and tool whitelist.
* refactor(memory): remove legacy extract fallback pipeline
Delete the old patch/model/heuristic extraction path entirely.
Managed auto-memory extract now runs only through the forked-agent
execution flow, with no planner/apply fallback stages remaining.
Also remove obsolete exports/tests and update scheduler/integration
coverage to use the forked-agent-only architecture.
* refactor(memory): move auxiliary files out of memory/ directory
meta.json, extract-cursor.json, and consolidation.lock are internal
bookkeeping files, not user-visible memories. Move them one level up
to the project state dir (parent of memory/) so that the memory/
directory contains only MEMORY.md and topic files, matching the
clean layout of the upstream reference implementation.
Add getAutoMemoryProjectStateDir() helper in paths.ts and update the
three path accessors + store.test.ts path assertions accordingly.
* fix(memory): record lastDreamAt after manual /dream run
The /dream command submits a prompt to the main agent (submit_prompt),
which writes memory files directly. Because it bypasses dreamScheduler,
meta.json was never updated and /memory always showed 'never'.
Fix by:
- Exporting writeDreamManualRunToMetadata() from dream.ts
- Adding optional onComplete callback to SubmitPromptActionReturn and
SubmitPromptResult (types.ts / commands/types.ts)
- Propagating onComplete through slashCommandProcessor.ts
- Firing onComplete after turn completion in useGeminiStream.ts
- Providing the callback in dreamCommand.ts to write lastDreamAt
* fix(memory): remove scope params from /remember in managed auto-memory mode
--global/--project are legacy save_memory tool concepts. In managed
auto-memory mode the forked agent decides the appropriate type
(user/feedback/project/reference) based on the content of the fact.
Also improve the prompt wording to explicitly ask the agent to choose
the correct type, reducing the tendency to default to 'project'.
* feat(ui): show '✦ dreaming' indicator in footer during background dream
Subscribe to getManagedAutoMemoryDreamTaskRegistry() in Footer via a
useDreamRunning() hook. While any dream task for the current project is
pending or running, display '✦ dreaming' in the right section of the
footer bar, between Debug Mode and context usage.
* refactor(memory): align dream/extract infrastructure with Claude Code patterns
Five improvements based on Claude Code parity audit:
1. Memoize getAutoMemoryRoot (paths.ts)
- Add _autoMemoryRootCache Map, keyed by projectRoot
- findCanonicalGitRoot() walks the filesystem per call; memoize avoids
repeated git-tree traversal on hot-path schedulers/scanners
- Expose clearAutoMemoryRootCache() for test teardown
2. Lock file stores PID + isProcessRunning reclaim (dreamScheduler.ts)
- acquireDreamLock() writes process.pid to the lock file body
- lockExists() reads PID and calls process.kill(pid, 0); dead/missing
PID reclaims the lock immediately instead of waiting 2h
- Stale threshold reduced to 1h (PID-reuse guard, same as CC)
3. Session scan throttle (dreamScheduler.ts)
- Add SESSION_SCAN_INTERVAL_MS = 10min (same as CC)
- Add lastSessionScanAt Map<projectRoot, number> to ManagedAutoMemoryDreamRuntime
- When time-gate passes but session-gate doesn't, throttle prevents
re-scanning the filesystem on every user turn
4. mtime-based session counting (dreamScheduler.ts)
- Replace fragile recentSessionIdsSinceDream Set in meta.json with
filesystem mtime scan (listSessionsTouchedSince)
- Mirrors Claude Code's listSessionsTouchedSince: reads session JSONL
files from Storage.getProjectDir()/chats/, filters by mtime > lastDreamAt
- Immune to meta.json corruption/loss; no per-turn metadata write
- ManagedAutoMemoryDreamRuntime accepts injectable SessionScannerFn
for clean unit testing without real session files
5. Extraction mutual exclusion extended to write_file/edit (extractScheduler.ts)
- historySliceUsesMemoryTool() now checks write_file/edit/replace/create_file
tool calls whose file_path is within isAutoMemPath()
- Previously only detected save_memory; missed direct file writes by
the main agent, causing redundant background extraction
* docs(memory): add user-facing memory docs, i18n for all locales, simplify /forget
- Add docs/users/features/memory.md: comprehensive user-facing guide covering
QWEN.md instructions, auto-memory behaviour, all memory commands, and
troubleshooting; replaces the placeholder auto-memory.md
- Update docs/users/features/_meta.ts: rename entry auto-memory → memory
- Update docs/users/features/commands.md: add /init, /remember, /forget,
/dream rows; fix /memory description; remove /init duplicate
- Update docs/users/configuration/settings.md: add memory.* settings section
(enableManagedAutoMemory, enableManagedAutoDream) between tools and permissions
- Remove /forget --apply flag: preview-then-apply flow replaced with direct
deletion; update forgetCommand.ts, en.js, zh.js accordingly
- Add all auto-memory i18n keys to de, ja, pt, ru locales (18 keys each):
Open auto-memory folder, Auto-memory/Auto-dream status lines, never/on/off,
✦ dreaming, /forget and /remember usage strings, all managed-memory messages
- Remove dead save_memory branch from extractScheduler.partWritesToMemory()
- Add ✦ dreaming indicator to Footer.tsx with i18n; fix Footer.test.tsx mocks
- Refactor MemoryDialog.tsx auto-dream status line to use i18n
- Remove save_memory tool (memoryTool.ts/test); clean up webui references
- Add extractionPlanner.ts, const.ts and associated tests
- Delete stale docs/users/configuration/memory.md and
docs/developers/tools/memory.md (content superseded)
* refactor(memory): remove all Claude Code references from comments and test names
* test(memory): remove empty placeholder test files that cause vitest to fail
* fix eslint
* fix test in windows
* fix test
* fix(memory): address critical review findings from PR #3087
- fix(read-file): narrow auto-allow from getMemoryBaseDir() (~/.qwen) to
isAutoMemPath(projectRoot) to prevent exposing settings.json / OAuth
credentials without user approval (wenshao review)
- fix(forget): per-entry deletion instead of whole-file unlink
- assign stable per-entry IDs (relativePath:index for multi-entry files)
so the model can target individual entries without removing siblings
- rewrite file keeping unmatched entries; only unlink when file becomes
empty (wenshao review)
- fix(entries): round-trip correctness for multi-entry new-format bodies
- parseAutoMemoryEntries: plain-text line closes current entry and opens
a new one (was silently ignored when current was already set)
- renderAutoMemoryBody: emit blank line between adjacent entries so the
parser can detect entry boundaries on re-read (wenshao review)
- fix(entries): resolve two CodeQL polynomial-regex alerts
- indentedMatch: \s{2,}(?:[-*]\s+)? → [\t ]{2,}(?:[-*][\t ]+)?
- topLevelMatch: :\s*(.+)$ → :[ \t]*(\S.*)$
(github-advanced-security review)
- fix(scan.test): use forward-slash literal for relativePath expectation
since listMarkdownFiles() normalises all separators to '/' on all
platforms including Windows
* fix(memory): replace isAutoMemPath startsWith with path.relative()
Using path.relative() instead of string startsWith() is more robust
across platforms — it correctly handles Windows path-separator
differences and avoids potential edge cases where a path prefix match
could succeed on non-separator boundaries.
Addresses github-actions review item 3 (PR #3087).
* feat(telemetry): add auto-memory telemetry instrumentation
Add OpenTelemetry logs + metrics for the five auto-memory lifecycle
events: extract, dream, recall, forget, and remember.
Telemetry layer (packages/core/src/telemetry/):
- constants.ts: 5 new event-name constants
(qwen-code.memory.{extract,dream,recall,forget,remember})
- types.ts: 5 new event classes with typed constructor params
(MemoryExtractEvent, MemoryDreamEvent, MemoryRecallEvent,
MemoryForgetEvent, MemoryRememberEvent)
- metrics.ts: 8 new OTel instruments (5 Counters + 3 Histograms)
with recordMemoryXxx() helpers; registered inside initializeMetrics()
- loggers.ts: logMemoryExtract/Dream/Recall/Forget/Remember() — each
emits a structured log record and calls its recordXxx() counterpart
- index.ts: re-exports all new symbols
Instrumentation call-sites:
- extractScheduler.ts ManagedAutoMemoryExtractRuntime.runTask():
emits extract event with trigger=auto, completed/failed status,
patches_count, touched_topics, and wall-clock duration
- dream.ts runManagedAutoMemoryDream():
emits dream event with trigger=auto, updated/noop status,
deduped_entries, touched_topics, and duration; covers both
agent-planner and mechanical fallback paths
- recall.ts resolveRelevantAutoMemoryPromptForQuery():
emits recall event with strategy, docs_scanned/selected, and
duration; covers model, heuristic, and none paths
- forget.ts forgetManagedAutoMemoryEntries():
emits forget event with removed_entries_count, touched_topics,
and selection_strategy (model/heuristic/none)
- rememberCommand.ts action():
emits remember event with topic=managed|legacy at command
invocation time (before agent decides the actual memory type)
* refactor(telemetry): remove memory forget/remember telemetry events
Remove EVENT_MEMORY_FORGET and EVENT_MEMORY_REMEMBER along with all
associated infrastructure that is no longer needed:
- constants.ts: remove EVENT_MEMORY_FORGET, EVENT_MEMORY_REMEMBER
- types.ts: remove MemoryForgetEvent, MemoryRememberEvent classes
- metrics.ts: remove MEMORY_FORGET_COUNT, MEMORY_REMEMBER_COUNT constants,
memoryForgetCounter, memoryRememberCounter module vars,
their initialization in initializeMetrics(), and
recordMemoryForgetMetrics(), recordMemoryRememberMetrics() functions
- loggers.ts: remove logMemoryForget(), logMemoryRemember() functions
and their imports
- index.ts: remove all re-exports for the above symbols
- memory/forget.ts: remove logMemoryForget call-site and import
- cli/rememberCommand.ts: remove logMemoryRemember call-sites and import
* change default value
* fix forked agent
* refactor(background): unify fork primitives into runForkedAgent + cleanup
- Merge runForkedQuery into runForkedAgent via TypeScript overloads:
with cacheSafeParams → GeminiChat single-turn path (ForkedQueryResult)
without cacheSafeParams → AgentHeadless multi-turn path (ForkedAgentResult)
- Delete forkedQuery.ts; move its test to background/forkedAgent.cache.test.ts
- Remove forkedQuery export from followup/index.ts
- Migrate all callers (suggestionGenerator, speculation, btwCommand, client)
to import from background/forkedAgent
- Add getFastModel() / setFastModel() to Config; expose in CLI config init
and ModelDialog / modelCommand
- Remove resolveFastModel() from AppContainer — now delegated to config.getFastModel()
- Strip Claude Code references from code comments
* fix(memory): address wenshao's critical review findings
- dream.ts: writeDreamManualRunToMetadata now persists lastDreamSessionId
and resets recentSessionIdsSinceDream, preventing auto-dream from firing
again in the same session after a manual /dream
- config.ts: gate managed auto-memory injection on getManagedAutoMemoryEnabled();
when disabled, previously saved memories are no longer injected into new sessions
- rememberCommand.ts: remove legacy save_memory branch (tool was removed);
fall back to submit_prompt directing agent to write to QWEN.md instead
- BuiltinCommandLoader.ts: only register /dream and /forget when managed
auto-memory is enabled, matching the feature's runtime availability
- forget.ts: return early in forgetManagedAutoMemoryMatches when matches is
empty, avoiding unnecessary directory scaffolding as a side effect
* fix test
* fix ci test
* feat(memory): align extract/dream agents to Claude Code patterns
- fix(client): move saveCacheSafeParams before early-return paths so
extract agents always have cache params available (fixes extract never
triggering in skipNextSpeakerCheck mode)
- feat(extract): add read-only shell tool + memory-scoped write
permissions; create inline createMemoryScopedAgentConfig() with
PermissionManager wrapper (isToolEnabled + evaluate) that allows only
read-only shell commands and write/edit within the auto-memory dir
- feat(extract): align prompt to Claude Code patterns — manifest block
listing existing files, parallel read-then-write strategy, two-step
save (memory file then index)
- feat(dream): remove mechanical fallback; runManagedAutoMemoryDream is
now agent-only and throws without config
- feat(dream): align prompt to Claude Code 4-phase structure
(Orient/Gather/Consolidate/Prune+Index); add narrow transcript grep,
relative→absolute date conversion, stale index pruning, index size cap
- fix(permissions): add isToolEnabled() to MemoryScopedPermissionManager
to prevent TypeError crash in CoreToolScheduler._schedule
- test: update dreamScheduler tests to mock dream.js; replace removed
mechanical-dedup test with scheduler infrastructure verification
* move doc to design
* refactor(memory): unify extract+dream background task management into MemoryBackgroundTaskHub
- Add memoryTaskHub.ts: single BackgroundTaskRegistry + BackgroundTaskDrainer shared
by all memory background tasks; exposes listExtractTasks() / listDreamTasks()
typed query helpers and a unified drain() method
- extractScheduler: ManagedAutoMemoryExtractRuntime accepts hub via constructor
(defaults to defaultMemoryTaskHub); test factory gets isolated fresh hub
- dreamScheduler: same pattern — sessionScanner + hub injection; BackgroundTask-
Scheduler initialized from injected hub; test factory gets isolated hub
- status.ts: replace two separate getRegistry() calls with defaultMemoryTaskHub
typed query methods
- Footer.tsx (useDreamRunning): subscribe to shared registry, filter by
DREAM_TASK_TYPE so extract tasks do not trigger the dream spinner
- index.ts: re-export memoryTaskHub.ts so defaultMemoryTaskHub/DREAM_TASK_TYPE/
EXTRACT_TASK_TYPE are available as top-level package exports
* refactor(background): introduce general-purpose BackgroundTaskHub
Replace memory-specific MemoryBackgroundTaskHub with a domain-agnostic
BackgroundTaskHub in the background/ layer. Any future background task
runtime (3rd, 4th, …) plugs in by accepting a hub via constructor
injection — no new infrastructure required.
Changes:
- Add background/taskHub.ts: BackgroundTaskHub (registry + drainer +
createScheduler() + listByType(taskType, projectRoot?)) and the
globalBackgroundTaskHub singleton. Zero knowledge of any task type.
- Delete memory/memoryTaskHub.ts: its narrow listExtractTasks /
listDreamTasks helpers are replaced by the generic listByType() call.
- Move EXTRACT_TASK_TYPE to extractScheduler.ts (owned by the runtime
that defines it); replace 3 hardcoded string literals with the const.
- Move DREAM_TASK_TYPE to dreamScheduler.ts; use hub.createScheduler()
instead of manually wiring new BackgroundTaskScheduler(reg, drain).
- status.ts: globalBackgroundTaskHub.listByType(EXTRACT_TASK_TYPE, ...)
- Footer.tsx: globalBackgroundTaskHub.registry (shared, filtered by type)
- index.ts: export background/taskHub.js; drop memory/memoryTaskHub.js
* test(background): add BackgroundTaskHub unit tests and hub isolation checks
- background/taskHub.test.ts (11 tests):
- createScheduler(): tasks registered via scheduler appear in hub registry;
multiple calls return distinct scheduler instances
- listByType(): filters by taskType, filters by projectRoot, returns []
for unknown types, two types co-exist in registry but stay separated
- drain(): resolves false on timeout, resolves true when tasks complete,
resolves true immediately when no tasks in flight
- isolation: tasks in hubA do not appear in hubB
- globalBackgroundTaskHub: is a BackgroundTaskHub instance with registry/drainer
- extractScheduler.test.ts (+1 test):
- factory-created runtimes have isolated registries; tasks in runtimeA
are invisible to runtimeB; all tasks carry EXTRACT_TASK_TYPE
- dreamScheduler.test.ts (+1 test):
- factory-created runtimes have isolated registries; tasks in runtimeA
are invisible to runtimeB; all tasks carry DREAM_TASK_TYPE
* refactor(memory): consolidate all memory state into MemoryManager
Replace BackgroundTaskRegistry/Drainer/Scheduler/Hub helper classes and
module-level globals with a single MemoryManager class owned by Config.
## Changes
### New
- packages/core/src/memory/manager.ts — MemoryManager with:
- scheduleExtract / scheduleDream (inline queuing + deduplication logic)
- recall / forget / selectForgetCandidates / forgetMatches
- getStatus / drain / appendToUserMemory
- subscribe(listener) compatible with useSyncExternalStore
- storeWith() atomic record registration (no double-notify)
- Distinct skippedReason 'scan_throttled' vs 'min_sessions' for dream
- packages/core/src/utils/forkedAgent.ts — pure cache util (moved from background/)
- packages/core/src/utils/sideQuery.ts — pure util (moved from auxiliary/)
### Deleted
- background/taskRegistry, taskDrainer, taskScheduler, taskHub and all tests
- background/forkedAgent (moved to utils/)
- auxiliary/sideQuery (moved to utils/)
- memory/extractScheduler, dreamScheduler, state and all tests
### Modified
- config/config.ts — Config owns MemoryManager instance; getMemoryManager()
- core/client.ts — all memory ops via config.getMemoryManager()
- core/client.test.ts — mock MemoryManager instead of individual modules
- memory/status.ts — accepts MemoryManager param, drops globalBackgroundTaskHub
- index.ts — memory exports reduced from 14 modules to 5 (manager/types/paths/store/const)
- cli/commands/dreamCommand.ts — via config.getMemoryManager()
- cli/commands/forgetCommand.ts — via config.getMemoryManager()
- cli/components/Footer.tsx — useSyncExternalStore replacing setInterval polling
- cli/components/Footer.test.tsx — add getMemoryManager mock
* feat: optimize compact mode UX — shortcuts, settings sync, and safety improvements
- Add Ctrl+O to keyboard shortcuts list (?) and /help command
- Sync compact mode toggle from Settings dialog with CompactModeContext
- Protect tool approval prompts from being hidden in compact mode
(MainContent forces live rendering during WaitingForConfirmation)
- Remove snapshot freezing on toggle — treat as persistent preference,
not temporary peek (differs from Claude Code's session-scoped model)
- Add compact mode tip to startup Tips rotation for non-intrusive discovery
- Remove compact mode indicator from footer to reduce UI clutter
- Add competitive analysis design doc (EN + ZH) comparing with Claude Code
- Update user docs (settings.md) and i18n translations (en/zh/ru/pt)
Relates to #3047, #2767, #2770
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* refactor: remove frozenSnapshot dead code and Chinese design doc
- Remove frozenSnapshot state, useEffect, and all related logic from
AppContainer, MainContent, CompactModeContext, and test files
- Simplify MainContent to always render live pendingHistoryItems
- Delete compact-mode-design-zh.md (redundant Chinese translation)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: address PR review feedback for compact mode optimization
- Add refreshStatic() call after setCompactMode in SettingsDialog
so already-rendered Static history updates immediately
- Fix outdated column split comment in KeyboardShortcuts (5+4+4)
- Update design doc: remove all frozenSnapshot references, renumber
optimization recommendations, fix file reference descriptions
- Add missing i18n keys for de.js and ja.js locales
- Add test for SettingsDialog compact mode sync with CompactModeContext
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: prevent subagent confirmation from being hidden in compact mode
hasConfirmingTool only checks ToolCallStatus.Confirming, but subagent
approvals arrive via resultDisplay.pendingConfirmation while the tool
status remains Executing. Add hasSubagentPendingConfirmation to the
showCompact guard so tool groups with pending subagent confirmations
are always force-expanded.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: force show subagent confirmation result in compact mode
The previous fix (47ee03c) correctly force-expanded the tool group
wrapper when a subagent had pending confirmation, but each inner
ToolMessage still hid its resultDisplay due to compactMode check,
which hid the AgentExecutionDisplay containing the inline confirmation
UI.
Add isAgentWithPendingConfirmation to forceShowResult conditions so
the inner AgentExecutionDisplay is rendered even in compact mode.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(compact-mode): merge consecutive tool groups across hidden items
In compact mode, sequential tool calls across multiple LLM turns each
produced a separate bordered box, defeating the "compact" intent. The
model typically emits a `gemini_thought` between consecutive tool calls,
which is hidden in compact mode — so visually the boxes look adjacent,
but in `history` they are separated by hidden items.
This commit adds render-time merging of consecutive tool_group history
items, where "consecutive" allows hidden-in-compact items
(`gemini_thought`, `gemini_thought_content`) between them.
Key pieces:
- New `mergeCompactToolGroups` utility that merges adjacent mergeable
tool_groups, skipping hidden items between them. Force-expand
conditions (Confirming/Error tools, subagent pending confirmation,
user-initiated, focused embedded shell) preserve group boundaries so
authorization prompts, errors, and shell focus stay visible.
- `MainContent.tsx` applies the merger only when `compactMode === true`
(verbose mode is unchanged) and calls `refreshStatic()` when a merge
consolidates items, because Ink's `<Static>` is append-only and
cannot replace already-committed terminal content.
- `CompactToolGroupDisplay.tsx` shows a `× N` count when a merged
group contains more than one tool, matching the existing single-turn
multi-tool display style.
- 19 unit tests covering empty/single/multiple groups, hidden-item
skipping (the 8-tool real-world scenario), force-expand boundaries,
mixed tool types, and complex sequences.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: 秦奇 <gary.gq@alibaba-inc.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(core): implement fork subagent for context sharing
- Make subagent_type optional in AgentTool
- Add forkSubagent.ts to build identical tool result prefixes
- Run fork processes in the background to preserve UX
* fix(core): fix test failures related to root execution and optional subagent_type
- Skip pathReader and edit tool permission tests when running as root
- Fix agent.test.ts to correctly mock execute call with extraHistory
- Remove unused imports in forkSubagent.ts
* fix(core): fix fork subagent bugs and add CacheSafeParams integration
Bug fixes:
- Fix AgentParams.subagent_type type: string -> string? (match schema)
- Fix undefined agentType passed to hook system (fallback to subagentConfig.name)
- Fix hook continuation missing extraHistory parameter
- Fix functionResponse missing id field (match coreToolScheduler pattern)
- Fix consecutive user messages in Gemini API (ensure history ends with model)
- Fix duplicate task_prompt when directive already in extraHistory
- Fix FORK_AGENT.systemPrompt empty string causing createChat to throw
- Fix redundant dynamic import of forkSubagent.js (merge into single import)
- Fix non-fork agent returning empty string on execution failure
- Fix misleading fork child rule referencing non-existent system prompt config
- Fix functionResponse.response key from {result:} to {output:} for consistency
CacheSafeParams integration:
- Retrieve parent's generationConfig via getCacheSafeParams() for cache sharing
- Add generationConfigOverride to CreateChatOptions and AgentHeadless.execute()
- Add toolsOverride to AgentHeadless.execute() for parent tool declarations
- Fork API requests now share byte-identical prefix with parent (DashScope cache hits)
- Graceful degradation when CacheSafeParams unavailable (first turn)
Docs:
- Add Fork Subagent section to sub-agents.md user manual
- Add fork-subagent-design.md design document
* fix(core): apply subagent tool exclusion to forked agents
Fork children were inheriting parent's cached tool declarations directly,
bypassing prepareTools() filtering and gaining access to AgentTool and
cron tools. Extract EXCLUDED_TOOLS_FOR_SUBAGENTS as a shared constant
and apply it to forkToolsOverride.
* fix(core): skip env history whenever extraHistory is provided
Previously gated on generationConfigOverride, which meant the no-cache
fallback path (CacheSafeParams unavailable) still ran getInitialChatHistory
and duplicated env bootstrap messages already present in the parent's
history. Gate on extraHistory instead so both fork paths skip env init.
* fix(core): use explicit skipEnvHistory flag for fork env handling
The previous fix gated env-init skipping on the presence of extraHistory,
but agent-interactive (arena) also passes extraHistory — its chatHistory is
env-stripped by stripStartupContext() and DOES need fresh env init for the
child's working directory. Skipping env there broke the interactive path.
Replace the implicit gate with an explicit skipEnvHistory option that only
fork sets (when extraHistory is present, since fork's history comes from
getHistory(true) and already contains env).
* fix(core): defend skipEnvHistory gate against empty extraHistory
Edge case: when the parent's rawHistory ends with a user message and has
length 1, extraHistory becomes []. The previous gate (extraHistory !==
undefined) would set skipEnvHistory: true, leaving the fork with neither
env bootstrap nor parent history. Check length > 0 so empty arrays fall
through to the normal env-init path.
* fix(core): apply skipEnvHistory to stop-hook retry execute
The second subagent.execute() call in the SubagentStop retry loop was
missing skipEnvHistory, so on retry the fork's env context would be
duplicated — same bug as the initial tanzhenxin report, just on a less
common code path.
* fix(core): prevent followup suggestion input/output from appearing in tool call UI
The follow-up suggestion generation was leaking into the conversation UI
through three channels:
1. The forked query included tools in its generation config, allowing the
model to produce function calls during suggestion generation. Fixed by
setting `tools: []` in runForkedQuery's per-request config (kept in
createForkedChat for speculation which needs tools).
2. logApiResponse and logApiError recorded suggestion API events to the
chatRecordingService, causing them to appear in session JSONL files
and the WebUI. Fixed by adding isInternalPromptId() guard that skips
chatRecordingService for 'prompt_suggestion' and 'forked_query' IDs.
uiTelemetryService.addEvent() is preserved so /stats still tracks
suggestion token usage.
3. LoggingContentGenerator logged suggestion requests/responses to the
OpenAI logger and telemetry pipeline. Fixed by skipping logApiRequest,
buildOpenAIRequestForLogging, and logOpenAIInteraction for internal
prompt IDs. _logApiResponse is preserved (for /stats) but its
chatRecordingService path is filtered by fix#2.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* refactor: deduplicate isInternalPromptId into shared export from loggers.ts
Address review feedback: extract isInternalPromptId() to a single
exported function in telemetry/loggers.ts and import it in
LoggingContentGenerator, eliminating the duplicate private method.
Also update loggingContentGenerator.test.ts mock to use importOriginal
so the real isInternalPromptId is available during tests.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* refactor: extract isInternalPromptId to shared utils, add tests
Address maintainer review feedback:
1. Move isInternalPromptId() to packages/core/src/utils/internalPromptIds.ts
using a ReadonlySet for the ID registry. Adding new internal prompt IDs
only requires changing one file. loggers.ts re-exports for compatibility,
loggingContentGenerator.ts imports directly from utils.
2. Extract `tools: []` magic value to a frozen NO_TOOLS constant in
forkedQuery.ts.
3. Add unit tests for isInternalPromptId: prompt_suggestion → true,
forked_query → true, user_query → false, empty string → false.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: address Copilot review — docs, stream optimization, tests
1. Update forkedQuery.ts module docs to reflect that runForkedQuery
overrides tools: [] at the per-request level while createForkedChat
retains the full generationConfig for speculation callers.
2. Propagate isInternal into loggingStreamWrapper to skip response
collection and consolidation for internal prompts, avoiding
unnecessary CPU/memory overhead.
3. Add logApiResponse chatRecordingService filter tests: verify
prompt_suggestion/forked_query skip recording while normal IDs
still record.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: deep-freeze NO_TOOLS, add internal prompt guard tests
Address Copilot review round 3:
1. Deep-freeze NO_TOOLS.tools array to prevent shared mutable state
across forked query calls.
2. Add LoggingContentGenerator tests verifying that internal prompt IDs
(prompt_suggestion, forked_query) skip logApiRequest and OpenAI
interaction logging while preserving logApiResponse.
3. Add logApiError chatRecordingService filter tests matching the
existing logApiResponse coverage.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs: reconcile createForkedChat JSDoc with module header
Clarify that createForkedChat retains the full generationConfig
(including tools) for speculation callers, while runForkedQuery
strips tools at the per-request level via NO_TOOLS.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: build errors and Copilot round 4 feedback
1. Fix NO_TOOLS type: Object.freeze produces readonly array incompatible
with ToolUnion[]. Use Readonly<Pick<>> instead; spread in requestConfig
already creates a fresh mutable copy per call.
2. Fix test missing required 'model' field in ContentGeneratorConfig.
3. Track firstResponseId/firstModelVersion in loggingStreamWrapper so
_logApiResponse/_logApiError have accurate values even when full
response collection is skipped for internal prompts.
4. Strengthen OpenAI logger test assertion: assert OpenAILogger was
constructed (not guarded by if), then assert logInteraction was
not called.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: remove dead Object.keys check, add streaming internal prompt test
1. Simplify runForkedQuery: requestConfig always has tools:[] from
NO_TOOLS spread, so the Object.keys().length > 0 ternary is dead
code. Pass requestConfig directly.
2. Add generateContentStream test for internal prompt IDs to match
the existing generateContent coverage, ensuring the streaming
wrapper also skips logApiRequest and OpenAI interaction logging.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: prevent Enter accept from re-inserting suggestion into buffer
When accepting a followup suggestion via Enter, accept() queued
buffer.insert(suggestion) in a microtask that executed after
handleSubmitAndClear had already cleared the buffer, leaving the
suggestion text stuck in the input.
Add skipOnAccept option to accept() so the Enter path bypasses the
onAccept callback. Also add runForkedQuery unit tests verifying
tools: [] is passed in per-request config.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(core): add speculation to internal IDs, fix logToolCall filtering, improve suggestion prompt
- Add 'speculation' to INTERNAL_PROMPT_IDS so speculation API traffic
and tool calls are hidden from chat recordings and tool call UI
- Add isInternalPromptId check to logToolCall() for consistency with
logApiError/logApiResponse
- Improve SUGGESTION_PROMPT: prioritize assistant's last few lines and
extract actionable text from explicit tips (e.g. "Tip: type X")
- Fix garbled unicode in prompt text
- Update design docs and user docs to reflect changes
- Add test coverage for all new behavior
* fix(core): deep-freeze NO_TOOLS, add speculation to loggingContentGenerator tests
- Object.freeze NO_TOOLS and its tools array to prevent runtime mutation
- Add 'speculation' to loggingContentGenerator internal prompt ID tests
for consistency with loggers.test.ts and internalPromptIds.ts
* fix(core): fix NO_TOOLS Object.freeze type error
Use `as const` with type assertion to satisfy TypeScript while keeping
runtime immutability via Object.freeze.
* refactor(core): remove unused isInternalPromptId re-export from loggers.ts
All consumers import directly from utils/internalPromptIds.js.
The re-export was dead code with no importers.
---------
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(core): adaptive output token escalation (8K default + 64K retry)
99% of model responses are under 5K tokens, but we previously reserved
32K for every request. This wastes GPU slot capacity by ~4x.
Now the default output limit is 8K. When a response hits this cap
(stop_reason=max_tokens), it automatically retries once at 64K — only
the ~1% of requests that actually need more tokens pay the cost.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs: add design doc and user doc for adaptive output token escalation
- Add design doc covering problem, architecture, token limit
determination, escalation mechanism, and design decisions
- Document QWEN_CODE_MAX_OUTPUT_TOKENS env var in settings.md
- Add max_tokens adaptive behavior explanation in model config section
---------
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(cli, webui): add follow-up suggestions feature
Implement context-aware follow-up suggestions that appear after task
completion, suggesting relevant next actions like "commit this", "run
tests", etc.
- Add `followup/` module with types, generator, and rule-based provider
- Export follow-up types and functions from core index
- 8 default suggestion rules covering common workflows
- Add `useFollowupSuggestionsCLI` hook for Ink/React
- Integrate suggestion generation in AppContainer when streaming completes
- Add Tab key to accept, arrow keys to cycle through suggestions
- Display suggestions as ghost text in input prompt
- Add `useFollowupSuggestions` hook for React
- Update InputForm to display suggestions as placeholder
- Add CSS styling for suggestion appearance with counter
- Add keyboard handlers (Tab, arrow keys)
- After streaming completes with tool calls, suggestions appear
- Tab accepts the current suggestion
- Left/Right arrows cycle through multiple suggestions
- Typing or pasting dismisses the suggestion
- Shell command rules (tests, git, npm install) don't work yet due to
history not storing tool arguments
- VSCode extension integration pending
- Web UI needs parent app integration for suggestion generation
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* fix: resolve merge conflicts and build errors
- Rebased on upstream main (5d02260c8)
- Fixed JSX structure in InputPrompt.tsx
- Changed `return;` to `return true;` in follow-up handlers
- Added @agentclientprotocol/sdk to core package dependencies
- Restored correct BaseTextInput usage (self-closing, no children)
- Follow-up suggestions now shown via placeholder prop only
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* fix: remove @agentclientprotocol/sdk from core package.json
The types are imported in fileSystemService.ts but the package
should not be a runtime dependency of core. It's provided by
the CLI package which depends on core. This was causing
package-lock.json sync issues on Node.js 24.x CI.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
* fix: restore alphabetical order of dependencies in core/package.json
* fix: restore package-lock.json from upstream to fix Node 24.x CI
* fix: resolve acpConnection test failure and ESLint warning
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* style: apply prettier formatting after merge
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* fix(followup): address review issues in follow-up suggestions
- Export followupState.ts from core index (was dead code)
- Refactor CLI and WebUI hooks to use shared followupReducers (eliminate duplication)
- Move side effects out of setState updaters via queueMicrotask
- Fix AppContainer useEffect dependency on unstable historyManager.history reference
- Reorder matchesRule to check pattern before condition (cheaper first)
- Make RuleBasedProvider collect from all matching rules with dedup and limit
- Add missing resetGenerator export for testing
- Add explicit implements SuggestionProvider to RuleBasedProvider
- Fix unstable followup object in useEffect dependency arrays
- Merge duplicate imports to fix eslint import/no-duplicates warnings
- Standardize copyright year to 2025
- Add test files for followupState, ruleBasedProvider, suggestionGenerator
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): address review feedback from PR #2525
- Fix acceptingRef race: set lock synchronously before queueMicrotask
- Derive hasError/wasCancelled from actual tool call statuses
- Incorporate rule priority into suggestion priority calculation
- Clear suggestions immediately when setSuggestions([]) is called
- Add !completion.showSuggestions guard to Tab handler
- Fix onAcceptFollowup type from (string) => void to () => void
- Fix ToolCallInfo.name doc examples to match display names
- Scope CSS counter ::after to data-has-suggestion + empty conditions
- Reset regex lastIndex before test() for g/y flag safety
- Stabilize hook return with useMemo + onAcceptRef pattern
- Add @qwen-code/qwen-code-core as webui external + peerDependency
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): address second round of review feedback
- Scope CSS max-width to match counter condition (not count=1)
- Only dismiss followup on printable character input, not navigation keys
- Restrict tool_group scan to most recent contiguous block (current turn)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): clear suggestions on new turn, add search guards
- Clear followupSuggestions when streaming starts (Idle → Responding)
to prevent stale suggestions from previous turns
- Add !reverseSearchActive && !commandSearchActive guards to Tab handler
to avoid keybinding conflicts with search modes
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): address third round of review feedback
- Fix string pattern asymmetry: only match tool names when matchMessage=false
- Collect tool_groups from last user message boundary, not contiguous tail
- Flatten to individual tool calls before slicing to cap at 10 actual calls
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): fix arrow cycling guard and align rule conditions with patterns
- Remove unreliable textContent check for arrow cycling in WebUI InputForm;
rely on inputText state which already accounts for zero-width spaces
- Add 'error' to fix/bug rule condition to match its regex pattern
- Add 'clean up' to refactor rule condition to match its regex pattern
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): reset acceptingRef in clear() to prevent deadlock
If clear() is called during accept debounce window, acceptingRef
could remain stuck true permanently. Now reset in clear().
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): cancel pending timeout in dismiss() and accept()
Prevents stale suggestion timeout from re-showing suggestions
after user dismisses or accepts during the 300ms delay window.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): reset lastIndex in removeRules() for g/y flag safety
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(vscode-ide-companion): mark @qwen-code/qwen-code-core as external in webview esbuild
The webui package now declares @qwen-code/qwen-code-core as external in its
vite build config. Without this change, the vscode-ide-companion webview
esbuild (platform: 'browser') would try to bundle core's Node.js-only
dependencies (undici, @grpc/grpc-js, fs, stream, etc.), causing 562 build
errors during `npm ci`.
* fix: restore node_modules/@google/gemini-cli-test-utils workspace link in lockfile
The top-level workspace symlink entry was accidentally removed by a local
npm install in commit 004baaeb, which replaced it with a nested
packages/cli/node_modules/ entry. npm ci requires the top-level link entry
to be present in the lockfile, otherwise it fails with:
"Missing: @google/gemini-cli-test-utils@0.13.0 from lock file"
Also syncs @qwen-code/qwen-code-core peerDependency into the lockfile
to match the updated packages/webui/package.json.
* refactor(followup): extract controller and improve rule matching
- Extract createFollowupController for unified state management across CLI and WebUI
- Refactor rule-based provider to match via assistant message keywords instead of tool arguments
- Add enableFollowupSuggestions user setting in UI category
- Decouple WebUI from @qwen-code/qwen-code-core by copying browser-safe state logic
- Add followupHistory.ts for extracting suggestion context from CLI history
- Add comprehensive tests for controller and rule matching scenarios
- Use --app-primary CSS variable for consistency
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(webui): import followup state from core package
- Remove followupState.ts from webui (moved to core)
- Import FollowupSuggestion, FollowupState types from core
- Add @qwen-code/qwen-code-core as peerDependency
- Add core to vite external list
- Update test to include id field in HistoryItem
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
* refactor(followup): simplify generator, revert unrelated changes
- Collapse FollowupSuggestionsGenerator class into a single
generateFollowupSuggestions() function (152 → 26 lines)
- Inline extractSuggestionContext into followupHistory.ts
- Remove unused RuleBasedProvider.addRule/removeRules methods
- Revert unrelated acpConnection.test.ts refactor
- Fix followupHistory.test.ts HistoryItem missing id field
- Reduce test verbosity (162 → 36 lines for generator tests)
* fix(followup): fix accept() deadlock and restore UMD globals mapping
- Wrap queueMicrotask callback in try/catch/finally to prevent accepting
lock from being permanently held when onAccept throws
- Restore '@qwen-code/qwen-code-core': 'QwenCodeCore' in webui
vite.config.ts globals (regression from d0f38a5f)
- Add test case verifying accept() recovers after callback exception
* fix(followup): log accept callback errors instead of swallowing them
Replace empty catch {} with console.error to ensure onAccept errors
remain visible for debugging while still preventing deadlock via finally.
Update test to verify error is logged.
* refactor(webui): move followup hook to separate subpath entry
Move useFollowupSuggestions from the root entry to a dedicated
'@qwen-code/webui/followup' subpath so that consumers who only need
UI components are not forced to install @qwen-code/qwen-code-core.
- Add src/followup.ts as separate Vite lib entry
- Remove followup exports from src/index.ts
- Add ./followup exports map in package.json
- Mark @qwen-code/qwen-code-core as optional peerDependency
- Switch build from single-entry UMD to multi-entry ESM/CJS
* fix(webui): restore UMD build and isolate core from root type boundary
- Restore UMD output for root entry (used by CDN demos, export-html, etc.)
- Build followup subpath via separate vite.config.followup.ts to avoid
Vite's multi-entry + UMD limitation
- Replace FollowupState import in InputForm.tsx with a local structural
type (InputFormFollowupState) so root .d.ts no longer references
@qwen-code/qwen-code-core
- Root entry (JS + UMD + .d.ts) is now fully free of core dependency;
core is only required by '@qwen-code/webui/followup' subpath
* refactor(followup): replace rule-based suggestions with LLM-based prompt suggestion
Replace the hardcoded rule-based follow-up suggestion engine with an LLM-based
prompt suggestion system, aligned with Claude Code's NES (Next-step Suggestion)
architecture.
Core changes:
- Replace ruleBasedProvider with generatePromptSuggestion using BaseLlmClient.generateJson()
- Port Claude Code's SUGGESTION_PROMPT and 14 filter rules (shouldFilterSuggestion)
- Simplify state from multi-suggestion array to single string (FollowupState)
- Add framework-agnostic controller with Object.freeze'd initial state
Guard conditions (9 checks):
- Settings toggle, non-interactive/SDK mode, plan mode
- Permission/confirmation/loop-detection dialogs, elicitation requests
- API error response detection, conversation history limit (slice -40)
UI interaction (CLI + WebUI):
- Tab: fill suggestion into input
- Enter: accept and submit
- Right Arrow: fill without submitting
- Typing/paste: dismiss suggestion
- Autocomplete conflict prevention
Telemetry (PromptSuggestionEvent):
- outcome (accepted/ignored/suppressed), accept_method (tab/enter/right)
- time_to_accept_ms, time_to_ignore_ms, time_to_first_keystroke_ms
- suggestion_length, similarity, was_focused_when_shown, prompt_id
- Per-rule suppression logging with reason strings
Deleted files:
- ruleBasedProvider.ts/test, followupHistory.ts/test, types.ts (dead FollowupSuggestion type)
13 rounds of adversarial audit, 17 issues found and fixed.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): address qwen3.6-plus-preview review findings
P0: Fix API error detection — check pendingGeminiHistoryItems for error
items (API errors go to pending items, not historyManager.history).
P1: Don't log abort as 'error' in telemetry — aborts are normal user
behavior (user started typing), not errors.
P3: Early return in dismiss() when state already cleared, avoiding
redundant applyState call after accept().
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(settings): update suggestion feature description to match current behavior
Remove outdated "arrow keys to cycle" text — the feature now uses
Tab/Right Arrow to accept and Enter to accept+submit (no cycling).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): fix WebUI Enter submitting empty text + defend onOutcome
P0/P1: WebUI Enter handler now passes suggestion text explicitly via
onSubmit(e, followupSuggestion) instead of relying on React setState
(which is async and would leave inputText as "" in the closure).
P3: Wrap onOutcome callbacks in try/catch in both accept() and dismiss()
so telemetry errors cannot block state transitions.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): allow setSuggestion(null) when disabled + fix dts clobber
- setSuggestion(null) now always clears state/timers even when disabled,
preventing stale suggestions from lingering after feature toggle.
- Set insertTypesEntry: false in followup vite config to prevent
overwriting the main build's index.d.ts.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(webui): thread explicitText through submit chain for Enter accept
handleSubmit and handleSubmitWithScroll now accept an optional
explicitText parameter. When provided (e.g., from prompt suggestion
Enter accept), it is used instead of the closure-captured inputText,
fixing the React setState race where onSubmit reads stale empty text.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): address Copilot review — 4 fixes
- Enter accept: use buffer.text.length === 0 instead of !trim() to
prevent whitespace-only input from triggering suggestion accept
- Move ref tracking from render body to useEffect to avoid
render-time side effects in StrictMode/concurrent rendering
- Align PromptSuggestionEvent event.name to 'qwen-code.prompt_suggestion'
matching the EVENT_PROMPT_SUGGESTION constant used by the logger
- Fix onOutcome JSDoc: remove mention of 'suppressed' (handled separately)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): address Copilot review — curated history, type compat, peer version
- Use curated history (getChat().getHistory(true)) to avoid invalid
entries causing API 400 errors in suggestion generation
- Use method signature for onSubmit in InputFormProps to maintain
bivariant compatibility with existing consumers under strictFunctionTypes
- Tighten @qwen-code/qwen-code-core peer dependency to >=0.13.1
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(followup): add prompt cache sharing + speculation engine
Phase 1 — Forked Query (cache sharing):
- CacheSafeParams: snapshot of generationConfig (systemInstruction + tools)
+ curated history + model + version, saved after each successful main turn
- createForkedChat: isolated GeminiChat sharing the same cache prefix for
DashScope cache_control hit
- runForkedQuery: single-turn request via forked chat with JSON schema support
- suggestionGenerator: uses forked query when CacheSafeParams available,
falls back to BaseLlmClient.generateJson otherwise
- GeminiChat.getGenerationConfig(): new getter for cache param snapshots
- Feature flag: enableCacheSharing (default: false)
Phase 2 — Speculation (predictive execution):
- OverlayFs: copy-on-write filesystem for speculation file isolation
(/tmp/qwen-speculation/{pid}/{id}/), handles new files + existing files
- speculationToolGate: tool boundary enforcement using AST-based shell
checker (not deprecated regex), write tools gated by ApprovalMode
(only auto-edit/yolo allow overlay writes)
- speculation.ts: startSpeculation (on suggestion display), acceptSpeculation
(on Tab/Enter — copies overlay to real FS, injects history via addHistory),
abortSpeculation (on user input/new turn — cleanup overlay)
- Custom execution loop: toolRegistry.getTool → tool.build → invocation.execute
(bypasses CoreToolScheduler — permission handled by toolGate)
- ensureToolResultPairing: strips unpaired functionCalls at boundary
- Boundary-aware tool result preservation: keeps executed tool results
even when boundary truncates remaining calls
- Feature flag: enableSpeculation (default: false)
Telemetry:
- SpeculationEvent: outcome, turns_used, files_written, tool_use_count,
duration_ms, boundary_type, had_pipelined_suggestion
- logSpeculation logger function
Security:
- Write tools only allowed in auto-edit/yolo mode during speculation
- Shell commands gated by isShellCommandReadOnlyAST (AST parser)
- Unknown/MCP tools always hit boundary (safe default)
- All structuredClone for cache param isolation
4 rounds of adversarial audit, 20+ issues found and fixed.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): address Copilot review — curated history, type compat, peer version
- Move web_fetch/web_search from SAFE_READ_ONLY to BOUNDARY tools
(they require user confirmation for network requests)
- Add overlay read path resolution for read tools (resolveReadPaths)
so speculative reads see overlay-written files
- Wire enableCacheSharing setting into generatePromptSuggestion
- Fix esbuild comment to not hardcode webui version
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(speculation): use index-based tracking for boundary tool pairing
Track executed function calls by order (first N matching
functionResponses.length) instead of by name. Fixes incorrect
pairing when model emits multiple calls with the same tool name.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(speculation): handle undefined functionCall.name + wrap rewritePathArgs
- Skip functionCall parts with missing name instead of non-null assertion
- Wrap rewritePathArgs in try/catch — treat path rewrite failure as boundary
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(followup): pipelined suggestion, UI rendering, dismiss abort
- Pipelined suggestion: after speculation completes, generate next
suggestion using augmented context. Promoted on accept.
- UI rendering: completed speculation results rendered via historyManager.
- Dismiss abort: typing/pasting calls dismissPromptSuggestion → clears
promptSuggestion → useEffect aborts running speculation immediately.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): clear cache on reset, truncate history, fix test + comment
- Clear CacheSafeParams on startChat/resetChat to prevent cross-session leakage
- Truncate history to 40 entries before deep clone in saveCacheSafeParams
to reduce CPU/memory overhead on long sessions
- Update stale comment about speculation dismiss lifecycle
- Add onAccept assertion to accept test with proper microtask flush
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs(design): add prompt suggestion design documentation
- prompt-suggestion-design.md: architecture, generation, filtering, state
management, keyboard interaction, telemetry, feature flags
- speculation-design.md: copy-on-write overlay, tool gate security, boundary
handling, pipelined suggestion, forked query cache sharing
- prompt-suggestion-implementation.md: implementation status, test coverage,
audit history, Claude Code alignment tracking
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(overlay): align catch comment with silent behavior
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): wire augmented context into pipelined suggestion + guard Tab/Right
- Pipelined suggestion now includes the accepted suggestion text and
speculated model response as context for the next prediction
- Tab/ArrowRight handlers only preventDefault when onAcceptFollowup
is provided, preventing key interception without a wired callback
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(speculation): filter thought parts + add filePath to path keys
- Skip thought/reasoning parts from model responses to prevent leaking
internal reasoning into speculated history
- Add 'filePath' to path rewrite key list for LSP and other tools that
use camelCase argument names
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(overlay): resolve relative paths against realCwd not process.cwd
Relative tool paths are now resolved against the overlay's realCwd
before computing the relative path, preventing incorrect outside-cwd
detection when process.cwd() differs from config.getCwd().
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs(design): fix 4 doc-code inconsistencies
- Guard conditions: clarify 13 code checks vs 11 table categories,
separate feature flags from guard block, add streaming transition
- Filter rules: 14 → 12 (actual count in code and table)
- BOUNDARY_TOOLS: add todo_write + exit_plan_mode to doc table
- SpeculationEvent: 8 → 7 fields (matching code)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): turns_used metric + reuse SUGGESTION_PROMPT + reduce clones
- turns_used: count only model messages (not all Content entries)
to accurately reflect LLM round-trips instead of inflated 3x count
- Pipelined suggestion: reuse exported SUGGESTION_PROMPT from
suggestionGenerator instead of a degraded local copy, ensuring
consistent quality (EXAMPLES, NEVER SUGGEST rules included)
- createForkedChat: replace redundant structuredClone with shallow
copies since params are already deep-cloned snapshots
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(followup): speculation UI tool rendering + speculationModel setting
- Speculation UI: render tool calls as tool_group HistoryItems with
structured name/description/result instead of plain text only
- speculationModel setting: allows using a cheaper/faster model for
speculation and pipelined suggestion. Leave empty to use main model.
Passed through startSpeculation → runSpeculativeLoop → pipelined.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs(design): sync docs with latest code changes
- Add speculationModel setting to feature flags table
- Document tool_group UI rendering in speculation accept flow
- Fix createForkedChat: deep clone → shallow copy (already cloned snapshots)
- Document pipelined suggestion SUGGESTION_PROMPT reuse
- Add Model Override and UI Rendering sections to speculation-design
- Update line counts to match actual file sizes
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* test(followup): add unit tests for overlayFs, toolGate, forkedQuery
overlayFs (15 tests): COW write, read resolution, apply, cleanup, path traversal
speculationToolGate (24 tests): tool categories, approval mode gating, shell AST, path rewrite
forkedQuery (6 tests): cache params save/get/clear, deep clone, version detection
Total: 27 → 173 tests
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* test(followup): P0-P2 test coverage for speculation + controller + toolGate
speculation.test.ts (7 tests):
- ensureToolResultPairing: empty, no calls, paired, unpaired text+call,
unpaired call-only, user-ending, empty parts
followupState.test.ts (+8 tests = 15 total):
- onOutcome: accepted/tab, ignored/dismiss, error caught, no-op when cleared
- clear(): resets accepting lock allowing re-accept
- double accept blocked by debounce
- setSuggestion replaces pending timer
speculationToolGate.test.ts (+3 tests = 27 total):
- resolveReadPaths: overlay path after write, unchanged when not written
- rewritePathArgs: path key coverage
Total: 173 → 190 tests
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* test(followup): smoke tests + P0-P2 coverage gaps
smoke.test.ts (21 tests): E2E verification across modules
- Filter against realistic LLM outputs (9 good + 7 bad + reason check)
- OverlayFs full round-trip (write → read → apply → verify)
- ToolGate → OverlayFs integration (write redirect → read resolve)
- CacheSafeParams lifecycle (save → mutate → isolation → clear)
- ensureToolResultPairing orphaned functionCalls
followupState.test.ts (+8 tests):
- onOutcome: accepted/tab, ignored/dismiss, error caught, no-op cleared
- clear(): resets accepting lock
- double accept debounce
- setSuggestion replaces pending timer
speculationToolGate.test.ts (+3 tests):
- resolveReadPaths through overlay after write
- path key coverage for rewritePathArgs
Export ensureToolResultPairing for testing.
Total: 190 → 211 tests
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): dismiss aborts suggestion, boundary skip inject, parentSignal check
- dismissPromptSuggestion now also aborts suggestionAbortRef to prevent
race between dismiss and in-flight startSpeculation
- Boundary speculation: skip acceptSpeculation (which injects history),
fall through to normal addMessage to avoid duplicate user turns
- startSpeculation: check parentSignal.aborted upfront before starting
- Speculation rendering: use index-based loop instead of indexOf O(n²)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs(design): fix speculation accept diagram — boundary skips inject
The architecture diagram now shows the branching logic: completed
speculations go through acceptSpeculation (inject + render), while
boundary speculations are discarded and the query is submitted fresh
via addMessage.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(followup): enable cache sharing by default
enableCacheSharing now defaults to true. This is a pure cost
optimization with no behavioral change — suggestion generation
uses the forked query path (sharing the main conversation's
prompt cache prefix) when CacheSafeParams are available.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): aborted parent skips loop, acceptSpeculation try/finally, doc sync
- startSpeculation: return aborted state immediately when parentSignal
is already aborted, without creating overlay or starting loop
- acceptSpeculation: wrap in try/finally to guarantee overlay cleanup
even if applyToReal or addHistory throws
- Doc: enableCacheSharing default false → true (matches code)
- Doc: update test count table (7 → 15 followupState, add 6 new files)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): remove debug logs, add function calling fallback for non-FC models
- Remove all followup-debug process.stderr.write logs
- Add direct text fallback in generateViaBaseLlm when generateJson
returns {} (model doesn't support function calling, e.g., glm-5.1)
- Add CJK text support in filter: skip whitespace-based word count
for Chinese/Japanese/Korean text, use character count instead
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(followup): add suggestionModel setting for faster suggestion generation
New setting `suggestionModel` allows using a smaller/faster model
(e.g., qwen-turbo) for prompt suggestion generation instead of the
main conversation model. Reduces suggestion latency significantly.
Passed through: settings → AppContainer → generatePromptSuggestion
→ generateViaForkedQuery / generateViaBaseLlm (both paths).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(followup): suggestionModel setting, /stats tracking, /about display
- suggestionModel: new setting to use a faster model for suggestion
generation (e.g., qwen3.5-flash instead of main model glm-5.1)
- /stats: suggestion API calls now report usage to UiTelemetryService
so token consumption appears in /stats model breakdown
- /about: shows Suggestion Model field (configured or main model)
Also:
- Function calling fallback for non-FC models (direct text generation)
- CJK text support in word count filter (character-based for Chinese)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* i18n: add Suggestion Model translations for /about display
en: Suggestion Model | zh: 建议模型 | ja: 提案モデル
de: Vorschlagsmodell | pt: Modelo de Sugestão | ru: Модель предложений
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): always use generateContent for suggestion (not generateJson)
generateJson doesn't expose usageMetadata, so /stats can't track
suggestion model tokens. Switch to direct generateContent which
always returns usage data. Also simplifies the code by removing
the function-calling + fallback dual path.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): fix /stats tracking — use ApiResponseEvent constructor
Use ApiResponseEvent class constructor with proper response_id and
override event.name to match UiEvent type for UiTelemetryService
switch statement. This ensures suggestion model token usage appears
in /stats model output.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* i18n: fix Chinese translation for Suggestion Model
"建议模型" → "提示建议模型" to avoid ambiguity.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* refactor(followup): merge suggestionModel + speculationModel into fastModel
Single unified setting for all background tasks: suggestion generation,
speculation, pipelined suggestions, and future background tasks.
Users only need to understand one concept: main model for conversation,
fast model for background tasks.
- Remove: suggestionModel, speculationModel
- Add: fastModel (ui.fastModel in settings.json)
- Update /about display: "Fast Model" with i18n translations
- Update all 6 locale files (en/zh/ja/de/pt/ru)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* refactor(settings): move fastModel to top-level (parallel to model)
fastModel is an independent model concept, not a property of the
main model. Move from model.fastModel to top-level settings.fastModel.
Config: { "fastModel": "qwen3.5-flash", "model": { "name": "glm-5.1" } }
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): report usage in both forkedQuery and baseLlm paths
The forkedQuery path (used when enableCacheSharing=true) was not
reporting token usage to UiTelemetryService, so /stats model didn't
show the fast model. Now both paths report usage.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(cli): add /model --fast command to set fast model
Usage:
/model --fast qwen3.5-flash — set fast model
/model --fast — show current fast model
/model — open model selection dialog (unchanged)
Saves to user settings (SettingScope.User).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs(design): update to fastModel (replace suggestionModel/speculationModel)
- prompt-suggestion-design.md: speculationModel → fastModel (top-level)
- speculation-design.md: Model Override → Fast Model, update description
- prompt-suggestion-implementation.md: update settings description
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(cli): /model --fast opens model selection dialog for fast model
When called without a model name, /model --fast now opens the same
model selection dialog used by /model, but selecting a model saves
it as fastModel instead of switching the main model.
- useModelCommand: add isFastModelMode state
- ModelDialog: intercept selection in fast model mode, save to fastModel
- DialogManager: pass isFastModelMode prop to ModelDialog
- types.ts: add 'fast-model' dialog type
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): pass resolved model (not undefined) to runForkedQuery
model: modelOverride → model: model (which has the fallback applied)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(cli): /model --fast defaults to current fast model in dialog
When opening the model selection dialog via /model --fast, the
currently configured fastModel is pre-selected instead of the
main model.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* feat(cli): add --fast tab completion for /model command
/model <Tab> now shows --fast as a completion option with description.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(schema): regenerate settings.schema.json with new followup settings
Adds enableCacheSharing, enableSpeculation, and fastModel to the
generated JSON schema so CI validation passes.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(test): update tests for new Fast Model field in system info
Add "Fast Model" to expected labels in systemInfoFields and bugCommand
tests to match the new field added to /about and bug report output.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* ci: trigger PR synchronize event
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: address Copilot review comments (batch 4)
- modelCommand: use getPersistScopeForModelSelection for fastModel,
return meaningful info message instead of empty content
- ModelDialog: handle $runtime|authType|modelId format in fast-model mode
- forkedQuery: return structuredClone from getCacheSafeParams
- client: fix stale comment about history truncation order
- speculation: detect abort in .then() handler, set 'aborted' status
and cleanup overlay to prevent leaks
- docs: update test count table
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs(users): add followup suggestions user manual
- New feature page: followup-suggestions.md covering usage, keybindings,
fast model configuration, settings, and quality filters
- commands.md: add /model --fast command reference
- settings.md: add enableFollowupSuggestions, enableCacheSharing,
enableSpeculation, and fastModel settings documentation
- _meta.ts: register new page in navigation
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs(users): audit fixes for followup suggestions documentation
- followup-suggestions.md: add 300ms delay, WebUI support, plan mode
guard, non-interactive guard, slash commands as single-word, meta/error
filters, character limit
- settings.md: move fastModel next to model section, add /model --fast
cross-reference and link to feature page
- overview.md: add followup suggestions to feature list
- i18n: add missing translations for 'Set fast model for background
tasks' and 'Fast model updated.' in all 6 locales
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix: address Copilot review comments (batch 5)
- modelCommand: remove duplicate info message (keep addItem only)
- followup-suggestions.md: clarify WebUI requires host app wiring
- speculation-design.md: fix abort telemetry description
- i18n: add missing translations for fast model strings
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(cli): remove duplicate message in /model --fast command
Use return message instead of addItem + empty return to avoid
blank INFO line in history. Also handle missing settings service.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(i18n): remove unused 'Fast model updated.' translations
The /model --fast command now returns the model name directly
instead of using this string. Remove dead translations.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* fix(followup): disable thinking mode for suggestion and speculation
Forked queries inherit the main conversation's generationConfig which
may have thinkingConfig enabled. This wastes tokens and adds latency
for background tasks that don't need reasoning. Explicitly set
thinkingConfig.includeThoughts=false in both paths:
- createForkedChat (covers forked query + speculation)
- generateViaBaseLlm (non-cache-sharing fallback)
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
* docs: document thinking mode auto-disable for background tasks
- User docs: note that thinking is auto-disabled for suggestions/speculation
- Design docs: detail thinkingConfig override in both forked query and
BaseLlm paths, explain why cache hits are unaffected
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
Co-authored-by: jinjing.zzj <jinjing.zzj@alibaba-inc.com>
Co-authored-by: yiliang114 <1204183885@qq.com>
- Fix broken references to non-existent files
- Replace "What's Next" with detailed "Future Work" roadmap
- Remove redundant implementation, roadmap, and testing guide files
- User docs already cover these topics in docs/users/features/channels/
This consolidates the channels design documentation into a single
authoritative design doc, reducing duplication and maintenance burden.
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
- Architecture overview with platform adapters and ACP bridge
- Plugin system contract and extension loading
- Implementation guides for Telegram, WeChat, DingTalk
- Testing guide with mock servers and E2E scenarios
- Feature roadmap and known limitations
These docs provide the foundation for the external messaging integrations.
Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>