213 commits

Author	SHA1	Message	Date
Kai	691ec4679e	fix: remove the blocking wait from the TaskOutput tool (#2379) ... * fix: remove the blocking wait from the TaskOutput tool The block/timeout parameters let a model stall the whole turn waiting for a background task (up to 3600s), even though completion already arrives via automatic notification. Remove both parameters from the v1 and v2 engines (kept in model-facing parity), simplify retrieval_status to success/not_ready, and update the tool, Bash, and Agent prompt wording plus user docs accordingly. Stale callers passing block are silently treated as a non-blocking snapshot. * fix: align background-task prompts with the non-blocking TaskOutput The compaction reminder promised TaskOutput could fetch a task's result for tasks that are still running, where it now returns not_ready — reword it to snapshot semantics and point at the completion notification. Also list AskUserQuestion(background=true) as a task source in the TaskOutput description. * test: exercise stale TaskOutput args through the runtime validator A stale block/timeout argument never reaches the tool: the executor's preflight validates args against the closed tool schema and rejects them immediately, so the old test documented silent-tolerance semantics the runtime never exhibits. Assert the real behavior through compileToolArgsValidator/validateToolArgs instead, and drop statement-adjacent comments to match the package's header-only comment convention.	2026-07-30 01:26:56 +08:00
7Sageer	fa2c5ce18b	feat: support plugin-contributed custom agents (#2365) ... * feat: support plugin-contributed custom agents * fix: await plugin loading before agent catalog * fix: refresh plugin agents on v1 reload * test(agent-core-v2): add enabledSystemPrompts to the plugin service stub	2026-07-29 21:59:48 +08:00
7Sageer	02d77b20d9	feat(agent-core-v2): let plugins contribute system prompt instructions via the manifest systemPrompt field (#2314) ... * feat(agent-core-v2): let plugins contribute system prompt instructions via the manifest systemPrompt field * feat(agent-core-v2): add systemPromptPath to load plugin system prompt from a file * docs: explain plugin system prompt templates * fix(agent-core-v2): refresh plugin system prompts after changes * fix(agent-core-v2): freeze restored profile bindings and converge plugin contributions at session scope - restore no longer re-renders or re-persists prompts: a resumed agent keeps its replayed profile binding (prompt and tool set) as persisted - a new Session-level convergence point reloads plugin skills into the session skill catalog before fanning out to every live agent prompt, and every catalog-kind plugin mutation awaits the whole pipeline; MCP-only toggles carry a distinct change kind and skip it - live refreshes after a restart re-resolve the bound profile by name and rebind the full slice (prompt, disallowed tools, active tools) atomically, warning and keeping the persisted state when the profile is gone; renders reuse the first-render timestamp and unchanged prompts are not re-persisted, so convergence never churns the wire - cap plugin system-prompt contributions (32 KB per field/file, 64 KB aggregate per prompt build) with manifest diagnostics and warnings - bump the changeset to minor: this is a new user-facing capability * fix(agent-core-v2): register the new session domain and dedupe the missing-profile warning - add sessionPluginContribution to the domain-layer registry so lint:domain stays green - emit system-prompt-refresh-profile-missing once per profile name, matching the service's other deduped warnings - document the convergence timeout escape hatch and the klient exclusion of enabledSystemPrompts * fix(agent-core-v2): dedupe the plugin budget warning and surface section read failures - emit plugin-sections-oversized once per skipped-plugin signature - let enabledSystemPrompts failures propagate to the refresh catch (keeps the current prompt and warns) instead of silently rendering and persisting a prompt without plugin instructions - cover the convergence timeout cut-off with a fake-timers test - clarify that the first-render timestamp anchors per process * fix(agent-core-v2): serialize session convergence and restore onDidReload timing - run at most one convergence per session and bound each change's wait by the timeout, so a fan-out emitter never interleaves deliveries after a timed-out convergence - fire onDidReload as soon as the reload commits again, keeping hook reloads independent of prompt convergence - sign the plugin budget warning with an unambiguous key * docs(agent-core-v2): align convergence wording with the serialized semantics - the timeout retry promise only holds once stalled work clears - note the per-session serial delivery cost model on the plugin change contract and the dual-queue invariant on the service * fix(agent-core-v2): keep empty plugin sections byte-neutral in the prompt template - place ${plugin_sections} on the same template line as ${skills_section} so prompts without either block render exactly as before this feature - note on the change contract that waitUntil work must not call back into plugin mutations, and spell out the per-session convergence order in the user docs * fix(agent-core-v2): pin a fork's profile so refresh triggers never rebind it - applyBindingSnapshot left the fork with no pinned profile, which routed in-process forks into the post-restart catalog rebind and could reset an inherited tool set; forks now inherit the source agent's pinned profile object - pin the first-render timestamp reuse with a ${now}-embedding test and document the anchored ${now} semantics - tighten the plugin docs budget and resume-refresh wording * fix(agent-core-v2): join in-flight convergence during agent bootstrap - an agent created while a plugin convergence is in flight now waits for it, and a restored agent refreshes once after it, so a plugin mutation never straddles an agent's bootstrap - warn on a non-string systemPrompt field and strip a UTF-8 BOM from systemPromptPath files before trimming - correct the consumption-surface wording (every CLI surface on the experimental flag, not just kimi -p), the per-session queueing note, and the single-plugin combined budget clause * fix(agent-core-v2): bound the bootstrap convergence join by the timeout A permanently wedged convergence kept convergeTail pending forever, and the unconditional settled() wait in bindBootstrap would have blocked every later agent creation in that session; the join now races the shared convergence timeout and continues (a restored agent still refreshes once, which never touches the tail), and the timeout constant moves to the contract for reuse * fix(agent-core-v2): close the convergence race against in-progress restores - a convergence fan-out could land while an agent's wire log is still replaying, dispatching a replay-visible config record whose effect the rest of the replay then overwrites; refreshSystemPrompt now skips while the wire restore is in progress - convergence completion is tracked by a generation counter; bootstrap compares it (after a bounded join) and refreshes a restored agent exactly once when a round completed after its creation began, replacing the wasConverging flag that could miss both windows * fix(agent-core-v2): bound each convergence so a wedged participant cannot stop the pipeline - the fan-out now races the convergence timeout, so convergeTail always settles: a permanently hung refresh delays its round (blocked entries drain oldest-first on later changes) instead of killing the session's convergence for good - warn when agent bootstrap stops waiting on a stalled convergence - diagnose a blank systemPromptPath and pin the plugin-root escape guard with traversal, absolute-path, and symlink tests * fix(agent-core-v2): bound the skill reload, preserve user-tool overlays, roll the prompt clock daily - the convergence's skill-reload segment now races the same timeout as the fan-out, so no segment of the pipeline can wedge a session for good; it continues with the previous catalog and retries next change - a cold rebind that resets the tool set replays session-added user tools onto the new base instead of dropping them for the rest of the process - the rendered timestamp re-anchors when the UTC date rolls over, so long-lived processes keep a fresh clock while steady-state renders stay byte-stable within a day - the plugin budget warning dedupes per plugin id, and the docs note that systemPromptPath content is frozen until the next reload * feat(agent-core-v2): converge cold plugin changes on resume through a drift-free gate - restore replays the persisted binding untouched, then bootstrap refreshes only when drift-free inputs changed while the session was cold: the catalog profile's tool set/denylist, or the plugin-sections baseline persisted alongside the prompt on the existing bind/update payloads; directory-listing and date drift wait for live triggers, so quiet resumes append no replay-visible records - the rendered timestamp is day-precision (UTC date at 00:00, re-anchored on rollover), keeping steady-state renders byte-stable across resumes and sessions on the same day - consolidate both timeout helpers onto a shared raceOutcome, and drop the generation counter the gate supersedes - align the plugin-sections precedence prose with the AGENTS.md disclaimer (no self-granted authority, system instructions win on conflict) * fix(agent-core-v2): bound the restored-prompt gate and land the sections baseline - the gate's plugin-sections read now races the convergence timeout, so agent creation never blocks behind an unrelated plugin mutation - refreshes serialize per agent through a tail, so overlapping triggers cannot write prompts out of order - when plugin sections change but a plugin-free custom prompt does not, the new baseline lands as a sections-only update instead of making every later resume re-render in vain - align the system prompt's Date and Time paragraph with the day-precision anchored timestamp * Update plugin system-prompt instructions in changeset Live sessions pick up plugin changes, while the default TUI and `kimi -p` paths ignore these fields. Signed-off-by: 7Sageer <sag77r@hotmail.com> * refactor(agent-core-v2): keep plugin skill reload user-driven Plugin mutations still converge live agent prompts, but the session skill catalog goes back to refreshing only on explicit plugin reload, as before: the prompt feature does not need skill convergence, and the pre-existing manual-reload semantics stay uniform across all plugin contributions. Removes the convergence-driven skill reload, the reloadSource de-privatization, and their tests; restores the PluginSkillSource onDidReload forwarding and its catalog tests. * refactor(agent-core-v2): apply plugin system-prompt changes only on explicit reload Drop the live convergence machinery (the plugin onDidChange barrier, the sessionPluginContribution fan-out, the restored-prompt drift gate, and the day-precision render clock) so plugin system-prompt sections take effect at the same point as every other plugin contribution: /plugins reload or a new session. The profile now refreshes when the session skill catalog re-pulls its plugin source on reload, reading both the skill list and the prompt sections fresh. * feat(agent-core): let plugins contribute system prompt instructions via the manifest systemPrompt field * chore(agent-core-v2): remove inline implementation comment * docs: clarify plugin prompt refresh semantics --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-07-29 20:30:07 +08:00
wenhua020201-arch	f8ec3d1656	docs: fix dead anchor links in en/zh docs (#2348) ... * docs: fix dead anchor links in en/zh docs - #loop_control -> #loop-control (heading slug uses hyphens) - #secondary_model -> #secondary-model - env-vars model section anchors: kimi_model -> kimi-model - provider credential section anchors: configtoml -> config-toml - /provider management anchors: point at the renamed heading in each locale - hooks: point the stale config-files#hooks reference at the local Configuration section - en files: replace two leftover Chinese anchors with their English targets * docs: add missing .md extension to themes page links --------- Co-authored-by: qer <wbxl2000@outlook.com>	2026-07-29 15:57:48 +08:00
liruifengv	37d9bdc585	docs(changelog): sync 0.30.0 from apps/kimi-code/CHANGELOG.md (#2343)	2026-07-29 12:13:20 +08:00
7Sageer	efac96c8a9	feat(agent-core): custom agent files and secondary model on the v1 engine (#2232) ... * feat(agent-core): custom agent files and secondary model on the v1 engine Migrate the custom agentfile and secondary-model capabilities from agent-core-v2 to the v1 engine so they work in the TUI and plain kimi -p sessions: - discover Markdown agent files from user/project/extra/explicit directories with the v2 precedence rules, a merged session profile catalog replacing the hardcoded builtin profile lookups, SYSTEM.md main prompt override, and ${base_prompt} backed by the effective default - --agent/--agent-file now work in print mode on the default engine; CreateSessionOptions gains agentProfile/agentFiles - [secondary_model] config + KIMI_SECONDARY_MODEL/EFFORT bind newly spawned subagents to a cheaper model behind the secondary-model experiment flag, with primary/secondary model params on Agent and AgentSwarm and upfront session warnings - full disallowedTools deny semantics (exact names + mcp__ globs) evaluated by the tool manager and persisted in the agent wire * fix(cli): guard optional agentFiles in the prompt runner runPrompt is also driven programmatically (headless goal flow) with options that never pass through the CLI parser defaults, so agentFiles can be undefined; mirror the addDirs optional-chaining pattern. Also extend the SDK experimental-feature assertion with the secondary-model flag. * fix(agent-core): preserve custom agent bindings on v1 * fix(agent-core): narrow secondary model error hints * fix(agent-core): persist custom agent profile bindings * Delete .changeset/sdk-agent-profile-options.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * Update v1-custom-agent-files.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * Update v1-secondary-model.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * Update v1-custom-agent-files.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * fix(agent-core): keep SYSTEM.md a prompt-only overlay for delegation * docs: update agent file and secondary model availability wording * fix(cli): reject --agent-file combined with session resume The resume path only forwards the agent file's name for the bound-profile assertion; the file's content is never re-applied (the session keeps its creation-time catalog snapshot). Previously the combination was silently accepted, so an edited file (or a same-named one) appeared to apply but did not. Reject it at option validation and document the constraint. * refactor(agent-core): share prompt-section prose and note v2 twins in agentfile headers The Windows notes, additional-dirs and skills prose blocks existed twice: inline in the builtin default template (system.md) and as constants in the agent-file renderer (from-file.ts). Extract them to profile/prompt-sections.ts as the single source: system.md renders them through injected KIMI_* template variables and from-file.ts imports the same constants. Rendered prompts are byte-identical for all four builtin profiles across macOS/Windows and skills/dirs on/off; a new test pins system.md to the shared constants. Also mark each profile/agentfile file with the path of its agent-core-v2 counterpart so format/semantics changes land in both engines. * feat(cli): add /secondary_model command for the subagent model Mirror /model: a picker with a thinking-effort step that persists [secondary_model] and live-applies to the current session via a new Session.setSecondaryModel RPC (node-sdk wrapper included), so newly spawned subagents bind the new model right away. The /model picker now hides the synthesized __secondary__ derived entry; docs and the update-config builtin skill mention the section. * feat(tui): show the bound model in subagent run stats Subagents report their model alias via agent.status.updated after spawn; resolve it to a display name and surface it in tool-call subagent stats and agent-group rows. * fix(agent-core): validate agent profile before session persistence * fix(agent-core): refresh subagent tools after model switch * fix(agent-core): show subagent model preferences * fix(agent-core): preserve secondary model recipe on live apply * fix(agent-core): make secondary model apply explicit * fix(tui): refresh secondary model display state * chore: merge secondary model changesets into one * Add /secondary_model command for subagent configuration Show each subagent's model in the subagent card header and agent-group rows. Requires the secondary-model experiment (KIMI_CODE_EXPERIMENTAL_SECONDARY_MODEL=1); run /secondary_model to pick a model and thinking effort, applied to the current session immediately. Signed-off-by: 7Sageer <sag77r@hotmail.com> * fix(agent-core): align explicit agent file precedence * fix(agent-core): let disallowedTools deny select_tools * chore(cli): drop engine mention from --agent/--agent-file help text * feat(cli): support --agent/--agent-file in the interactive TUI Bind the selected agent profile to the startup session when launching the TUI with --agent/--agent-file, including the session created after an OAuth login at startup. Sessions created later in the process (/new) keep the default profile. Make both flags creation-only in every mode: combining them with --session/--continue is now rejected in print mode too, since resume restores the bound agent from the session automatically. * fix(agent-core): persist new secondary-model selections under env overrides stripSecondaryModelConfig restored secondary_model.model/default_effort from raw whenever KIMI_SECONDARY_MODEL/KIMI_SECONDARY_EFFORT was set, so a /secondary_model pick made under the env vars was silently discarded on write. Restore from raw only when the value being written still equals the env value (an overlay round-trip), mirroring the pointer check in stripEnvModelConfig; a genuinely different selection now reaches config.toml. * fix(cli): report the effective secondary model when env overrides the pick /secondary_model toasted the picked alias even when KIMI_SECONDARY_MODEL/KIMI_SECONDARY_EFFORT made the session bind a different model. Read the effective binding back from the reloaded config (as /model does from session status) and warn with the env-overridden values instead. * feat(tui): show the bound model name in the AgentSwarm panel header --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-07-29 12:06:26 +08:00
Yufeng He	67dd03149f	feat(tui): customizable footer status line via status_line config (#2255) ... * feat(tui): customizable footer status line via status_line config The bottom status bar was a fixed layout. Add a [status_line] section to tui.toml covering the two established models: - items: codex-style composition. Pick and order the built-in slots (mode, goal, model, tasks, cwd, git, tips); unset keeps today's layout, unknown ids are skipped with a warning, and an empty list blanks line 1. - command: claude-code-style custom line. The footer runs the command with a JSON snapshot on stdin (model, cwd, git branch, permission and plan mode, context usage, session id, version) and renders the first stdout line. Runs are throttled to one per second and capped at 300ms; nonzero exit, empty output, or a timeout falls back to the built-in layout. Line 2 (context readout) stays built-in in every mode. Resolve #2116. * feat(tui): apply status_line on /reload-tui and document it The reload command pushes reloaded tui.toml fields into AppState; the new statusLine field joins that list so edits go live without a restart. The config files reference (EN/ZH) documents the new section. * fix(tui): round-trip active status_line on save and harden the runner Codex review on #2255 caught a real one: saveTuiConfig rewrites the whole tui.toml, so changing any other preference dropped an active [status_line] section. Render it live when set (items and command), commented-out guide when unset. Also: spawn the command through ComSpec/cmd.exe on Windows instead of assuming sh.exe, and take the whole process tree down on timeout (process-group kill on POSIX, taskkill /T on Windows) so a script that spawned children cannot leak them. * fix(tui): address status_line review: runner lifecycle, capture cap, tips slot - recreate the command runner when a reload swaps status_line.command; the old runner kept executing the previous script until restart - schedule a trailing refresh instead of dropping updates that arrive inside the throttle window, so the last state change always lands - stop accumulating stdout once the first line is complete (and cap a missing-newline stream at 64KB); only the first line is ever rendered - honor the configured position of the tips slot in items instead of always pinning tips to the far right - route unknown status_line.items warnings through the TUI status area on reload instead of raw stderr, which could corrupt the display Changeset text tightened per maintainer note. --------- Co-authored-by: Kai <me@kaiyi.cool>	2026-07-28 22:37:52 +08:00
Petrichor	cdbd33c13c	fix(kosong): fail fast on quota-exhausted 429 instead of retrying (#1857) ... * fix(kosong): fail fast on quota-exhausted 429 instead of retrying A 429 caused by an exhausted account quota or insufficient balance (Moonshot error.type "exceeded_current_quota_error", OpenAI "insufficient_quota") can never succeed on retry, yet it was classified as APIProviderRateLimitError and silently retried for the whole budget (10 attempts, ~3 minutes of backoff) with no UI feedback — the session appeared frozen on every request. Introduce APIProviderQuotaExhaustedError, minted in normalizeAPIStatusError from the structured body error.type/error.code forwarded by convertOpenAIError, with billing-anchored message patterns as a fallback for gateways that flatten the body to text. The new class is excluded from isRetryableGenerateError (fail fast, even when a retry-after header is present) and from isProviderRateLimitError (no swarm requeue/suspend). toKimiErrorPayload and translateProviderError map it to provider.api_error (retryable: false) instead of provider.rate_limit, and classifyApiError reports it as quota_exhausted in telemetry. agent-core-v2 mirrors the same fix. Transient rate-limit 429s keep the existing retry, backoff, and Retry-After behavior (verified end-to-end against a mock provider: quota body fails after attempt 1/10; rate-limit body still walks the full 10-attempt ladder). Behavior changes to note: quota-failed swarm subagents now fail instead of suspending indefinitely as "Rate limited...", and quota errors cross the wire as provider.api_error rather than provider.rate_limit. * fix(kosong): classify quota exhaustion in OpenAI Responses stream errors Responses response.failed / error SSE events carry no HTTP status and were minted by errorFromOpenAIResponsesEvent as either a rate-limit error (rate_limit_exceeded / embedded status_code=429) or a base ChatProviderError — and the base class falls into the retryable unclassified-failure fallback, so an insufficient_quota event still burned the whole retry budget on the openai_responses path. Route the event code and message through the same quota-exhausted check before the rate-limit branch, in kosong and the agent-core-v2 mirror. Covers all three entry paths (error events, response.failed, nested gateway frames) since they share the single converter. * style(agent-core-v2): drop inline comments per AGENTS.md header-only rule agent-core-v2 comments live solely in the top-of-file block, never beside functions or statements; the kosong twins keep the full rationale. * refactor(kosong,agent-core-v2): move quota-429 checks to vendor hook Per review on #1857: the knowledge of how a backend signals quota exhaustion is vendor-specific and must not run for every OpenAI-compatible provider from the shared conversion layer. - Add a convertError hook: ProtocolTrait.convertError in agent-core-v2 (single-value, last-declarer-wins, bound by composeOpenAIChatHooks / composeAnthropicHooks / traitConvertError) and an equivalent optional hook parameter on convertOpenAIError / convertAnthropicError. Bases consult it with the raw failure (SDK error on HTTP paths, raw event on the Responses in-stream path) after the abort guard, before their own rules. - Declare Moonshot's quota signals (exceeded_current_quota_error, billing wordings) on the Kimi side: kimiOpenAITrait and kimiAnthropicTrait in v2, the KimiChatProvider and KimiFiles catch sites in kosong, all through the new classifyKimiQuotaError. - Drop the options parameter from normalizeAPIStatusError and the shared quota code/pattern tables: the contract layer keeps only the vendor-neutral APIProviderQuotaExhaustedError type and its retry / rate-limit / wire-mapping semantics. - The OpenAI bases keep recognizing only OpenAI's own documented insufficient_quota code (HTTP and Responses stream events) as protocol knowledge of that wire. Behavior: kimi and openai provider types classify exactly as before; an unregistered vendor speaking Moonshot billing wordings through a plain openai transport now stays a retryable rate limit by design. * fix(kosong,agent-core,agent-core-v2): wire kimi quota hook fully Follow-up to the second review round on #1857, all four findings: - Kimi-over-Anthropic (legacy engine): AnthropicOptions gains the same optional convertError hook as the OpenAI bases, threaded through AnthropicStreamedMessage and every catch site, and the provider manager's anthropic route now passes classifyKimiQuotaError for provider type kimi — a quota-exhausted 429 over this transport previously still burned the retry budget. classifyKimiQuotaError now also walks error -> .error -> .error.error for the code/type, since the Anthropic SDK keeps the full body on .error instead of hoisting. - v2 telemetry: ApiErrorKind gains 'quota_exhausted' and classifyApiError checks APIProviderQuotaExhaustedError before the generic 429 branch, matching the legacy engine's reporting. - Hook contract: converted ChatProviderErrors now pass through before the vendor hook is consulted in convertOpenAIError / convertAnthropicError (both engines), so the hook sees each raw failure exactly once even when a stream-minted error crosses an outer catch; tests assert the single consult. - protocolTrait: the convertError member doc shrinks to the concise style and the consult contract moves into the file header's composition rules. * test(kosong,agent-core,agent-core-v2): lock quota hook assembly paths Third review round on #1857: - Fix the v2 anthropic base header and AnthropicHooks doc still claiming withThinking is the only hook. - Drop the two remaining non-header JSDoc blocks in protocolTrait.ts per the AGENTS.md header-only rule; the consult contract already lives in the file header. - Update the ProtocolTrait contract test to the seventeen-hook shape (convertError included) and cover the traitConvertError binding. - Add real-assembly regression probes: the v2 registry composes a (kimi, anthropic) provider whose mocked SDK client throws a Moonshot quota 429 and generate rejects with the non-retryable APIProviderQuotaExhaustedError (a plain anthropic composition keeps the same 429 retryable); the legacy ProviderManager routing test asserts convertError is classifyKimiQuotaError on the kimi-anthropic route and absent for plain anthropic; the legacy provider threads options.convertError to its generate catch. * test(kosong,agent-core-v2): cover KimiFiles quota 429 and drop stale docs Fourth review round on #1857: - Drop the AnthropicHooks member JSDoc (its content already lives in the anthropic.ts and anthropicHooks.ts file headers) and fix the anthropic contrib header still calling the hook set single-hook. - Add the missing KimiFiles regression in both engines: a mocked files client rejecting with a Moonshot quota 429 makes uploadVideo reject with the non-retryable APIProviderQuotaExhaustedError, locking the classifyKimiQuotaError argument at the upload catch sites.	2026-07-28 14:35:12 +08:00
qer	29783e471a	feat(cli): add plugin quota and update notices (#2147) ... * feat(cli): add plugin quota and update notices - Show "Note: This plugin consumes your quota." after installing quota-consuming official plugins (currently Kimi Datasource). - Show a one-time update notice after invoking an outdated plugin (a plugin MCP tool call or a /<plugin>:<command> turn); the last notified version is persisted so each new marketplace version reminds once. - Skip the third-party trust prompt for loopback sources that mirror the official plugin CDN path, so the dev plugin marketplace no longer prompts when installing official plugins. * feat(cli): report plugin update notices at turn end Buffer plugin MCP tool usage during the turn and report it together with plugin command usage when the turn's output has fully ended, instead of firing the check mid-turn at tool result time. Cancelled turns no longer trigger the notice. * fix(cli): refresh plugin MCP map on miss and serialize notice writes Address review findings on the plugin update notifier: - The memoized MCP server-to-plugin map is reused across /reload, /new, and session switches, so plugins installed or enabled later in the same app run never resolved. Refresh the map once on a lookup miss, and never pin an empty map when there is no session. - Concurrent notices (a turn that used two outdated plugins) raced on the read-modify-write cycle of the notice state file and could drop each other's entries. Serialize checks through a promise queue so each notified version is persisted exactly once. * fix(cli): gate plugin notices on official provenance and survive tool-name truncation Address review findings: - The quota note and the update notice keyed on the plugin id alone, so a local/GitHub fork reusing a billed plugin's manifest id was treated as the official build. Both now require official provenance (a zip install from the official CDN plugin path or its loopback dev mirror) via a shared isOfficialPluginInstall check. - Resolving plugin MCP tools by splitting on the '__' separator broke for qualified names core truncates to 64 chars, which can cut the separator. Match known server names by longest prefix with a name boundary instead, which survives truncation as long as the server part itself is intact. * revert(cli): drop the dev marketplace trust relaxation The loopback carve-out let any local service bypass the third-party trust prompt by serving a zip under the official path shape, which does not prove official provenance (review P1). Revert to the single rule — only https://code.kimi.com/kimi-code/plugins/official/* is a trusted official source — and restore the stock dev marketplace server. Installing official plugins from the dev marketplace shows the trust prompt again. * fix(cli): restrict update notices to the official catalog and settle tests - Skip the update check when the loaded marketplace is not the default official catalog, so a custom KIMI_CODE_PLUGIN_MARKETPLACE_URL can no longer produce a notice that claims to come from the Official Marketplace. - Return a never-rejecting promise from the notifier entry points so tests await the serialized queue directly instead of relying on zero-delay timers for ordering.	2026-07-27 17:00:42 +08:00
liruifengv	a9af42e698	docs(changelog): sync 0.29.2 from apps/kimi-code/CHANGELOG.md (#2236)	2026-07-27 15:04:24 +08:00
7Sageer	d40d0d305d	refactor(agent-core-v2): make undo domain-owned (#2055) ... * refactor(agent-core-v2): rebuild undo as wire-level journal rewind Replace the compensating context.undo op with a wire-layer rewind primitive: a log.cut control record with a persisted target, applied uniformly by the wire during fold. Turn boundaries become first-class (TurnIndexModel indexing turn.prompt record positions), models declare a temporal classification (rewindable), and a single IAgentRewindService owns the undo pipeline (quiesce -> precheck -> cut -> reconcile) with all entry points converged. - wire: log.cut record, rewindable model flag, re-fold rebuild; OpApplyContext.recordIndex for position-aware reducers - rewind service: aborts the active turn, cancels in-flight compaction, preserves the pending queue, rebases measured tokens, reconciles lastPrompt, tracks conversation_undo - todo list, plan mode, task-notification delivery and the turn index now rewind together with the undone turns - transcript reducer applies cut ranges so snapshot/messages surfaces stay consistent with the model context - REST/RPC/debug undo entry points converge on the rewind service; TUI parses the v2 undo-unavailable error shape - legacy context.undo records keep replaying for old journals * refactor(agent-core-v2): keep undo domain-owned * refactor: enhance /undo functionality for consistency and safety, including todo list rollback and improved event handling * chore: clean up undo changeset artifacts * refactor: rebuild rewind consistency * fix: make conversation undo durable and consistent * fix(agent-core-v2): stabilize undo restoration * fix: keep TUI undo on legacy error contract * refactor(agent-core-v2): drop unused full compaction cancel API Undo now rejects with session.busy while compaction runs instead of cancelling it, so the awaitable cancel() added for the earlier rewind semantics has no callers left. Remove it from the interface and implementation; the RPC cancel path keeps using the task abort controller directly. * fix(agent-core-v2): remove injected context on undo * chore(agent-core-v2): regenerate wire manifest * docs(agent-core-dev): rename rewind to undo in layer table * fix(agent-core-v2): undo prompt-owned image reminders * refactor: remove transcript undo reconciliation * fix(kap-server): map undo busy errors * refactor(agent-core-v2): rename undo participant registry and attribute checkpoint depth - Rename IAgentConversationUndoReconciliationRegistry to IAgentConversationUndoParticipantRegistry (conversationUndoParticipants). - Return the limiting model from checkpointDepth and include it in the SESSION_UNDO_UNAVAILABLE details; report checkpoint_lost instead of compaction_boundary when no compaction explains the missing depth. - Add a registry invariant test: every model reacting to context.* ops must be registered via defineCheckpointedModel or explicitly exempt. * Delete .changeset/fix-undo-injections.md Signed-off-by: 7Sageer <sag77r@hotmail.com> --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-07-27 11:09:26 +08:00
liruifengv	c2b2c4eb49	docs(changelog): sync 0.29.1 from apps/kimi-code/CHANGELOG.md (#2136)	2026-07-24 13:56:33 +08:00
7Sageer	7b62ed5b2c	feat: support a configurable secondary model for subagents (#2064) ... * feat: support a configurable secondary model for subagents * refactor: move the subagent model config to a consumer-neutral [secondary_model] The secondary model becomes a model-domain concept next to default_model so future consumers beyond subagents can share it: [secondary_model] model / effort in config.toml, KIMI_SECONDARY_MODEL / KIMI_SECONDARY_EFFORT env overrides, and the Agent / AgentSwarm per-spawn choice renamed from "subagent" to "secondary". * docs: replace "v2 engine only" notes with the concrete effective surfaces State that [secondary_model], its env overrides, the Agent/AgentSwarm model parameter, and SYSTEM.md take effect only under kimi web and experimental kimi -p (the TUI ignores them), and that --agent / --agent-file are available only under experimental kimi -p. Also drop the SYSTEM.md claim of parity with --agent/--agent-file, which was inaccurate: SYSTEM.md is an agent-core-v2 app-domain feature and also applies under kimi web, while the flags are gated at the CLI. * fix: review follow-ups for the subagent secondary model - Drop the "cheaper" claim from the Agent/AgentSwarm model parameter descriptions and the advertised model list — the secondary model is not necessarily the cheaper one. - Downgrade the changeset to patch, note the kimi web / experimental kimi -p effective surface, and tighten the wording. - Remove the onWillRestore stub fields from two lifecycle stubs; they belong to upcoming lifecycle work, not to this change. * fix(agent-core-v2): prevent ghost agents from invalid model bindings * fix: narrow the secondary-model error hint to missing-alias failures The model catalog's not-configured throw now carries details.model, and wrapSubagentModelError only decorates errors whose details.model matches the bound model. Malformed [models.*] entries and unrelated config.invalid failures during agent creation pass through untouched instead of being misattributed to an invalid secondary-model alias. * fix: mark subagent resume semantics as breaking * chore(agent-core-v2): follow header-only comment convention * fix(agent-core-v2): await agent restore preparation * feat(agent-core-v2): support agent model preferences * Update subagent-secondary-model.md Signed-off-by: 7Sageer <12210216@mail.sustech.edu.cn> * fix: validate secondary models before agent creation * Delete .changeset/secondary-model-startup-warning.md Signed-off-by: 7Sageer <12210216@mail.sustech.edu.cn> * Add secondary_model config section for subagents Individual agents can override this via the new `model_preference` field in their agent file. Signed-off-by: 7Sageer <sag77r@hotmail.com> * feat(agent-core-v2): support override patches in [secondary_model] The recipe is now `model` plus the flattened ModelOverride field set. With any patch field set, a config overlay synthesizes a derived registry entry (base copy, patch merged into overrides, aliases dropped) so subagent spawning rides the standard effectiveModelConfig merge; with none, subagents bind the pointed entry directly. `default_effort` replaces `effort` (KIMI_SECONDARY_EFFORT rebinds) and doubles as the explicit subagent thinking; unset, thinking resolves naturally instead of inheriting the caller. The overlay strips the derived entry (and any defaultModel pointer to it) from writes, and the kap-server GET /models route hides it from pickers. * fix(agent-core-v2): fire section events for overlay-rewritten domains rebuildEffective only committed the caller-named domains, so a ConfigEffectiveOverlay or section env binding that rewrote a sibling domain (setting [secondary_model] synthesizes a derived models entry; removing the recipe retracts it) left consumers of the models section stale. Widen the commit candidates with every domain the recompute actually changed; commit() deepEqual-guards each candidate, so the widening costs nothing. * feat(agent-core-v2): gate secondary model behind experimental flag * Update subagent-secondary-model.md Signed-off-by: 7Sageer <sag77r@hotmail.com> --------- Signed-off-by: 7Sageer <12210216@mail.sustech.edu.cn> Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-07-24 12:16:53 +08:00
7Sageer	5fdbdb4a22	feat: configure web search/fetch services via KIMI_WEB_* env vars (#2096) ... * feat: configure web search/fetch services via KIMI_WEB_* env vars KIMI_WEB_SEARCH_BASE_URL / KIMI_WEB_SEARCH_API_KEY and KIMI_WEB_FETCH_BASE_URL / KIMI_WEB_FETCH_API_KEY overlay the [services] config section field by field in both engines (env wins over config.toml), so the WebSearch and FetchURL backends can be pointed at a Moonshot service without OAuth login. The v2 engine now also honors the explicit [services.moonshot_fetch] section (config > managed OAuth > local), which it previously parsed but never consumed. * fix(agent-core-v2): guard stripServicesEnv against clearing the services section config.replace(SERVICES_SECTION, undefined) — the logout deprovisioning path in authService — passes undefined straight into the section strip, and the composed stripServicesEnv dereferenced it (value[key]), throwing TypeError and aborting logout mid-cleanup. Add the same isPlainObject guard the other strip implementations (stripProvidersEnv, stripEnvBoundFields) already have, plus a regression test that also locks in the env overlay staying effective after the file value is cleared. * style(agent-core-v2): follow header-only comment convention * fix: isolate env web service credentials * Add env vars for web search and fetch services The new environment variables `KIMI_WEB_SEARCH_BASE_URL`, `KIMI_WEB_SEARCH_API_KEY`, `KIMI_WEB_FETCH_BASE_URL`, and `KIMI_WEB_FETCH_API_KEY` take priority over the corresponding fields in `config.toml`. The `kimi web` backend now honors the `[services.moonshot_fetch]` config section. Signed-off-by: 7Sageer <sag77r@hotmail.com> --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-07-23 17:36:16 +08:00
7Sageer	527d485d92	feat: add global default MCP server timeout configs (#2065) ... * feat: add global default MCP server startup timeout config Add a `[mcp] startup_timeout_ms` config.toml section with a `KIMI_MCP_STARTUP_TIMEOUT_MS` env override as the global default MCP server connection (startup + tool discovery) timeout. Precedence: per-server `startupTimeoutMs` in mcp.json > env var > config.toml > built-in 30s default. * feat: add global default MCP tool call timeout config Extend the `[mcp]` section with `tool_timeout_ms` and the `KIMI_MCP_TOOL_TIMEOUT_MS` env override as the global default for single MCP tool calls, mirroring the startup timeout: a per-server `toolTimeoutMs` in mcp.json still wins, and unset entries fall back to the SDK built-in 60s default. * chore: shorten the mcp timeouts changeset * feat(agent-core): add global default MCP server timeout configs Port the `[mcp]` section (`startup_timeout_ms` / `tool_timeout_ms`) and the `KIMI_MCP_STARTUP_TIMEOUT_MS` / `KIMI_MCP_TOOL_TIMEOUT_MS` env overrides to agent-core (v1), mirroring the v2 semantics: per-server fields in mcp.json > env vars > config.toml > built-in defaults. The v1 TOML loader gains explicit `mcp` read/write mappings, and both connection-manager construction sites (Session, testGlobalMcpServer RPC) pass the resolved defaults through. * fix(agent-core): validate and apply MCP timeout defaults * fix: propagate MCP startup timeout to SDK requests * refactor(agent-core-v2): resolve MCP default timeouts at connect time Keep the session connection manager synchronously lazy instead of gating its existence on config readiness: resolveDefaultTimeouts is read from the mcp config section at each (re)connect, so AgentMcpService's eager construction stays unconditionally safe and reconnects pick up changed preferences. The initial connect still awaits config.ready for a deterministic snapshot. Also restore the ISessionMcpService method docs, bump the changeset to minor, and fix the v1 env-parse comment. * chore(agent-core-v2): regenerate config manifest for the mcp section * Add global default MCP server timeouts configuration Specify the new global default MCP server timeouts in both the config file and environment variables. Signed-off-by: 7Sageer <sag77r@hotmail.com> --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-07-23 12:41:08 +08:00
qer	e0f2a41769	feat(datasource): add wind, imf, gildata, sec_edgar, and sp_data sources (#2029) ... * feat(datasource): add wind, imf, gildata, sec_edgar, and sp_data sources * feat(datasource): strengthen source routing in skill and tool schema * feat(datasource): retry on credential rotation and enforce single-source routing contract * feat(datasource): neutral source selection with objective capability boundaries * feat(datasource): note wind_search_fields field-name mapping in skill and schema	2026-07-22 22:45:55 +08:00
liruifengv	b32170b018	docs(changelog): sync 0.29.0 from apps/kimi-code/CHANGELOG.md (#2054)	2026-07-22 18:23:48 +08:00
Haozhe	8250e590f3	docs(cron): drop references to the non-existent kimi resume command (#2050) ... * docs(cron): drop references to the non-existent `kimi resume` command - point user docs at the real resume command `kimi --session` - reword cron tool descriptions and code comments in agent-core and agent-core-v2 to describe session resume without naming a subcommand * chore: add changeset for cron docs wording fix	2026-07-22 16:59:08 +08:00
Kai	ba921ca531	fix: gate always-thinking inference to OpenAI wires, plus catalog review follow-ups (#2036) ... * fix: gate always-thinking inference to OpenAI wires, plus review follow-ups - catalog: strip the inferred alwaysThinking marker on non-OpenAI wires so Claude/Gemini keep their native off; verified against live models.dev - v1 provider-manager: honor per-alias baseUrl on kimi/google-genai/vertexai - thinking: rewrite the PHASE-6 contract comment, drop three dead cannot-disable warning branches, normalize requested effort in v1 to match v2 - tests: input-cap compaction preference in both engines, kap-server WS status cap, v2 legacy status input cap - docs + changeset: new model fields, catalog-refresh behavior, kap-server * fix: strip always-thinking only where the wire encodes a true off The previous gate kept the marker only on the OpenAI wires, which wrongly stripped it from Gemini 3 on the Google wires: its floor is thinkingLevel MINIMAL with suppressed thoughts — still reasoning — so an Off option there would be a lie. The criterion is now the wire's encoding, not its family: strip only on anthropic and kimi, the two wires with a protocol-level `thinking: {type: 'disabled'}` that the catalog's effort list can never show. Verified against live models.dev data: google now marks exactly the gemini-3 family (10), anthropic and moonshotai stay 0. * docs(agent-core-v2): move the strict-validation contract into the thinking.ts file header The scoped guide keeps comments in the top-of-file block only; the function JSDoc shrinks to a short what-it-answers note matching its neighbors. No behavior change.	2026-07-22 13:43:10 +08:00
Kai	b5efba7abc	fix: consume the model metadata declared by the models.dev catalog (#2015) ... * fix: stop advertising Claude thinking efforts for non-Claude models Models served over the Anthropic protocol whose names carry no Claude marker (e.g. a catalog-imported Kimi K3) no longer inherit the latest Opus effort list, so the model selector stops offering levels the model does not accept. The models.dev catalog import now also parses reasoning_options and records the declared effort levels on the model alias, so K3 offers its real levels (low / high / max). * fix: consume deprecated, override, and input-limit metadata from the models.dev catalog - Models declared status=deprecated in the catalog are no longer offered for import. - Per-model provider overrides on gateway providers (an npm package targeting an Anthropic SDK plus a usable endpoint) now land as alias protocol and base_url, so those models are served over the right protocol and endpoint; overrides without a usable URL are skipped. - A declared limit.input now sizes the context budget instead of the larger total context window (e.g. gpt-5: 272k instead of 400k). The model alias schema gains an optional base_url field (not accepted in overrides) that Anthropic wire resolution prefers over the provider-level base URL. * fix: honor thinking-disable semantics and the OpenAI-compatible fallback in catalog imports - reasoning_options 'none' is the model's off encoding: off_effort flows from the catalog through the model alias to the OpenAI wire providers, so turning thinking off sends 'none' instead of omitting the effort field; models with effort levels but no way to disable thinking are imported as always_thinking and no longer offer an Off option. - Bare Claude family aliases (e.g. sonnet-latest) recover the inferred Anthropic effort profile; v2 comment conventions restored. - Providers whose SDK the catalog does not type now fall back to the OpenAI-compatible wire (with a visible "guessed" note) instead of being refused; imports lacking a usable endpoint ask for one (--base-url on the CLI, a prompt in the TUI). Proprietary SDKs (Amazon Bedrock), unrecognized explicit types, and env-placeholder URLs are refused with a clear reason. * fix: align catalog imports with the reference models.dev consumer - A JSON null tier in declared effort values is now read as the 'none' off-encoding (previously such models were wrongly imported as always-thinking with no way to turn reasoning off). - Alpha-status models are filtered out alongside deprecated ones. - Models whose per-model provider override targets a wire that cannot be expressed per-model (e.g. Claude on google-vertex, whose wire here is Gemini-mode Vertex, or gpt entries on an Anthropic provider) are skipped instead of being imported under the silently wrong protocol. - interleaved: true no longer pins reasoning_content: the provider's default three-field scan is wider and the pinned key only narrowed reasoning parsing for gateways answering with another field name. * fix: require endpoints for Anthropic-compatible catalog imports and honor --base-url - catalogProviderNeedsBaseUrl now covers the Anthropic wire: a non-official Anthropic-compatible vendor without a concrete catalog endpoint (e.g. google-vertex-anthropic) must supply --base-url / the TUI prompt instead of silently falling back to the default Anthropic endpoint. - --base-url now takes precedence over the catalog-declared endpoint, and an empty --base-url is rejected instead of persisting a blank endpoint. * fix: enforce always-on thinking on every wire and refuse Cohere at import A model that declares always_thinking (e.g. a catalog-imported gpt-5) no longer resolves to a dishonest off state via thinking.enabled=false or an SDK/ACP off request: resolution clamps to the model's default effort on every wire instead of letting upstream keep reasoning while the UI reports Off. The Anthropic warn-and-send path for unlisted effort levels is unchanged. Cohere's proprietary SDK joins Amazon Bedrock on the import-refusal list instead of being guessed as OpenAI-compatible. * fix: harden catalog import edge cases - An explicit but unrecognized catalog type is now refused before npm/id inference, so a future catalog protocol is never silently miswired through the OpenAI fallback. - User-supplied --base-url values for Anthropic-wire providers get the same trailing-/v1 normalization as catalog endpoints, avoiding /v1/v1/messages requests. - The TUI import prompt rejects env-placeholder base URLs like the CLI does. * fix: await the floating assertion promise in the catalog add CLI test * refactor: unify catalog import resolution into a single decision function Wire-type inference, the OpenAI-compatible fallback, proprietary-SDK refusal, endpoint adaptation, and the base-URL requirement are now produced together by resolveCatalogImport, one pure resolver consumed by both the CLI and the TUI — replacing the cooperating predicates (inferWireType, isGuessedWireType, catalogProviderNeedsBaseUrl) whose permutations kept producing edge cases. No behavior change. * fix: close configured-off clamp hole, keep inferWireType compat, carry same-wire override endpoints - A configured thinking.effort = "off" no longer bypasses the always-on clamp: it is treated as absent and the model default applies, mirrored on both engines. - The previously public inferWireType stays as a deprecated compatibility wrapper over resolveCatalogImport so existing SDK consumers do not break on a patch release. - Catalog model overrides that stay on the provider's wire but declare their own endpoint now persist it on the alias (and the v1 OpenAI wire branches honor alias-level base URLs like the Anthropic branch). * fix: split total window from input cap and close override/endpoint gaps - max_context_tokens once again means the total context window (used by completion budgeting); a model's declared input limit is tracked as max_input_tokens, which compaction, context-splice and usage-ratio checks prefer — fixing the over-clamping introduced when the input cap was stored as the context budget. - A catalog endpoint declared only as an env placeholder now always produces needs-base-url (official SDK included), so credentials are never sent to the public vendor host by default. - api-only per-model overrides are honored as same-wire endpoint changes; overrides targeting another known but inexpressible wire (e.g. google-genai on an OpenAI gateway) are skipped; same-wire models whose declared endpoint is an unusable placeholder are skipped instead of silently rerouted. * style: drop a function-level comment from the v2 thinking resolver * chore: consolidate the PR's changesets into two user-facing entries	2026-07-22 01:23:31 +08:00
Kai	37eda4e59a	feat(config): add env overrides for loop control and background task limits (#1993) ... * feat(config): add env overrides for loop control and background task limits Add three operational environment overrides, resolved as env > config.toml > default in both engines (agent-core and agent-core-v2), matching the existing KIMI_IMAGE_MAX_EDGE_PX / KIMI_SUBAGENT_TIMEOUT_MS pattern: - KIMI_LOOP_MAX_STEPS_PER_TURN overrides loop_control.max_steps_per_turn - KIMI_LOOP_MAX_RETRIES_PER_STEP overrides loop_control.max_retries_per_step - KIMI_CODE_BACKGROUND_MAX_RUNNING_TASKS overrides background.max_running_tasks Invalid values are ignored and fall back to the config value. The v2 engine resolves them through config section env bindings (effective-only, never persisted); the v1 engine resolves them at the consumption point. * fix(config): strip env-bound fields before persisting config writes Environment overrides resolved into the effective config could be echoed back through IConfigService.set/replace (e.g. GET then POST /api/v1/config) and persisted into config.toml, outliving the env var. This affected the pre-existing image / subagent / keep-alive bindings as well as the new loop control and max-running-tasks bindings. Extend ConfigStripEnv with a getEnv parameter and add a shared stripEnvBoundFields helper: while a field's env var is set, writes restore the field's raw on-disk value (or drop it) instead of persisting an echoed env value; when unset, normal writes persist. Register it for the loopControl, task/background, image, and subagent sections. Also fix ConfigService.stripEnv looking up rawSnake by the camelCase domain key; on-disk sections are keyed snake_case. * fix(config): honor binding parsers when stripping env fields on persist An invalid env value (e.g. KIMI_LOOP_MAX_STEPS_PER_TURN=abc) is ignored on the read path but still marked the field env-owned on the write path, so a config write for that field was silently dropped. stripEnvBoundFields now derives the guard from the section's envBindings and skips fields whose env value fails the binding's parse, so invalid env values are ignored on both paths — and the duplicated field/env descriptor list is gone. Also drop function-level comments added beside helpers; agent-core-v2 keeps comments solely in the top-of-file block, so the strip semantics now live in the config.ts / configService.ts headers. * fix(config): re-apply env overlays from the env-free base on every read Two follow-ups from review: - ConfigService.get()/getAll() re-applied section env bindings on the already-overlaid effective cache (and get() mutated it in place), so a valid override degraded to invalid or unset kept serving the stale value until the next reload — and an echoed stale value could then be persisted by a config write. Reads now recompute from a cached env-free validated base, so degraded or removed env values fall back to the file immediately. - stripEnvBoundFields restored env-owned fields from the raw snake sub-object, missing values persisted under legacy keys (e.g. max_steps_per_run). Section stripEnv now receives the env-free, fromToml-normalized raw base, so legacy aliases are honored. * test(kap-server): retry temp-home cleanup in auth tests auth.test.ts removed its temp home with a plain recursive rm, which races late async writers in the server shutdown path and flakes with ENOTEMPTY (seen on main CI and locally on main). Harden the cleanup with the same maxRetries/retryDelay options sessions.test.ts already uses. * chore(changeset): consolidate the env-override changesets into two entries One feature entry (loop/background env overrides, both engines plus the CLI) and one fix entry (env values persisting on writes and sticking after degrade/unset, agent-core-v2 plus the CLI). * fix(config): clear fully-stripped sections and refresh overlay domains on get() Two follow-ups from review: - stripEnvBoundFields returned an empty object when every written field was env-owned, so a section with a non-empty default (e.g. subagent) stored raw = {} and the default stopped applying until the next reload. A fully stripped result now clears the raw section instead. - get(domain) only recomputed env overlays for sections with env bindings, so domains written solely by a ConfigEffectiveOverlay (models / defaultModel from KIMI_MODEL_NAME) kept serving stale cached values after the env changed. get() now derives every non-memory domain from the fresh env-free base, matching getAll(). * test(config): drive the get() overlay freshness test with an inline overlay The previous version imported the model env overlay to activate it, which the CI runners failed to resolve from this test file (both tsgo and vitest, while the same specifier resolves elsewhere — not reproducible locally). An inline ConfigEffectiveOverlay double exercises the same ConfigService contract with a tighter seam and no module dependency. * fix(config): preserve unknown fields on full strip and clone nested env targets Two follow-ups from review: - stripEnvBoundFields cleared the raw section whenever the stripped result was empty, so an env echo write could drop unknown forward-compatible fields from the TOML table. An emptied section now keeps its raw table while the env-free base still holds other fields, and is cleared only when nothing remains (defaults keep applying). - applyEnvBindings reused nested child objects in place, so a nested env binding on a persistable key would mutate the env-free validated base and serve stale values after the env var is removed. Children are now cloned before descending. * fix(config): keep the env-free base when a strip leaves nothing to persist Returning {} for a fully stripped write stored the empty object into the raw layer while the TOML table survived via rawSnake, so the bases diverged; a second echo write then saw an empty base, cleared the section, and deleted the table — dropping unknown forward-compatible fields. When nothing persistable remains, the write is now a no-op for the section (the env-free base is kept as-is), and the section is cleared only when the base is empty. * fix(config): revalidate stripped results so restored raw values never persist A strip may restore on-disk values from the unvalidated raw base (e.g. an env-masked invalid field), smuggling them past the merge-time validation into the stored config: the section would then fail the next buildValidated pass, dropping accompanying valid edits from the runtime while the invalid value stayed persisted. set() now revalidates the stripped result — discarding the parse output so unknown fields survive — and rejects the write instead, matching replace().	2026-07-21 19:49:00 +08:00
7Sageer	ce0e3ceb04	feat: support custom agent files (#1735) ... * feat: support custom agent files Discover Markdown+frontmatter agent definitions from user, project, and configured directories; merge them into a session-level profile catalog (priority: builtin < user < extra < project < explicit). Custom agents work as subagents via the Agent tool and as the main agent. - agent-core-v2: new agentFileCatalog domain (discovery/parsing/profile factory, mirroring skillRoots/parseFrontmatter) and sessionAgentProfileCatalog merged view; AgentProfile.tools becomes optional (undefined = all tools) and gains disallowedTools deny list, evaluated in profileService.isToolActive and persisted in session wire records so resume keeps the gate even if the file is gone - CLI: restore --agent/--agent-file for the v2 print runner (KIMI_CODE_EXPERIMENTAL_FLAG); the v1 TUI rejects them with a clear v2-only error - kap-server/protocol: optional profile field on prompt submission with first-bind semantics (same-name no-op, different name rejected) - docs: custom agents section (en/zh) + config/CLI references + changeset * chore: shorten custom agents changeset * fix(agent-core-v2): stringify caught errors in agent catalog log calls * docs: drop v2 engine notes from custom agents docs * fix: align custom agent binding semantics across engine and edges - agent-core-v2: bind now owns the first-bind invariant — switching profiles after bind throws profile.already_bound (checked again in the synchronous segment before the first wire dispatch, so concurrent binds cannot both pass); unknown names throw profile.unknown; same-name rebinds keep the persisted thinking effort. - kap-server / CLI: edges degrade to error mapping / same-name no-op instead of their own divergent guards. - agent files: reject non-string mode values, honor disallowedTools in the append-mode Skill probe, pass --agent-file through unresolved so the engine can expand ~, reject empty --agent-file values. - session catalog: ready is recoverable via reload() after a fatal source failure, and agent-file discovery is kicked at session materialize so resumed sessions see file agents from the first turn. - docs: first-bind semantics, name: agent override, tools: [] meaning, --agent-file last-wins. * fix: tighten custom agent behavior * fix: address custom agent review findings * fix(agent-core,agent-core-v2): keep active-tool wire records replayable by v1 Binding a profile without a tool allowlist (the default for file-defined custom agents) persisted a tools.set_active_tools record with no `names` key. v1 clients discover v2 sessions through the shared session index and replay newer wire versions without migration, so the record crashed v1 resume with a TypeError and wedged the session permanently. The v2 engine no longer writes the record when the base set is already "every tool active" (its absence encodes the same state), and v1 replay now skips records that lack `names` as defense in depth for wires already written by preview builds. A same-name rebind that resets an allowlist to "all tools" has no v1-safe encoding and is left as a documented gap (no production caller today); a future tools.reset_active_tools Op is safe because v1 silently no-ops unknown record types. * fix(agent-core-v2): tolerate unreadable directories in agent-file discovery A single unreadable subdirectory (EACCES anywhere in the scanned tree) previously aborted the whole discovery pass, zeroing every agent of that source on every session start with one path-less warning. The walker now skips-and-warns per directory below the root (mirroring the skill discovery it parallels), root-level failures are isolated per root so one bad root no longer takes its siblings down, and only a genuinely transient whole-fs outage (os.fs.unavailable) still propagates so the session catalog keeps its previous contribution. Source-level warnings now name the offending path, and repeated skip warnings are capped with a summary that samples the suppressed paths. Also consolidates the path primitives (~ expansion, base-relative resolution, realpath type probes) shared by the root resolvers, the walker, and the explicit-file source into agentFileCatalog/paths.ts, and tightens parser diagnostics: frontmatter null is treated as absent, and a present-but-wrong-typed name/description reports a type error instead of "missing". * fix(agent-core-v2): warn when a same-name builtin suppresses a file profile A directory-discovered agent file colliding with a builtin profile without override: true was silently dropped at merge time. The suppression now logs a warning naming the profile and the opt-in. * refactor(agent-core-v2): pass skillActive explicitly to renderSystemPrompt The third parameter was a full tool list used only for includes('Skill'), which forced the agent-file profile factory to answer a boolean question with sentinel lists. The template now takes an explicit skillActive flag; a skillActiveFor helper keeps builtin call sites derived from their tool arrays. * refactor(agent-core-v2): fall back to the configured default model in bind BindAgentInput.model is now optional: the engine resolves a missing model against the configured defaultModel and throws model.not_configured when neither is set, so edges no longer each re-implement the fallback. * fix(agent-core-v2,kap-server): reject unsupported thinking atomically at first bind A REST prompt carrying profile + an unsupported thinking effort bound the session first and failed setThinking after, wedging the session on an identity the user never successfully used. The effort is now validated up front when the caller marks it as an explicit request (strictThinking): the bind rejects before any await or state mutation, and the requested effort rides along in the bind instead of a separate setThinking. Internal spawn/fork paths pass inherited thinking without the flag and keep the previous clamp behavior — a persisted effort that drifted out of the model's support list must not break subagent spawning. The route's now-redundant model fallback is dropped in favor of the engine-side default. * fix(agent-core-v2): await the agent profile catalog at session materialize The catalog's ready promise was only kicked, so a resumed session's first turn could render the Agent tool description without the file-defined agent types. Discovery is local-fs and cheap, so materialize now awaits it; ready only rejects for a fatal explicit-source error, which is exactly the case that should fail fast. A failure there now also removes and disposes the half-materialized handle instead of leaving it registered in the session cache. * test: cover the --agent-file fatal path and tidy profile registration hygiene The v2 print CLI now has a test asserting an invalid --agent-file fails before any turn. The denylist profiles in binding.test.ts register in a beforeAll (idempotent, scoped to the describe's run window) instead of at module scope during collection. * docs: align custom agent docs with v2-engine gating --agent/--agent-file are rejected without the v2 engine, so restore the requirement in the Agents and Command Reference pages (and use KIMI_CODE_EXPERIMENTAL_FLAG=1 in the examples), note that tool lists only shape model-visible disclosure (permission rules are the enforcement layer), and remind authors of delegation-bound agents to state the handoff contract in the prompt body. * test(agent-core-v2): revert unrelated style churn in fs/workspace tests Keep these files' diff limited to the realpath fakes the feature needs; the lint-preference rewrites belong to a separate cleanup. * feat(agent-core-v2): add permanent system prompt override via SYSTEM.md Read $KIMI_CODE_HOME/SYSTEM.md on every startup and inject it as the default main-agent profile (name "agent", override: true), replacing the builtin default system prompt while inheriting builtin tools and description. Missing or empty files are ignored; unreadable files warn and fall back to the builtin profile. The body supports variable substitution (${skills}, ${agents_md}, ${cwd}, ${cwd_listing}, ${os}, ${shell}, ${now}); unknown variables pass through verbatim. Priority: --agent-file / --agent / project override > SYSTEM.md > same-name user-scope scan files. * feat(agent-core-v2): gate tools globally and accept session disabledTools Add a [tools] config section: "enabled" acts as a global allowlist (empty = unconstrained), "disabled" as a denylist applied on top, both intersected with the active profile's policy in isToolActive (mcp glob supported). Plumb a session-persistent disabledTools parameter through the stack: v2 RPC PromptPayload, REST "disabled_tools" (protocol and kap-server parallel schemas), klient contract/facade, and node-sdk. The server applies it via profileService.setSessionDisabledTools, which replaces the client-owned denylist, keeps the profile's own deny, persists across resume, and rejects calls before a profile is bound with profile.not_bound (mapped to 40001). v1 core-api gains a type-only field and ignores it. * fix: enforce session tool policy across agents * fix(agent-core-v2): enforce tool policy at execution * fix(agent-core-v2): align subagent tool descriptions with policy * fix(agent-core-v2): harden custom agent policy state * fix(agent-core-v2): harden custom agent lifecycle * refactor(agent-core-v2): persist profile binding in a single profile.bind record * fix(agent-core-v2): skip unreadable paths during agent file discovery * fix(agent-core-v2): exempt select_tools from the executor policy guard - share one composed profile/global/session tool-policy evaluation between the executor gate and prompt rendering instead of two verbatim copies - tolerate context-build failure in system prompt refresh instead of rejecting callers (config watcher void-fire, session policy fan-out) * test(agent-core-v2): resolve profile and tool-policy SUTs by interface - drop the Object.assign patching of tool-policy methods onto the shared profile service; rename describes so the SUT ownership is accurate - classify profile.bind as v2-only with the accepted v1-replay tradeoff documented, un-red the wire vocabulary guard test - cover the select_tools guard exemption with an executor-level test * fix(agent-core-v2): enforce explicit select_tools policy * feat(agent-core-v2): accept Claude-style tool lists and rename agent-file mode to promptMode * feat(agent-core-v2): unify prompt templating on ${var} - Replace the nunjucks renderer with a single ${var} regex renderer (unknown placeholders pass through verbatim) and drop nunjucks from agent-core-v2. - Merge the variable tables into one catalog shared by the builtin system.md, SYSTEM.md, and agent file bodies; adds additional_dirs_info plus code-composed blocks (windows_notes, additional_dirs_section, skills_section). - Replace the agent-file promptMode field with ${base_prompt}: bodies are always rendered as templates, and ${base_prompt} expands to the effective default profile prompt (honoring the SYSTEM.md override). - Migrate the builtin system.md, goal reminders, compaction instruction, and tool description templates to the same syntax. * docs: complete agent priority chain and link SYSTEM.md precedence * test: fix invalid custom agent fixture * fix(cli): reject multiple agent selectors * feat(agent-core-v2): add subagents allowlist to agent files * fix(agent-core-v2): persist the subagent allowlist in the profile binding The delegation allowlist now rides the profile.bind record like the tool denylist, so a resumed session keeps enforcing it even when the source agent file was deleted or changed. Agent/AgentSwarm resolve the caller's allowlist from the persisted binding data instead of looking the profile up in the live catalog. * feat(agent-core-v2): warn on tool patterns that never match Profile bind/apply and [tools] config changes now statically flag entries that can never activate anything — wildcards without the mcp__ prefix (a bare * in an allowlist disables everything, in a denylist nothing), incomplete mcp__ literals, and names no registered or builtin-profile tool has — via a tool-pattern-no-match warning event, once per pattern, instead of letting the tool set silently shrink. The known-name vocabulary is the live registry plus literal names from the builtin profiles, so flag-gated tools stay known and a typo in one agent file cannot legitimize the same typo in another. * docs: align --agent-file docs with the single-selector CLI The flag accepts exactly one file and conflicts with --agent, but the docs still described the earlier repeatable, composable design. * docs: note the agent-file trust model and never-matching tool patterns Spell out that project-scoped agent files can replace the default main agent's whole system prompt (unlike AGENTS.md reference injection), and list the three tool-pattern shapes that never match and now raise a warning. * chore: slim changeset wording to user-facing language Drop wire record names, enforcement mechanics, and template syntax from the entries; split the v1 resume fix into its own patch changeset; add a patch entry for the tool-pattern warnings. * chore: shorten changeset entries to one-line summaries * Delete .changeset/v1-resume-v2-sessions.md Signed-off-by: 7Sageer <12210216@mail.sustech.edu.cn> * test: drop class-instance spread in sessionLifecycle test stub * chore: clear the comments --------- Signed-off-by: 7Sageer <12210216@mail.sustech.edu.cn>	2026-07-21 15:01:43 +08:00
liruifengv	c2d7bebd04	docs(changelog): sync 0.28.1 from apps/kimi-code/CHANGELOG.md (#1975)	2026-07-20 23:46:39 +08:00
Haozhe	ad8cc85251	feat(cli): foreground-only web servers, deprecated kimi server kill (#1967) ... - the /web slash command now always starts a new server instead of offering to reuse a running one - remove the kimi web kill and kimi web ps subcommands; foreground servers stop with Ctrl+C - keep kimi server kill as a deprecated fallback that only stops servers started by a version before 0.28.0 (recorded in the legacy server lock)	2026-07-20 21:50:09 +08:00
liruifengv	e8f2a077d3	docs(changelog): sync 0.28.0 from apps/kimi-code/CHANGELOG.md (#1944) ... * docs(changelog): sync 0.28.0 from apps/kimi-code/CHANGELOG.md * docs: tighten the 0.28.0 changelog and fix web command references --------- Co-authored-by: qer <wbxl2000@outlook.com>	2026-07-20 17:28:48 +08:00
Haozhe	a41a09c33c	feat(cli): replace the kimi server command tree with kimi web and share one home across servers (#1826) ... * feat(kap-server): enable multi-server shared home by default - always register kap-server instances under server/instances and drop the legacy single-instance lock (acquireLock/getLiveLock/ServerLockedError) - remove the multi_server experimental flag and its KIMI_CODE_EXPERIMENTAL_MULTI_SERVER env var from agent-core-v2 - discover running servers via the instance registry in server ps/kill/rotate-token, kimi web daemon reuse, and the desktop app - remove the pending minidb changesets * feat(cli): add per-instance targeting to server kill and ps - `kimi server kill [serverId]` stops only the matching instance; without an id it still stops the longest-running one, and an unknown id errors with the live server ids listed - `kimi server ps` lists connections grouped per server id (`--json` nests them under a per-server object); an unreachable instance degrades to a per-server note instead of failing the whole listing - update the zh/en command reference and the multi-server changeset * feat(cli): replace kimi server with the kimi web command tree - `kimi web` now runs the local server in the foreground and opens the browser; the background daemon (ensureDaemon / spawn / idle-exit) is removed, so repeated runs simply start another instance on the next free port - drop the OS-service lifecycle (install/uninstall/start/stop/restart/ status) together with kap-server's svc layer - `kimi web kill [serverId]`, `kimi web ps`, and `kimi web rotate-token` manage instances from the registry - the TUI /web command now connects to an already-running instance instead of spawning a background daemon - update the zh/en command reference, dev scripts, and tests * feat(cli): route kimi server invocations to a deprecation notice Any `kimi server …` call — bare or with any legacy subcommand/flags — now prints a deprecation notice pointing at `kimi web` and exits 1, instead of failing with an opaque "unknown command". The shim is scheduled for removal in the next major version. * feat(cli): add the `all` keyword to kimi web kill `kimi web kill all` stops every live instance in the registry (ULIDs can never collide with the keyword). Each instance still gets the API shutdown + SIGTERM/SIGKILL treatment; a failure on one instance does not stop the sweep and is reported at the end. * docs(changeset): drop the web-foreground-default changeset The kimi web command tree replaces the foreground-default behavior this entry describes: --background, daemon reuse, and the version-mismatch hint no longer exist, so the pending entry would contradict the actual release notes. * docs(changeset): tighten the multi-server entry wording * feat(cli): let /web pick a running server or start a new one The /web picker now lists the live instances from the registry with their versions (flagging a CLI mismatch) instead of only connecting to the longest-running one, and offers starting a new server: that one runs in the foreground attached to the terminal after the TUI exits, via the restored exit-takeover wiring. formatReadyBanner is exported and adapts its Stop hint to Ctrl+C for the attached case. * feat(cli): skip the /web picker and start a new server when none is running	2026-07-19 11:43:46 +08:00
qer	4f3c7240c4	feat(cli): run kimi web and the TUI /web command in the foreground by default (#1853) ... * feat(cli): run kimi web and the TUI /web command in the foreground by default kimi web and /web now start the server attached to the terminal (Ctrl+C stops it) instead of backgrounding a daemon; --background opts back into the daemon behavior. kimi server run is unchanged. A foreground kimi web reuses an already-running server instead of failing to bind, the /web handoff prints the same ready banner as kimi web (plus the session deep link), and the banner Stop hint adapts to the hosting mode. * fix(cli): resolve the server token after the server is up in /web The token lookup had moved ahead of ensureDaemon()/startServerForeground() during the foreground-default refactor, so a first-time start (no server.token on disk yet) opened the browser without the #token= fragment and left the user at the auth gate. Resolve the token after the daemon is healthy, and inside the foreground ready hook. * docs(changeset): flag the web foreground default as breaking in the changelog The bump stays minor, but the entry now calls out the behavior break and the --background mitigation for scripts that expect kimi web to return immediately. * feat(cli): flag a version mismatch when reusing a server from an older CLI After an upgrade, an older still-running server is reused as-is. The lock's host_version is now surfaced: kimi web / server run print a version-mismatch line next to the reuse notice, /web shows the same as a status warning, and the docs plus changeset tell users a single kimi server kill switches them onto the new version.	2026-07-18 23:32:41 +08:00
Kai	3086e47039	fix: unify YOLO and Auto permission mode descriptions across surfaces (#1867) ... * fix(tui): correct YOLO and Auto permission mode descriptions * fix: unify YOLO and Auto permission mode descriptions across CLI, ACP, web, and docs * docs: correct YOLO and Auto mode descriptions in the interaction guide * fix: correct YOLO mode notices in session replay and vscode extension * feat(vscode): rename /afk command to /auto, keeping afk as hidden alias Also correct the stale 'afk' mode reference in the built-in MCP config skill guidance of both agent engines. * fix(vscode): forward engine approval requests instead of blanket-approving them The extension-level approval handler auto-approved every request when legacy yolo/afk was on, silently swallowing the sensitive-file, plan-review, and ask-rule prompts the engine yolo mode still sends. Forward every request to the user and let the engine permission mode do the auto-approving, matching TUI and web behavior.	2026-07-18 02:09:31 +08:00
liruifengv	ada523ae6a	docs(changelog): sync 0.27.0 from apps/kimi-code/CHANGELOG.md (#1852)	2026-07-17 21:18:19 +08:00
liruifengv	bfecd0128f	feat: refresh model list for API-key providers at the managed endpoint (#1824) ... * feat: refresh model list for API-key providers at the managed endpoint * docs: simplify changeset wording * docs: add kimi-code/k3 to the default config example * fix: clear stale default model when a refresh drops its alias * fix: clear refresh defaults via replace; set(undefined) cannot delete * docs: drop the auto model refresh paragraph from providers page * docs: simplify changeset wording	2026-07-17 17:17:58 +08:00
liruifengv	a5c568dc7a	feat(tui): add /copy slash command to copy the last assistant message (#1822) ... * feat(tui): add /copy slash command to copy the last assistant message The command copies the latest assistant reply (text parts only, skipping thinking, tool-call-only turns, error and internal messages) to the clipboard. Clipboard writes now also emit an OSC 52 sequence (tmux-aware) so copying keeps working over SSH and in containers where no native clipboard tool exists. * fix(tui): gate /copy to idle and report OSC 52-only copies as unverified During streaming the in-flight assistant text is not in getContext() history yet, so /copy would silently copy an older message; make the command idle-only like /export-md. copyTextToClipboard now returns how the text was delivered so /copy can say when only an unverified OSC 52 escape carried it. * fix(tui): source /copy text from the visible transcript After /compact the model context keeps only user messages plus a user-role summary, so scanning it found no assistant message even though the last reply is still on screen. Read the last assistant transcript entry instead — it matches what the user sees and survives compaction and resume. * fix(tui): mark real model text in the transcript so /copy skips synthetic cards Hook-result and goal-completion cards are also 'assistant' transcript entries appended after the real reply, so /copy could copy a hook card instead of the answer. Tag the single entry-creation site for genuine model text (both live and replay flow through it) and have /copy only accept tagged entries.	2026-07-17 16:39:19 +08:00
liruifengv	3423ab8273	docs(changelog): sync 0.26.0 from apps/kimi-code/CHANGELOG.md (#1786)	2026-07-16 19:15:22 +08:00
Haozhe	ffaf0b98ca	feat(agent-core): align coder subagent tools with v2 and drain background tasks (#1776) ... * feat(agent-core): align coder subagent tools with v2 and drain background tasks - align the bundled coder subagent profile tools with agent-core-v2 CODER_TOOLS (Skill, Agent, AgentSwarm, Task* trio, plan-mode tools, TodoList); cron tools stay declared-but-undelivered on sub agents, matching v2 - rebuild builtin tools in setActiveTools: profile-gated capabilities (Bash/Agent allowBackground via the Task* trio) were baked at construction with an empty enabled set, so profiles applied later (every subagent) silently lost them - hold subagent completion until the child agent's background tasks settle (print-mode drain semantics) and suppress their terminal notifications, so no unobserved follow-up turn runs on a finished subagent; the run's timeout/cancel signal bounds the drain - cover with real-Session e2e (tool execution, nested Agent/AgentSwarm, drain blocking and cancel) and update profile/subagent-host tests * chore: add changeset for coder subagent tool alignment * docs(agents): sync sub-agent capabilities with expanded coder tool set - coder sub-agents can now dispatch nested sub-agents and use background tasks, todo lists, Plan mode, and skills; drop the stale claim that sub-agents cannot schedule nested sub-agents - note that a sub-agent run reports completion only after its background tasks settle * fix(agent-core): close drain race for tasks settled before completion A background task that terminated before the drain's suppression pass was excluded from the active-only list, so its terminal notification escaped suppression and could still steer an orphan turn onto the finished subagent. Suppress every child task (including settled ones whose notification may still be in flight) and run the pass both before and after the settle wait; notification delivery re-checks suppression after its async output snapshot, which makes the block deterministic. Cover the mid-turn delivery path with an e2e case.	2026-07-16 17:14:53 +08:00
liruifengv	ede69068ea	docs(changelog): sync 0.25.0 from apps/kimi-code/CHANGELOG.md (#1760) ... * docs(changelog): sync 0.25.0 from apps/kimi-code/CHANGELOG.md * docs(changelog): simplify verbose 0.25.0 entries * docs(changelog): trim diagnostics entry wording * docs(changelog): drop crash telemetry entry * docs(changelog): trim symlinked workspace entry * docs(changelog): trim subagent output entry * docs(changelog): drop refactor entry * docs(changelog): simplify remaining verbose 0.25.0 entries	2026-07-16 10:42:48 +08:00
liruifengv	f27c3cd02f	docs(changelog): sync 0.24.2 from apps/kimi-code/CHANGELOG.md (#1748)	2026-07-15 18:53:11 +08:00
Haozhe	a74ab44ac7	feat: raise default per-step LLM retry budget to 10 attempts (#1740) ... * feat: raise default per-step LLM retry budget to 10 attempts The default of 3 attempts only produced ~1.5s of backoff (0.5s/1s), so sustained provider overload (429) surfaced to the user almost immediately. With 10 attempts the exponential ramp (500ms base, x2, 32s cap, 25% jitter) waits out multi-minute overload windows before failing the turn. Applies to both agent-core (chatWithRetry) and agent-core-v2 (stepRetry service); loop_control.max_retries_per_step still overrides. * test(agent-core): pin retry-dependent tests to the new default budget - error-paths: the warn-log attempt field now reads 1/10 with the default 10-attempt budget - goal-session pause tests: every LLM call throws a retryable error, so the default 10-attempt backoff (~2min) blew the 5s test timeout; pin maxRetriesPerStep=1 since the pause behavior does not depend on the retry count	2026-07-15 15:24:17 +08:00
Haozhe	5d6ff022b1	feat(agent-core): drop default timeouts for print-mode background tasks (#1737) ... * feat(agent-core): drop default timeouts for print-mode background tasks - add `bash_task_timeout_s` config under [background] (0 = no timeout), covering the background Bash default and the re-arm after a foreground command is moved to the background on timeout - allow `[subagent] timeout_ms = 0` (no timeout) and thread it through Agent/AgentSwarm task registration and the swarm batch timer - fill both with 0 in print-mode config defaults so `kimi -p` never kills background work by wall-clock and only the model stops a task; interactive defaults are unchanged - sync the Bash tool description/parameter text with the effective default and update user docs (en/zh) plus changeset * test(agent-core): satisfy KimiConfig providers requirement in print-defaults tests * fix(agent-core): clear the foreground deadline on detach when the background timeout is disabled `detach()` only re-arms when `detachTimeoutMs` is defined, so passing `undefined` with `bash_task_timeout_s = 0` kept the armed foreground deadline and a manually detached command was still killed at its foreground timeout. Pass `0` instead so the reset clears the timer. Caught by Codex review on #1737.	2026-07-15 14:35:32 +08:00
liruifengv	286d3e7aca	feat: add check-kimi-code-docs builtin skill (#1727) ... * feat(agent-core): add check-kimi-code-docs builtin skill * feat(agent-core-v2): add check-kimi-code-docs builtin skill * docs: list check-kimi-code-docs in builtin skill commands * chore: add changeset for check-kimi-code-docs skill	2026-07-15 11:42:47 +08:00
Luyu Cheng	7de218a909	fix(kimi-web): resume paused goals (#1693) ... * fix(kimi-web): resume paused goals * fix(agent-core-v2): defer paused goal continuation	2026-07-15 00:00:29 +08:00
liruifengv	6b0a116326	docs(changelog): sync 0.24.1 from apps/kimi-code/CHANGELOG.md (#1703)	2026-07-14 17:47:24 +08:00
Kai	d158e0a7ac	fix: resolve and synchronize thinking effort (#1625) ... * fix: preserve provider thinking effort values * fix: resolve Kimi thinking effort fallbacks * fix: use resolved Kimi effort in v2 requests * fix: align Kimi effort resolution paths * fix: synchronize forced Kimi effort state * fix: synchronize forced Kimi effort in v2 state * fix: tolerate unresolved models in v2 status	2026-07-14 16:37:03 +08:00
liruifengv	268fd41734	docs(changelog): sync 0.24.0 from apps/kimi-code/CHANGELOG.md (#1683) ... * docs(changelog): sync 0.24.0 from apps/kimi-code/CHANGELOG.md * chore: update changelog --------- Co-authored-by: qer <wbxl2000@outlook.com>	2026-07-14 16:23:07 +08:00
Luyu Cheng	490303db16	fix(web): refine goal mode controls (#1669) ... * fix(web): refine goal mode controls * fix(web): hide goal progress without budget * fix(web): use design system for goal cancellation * docs: document web goal controls * fix(web): remove collapsed goal actions from tab order	2026-07-14 13:34:37 +08:00
qer	5eb62178b3	feat(web): add session diagnostic export (#1646) ... * feat(web): add session diagnostic export * fix(web): bound session export resources * fix(web): make session export atomic * feat(web): add session export entry to session menus with item icons	2026-07-14 12:48:28 +08:00
Kai	32a89c3643	fix(agent-core): prevent oversized media from poisoning sessions (#1657)	2026-07-14 12:46:45 +08:00
Kai	7c889f3a96	fix(agent-core): mark auto-approved plan exits as not user-reviewed (#1638) ... * fix(agent-core): mark auto-approved plan exits as not user-reviewed In auto permission mode ExitPlanMode is approved without user involvement, but its result read "## Approved Plan:" exactly like a genuine user approval and the transcript showed a green "Approved" chip. The model treated that as a signal to start executing, even when the user had asked it to stop after planning. - Emit an "auto-approved, not user-reviewed" result with a note that execution follows the user's original instructions (v1 + v2). - Extend the auto-mode reminder: plan approvals are automatic and are not a user signal to proceed (v1 + v2). - Render an "Auto-approved" warning-toned chip in the TUI, keeping backward compatibility with the old result marker. - Document the Auto mode plan-exit behavior in interaction guides. * fix(agent-core): only mark plan exits as auto-approved in auto permission mode Address review feedback on the auto-approved plan exit change: - Branch the direct-execution output on the permission mode in both engines: only auto mode yields the "auto-approved, not user-reviewed" result and telemetry outcome. In manual / yolo modes the direct path means a configured or session allow/ask rule let the call through — an explicit user decision that keeps the user-approved output, the Approved transcript chip, and the approved outcome. - Move the v2 rationale out of the method body into the file header, per the agent-core-v2 comment convention. - Drop the absolute "only Auto mode" wording from the interaction guides (en/zh).	2026-07-14 11:30:47 +08:00
Haozhe	e49b3b8777	fix(agent-core-v2): harden wire restore and background task lifecycle (#1635) ... * fix(agent-core-v2): fix wire migration rewrite race and reject unversioned logs (8 files) - await the migration rewrite in wireRecordService.restore() so restore only resolves once the migrated log is durable and rewrite failures surface - serialize AppendLogStore.rewrite() behind the log flush so appends arriving during the whole-file replace land after the new content - reject wire logs missing the metadata envelope (missingWireMetadataError) in restore, session fork, and agent create instead of fabricating a current-version envelope over legacy records * fix(agent-core-v2): stop background tasks on session close (10 files) - add IAgentTaskService.stopAllOnExit: suppress terminal notifications, then SIGTERM → grace → SIGKILL for every active task (v1 stopBackgroundTasksOnExit parity, gated by keepAliveOnExit) - call stopAllOnExit from agentLifecycle.remove before scope disposal, and abort live tasks in AgentTaskService.dispose as a last resort for disposal paths that bypass the graceful close - honor [task] killGracePeriodMs in the stop grace window and bind the v1 KIMI_CODE_BACKGROUND_KEEP_ALIVE_ON_EXIT env override for keepAliveOnExit * fix(agent-core-v2): root task persistence at the owning agent's scope - persist task records under <sessionScope>/agents/<agentId>/tasks/ (v1's per-agent layout) so tasks written by older versions are found on resume - stop one agent's restore from loading, marking lost, or re-notifying another agent's tasks - add a per-agent isolation test covering loadFromDisk + reconcile * fix(agent-core-v2): address task lifecycle review findings * fix(agent-core-v2): preserve queued appends across rewrites * test(agent-core-v2): cover rewrite cutover flush * fix(agent-core-v2): surface append durability failures * fix(agent-core-v2): retire released append log buffers * fix(agent-core-v2): preserve session-level task records * fix(agent-core-v2): harden append log cutover recovery * fix(agent-core-v2): suppress only background exit notifications --------- Co-authored-by: qer <wbxl2000@outlook.com>	2026-07-14 10:02:24 +08:00
liruifengv	83e175399f	feat: auto-background timed-out foreground bash commands (#1591) ... * feat: auto-background timed-out foreground bash commands * fix: discourage blocking TaskOutput waits on background tasks * test: avoid unsafe string conversion in bash timeout test * fix: align bash timeout description with auto-background opt-out * feat(agent-core-v2): auto-background timed-out bash commands - detach timed-out foreground Bash tasks and re-arm the background deadline - align TaskOutput guidance with non-blocking background task handling - add klient SEA end-to-end coverage for the v2 server * fix(klient): clean up lint errors in auto-background e2e example --------- Co-authored-by: haozhe.yang <yanghaozhe@moonshot.ai>	2026-07-13 21:08:21 +08:00
qer	f3dd006ab4	docs: update subagent timeout docs for configurable timeout_ms (#1582)	2026-07-12 21:09:17 +08:00
qer	febe030244	docs(changelog): sync 0.23.6 from apps/kimi-code/CHANGELOG.md (#1581)	2026-07-12 21:06:40 +08:00