6 commits

Author	SHA1	Message	Date
Nothing Chan	082b3bb3d9	fix(memory): give each linked git worktree its own auto-memory root (#6462) ... getAutoMemoryRoot() resolved linked worktrees back to the canonical repository root, so every worktree of a repo shared one project memory. Focused worktree sessions polluted the shared MEMORY.md index with unrelated entries, and chats/, workflows/, and team memory were already per-worktree — project memory was the only shared exception. Anchor project memory at the nearest git root (same resolution team memory already uses) so each worktree gets its own memory directory. The main checkout resolves to the same path as before, so existing memory is unaffected. Fixes #6449 Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-08 14:34:03 +00:00
pomelo	e92fcbab46	fix(cli): switch TUI prefix ✦→◆ to fix glyph overflow on some terminals (#5974) ... * fix(cli): replace ✦ (U+2726) with ◆ (U+25C6) and add ∵/∴ thinking icons - Replace ✦ with ◆ across all TUI components to fix East Asian Ambiguous width misalignment (string-width reports 1 but terminals render 2 columns). - Use ∵ (because) during thinking streaming, ∴ (therefore) when thinking is complete — matches the mathematical reasoning pair. Co-Authored-By: Qwen Code <noreply@alibaba-inc.com> * fix(cli): reduce STATUS_INDICATOR_WIDTH from 3 to 2 after ◆ replacement ◆ (U+25C6) is a consistent width-1 character across all terminals, so the tool status indicator no longer needs the extra column that was reserved for the ambiguous-width ✦ (U+2726). Co-Authored-By: Qwen Code <noreply@alibaba-inc.com> * fix(cli): catch missed ✦→◆ references in tests, docs, and scenarios * fix(cli): shorten tmux spinner frames from 3 to 2 chars to match STATUS_INDICATOR_WIDTH=2 TMUX_SPINNER_FRAMES changed from ['. ', '.. ', '...'] to ['· ', '··'] to prevent 1-column overflow in tmux when STATUS_INDICATOR_WIDTH was reduced from 3 to 2 after the ◆ replacement. * revert(cli): keep narrow '.' tmux spinner frames instead of ambiguous '·' '.' (U+002E) is Narrow (always 1 col), giving a guaranteed fixed-width tmux spinner. '·' (U+00B7) is East Asian Ambiguous, so on ambiguous-width=2 terminals the frames become 3/4 cols and the spinner jitters — the opposite of the "fixed-width frames" the surrounding comment promises. Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com> --------- Co-authored-by: Qwen Code <noreply@alibaba-inc.com> Co-authored-by: pomelo.lcw <pomelo.lcw@alibaba-inc.com> Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>	2026-06-30 22:44:34 +00:00
qqqys	673454839e	feat(memory): add a git-shared team memory tier (#5886) ... * feat(memory): add a git-shared team memory tier Add an opt-in third auto-memory tier — TEAM — stored in the repository at `.qwen/team-memory/` and shared with collaborators through git. The private USER and PROJECT tiers are unchanged. - Enabled via the `memory.enableTeamMemory` setting (default off) or the `QWEN_CODE_MEMORY_TEAM` env override; inactive otherwise. - The model is taught a three-tier prompt and when to route saves to the shared tier (project-wide conventions, team-wide references). - Writes to the team directory are scanned for secrets (a curated gitleaks-style ruleset) and hard-blocked, since the directory is committed to the repo and visible to everyone with repo access. - Team writes default to 'ask' permission — not auto-allowed like the private tiers — so they are proposed for confirmation in the default approval mode and surface in the git diff for review. Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com> * fix(vscode): update settings schema for team memory * fix(memory): harden team memory review gaps * fix(memory): address team-memory PR review feedback - secret-scanner: AWS key suffix is base62 ([A-Z0-9]), not base32 ([A-Z2-7]) — old class missed IDs with digits 0/1/8/9; add a positive test for such a key. - paths: document that isAnyAutoMemPath deliberately excludes team memory (security-load-bearing — team writes must stay 'ask'). - extractionAgentPlanner: name the team-memory dir in the scoped deny message so a denied team write is debuggable. - prompt: spell the tier count via a number-word lookup so a future 4th tier never silently reads "two". - team-memory-secret-guard: debug-log matched rule IDs only (never the secret content) when a write is blocked. - edit: when a blocked team write's secret already exists in the on-disk file, tell the user to delete the committed secret. - docs: caveat that a directory-form gitignore (.qwen/) makes the !-reinclude a no-op; use the file-glob form. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): harden team-memory secret guard on blocked writes and notebooks - write-file: blocked team-memory secret write now returns an `error` field (INVALID_TOOL_PARAMS) so the framework treats it as a failure instead of a silent success, mirroring edit.ts. - notebook-edit: scan the serialized .ipynb that hits disk through the team-memory secret guard before writing, blocking with the same `error` field; behavior unchanged for non-team-memory paths. - store: log non-ENOENT errors in readTeamAutoMemoryIndex before re-throwing, so EACCES/EIO/ELOOP no longer vanish via config.ts's best-effort `.catch(() => null)`. - config: emit a debug diagnostic when team memory is enabled but suppressed by the untrusted-workspace trust gate. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * feat(memory): auto-generate the team memory index Generate the team `MEMORY.md` index by scanning the saved memory files instead of having the model hand-maintain it. The index is derived and ordered by path, so the committed file is deterministic across machines. This removes the git merge-conflict surface a hand-edited shared index would have, keeps the index consistent with the files, and frees the model from the two-step save for the team tier. Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com> * feat(memory): opt-in git sync for team memory Add an opt-in, best-effort git sync of team memory at session start so a daemon can share team memory through the remote without manual git. Off by default; enabled with `QWEN_CODE_MEMORY_TEAM_SYNC=1`. It commits the team directory (only that path), pulls fast-forward-only, then pushes. `--ff-only` is deliberate: it never creates a merge commit or a conflict — a diverged branch is skipped rather than touching the working tree. All git is best-effort and never throws, so a failure cannot break a session. Commits can be attributed to the acting user via an optional author, for cooperative per-user attribution on a shared daemon. Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com> * fix(core): close team-memory secret-guard regex + test gaps - secret-scanner: add `_` to the two T3BlbkFJ-marker char classes so legacy base64url OpenAI keys with underscores in the body no longer bypass the scanner; extend the OpenAI positive samples with an underscore key body. - edit: cover the pre-existing-secret branch — seed the on-disk file with a full detectable token, assert the distinct "already exists" message and that the blocked edit leaves the file untouched. - team-paths: cover the first-ever write before .qwen/team-memory exists, exercising realpathNearestExisting walking up to an existing ancestor. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * feat(core): add Google OAuth client secret and SendGrid secret-scanner rules Extend the team-memory secret scanner with two more high-confidence, distinctive-prefix credential patterns (both gitleaks rules): - gcp-oauth-client-secret: GOCSPX- prefix + 24 base64url chars, placed next to the existing GCP AIza API-key rule. - sendgrid-api-token: SG. + 22-char id + . + 43-char secret. Both have a near-zero false-positive bar, matching the curated set's existing criteria. Add a load-bearing positive sample per rule. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): warn when team memory is enabled but not git-shareable When the team tier is active, emit a one-time startup warning if its directory is git-ignored (e.g. a directory-form `.qwen/` ignore that a `!`-reinclude cannot escape) or there is no git root — so the tier never silently shares nothing. Gated on the active (trusted + enabled) tier; probes a representative file path with `git check-ignore`, and is latched so refreshHierarchicalMemory re-runs do not re-emit it. Closes the last open review thread (wenshao + qwen-code-ci-bot both flagged the silent-inert case); the docs caveat already shipped. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * feat(memory): dedup team index by description; fix empty-frontmatter parse The team index now collapses entries that share a (normalized) description into one line — listing the other files via "(also: …)" — so two people saving the same shared fact don't surface as duplicates. Nothing is dropped; every file path is preserved and the grouping is deterministic (input is path-sorted). Also fix a pre-existing frontmatter bug: parseFrontmatterValue used `\s*`, which crosses newlines, so an empty value (`description:`) captured the next frontmatter line. Bound it to horizontal whitespace. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * feat(memory): add memory.enableTeamMemorySync setting Team-memory git sync was env-only (QWEN_CODE_MEMORY_TEAM_SYNC). Add a first-class `memory.enableTeamMemorySync` setting mirroring the enableTeamMemory plumbing (settingsSchema, cli/core config, acpAgent type/schema/default/keys/normalizer, desktop mirror), with the env var kept as a 0/1 override. Off by default. Docs updated. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): audit hardening — resilient scan, deterministic team index From a multi-round adversarial audit of the team-memory tier: - scan: a single unreadable memory file (EACCES, or a TOCTOU delete during `git pull`) no longer rejects the whole scan and wipe every memory from the index — per-file failures are caught and skipped (debug-logged). - indexer: order the team index by code unit, not `localeCompare()`, so the committed MEMORY.md is byte-identical across machines/locales and the ff-only sync can't wedge on index churn. - scan: escape the frontmatter key before building its RegExp (latent hardening). - config: surface a skipped/failed team-memory sync at debug level instead of silently swallowing it. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): deterministic team index cap + surface diverged sync Round-2 audit follow-ups: - scan: the >200-file cap selected its subset by mtime + locale basename, which differs per machine/locale — so a large team's committed index churned and wedged the ff-only sync. Team scans now cap by code-unit path (deterministic); private tiers keep mtime-recency (never shared, so it's fine). - sync: a diverged branch made `pull --ff-only` (and the push) fail with no `skippedReason` — a silent no-op for a user who opted into sync. Now reported as `pull-failed` / `push-failed` and logged. Docs note pull/push are whole-branch, not path-scoped. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): regenerate settings schema for enableTeamMemorySync Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): harden team-memory git sync (reconcile-first, scoped push, safe failure) The opt-in team-memory git sync could publish unrelated local commits, wedge a two-writer branch, leave team files staged on commit failure, and hang session start on a credential prompt. Harden all four maintainer-flagged criticals: - Reconcile first: run `git pull --ff-only` BEFORE committing so the local team commit lands on top of upstream instead of diverging; a diverged branch is skipped cleanly as `pull-failed` rather than committing then wedging `--ff-only`. - Scoped push: push only when THIS sync created the commit and the branch was not already ahead of `@{u}` (pre-sync), via an explicit single-branch refspec (`HEAD:<merge-ref>`) — never an unqualified `git push`. New `local-ahead` skip. - Safe failure: unstage the team path when the commit fails (hook/GPG/identity) so a user's next manual `git commit` cannot sweep team files in. - Non-interactive git: force `GIT_TERMINAL_PROMPT=0` + batch-mode SSH, SIGKILL on timeout, and a shorter timeout so sync cannot block session start on a prompt. config refresh: rebuild the team index BEFORE syncing (so a fresh MEMORY.md is committed/pushed, with a re-build after a pull that brought new files) and key the shareability latch by projectRoot so a newly entered repo is re-checked. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): harden team-memory index/scan/path security Address the security/correctness criticals from PR #5886 review. Team memory is committed to the repo and loaded into every collaborator's system prompt, so its write/scan/classification paths are trust boundaries. - indexer: pass noFollow on the team MEMORY.md write and reject a symlinked team root, so a committed `.qwen/team-memory` (or index) symlink can't redirect the generated index outside the repo. - indexer: sanitize attacker-controlled frontmatter title/description (strip control/zero-width/bidi chars, collapse newlines, defang code/link markdown, cap length) before embedding into MEMORY.md, to prevent prompt injection into the shared context. - indexer: skip the rewrite when the generated index is byte-identical, avoiding mtime churn and no-op commit cycles. - scan: normalize CRLF before parsing so a Windows checkout's team files don't silently drop out of the shared index. - paths: resolve a dangling final-component symlink via lstat/readlink in realpathNearestExisting, so a `decoy -> team-memory/leak.md` (missing target) is classified as team and the secret scanner can't be bypassed. - secret-scanner: bound both quantifiers in the openai-api-key T3BlbkFJ rule ({20,512}) to remove O(n^2) ReDoS backtracking; real keys still match. - team-memory-git-status: also probe a representative topic path so a repo that re-includes the index but ignores topic files is flagged as non-shareable. - notebook-edit: run the team-memory secret scan in validateToolParamValues too, for parity with edit/write-file. Adds load-bearing tests for each fix. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): sanitize team index paths and verify whole-path containment Refines the earlier team-memory security hardening with two fixes the first pass left open: - sanitizeIndexPath now defangs the attacker-controlled relativePath rendered into the committed MEMORY.md — at BOTH the `](path)` link target and the "(also: ...)" dedup suffix. A git filename may legally contain newlines and markdown delimiters, so a raw path could inject a second physical line (e.g. "- SYSTEM:") and reopen the prompt-injection structure the patch was closing for title/description. - rebuildTeamAutoMemoryIndex now realpath-resolves the whole team root and requires it to equal repoRoot/.qwen/team-memory. The prior lstat only inspected the leaf, so a symlinked PARENT component (e.g. `.qwen -> /tmp/out`) let scan/write escape the repo undetected while the guard believed it had rejected symlinks. Also adds a regression test pinning the security-load-bearing invariant that isAnyAutoMemPath excludes team paths (so team writes stay ask-gated). Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): keep team index link targets addressable, not just safe The earlier injection fix rewrote legal filename chars (`(` `)` `[` `]` and backticks) to `_` and used that destroyed value as the ACTUAL MEMORY.md link target. A real file `feedback/a(b).md` was emitted as `](feedback/a_b_.md)`, which does not exist (or, worse, collides with a different real file) — the link was injection-safe but no longer addressable. Replace `sanitizeIndexPath` with `encodeIndexPathTarget`, a reversible percent-encoder: every char outside an addressable allowlist (alphanumerics and `/ . - _ ~`) is percent-encoded, so breakout chars become inert ASCII (newline->%0A, `(`->%28, `)`->%29, space->%20, backtick->%60, ...). The target is a single line with no `](`/`)` breakout, yet `decodeURIComponent` recovers the exact original path so the link resolves to the real file. `/` is kept literal so the path still works as a relative reference. Applied at both index sites (the main `](path)` link and the `(also: ...)` suffix). The display label (title) stays non-reversibly sanitized as before — it is not addressable. Update the path tests to assert the emitted target percent-decodes back to the real relative path, and add a `feedback/a(b).md` case. The newline+`]`/`)` injection assertions remain (mutation-verified: they fail if the encoding is dropped). Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): gate team-memory sync on the index safety check rebuildTeamAutoMemoryIndex throws when the team root is a symlink that could redirect the committed index outside the repo, but the surrounding .catch swallowed the error and syncTeamMemory ran independently — so a refused symlink/escape still got git add/commit/push'd on the out-of-repo dir, defeating the indexer's refusal. Capture whether the rebuild succeeded and only sync when it did, so a failed safety check skips sync entirely. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): harden team-memory git sync and cover execute-time secret scan Several robustness fixes to the team-memory git sync, plus a missing test: - Respect a user's GIT_SSH_COMMAND: append our non-interactive batch guards (-oBatchMode=yes -oConnectTimeout=5) onto it instead of clobbering it, so a custom identity (-i), proxy jump (-J), or non-standard port is preserved. - Skip cleanly on a detached HEAD (new `detached-head` skippedReason) instead of creating an orphaned commit that can never be pushed. A branch with no upstream still commits locally as before. - Use SIGTERM (not SIGKILL) as the git kill signal so a timeout mid-commit/-pull lets git release index.lock and clean up; the non-interactive ssh guards already bound the network-hang case. - docs(memory): correct the sync description to match the implementation (rebuild index, ff-pull BEFORE commit, push only the scoped sync commit, skip on divergence/no-upstream). - test(notebook-edit): cover the execute-time team-memory secret scan (the full-notebook backstop), distinct from the existing validate-time test. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> * fix(memory): split security vs operational team-sync failures; per-op git kill signal Refine the recent team-memory sync changes per review: - indexer: throw a typed TeamMemoryRootSecurityError for the symlink/escape rejection so the sync gate can tell a SECURITY refusal apart from an OPERATIONAL IO failure. config now blocks sync ONLY on the security class; an operational rebuild failure (EACCES/ENOSPC/EPERM) is logged but self-corrects on the next rebuild and no longer permanently gates legitimate team sync. The security invariant (never add/commit/push an escaping root) is unchanged. - team-memory-sync: pass a per-op kill signal to tryGit — SIGKILL for the hang-prone network/ref ops (pull/push/rev-parse/symbolic-ref; no index.lock to corrupt), SIGTERM for mutating ops (add/commit) so git can release locks and clean up. Node's execFile timeout does not escalate to SIGKILL on its own, so a child trapping SIGTERM could hang past the timeout. - team-memory-sync: thread the resolved branch into resolvePushTarget so it no longer re-spawns `git symbolic-ref` after the detached-HEAD check. - docs: fix a broken sentence in the team-memory git-sync section. - tests: cover both rebuild failure classes (security -> sync skipped; operational -> sync still runs) and a positive gate (rebuild ok + sync enabled -> sync runs); assert the typed error on the indexer symlink tests. Co-Authored-By: Qwen-Coder <noreply@qwen.ai> --------- Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com> Co-authored-by: Qwen-Coder <noreply@qwen.ai> Co-authored-by: Shaojin Wen <shaojin.wensj@alibaba-inc.com>	2026-06-27 12:29:48 +00:00
顾盼	24ebfbc13e	feat(memory): load .qwen/QWEN.local.md as project-local context (#4091) (#4394) ... * feat(memory): load .qwen/QWEN.local.md as project-local context (#4091) Adds a per-developer, project-scoped context file slot at `<projectRoot>/.qwen/QWEN.local.md`. Loaded after all hierarchical QWEN.md / AGENTS.md files so local instructions can supplement or override shared ones. Use case: project-specific but personal instructions (local cluster IDs, container registry namespaces, accounts) that shouldn't live in the shared root `QWEN.md` (exposes them to the team) or in the global `~/.qwen/QWEN.md` (applies to every project). Mirrors Claude Code's `.claude/CLAUDE.local.md` convention. The slot is single and fixed (project root only — not searched in CWD subdirectories or via upward traversal), gated by the same trust and explicit-only checks as the rest of project-level discovery, and counted in `fileCount` so the `/memory` panel surfaces it. Users must gitignore the file themselves; `.qwen/` is not auto-ignored and `.qwen/settings.json` is commonly committed. * fix(memory): support .git-file repos when locating QWEN.local.md slot `findProjectRoot()` only accepted `.git` as a directory, so in git worktrees and submodules (where `.git` is a file containing a `gitdir:` pointer) it returned `null`. The new `.qwen/QWEN.local.md` slot then fell back to `<cwd>/.qwen/QWEN.local.md`, silently breaking the documented "single fixed slot at project root" behavior for users inside worktrees — including the developer of this feature. Two changes: 1. `findProjectRoot()` now accepts `.git` as either a directory or a regular file. This also incidentally repairs pre-existing breakage in `rulesDiscovery` / hierarchical-search stop boundary, both of which consume the same helper. 2. The local-context-file slot now requires a real `foundRoot` (the `null` case is no longer covered by the `effectiveRoot` fallback). Without this guard: - a deep cwd in a non-git workspace turned the slot into a per-cwd file, opposite the design; - `cwd === homedir` resolved the slot to `~/.qwen/QWEN.local.md`, colliding with the global Qwen directory. Three regression tests pin the new behavior: `.git`-as-file is recognized, no-`.git`-ancestor skips the slot, `cwd === homedir` without `.git` does not promote a global file to project-local. * refactor(memory): extract findProjectRoot to shared utility (#4091) Two duplicate `findProjectRoot` helpers existed in `packages/core/src/utils/`: one in `memoryDiscovery.ts` (returns `Promise<string | null>`) and one in `memoryImportProcessor.ts` (returns `Promise<string>`, falls back to startDir). The previous fix in 97c6fb41f only updated the first copy for `.git`-file support, so `@import` resolution under git worktrees and submodules was still silently broken — the QWEN.local.md file would load, but its imports would resolve against the wrong root. Extract the helper into `utils/projectRoot.ts`, with the unified nullable return type. Rewire both call sites; `memoryImportProcessor` preserves its previous fallback semantics at the call site (`?? path.resolve(basePath)`). Adds 5 unit tests for the utility (directory / file / null / deep / symlink) and 1 test for the previously-unverified dedup guard in `memoryDiscovery.ts` (exercised via `extensionContextFilePaths`). Addresses inline + cross-file findings from wenshao on PR #4394.	2026-05-25 11:22:55 +08:00
Shaojin Wen	b004450d7f	feat(cli): support multi-line status line output (#3311) ... * feat(cli): support multi-line status line output (#3211) Remove the single-line hard limit (.split('\n')[0]) from the status line hook so user scripts can output multiple rows. Footer renders each line as a separate <Text wrap="truncate"> element, preserving per-line horizontal truncation. Ink's virtual DOM handles re-rendering without manual ANSI cursor management. * feat(cli): cap status line output at 3 lines Prevent runaway scripts from flooding the footer — lines beyond the third are silently discarded. * docs: mention 3-line cap in status line docs and agent prompt * fix(cli): cap status line at 2 lines to keep footer within 3 rows Footer has a fixed bottom row (hint/mode indicator), so status line gets at most 2 lines to keep the total footer height at 3 rows max. * test(cli): improve useStatusLine coverage to 100% lines Add tests for: per-model metrics payload, contextWindowSize/version/ model fallbacks, config removal with pending debounce, command change cancelling pending debounce. * docs: update status line ASCII diagram for multi-line layouts Also fix TS error in test (null → null as never for mock return). * refactor(cli): return string[] from useStatusLine, filter empty lines Address review feedback: - Hook returns `lines: string[]` instead of `text: string | null`, eliminating the join/split round-trip with Footer. - Filter empty lines before slicing so leading blanks don't eat real content (e.g. "\n\nreal content" no longer yields ["", ""]). - Export MAX_STATUS_LINES with comment explaining the 3-row constraint. - Use `status-line-${i}` as React key for clarity. * test(cli): add Footer multi-line rendering, \r\n, and pure-newline tests Address remaining review feedback: - Footer test: mock useStatusLine, verify multi-line rendering and hint suppression. - useStatusLine test: add \r\n line ending and pure-newline edge case. * fix(cli): align right footer indicators to top When the status line has multiple rows, the left column becomes taller than the right section. The outer Box defaults to `alignItems: stretch` which caused the indicators to visually center; add `alignItems="flex-start"` on the right Box so they stay anchored to the top row. Reported via e2e test in #3311.	2026-04-17 12:44:30 +08:00
顾盼	9e2f63a1ca	feat(memory): managed auto-memory and auto-dream system (#3087) ... * 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	2026-04-16 20:05:45 +08:00