1205 commits

This branch

This branch

All branches

Author	SHA1	Message	Date
7Sageer	5c8df5973e	test: drop the assertion for the removed ambiguous-means-task example (#3030) ... #3028 removed the 'treat ambiguous requests as tasks' rule and its 'locate the method in the code' example from the default system prompt. The profile test pinned that example verbatim, so it now fails on main. The removal was intentional; update the test to the new contract.	2026-08-18 15:02:17 +08:00
Luyu Cheng	d6021fa036	feat(kap-server): accept bundled skill activations on the prompt submission route (#2982) ... * feat(kap-server): accept bundled skill activations on the prompt submission route The bundled-submission capability was only reachable through the in-process klient transports; the App talks to kap-server over /api/v1. The submit-prompt route now accepts an optional non-empty skills field and delegates to IAgentSkillService.promptWithSkills — same validation, events, and single bundled user message as the TUI path — skipping its own prompt-metadata update (the engine owns it there) and mapping skill.not_found / skill.type_unsupported onto the skills route's codes. To return the submission's queue identity, the engine's promptWithSkills now resolves with prompt_id / user_message_id / created_at / state (plus turn_id once launched), mirrored through the klient contract. * refactor(agent-core-v2): slim the promptWithSkills result contract Drop the user_message_id field (it is always the same identity as prompt_id — the route duplicates it) and narrow state to the running/queued/blocked vocabulary, mapped at the engine edge instead of exposing the internal seven-state PromptState on the wire. * fix(kap-server): harden bundled skill submissions against review findings - Validate bundled skill names and types before any media materialization or control override, so a rejected bundle leaves session state untouched (the engine still re-validates authoritatively). - Declare the 40415/40912 outcomes on the submit route so the generated API documentation includes them. - The klient output schema no longer tolerates a missing promptWithSkills result (a transport-level absence now raises instead of resolving undefined), and a failed launch surfaces as an error rather than a successful running result. - Add the changeset for the new public API field. * fix(kap-server): preflight bundled skills before agent materialization and stabilize listed content - Skill preflight now runs on the session's catalog before the main agent is resolved, so a rejected bundle cannot mutate session metadata by registering main (regression test on a cold session without an agent). - The prompts list projection strips the stored skill blocks from a bundled prompt, so GET /prompts returns the same caller-only content as the submit response. * fix(kap-server): reject bundled prompt_id combos at preflight and clean queued staging - The skills + prompt_id incompatibility rejection now runs at the initial bundled preflight, before the main agent is materialized or any override binds (previously a yolo override could bind before the 40001). - Queued bundles no longer skip staging cleanup forever: the discard is deferred to the bundle's prompt.completed / prompt.aborted lifecycle event, mirroring the plain path's launch-raced cleanup. * fix(kap-server): clean queued bundle staging on the steer path too A queued bundle steered into the active turn is consumed at steer time, but the engine publishes prompt.completed/aborted only for the parent — the deferred cleanup never fired and its subscription leaked. The prompt.steered event (matching promptIds) now counts as the child's intake-completion signal. * fix(agent-core-v2): materialize daemon-ref media on the steer and inject paths startNext materializes daemon file references into the session media store before a prompt's turn, but steer() and inject() enqueued the same references without that intake, leaving the staging upload as the only copy — any staging cleanup at steer time would delete the media the turn is about to consume. Both paths now run the same intake before the SteerStepRequest is created, so prompt.steered is a truthful intake-complete signal. * fix(kap-server): defer staging cleanup to turn settlement, never to steer time Prompt-intake materialization is best-effort: when it degrades, the daemon upload is the request-time resolver's fallback source. Discarding staging at prompt.steered could therefore delete the only readable copy before the parent's request ran. Cleanup is now uniformly event-driven — the bundle's own prompt.completed/aborted, or the steer parent's — so the upload always outlives the request it feeds. * fix(kap-server): install settlement tracking before bundled enqueue A hook-blocked bundle completes synchronously inside the submission call, and an exceptionally fast launch can settle just as early — a post-call subscription misses the only settlement event and leaks both the staging blob and the listener. The tracker now subscribes before enqueueing, buffers lifecycle events, and settles against the returned prompt id (or its steer parent's). * fix(kap-server): scope settlement tracking to the owning agent and dispose on rejection - The tracker now subscribes through the agent-scoped IEventBus instead of the App-scoped IEventService: prompt lifecycle events from other sessions never reach it, so a colliding client-chosen prompt id cannot trigger a foreign settlement (and the steer re-target only follows this agent's parent). - A bundled submission that rejects after the tracker was installed now disposes it on the error path instead of leaking a permanent listener. * fix(agent-core-v2): keep steered prompts queued until their media intake finishes Materializing a steered prompt's daemon-ref media awaits a file copy during which the active turn may finish. Records are now spliced out of the queue only after that copy completes, and when the turn is gone by enqueue time they are restored to pending so startNext can launch them as fresh prompts — their handles always launch or settle. * fix(agent-core-v2): revalidate the queue and active turn after steer media intake The daemon-ref copy yields, so settle/abort can consume selected records and the active turn can rotate meanwhile. Only records still pending are steered, and only into the turn that was active at entry; records that vanish from the queue are left to their own launch path, and a missing turn restores them to pending instead of splicing an unrelated tail prompt. The intake/queue-preservation contract is documented in the module header. * fix(agent-core-v2): steer only the surviving records and keep their media truthful - The steered content is rebuilt from the records that are still pending after the media intake, so an aborted or concurrently consumed record's text is never injected (or injected twice) alongside the surviving handles. - The enqueue is wrapped so an activeTurnOnly rejection restores the records to pending (the loop throws instead of resolving a missing turn, which made the previous rollback unreachable). - The merged origin now carries the union of every record's bundled skillActivations, and prompt.steered publishes the caller-only content, so the skill instructions reach the model with their metadata intact while the event projection stops leaking internal skill markdown. * fix(agent-core-v2): harden steer rollback and register bundled prompt ids * fix(agent-core-v2): strip bundled blocks from prompt.queued and reject partial steers * fix(kap-server): update session metadata for bundled prompts routed to subagents * fix(agent-core-v2): restart queue after raced steer rollback and prefix skill blocks in merged steer * fix(agent-core-v2): block queue advancement during steer admission * chore: drop the changeset for server-only protocol plumbing	2026-08-18 14:57:13 +08:00
7Sageer	40e1784089	fix: tone down over-proactiveness in the default system prompt (#3028) ... * fix: tone down over-proactiveness in the default system prompt The default system prompt pushed the agent to act before discussing: ambiguous requests were explicitly resolved to tasks, the opening framed the primary goal as taking action, and 'default to making progress, not to asking' discouraged clarifying questions. Trim both copies (agent-core and agent-core-v2) by deletion only: the ambiguous-means-task rule and its example, the action-framed opening clause, the 'default to taking action with tools' paragraph, the duplicated must-use-tools sentence (kept once in Ultimate Reminders), and the 'default to making progress, not to asking' bullet. Operational guidance and the execution guards stay untouched. * Delete .changeset/tame-system-prompt-proactiveness.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * fix: drop the tool-use and no-placeholder bullets from the default system prompt --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-08-18 14:47:52 +08:00
bj456736	d3150fe947	chore: remove internal-network references from comments and test fixtures (#3029) ... * chore: remove internal-network references from comments and test fixtures - Reword two comments that named the internal free-tokens model registration flow; the generic OAuth / managed wording carries the same meaning - Replace the qianxun.example placeholder base URL in google-genai and runtime-provider tests with genai-gateway.example - Swap realistic-looking LAN fixture IPs in the kimi web banner tests (192.168.98.66, 10.8.12.216) for RFC 5737 documentation addresses (192.0.2.66, 198.51.100.216) * chore: retrigger CI (flaky kap-server searchRoute title-indexing test) --------- Co-authored-by: bj456736 <bj456736@users.noreply.github.com>	2026-08-18 14:14:56 +08:00
liruifengv	eaa3969dd3	feat(kap-server): add page mode, updated_before, and batch archive/restore to v2 sessions (#2983) ... * feat(kap-server): add page-number mode and total to GET /api/v2/sessions The v2 session list gains a stateless 1-based `page` parameter beside the opaque page_token cursor for admin-style lists that jump arbitrarily: each request stays a full independent snapshot, no token is minted, and `page` + `page_token` together fail 40001. Every response now carries `total` (the filtered/sorted set size) in both pagination modes. * feat(kap-server): add meta.updated_before filter to GET /api/v2/sessions Symmetric with meta.updated_after (inclusive boundary, Unix ms), applied at the edge over the drained set and bound into the page_token query fingerprint like every other condition. * feat(kap-server): add POST /api/v2/sessions:archive and :restore batch endpoints Batch archive/restore for session-management views: { ids } (non-empty, ≤5000 unique after dedup) answers per-item results in input order with succeeded/failed counts — only a body validation failure fails the whole request, and an unknown id folds into its own item as 40401. The live/cold split keeps the batch cheap: a session with a live handle goes through the full ISessionLifecycleService chain (agents drain, scope teardown, mirror drain), while a cold session is never materialized — the new setColdSessionArchived helper in agent-core-v2 patches the persisted state.json (archived/archivedAt, updatedAt preserved, mirroring setArchived's touchUpdatedAt: false semantics), mirrors the flipped summary into the read-model queue, and republishes the same event.session.archived bus event the live lifecycle emits (:restore publishes nothing, matching the live restore). Hot items run with bounded concurrency and the batch ends with one shared ISessionIndexMirror.drain(). * docs(server-api): document v2 sessions page mode, total, updated_before, and batch archive/restore * fix(kap-server): deep-import workspace lifecycle symbols in the v2 sessions route CI's tsgo/rolldown (Linux) fail to bind liveHandlerForSession and IWorkspaceLifecycleService through the agent-core-v2 package-root barrel even though it re-exports them; the same files use the established deep-import pattern already used for the git domain. * fix(kap-server): inline the live-handler lookup in the batch route The previous deep imports still fail to resolve on CI's Linux toolchain (tsgo TS2307, rolldown MISSING_EXPORT) while every other module path from the same package binds fine. Keep the route self-contained: the hot-path lookup is a five-line loop over IWorkspaceLifecycleService's handlers (mirrors agent-core-v2's liveHandlerForSession), and the tests assert non-materialization behaviorally via the live map instead of importing the same two symbols for spies. * fix(kap-server): drive the batch hot path through getLiveSessionById The phantom only hits the workspaceLifecycle-group symbols in these two files on CI's Linux toolchain; getLiveSessionById is observed to bind fine there. It returns the session's live scope directly (no resume), which is exactly what the batch hot path needs. * refactor(kap-server): move the batch live/cold split into agent-core-v2 setSessionArchivedBatch owns the split next to the cold patch: live sessions go through the full lifecycle chain via the workspace handler accessor (the v1-proven resolution path), cold sessions through the direct write. The route becomes a thin wire-code adapter, and the batch tests assert the live chain behaviorally (disposal, events, index) instead of spying through scope accessors. * fix(agent-core-v2): import sessionLookup relatively from coldSessionArchive The '#/app/workspaceLifecycle/*' specifier resolves from src/ and src/app/* files on CI's Linux toolchain but not from src/workspace/sessionLifecycle/ (tsgo TS2307, rolldown follows); a relative import bypasses the package-imports mapping. * fix(agent-core-v2): migrate the batch hot path to ISessionManager Main's workspace/session DI refactor removed the workspaceLifecycle lookup modules; the live branch now goes through the App-level ISessionManager (the same entry the v1 action route uses post-refactor) with getLiveSessionById from the new sessionManager lookup. * feat(kap-server): add the id,archived item projection to GET /api/v2/sessions fields=id,archived trims each item to { id, archived } for select-all-matching flows (the session admin page's Gmail-style select-all). Only that projection gets the relaxed page_size ceiling (10000); unknown fields, non-pair subsets, and include=git combinations are 40001, and the projection binds into the page_token fingerprint so shapes never flip mid-pagination. * fix(agent-core-v2): serialize the batch cold write against in-flight resumes Codex review on #2983: while a resume is in flight the live registry hides the handle, so the batch route could classify the session as cold and its direct write would race the materializing metadata service (its stale in-memory document wins the next write, silently un-archiving the session after the endpoint reported success). The batch now settles the resume first: SessionManager registers the whole resume promise synchronously at the App level (controllerForSession is async, so the controller's own resuming map learns about it a few microtasks late) and whenResumeSettled awaits it before classification — a settled resume lands the item on the live chain, a failed one falls back to the cold path. Also folds the module header down to the package's external-role comment convention. * fix(agent-core-v2): publish SessionArchived as an Event2 class in cold archive * fix(agent-core-v2): serialize batch archive/restore with session lifecycle transitions * fix(agent-core-v2): serialize session delete with the lifecycle chain * fix(agent-core-v2): mirror the persisted metadata on cold archive, not the index summary * docs(agent-core-v2): bring sessionManager comments and new tests to package conventions * fix(agent-core-v2): normalize legacy session metadata before the cold archive write * fix(kap-server): serialize the v1 single-session archive with the lifecycle chain * chore: drop changesets for internal-only protocol work * fix(agent-core-v2): encode cold-archived metadata for v1 readers * fix(agent-core-v2): serialize fork and createChild with the source session's chain * refactor(agent-core-v2): chain every session lifecycle method and hand batch sections unguarded ops * fix(agent-core-v2): propagate failed resumes to the next settle * fix(agent-core-v2): roll back the unannounced handle when a resume fails mid-materialization * fix(agent-core-v2): read and migrate the legacy session-meta location on cold archive * fix(agent-core-v2): serialize explicit-id session creation with the lifecycle chain create() with a caller-supplied sessionId bypassed the per-session chain, so a concurrent batch archive could classify the half-created session as cold and write archived state that the live metadata service later overwrites. Creation now queues on the target id's chain whenever an explicit id is present. Also type the resume-failure maps as Error and normalize at the catch site, satisfying only-throw-error. * style(kap-server): strip comments from the session routes per the no-comments convention * fix(agent-core-v2): serialize explicit fork and child target ids on the lifecycle chain fork() and createChild() with a newSessionId locked only the source id, so a batch archive of the target could slip into the creation window: the index already knows the half-created session, the batch writes archived state to its document, and the fork's in-memory metadata later overwrites it. Both operations now acquire the deduped, sorted key set so multi-key sections always take locks in one deterministic order.	2026-08-18 13:57:37 +08:00
Haozhe	5ae82cd5bc	feat(agent-core-v2): disable the tower feature entirely (#3023)	2026-08-18 13:38:13 +08:00
bj456736	13857f3832	chore: rewrite pending changesets for the new changelog conventions (#3026) ... * Rewrite pending changesets for the new changelog conventions * chore: drop the /tower changeset per reviewer request * chore: trim pending changeset entries further per reviewer feedback --------- Co-authored-by: bj456736 <bj456736@users.noreply.github.com>	2026-08-18 13:06:14 +08:00
bj456736	8f5090782c	chore: simplify the gen-changesets skill (#3024) ... * Simplify the gen-changesets skill * chore: state only what changed, drop explanatory trailing clauses * docs: require strict adherence to the changeset rules in AGENTS.md --------- Co-authored-by: bj456736 <bj456736@users.noreply.github.com>	2026-08-18 13:05:50 +08:00
Haozhe	98ebda840a	fix(kimi-code): revert the todo panel to its pre-turn state on undo (#3016) ... * fix(kimi-code): revert the todo panel to its pre-turn state on undo * fix(kimi-code): hide all-done todo lists on undo refresh and detach SDK todo state	2026-08-18 12:00:19 +08:00
Haozhe	8267bb8fce	feat(kap-server): add workspace fs:suggest file completion endpoint (#3019)	2026-08-18 11:53:48 +08:00
Haozhe	3ded08084a	fix(protocol): expose turn ended event time (#3011) ... * fix(protocol): expose turn ended event time * fix(protocol): expose turn ended event time * chore(changeset): remove patch release entry * test(node-sdk): align background task parity expectations	2026-08-18 10:16:12 +08:00
Haozhe	1ab19190e9	refactor(agent-core-v2): strip comments from agent-core-v2, kap-server, and transcript (#3010)	2026-08-18 00:30:49 +08:00
bj456736	a7dc1ea284	fix(agent-core-v2): degrade media tool registration when the bound model alias is stale (#2985) ... * fix(agent-core-v2): degrade media tool registration when the bound model alias is stale A restored session replays its persisted profile.bind without catalog validation, so the profile can carry a model alias that no longer resolves (e.g. the managed kimi-code models were removed from config.toml on logout). AgentMediaToolsRegistrar.refresh() called modelCatalog.getRequester() unguarded on that alias; the throw escaped the agent.status.updated listener and was reported as an [unexpected] Error2 (config.invalid) on startup. Catch the resolution failure and degrade to "no model": media tools stay registered off the profile-reported capabilities, just without a model-bound video uploader, matching the tryResolveRawModel style used elsewhere in the profile service. * test(agent-core-v2): reproduce the stale-alias regression with production-consistent collaborators A stale alias makes the real AgentProfileService report UNKNOWN_CAPABILITY, so the regression now binds unknown capabilities, asserts the tool stays unregistered without surfacing an [unexpected] error, and covers recovery once the alias resolves again. The rationale moves into the mediaToolsRegistrar file header per the package comment conventions. --------- Co-authored-by: Mira <bj456736@users.noreply.github.com>	2026-08-17 21:46:52 +08:00
7Sageer	5dffed2545	refactor(agent-core-v2): rebuild context projection as a staged block pipeline (#3001) ... * refactor(agent-core-v2): carry the context fold cursor in state and converge fold/projection internals - ContextModel state is now { messages, fold }: the loop-event fold cursor (openStepUuid / pending / deferred) lives in the state instead of a module-level WeakMap keyed by array identity, so wholesale replacements (undo / clear / compaction / swarm exit) reset it structurally via EMPTY_FOLD instead of a manual resetFold at five call sites. - The display transcript and the wire model now share one generic fold kernel (FoldFrame / FoldEntryAdapter), eliminating the mirrored second implementation. Events tagged with a non-open step uuid are dropped and step.end settles only the step it names — defensive in abnormal streams, identical on well-formed ones (v1 replay unaffected). - IAgentContextProjectorService converges to project(messages, policy) with a ProjectionPolicy data object; llmRequester builds the policy from retry state instead of selecting among four methods. - Blob rehydrate now also covers messages still deferred in the fold cursor. - ContextState is deeply frozen at the op boundary to preserve the consumer immutability the wire's shallow freeze gave the bare array state. * test(agent-core-v2): move fold parity rationales into the test file header * docs(agent-core-v2): move fold declaration comments into module headers * refactor(agent-core-v2): merge FoldFrame into generic ContextState * refactor(agent-core-v2): compile-enforce part/event handling decisions in context memory - isVacuousContentPart and dehydrateRecord now switch exhaustively over ContentPart / LoopRecordedEvent variants, so a new variant fails compilation until it takes an explicit position - the transcript/model parity comparator spreads whole messages and masks only summary content, so new ContextMessage fields join the comparison automatically - correct two stale header comments: local message ids persist with append_message records, and undo's prompt-owned-injection pairing depends on them after a resume * refactor(agent-core-v2): converge undo-cut decision in conversationTime The model Op and the display transcript each walked the undo anchors with their own loop, and the transcript partially removed the tail when an undo was blocked (compaction summary / clear floor / too few anchors) while the model side no-ops at the precheck. Move the walk into conversationTime as computeUndoCut/computeUndoCutFrom applied destructively by the context.undo Op and non-destructively by the transcript reducer, so a blocked undo reads identically on both sides. Also: make isUndoAnchor exhaustive over origin kinds with a never assertion, mirrors the compaction result message count via compactionHandoff, and extend UndoCut with anchorIndex distinguishing the counted anchor from the injection-extended cut point. * fix(agent-core-v2): drop removed prompts' injections on multi-turn transcript undo The transcript's kept-loop retained every injection after the oldest counted anchor, so with count > 1 a prompt-owned injection of a newer removed prompt (e.g. an image-compression caption) survived the display undo while the model Op removed it. Collect the removed anchors' ids on the same pass and keep only injections not owned by them, so the header's 'prompt-owned ones leave with their prompt' holds for every count. * refactor(agent-core-v2): accumulate request projection repairs as policy The llmRequester retry chain kept a RequestProjection union and translated it into a ProjectionPolicy per attempt; repairs were mutually exclusive, so a strict resend rejected again for body size or image format either aborted or silently dropped the strict repair. Retry state is now the ProjectionPolicy itself: each rejection adds its repair on its own axis (media: 413 -> degraded -> strip; wire: structure -> strict) without discarding the other, requestInput's translation layer and the unreachable snapshot ??= disappear, and the persisted llm.request projection name derives from the policy (the op enum gains strict-media-degraded / strict-media-stripped). Also narrows ProjectionPolicy to the variants actually produced (wire 'strict'; media 'degraded' | { strip }), dropping the dead 'default'/'keep' literals and their guard. * refactor(agent-core-v2): derive the visible context window from an append-only log context.apply_compaction now appends a summary marker carrying the record fields as CompactionMeta instead of replacing the folded history; the model-visible window is derived at read time (visibleWindow) with the same [head, elision?, tail, summary] layout, one deterministic derivation for live dispatch and replay alike. The record format is unchanged, so v1- and v2-written sessions keep replaying identically both ways. - undo maps the visible-window cut back to a log position (the verbatim legacy-summary edge falls back to the pre-append-only destructive cut) - replay rehydrate only loads blobs the window derivation can surface - contextInjector drops position tracking; injection positions become a read-time scan that splices can never desync - fullCompaction's safety check moves to the stable-identity log * fix(agent-core-v2): rehydrate exactly the messages the visible window surfaces The first append-only rehydrate rule kept pre-marker real user input plus markers, but a legacyTail derivation keeps window.slice(compactedCount) visible — assistant/tool media in that range stayed blobref after replay and could be resent unresolved. Decide survivors by identity membership in the derived window instead, which covers every derivation branch at once and skips the unselected pre-marker pool as a bonus. * fix(agent-core-v2): pop the visible-tail swarm reminder behind a legacy marker SwarmService.exit decides the pop on the derived window's tail, but the swarm_mode.exit reducer tested the raw log tail — after a legacyTail compaction the survivor reminder is visible at the window tail while the marker is the log tail, so the pop silently skipped and the stale reminder stayed in the model context. Mirror the visible-tail decision in the reducer and remove the entry by its stable log identity. * fix(agent-core-v2): settle open transcript frames when compaction lands mid-fold An overflow-triggered compaction arrives with the failed attempt's vacuous partial still open. The transcript appended the summary marker and reset the fold but left the frame; the retried step's step.begin then settled it (-1) alongside the new frame (+1), so foldedLength stayed one short of the model-visible window and kap-server's live-tail merge could duplicate the retry tail. Settle the frame at the marker through the shared kernel; recoverFoldedLength recomputes the absolute count right after either way. * fix(agent-core-v2): settle open frames at the compaction marker Apply settleModelOpenStep inside context.apply_compaction so a marker only ever lands on a settled frame: no partial survives a marker and nothing mutates the log behind one, making the append-only invariant structural (the identity-prefix check in historySafeToCompact relied on it) instead of timing-dependent. Mirrors the transcript's settle-at-marker. Also freeze the derived visible window before caching it (an in-place consumer mutation now throws instead of silently polluting the shared cache), and drop the production-unreachable legacy branch of buildContextCompactionShape so the legacy tail layout lives only in deriveCompactionWindow. * refactor(agent-core-v2): tighten naming and comments in context memory internals - Slim file headers to the package header-only comment convention - Rename PR-introduced identifiers for clarity: getMessageLog, ProjectionPolicy.structure, pendingToolCallIds/deferredEntries, removedEntryCount, deriveVisibleWindowAfterCompaction, compactedWindowMessageCount - Extract nextProjectionPolicyForError, removeUndoOwnedEntries and summarizeProjectionRepairs; name fold intermediates after their business stage - Regroup splice-replay tests by topic and unify projection-call recording in llmRequester tests * fix(agent-core-v2): preserve bounded context state * docs(agent-core-v2): restore the domain identity line in the compactionHandoff header * refactor(agent-core-v2): rebuild context projection as a staged block pipeline Split the 650-line projector service into three modules by concern: mediaProjection (read-side media degrade/strip fallbacks), projection (the structural transform), and the service (DI binding plus repair reporting). Rebuild the structural projection as a two-stage pipeline: pairBlocks groups tool exchanges into blocks that own their calls' results, flattenBlocks serializes them back to wire order and merges consecutive user prompts. The shared slot sentinel and index back-patching are gone; the trailing-close and sizing-slice rules are named and documented in the module header. Behavior is pinned unchanged by the existing projector and llmRequester suites. * docs(agent-core-v2): trim the projection helper header to its external role * docs(agent-core-v2): keep the contextProjector module headers at the external-role level	2026-08-17 20:34:39 +08:00
bj456736	09976b0914	feat(cli): add --web-title and expose it via /meta (#2989) ... * feat(cli): add --web-title and expose it via /meta * refactor(kap-server): pass optional web_title directly in /meta Per the repo rule for optional object properties, pass undefined directly instead of a conditional spread; serialization omits the unset value. * fix(cli): sync web bundle with instance tab title support The committed dist-web bundle predates the document title feature, so a released `kimi web --web-title` served a client that never read web_title. Rebuilt from code-app (feat/web-document-title) via sync:web; the bundle now titles tabs from web_title or the active workspace directory. * ci: retrigger checks after flaky harness cleanup failure --------- Co-authored-by: wbxl2000 <wbxl2000@outlook.com> Co-authored-by: bj456736 <bj456736@users.noreply.github.com>	2026-08-17 20:19:15 +08:00
7Sageer	02aa24e2f4	refactor(agent-core-v2): carry the context fold cursor in state and converge fold/projection internals (#2875) ... * refactor(agent-core-v2): carry the context fold cursor in state and converge fold/projection internals - ContextModel state is now { messages, fold }: the loop-event fold cursor (openStepUuid / pending / deferred) lives in the state instead of a module-level WeakMap keyed by array identity, so wholesale replacements (undo / clear / compaction / swarm exit) reset it structurally via EMPTY_FOLD instead of a manual resetFold at five call sites. - The display transcript and the wire model now share one generic fold kernel (FoldFrame / FoldEntryAdapter), eliminating the mirrored second implementation. Events tagged with a non-open step uuid are dropped and step.end settles only the step it names — defensive in abnormal streams, identical on well-formed ones (v1 replay unaffected). - IAgentContextProjectorService converges to project(messages, policy) with a ProjectionPolicy data object; llmRequester builds the policy from retry state instead of selecting among four methods. - Blob rehydrate now also covers messages still deferred in the fold cursor. - ContextState is deeply frozen at the op boundary to preserve the consumer immutability the wire's shallow freeze gave the bare array state. * test(agent-core-v2): move fold parity rationales into the test file header * docs(agent-core-v2): move fold declaration comments into module headers * refactor(agent-core-v2): merge FoldFrame into generic ContextState * refactor(agent-core-v2): compile-enforce part/event handling decisions in context memory - isVacuousContentPart and dehydrateRecord now switch exhaustively over ContentPart / LoopRecordedEvent variants, so a new variant fails compilation until it takes an explicit position - the transcript/model parity comparator spreads whole messages and masks only summary content, so new ContextMessage fields join the comparison automatically - correct two stale header comments: local message ids persist with append_message records, and undo's prompt-owned-injection pairing depends on them after a resume * refactor(agent-core-v2): converge undo-cut decision in conversationTime The model Op and the display transcript each walked the undo anchors with their own loop, and the transcript partially removed the tail when an undo was blocked (compaction summary / clear floor / too few anchors) while the model side no-ops at the precheck. Move the walk into conversationTime as computeUndoCut/computeUndoCutFrom applied destructively by the context.undo Op and non-destructively by the transcript reducer, so a blocked undo reads identically on both sides. Also: make isUndoAnchor exhaustive over origin kinds with a never assertion, mirrors the compaction result message count via compactionHandoff, and extend UndoCut with anchorIndex distinguishing the counted anchor from the injection-extended cut point. * fix(agent-core-v2): drop removed prompts' injections on multi-turn transcript undo The transcript's kept-loop retained every injection after the oldest counted anchor, so with count > 1 a prompt-owned injection of a newer removed prompt (e.g. an image-compression caption) survived the display undo while the model Op removed it. Collect the removed anchors' ids on the same pass and keep only injections not owned by them, so the header's 'prompt-owned ones leave with their prompt' holds for every count. * refactor(agent-core-v2): accumulate request projection repairs as policy The llmRequester retry chain kept a RequestProjection union and translated it into a ProjectionPolicy per attempt; repairs were mutually exclusive, so a strict resend rejected again for body size or image format either aborted or silently dropped the strict repair. Retry state is now the ProjectionPolicy itself: each rejection adds its repair on its own axis (media: 413 -> degraded -> strip; wire: structure -> strict) without discarding the other, requestInput's translation layer and the unreachable snapshot ??= disappear, and the persisted llm.request projection name derives from the policy (the op enum gains strict-media-degraded / strict-media-stripped). Also narrows ProjectionPolicy to the variants actually produced (wire 'strict'; media 'degraded' | { strip }), dropping the dead 'default'/'keep' literals and their guard. * refactor(agent-core-v2): derive the visible context window from an append-only log context.apply_compaction now appends a summary marker carrying the record fields as CompactionMeta instead of replacing the folded history; the model-visible window is derived at read time (visibleWindow) with the same [head, elision?, tail, summary] layout, one deterministic derivation for live dispatch and replay alike. The record format is unchanged, so v1- and v2-written sessions keep replaying identically both ways. - undo maps the visible-window cut back to a log position (the verbatim legacy-summary edge falls back to the pre-append-only destructive cut) - replay rehydrate only loads blobs the window derivation can surface - contextInjector drops position tracking; injection positions become a read-time scan that splices can never desync - fullCompaction's safety check moves to the stable-identity log * fix(agent-core-v2): rehydrate exactly the messages the visible window surfaces The first append-only rehydrate rule kept pre-marker real user input plus markers, but a legacyTail derivation keeps window.slice(compactedCount) visible — assistant/tool media in that range stayed blobref after replay and could be resent unresolved. Decide survivors by identity membership in the derived window instead, which covers every derivation branch at once and skips the unselected pre-marker pool as a bonus. * fix(agent-core-v2): pop the visible-tail swarm reminder behind a legacy marker SwarmService.exit decides the pop on the derived window's tail, but the swarm_mode.exit reducer tested the raw log tail — after a legacyTail compaction the survivor reminder is visible at the window tail while the marker is the log tail, so the pop silently skipped and the stale reminder stayed in the model context. Mirror the visible-tail decision in the reducer and remove the entry by its stable log identity. * fix(agent-core-v2): settle open transcript frames when compaction lands mid-fold An overflow-triggered compaction arrives with the failed attempt's vacuous partial still open. The transcript appended the summary marker and reset the fold but left the frame; the retried step's step.begin then settled it (-1) alongside the new frame (+1), so foldedLength stayed one short of the model-visible window and kap-server's live-tail merge could duplicate the retry tail. Settle the frame at the marker through the shared kernel; recoverFoldedLength recomputes the absolute count right after either way. * fix(agent-core-v2): settle open frames at the compaction marker Apply settleModelOpenStep inside context.apply_compaction so a marker only ever lands on a settled frame: no partial survives a marker and nothing mutates the log behind one, making the append-only invariant structural (the identity-prefix check in historySafeToCompact relied on it) instead of timing-dependent. Mirrors the transcript's settle-at-marker. Also freeze the derived visible window before caching it (an in-place consumer mutation now throws instead of silently polluting the shared cache), and drop the production-unreachable legacy branch of buildContextCompactionShape so the legacy tail layout lives only in deriveCompactionWindow. * refactor(agent-core-v2): tighten naming and comments in context memory internals - Slim file headers to the package header-only comment convention - Rename PR-introduced identifiers for clarity: getMessageLog, ProjectionPolicy.structure, pendingToolCallIds/deferredEntries, removedEntryCount, deriveVisibleWindowAfterCompaction, compactedWindowMessageCount - Extract nextProjectionPolicyForError, removeUndoOwnedEntries and summarizeProjectionRepairs; name fold intermediates after their business stage - Regroup splice-replay tests by topic and unify projection-call recording in llmRequester tests * fix(agent-core-v2): preserve bounded context state * docs(agent-core-v2): restore the domain identity line in the compactionHandoff header	2026-08-17 18:14:44 +08:00
Haozhe	2265305e81	refactor(agent-core-v2): replace defineOp/Model with Event2 dispatch and replayable states (#2909) ... * refactor(agent-core-v2): replace defineOp/Model with Event2 dispatch and replayable states - replace defineOp/Op/OpDescriptor/toEvent and defineModel/defineCheckpointedModel with Event2 subclasses: durable classes declare static durable + schema, serialize() keeps the wire record shape byte-frozen, transient classes stay off the journal - define states via defineState(...).replayable(...).on(Event2, fold): immer produceWithPatches folds with atomic prepare/commit, .undoable() trait drives prompt-submit checkpoints and context.undo, ephemeral kv keys keep imperative set - degrade IWireService to a journal adapter; the agent event dispatcher owns the pipeline (fold -> set -> appendRecord -> publish) and silent restore - align downstream event surfaces: kap-server WS envelope timestamp from event.time, klient event schemas gain time, node-sdk/acp-server/print wiring updated - rewrite gen-wire-manifest/gen-state-manifest for the unified registry and replace the op-uniqueness lint with event-uniqueness * fix(ci): repair Event2 prompt and media projections - restore prompt admission and session media materialization - align transcript, WS, SDK, and replayable media state projections - update affected tests and generated state manifest * fix(ci): update prompt event and projection expectations - update snapshots for the durable prompt.accepted event - normalize prompt.steered media in transcript projections	2026-08-17 17:38:50 +08:00
Haoyang Ma	1cf617d769	fix(google-genai): preserve Gemini tool-call thought signature and trailing user text order (#2914) ... * fix(agent-core-v2): preserve tool call extras in tool.call loop events * fix(google-genai): keep trailing user text before function results when merging --------- Co-authored-by: Selene <mahaoyang@corp.netease.com>	2026-08-17 17:28:41 +08:00
7Sageer	ee55c4d523	fix(kimi-code): persist pasted-image originals into the session dir at dispatch (#2993) ... * fix(kimi-code): persist pasted-image originals into the session dir at dispatch Paste-time original persistence ran before the session existed on a fresh TUI, so the compression caption baked a shared temp-dir path the OS can reap. Keep the pre-compression bytes on the attachment in memory and let dispatch-time caption resolution (sendMessageInternal, steerMessage, runInlineSkillActivations) write them into the session's media-originals dir — owned by the session, cleaned up with it, immune to OS temp reaping. * fix(kimi-code): harden pasted-image original lifecycle Address review feedback: - carry the pre-compression original in the resend snapshot so a cache-hint "new session" resend still persists it into the new session's originals dir and authors the compression caption - release the in-memory original bytes once persistence succeeds, keeping only the metadata the caption needs - apply the same 1 GiB mtime-bounded eviction to the sync originals store as the engine's async twin * fix(kimi-code): keep compression captions consistent with the sent image Address review feedback: - author a caption only when the image part still matches the attachment's current state, so a paste whose ingestion landed after extraction (inline pre-compression fallback) is not described as downsampled - leave the original's path unset when persistence fails so a later dispatch retries the write instead of dropping the original for good * fix(kimi-code): keep staged media across lazy session creation setSession() released ALL staging leases on the assumption that they belong to the session being replaced. On the lazy first-creation path there is no previous session: the outstanding lease belongs to the new session's first prompt, whose dispatch continues right after. The premature release deleted a pasted image's daemon upload before the engine's intake could read it, so the model only received '[image omitted: the uploaded file is no longer available]'. Gate the release on actually replacing a live session; shutdown and explicit close keep their own releaseAll(). * Delete .changeset/lazy-session-staging-lease.md Signed-off-by: 7Sageer <sag77r@hotmail.com> * Delete .changeset/pasty-image-originals-session-dir.md Signed-off-by: 7Sageer <sag77r@hotmail.com> --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-08-17 15:04:52 +08:00
7Sageer	59dde734f3	feat(agent-core): unify the v1 MCP management plane (#2858) ... * feat(agent-core): unify the v1 MCP management plane - McpServerRegistry: one config view over global (layered mcp.json), plugin (manifests, read-only, final effective config), and caller (SDK-injected) servers; name collisions keep both entries. - Write plane: add/update/removeGlobalMcpServer mutate the user-level file and push into live sessions; getGlobalMcpServer returns the effective config; mutations of read-only entries are rejected. - testGlobalMcpServer accepts an inline config; addSessionMcpServer connects a server in one live session with an optional persist flag; reconnect accepts a replacement config and re-resolves via the registry. - One process-wide McpOAuthService shared with every session: obtained_at stamps, offline token state, single-flight and proactive refresh, and credential events. Sessions self-subscribe in the constructor, so even initializing sessions see every event; token writes serialize through the process-local OAuthTokenTransaction per credential identity. - inspectAppMcpServers + locator-addressed begin/complete/cancel/reset cover plugin servers; inspection output redacts env/headers to sorted key lists; locator OAuth ops reject ambiguous shared runtime names. - The legacy auth-status surface reads the registry (offline by default, verify=true probes) and never mutates credentials. - VS Code panel receives source/origin/mutable and hides mutating actions on read-only entries. - v2 client facade in node-sdk mirrors the surface over agent-core-v2 (plugin inventory stays v1-only for now). * fix(agent-core): close the v1 MCP live-session reconciliation gaps Recompute each live session's MCP target from the registry's runtime resolution (enabled plugin > project layer > user file; caller injection shadows everything) behind every config mutation, instead of per-path patching: shadowed file layers recover when a plugin winner is disabled or removed, removing a user-level entry resurrects its project-layer shadow, disabled plugin descriptors no longer block removals, persisted session adds validate against the session's project layer and broadcast to other live sessions, and per-session sync failures are logged with context. Session status entries and read-only management entries now report redacted config views (envKeys/headerKeys instead of literal env/headers values); core-internal reconciliation compares full configs via the connection manager's raw-entry accessor. OAuth: interactive flows are serialized per credential (concurrent begins join the in-flight flow instead of clobbering its PKCE/state), a malformed credential meta sidecar no longer aborts core start, grants inside the refresh-ahead window refresh immediately while far-future grants re-arm through a max-length timer, and the service shuts its timers and flows down with KimiCore/SDKRpcClient close. * fix(agent-core): route the proactive MCP OAuth refresh through the token transaction refreshNow ran its /token request with the SDK default fetch, outside the credential-serializing OAuthTokenTransaction that every other token write uses; a slower response carrying an older rotating refresh token could overwrite a newer grant written by a concurrent transport-side refresh. * fix(agent-core): keep disabled MCP servers out of auth-state classification The unified mcpServerAuthState dropped the previous enabled short-circuit, so a disabled oauth-flagged server reported oauth-required — or was even probed over the network — instead of not-applicable. * fix(kimi-code-sdk): short-circuit disabled MCP servers in the v2 auth-status classifier The v2 parity copy of v1's mcpServerAuthState missed the same enabled guard v1 just regained; a disabled oauth-flagged entry would report oauth-required (or be probed). The parity suite now pins the disabled case on both engines. * fix(kimi-code): refresh the VS Code MCP list with the workspace cwd after mutations The add/update/remove RPCs return a cwd-less management list, so the webview broadcast dropped project-layer entries until the next full load; re-list with the workspace cwd after every mutation instead. * fix(agent-core): keep SDK token saves matched to the OAuth token transaction saveTokens stamped obtained_at onto a fresh object before calling tokenTransaction.save, so it never matched the exact payload the transaction recorded for a grant fetch; the consume path was dead and every save re-wrote. Between the fetch and the SDK callback an intervening clear could then be overwritten — the resurrected grant came back after a reset. The write callback stamps the durable record instead. * fix(agent-core): reject ambiguous legacy name-based MCP auth lookups The legacy begin/reset auth RPCs took the registry's first name match, silently starting OAuth for one entry of a runtime-name collision while the locator path refused the same ambiguity; align them on the shared uniqueness rule and point callers at the locator-addressed variants. * fix(agent-core): propagate registry errors during live-session MCP sync resolveMcpRuntimeTarget collapsed every registry failure into "no target": a project config file that turned malformed mid-session made sync treat a still-configured server as gone (tearing down the live connection) and made config-aware reconnects report "no longer configured" instead of the actionable config error. Absence still resolves to undefined; malformed config now propagates — per-session sync logs and keeps the entry, and reconnect surfaces config.invalid. * fix(agent-core): close the remaining registry-error and ambiguity gaps The management guard lookup mapped every registry failure to "absent", so a malformed project config let a persisted session add write a user-level entry over an unknown state; only not-found is a miss now. And the name-only connection test now shares the auth paths' uniqueness rule instead of probing the first match of a runtime-name collision. * fix(agent-core): probe the enabled MCP entry under a disabled-name collision The name-only connection test counted enabled matches for its ambiguity guard but still probed the first registry match, and the file layers list before plugins. With a disabled file entry shadowing an enabled plugin of the same runtime name, Test probed the disabled entry instead of the one a live session would run. Select the sole enabled match, falling back to the first entry only when every match is disabled so it reports as disabled. * fix(agent-core): let session-local MCP adds shadow plugin entries Caller injection shadows every registry source at session start, plugins included, and reconciliation leaves caller entries untouched; the live non-persist add path rejected plugin-owned names anyway, so SDK clients could not apply the same per-session override without a restart. Gate the plugin-source rejection on persist: session-local adds connect as caller, while persisted adds stay rejected as user-level writes behind a read-only owner. * fix(agent-core): normalize session MCP names before connecting The persisted store trims server names, but addSessionMcpServer used the raw name for the live connect and cross-session reconciliation: a padded name persisted under the trimmed key while the requesting session ran and reconciled the raw one, and a blank name connected with no identity at all. Normalize once up front (rejecting blank) so the store write, the session entry, and reconciliation agree on the same server. * fix(agent-core,node-sdk): close the collision-selection and probe-freshness gaps The legacy name-only auth resolver started from the first registry match, so a disabled file-layer shadow plus an enabled plugin of the same runtime name was misread as an ambiguity conflict; select the sole enabled match before judging ambiguity, exactly like the test probe path. On the v2 client, addSessionMcpServer connected the raw name while the store wrote the trimmed key — normalize once for both, and route the verify-triggered auth probes through the per-call OAuth service instead of the cached one whose providers snapshot tokens at construction, so a grant saved after the first probe is honored. * fix(agent-core): normalize global MCP mutation names and guard disabled reconnect swaps The global add/update/remove mutations guarded and reconciled with the raw server name while the store persisted the trimmed key, so a padded name left live sessions unreconciled and could slip past the plugin read-only guard; normalize once before lookup, persistence, and reconciliation. And a config-carrying reconnect assigned the replacement before the disabled check fired, leaving a connected entry that reported the disabled config; reject disabled replacements before mutating, keeping the same error. * fix(agent-core): skip proactive refresh while an interactive flow owns the credential refreshNow reset the shared provider's flow state before and after the token request; when a proactive timer (or a manual refresh) fired while beginAuthorization was waiting on the browser callback for the same store key, that wiped the redirect URL, PKCE verifier, and state the in-flight flow needed — complete() then failed the exchange even though the user authorized. Refresh now skips when an interactive flow is active for the credential: the flow delivers fresh tokens on completion, and the 401 transport path is the backstop if it fails. * fix(agent-core): allow global MCP adds over disabled plugin descriptors A disabled plugin entry is absent from the runtime target, but the read-only guard still treated it as the owner, so a user-level fallback could only exist if it predated the plugin disable. Relax the shared guard: disabled plugin descriptors never block mutations (disabled project entries still shadow the user file and keep their rejection). * fix(node-sdk): close the v2 session-MCP parity gaps A v2 reconnect with an explicit enabled:false replacement config used connect()'s upsert semantics — closing the live client and reporting success where v1's manager reconnect rejects before applying anything; reject disabled replacements up front with the same error. And a persisted v2 session add never consulted the workspace config, so a same-named project-layer entry was silently shadowed: the user-level write never takes effect while the direct workspace-manager upsert displaces the project config for every live session. Resolve the workspace layers and reject like v1's read-only rule. * fix(agent-core): keep __proto__-named MCP servers through config parsing A z.record() parse rebuilds its output via property assignment, so a server literally named __proto__ hit the prototype setter and vanished before validation; the layer merge then repeated the same trap with plain object accumulators. Parse the server map entry-by-entry over the JSON own keys and accumulate into null-prototype maps, so session startup and the unified registry keep the declared server and its origin. * fix(node-sdk): begin v2 MCP auth against a fresh OAuth service The v2 begin path ran through the cached globalMcpOAuth, whose providers snapshot tokens at construction: a grant another process saved (or reset) after that cache materialized was invisible, so begin could open a browser flow over a valid grant, or report already-authorized off a removed one. Build the service per call — the read path and the verify probes already do — and route the status list through the same helper. The test fixture grows a real token endpoint honoring one rotating refresh token; the regression fails against the cached-service implementation on v2. * fix(agent-core): broadcast SDK-driven MCP token invalidations to live sessions * test(agent-core-v2): give the no-op reconnect test runtime plumbing The branch added the case against a bare McpConnectionManager, but #2961 made stdio connects resolve the runtime through runtimeResolver, matching every other case in the file.	2026-08-17 13:19:51 +08:00
7Sageer	d833a1a893	feat: engine-native image references via kimi-file:// media resolver (#2593) ... * feat: engine-native image references via kimi-file:// media resolver * fix(agent-core-v2): regenerate state manifest for media resolver rename * feat(agent-core-v2): add audio MediaKind and tag/ref fold helpers to media ref contract * fix(agent-core-v2): synthesize image path tag when degrading bare file references * fix(agent-core-v2): scrub dangling alias re-exports in contract type generator * feat(transcript): project paired media tag+ref as single attachments in read models * fix(kimi-code): fall back to inline image when cache write fails after upload * fix(agent-core-v2): pair media path tags with refs by adjacency and path, keep unpaired tags * fix(kap-server): fold media tag+ref pairs out of prompt snapshot projection * fix(kap-server): list attachment-only prompts as empty user messages * fix(kap-server): keep live attachment ids across transcript overlay and heal * fix(kap-server): keep promptAttachments off the legacy session event wire * fix(kap-server): inherit the backfilled turn header on mid-turn terminal projection A projector that attached after turn.started built the terminal turn.upsert with an empty header, and the whole-header replace downstream wiped the backfilled origin / prompt / attachmentIds — only the debounced best-effort heal could restore them. Fall back to the producer store's seeded header (via a new optional ProjectorLookups.turn) when currentTurn misses, and cover the mid-turn attach path with a service-level regression test. * refactor(agent-core-v2): move media ref contract out of kosong into agent/media The kimi-file:// daemon reference grammar, media path tags, and the tag/ref fold are engine-internal conventions, not provider-wire contract; keep src/kosong untouched. Root exports and SDK re-exports are unchanged. * feat(agent-core-v2): materialize prompt media into the session media dir Pasted and uploaded media now materialize under the session's own media/ dir instead of the shared cache, so the copies follow the session's lifecycle: fork carries them along, session deletion cleans them up. A new Session-scope ISessionMediaStore owns the dir: atomic tmp+rename materialization with a unified extension policy, and canonical-vs-hint display-path resolution. The persisted ?path= is a write-time snapshot — readers prefer the session-canonical location, so fork and home relocation never hand the model a dead path. Prompt intake normalizes every daemon reference through the single enqueue funnel (REST edge, SDK prompt/steer, gateway), serialized in arrival order to keep the FIFO across the async file I/O. The kap-server edge materializes through the same store with a shared-cache fallback, and the request-time resolver refreshes stale persisted and memoized path tags; a claimed video reference degrades to its tag alone instead of duplicating it. * fix(agent-core-v2): take prompt media intake off the enqueue critical path The record now joins the FIFO synchronously and its daemon-ref intake runs as a per-record promise, awaited by the launch and steer paths before the message is consumed — queue order, list/abort visibility, and prompt submission latency no longer wait on file I/O, and a slow intake no longer head-of-line blocks later prompts. The launching record is tracked so abort and clear stay reachable inside the launch window; startNext re-checks cancellation after every await (intake race, hook, turn admission), a cancelled record is never re-queued, and a compaction requeue waits for onDidFinishCompaction instead of busy-looping the scheduler. * fix(agent-core-v2): record the claiming ref in the media path-tag pairing pairMediaPathTagRefs now exposes claimingRefByTagIndex, and claimingRefIndex reads it instead of recovering the claimer by path equality — which mis-attributed a tag when two different fileIds carried the same path in an interleaved sequence, breaking the pair and leaking the tag as user text. Also covers the memoized-video-tag claimed-drop branch. * fix(transcript): fold upload pairs in user-slash turns and pin pairing parity The cold rebuild's user-slash branch now folds the turn-opening input like any user turn (claimed tag out of the prompt text, one attachment entity), matching the live projection. The ref extraction is consolidated into the contract module (daemonFileRefFromPairingPart, the mirror of the engine's daemonFileRefFromPart) and the mirror carries the new claimingRefByTagIndex map. A new kap-server parity test imports both implementations and asserts identical pairings over shared fixtures, so the engine/mirror pair can no longer drift silently. * fix(kap-server): fold upload media tags out of the search index The global search indexer concatenated every text part of a persisted user message, so the upload pair's <image path> tag made pure-image prompts searchable and wrote the materialization path into the index — breaking the module's documented pure-image invariant and diverging from the live route. textOfContent now folds the pair like every other read model (with a fold-safe coercion for malformed wire parts). Also pins the prompt-media cache-dir fallback with a read-only session media dir test (skipped as root). * feat(node-sdk): re-export the media fold helpers and cover the v1 uploadFile rejection foldMediaPathTagRefs and matchSingleMediaPathTag join the daemon file-reference helper re-exports so hosts can fold the upload tag+ref pair without importing agent-core-v2; the v1 harness's uploadFile not_implemented rejection is pinned by a test. * fix(kimi-code): fold upload pairs in replay/export and keep media tags atomic in steer input Resumed-session replay rendered the upload pair raw — the <image path> tag as user text and the kimi-file:// url as an XML-ish reference — and the markdown export leaked the tag into both the turn body and the overview topic. contentPartsToText and the exporter now fold the pair, and daemon references render as a bare [image]/[video] placeholder. combineSteerInput moves to tui/utils/steer-input and no longer merges a standalone media tag into adjacent text, which would have broken the engine-side pairing for steered image messages. * fix(kimi-code): drop the steer separator before a leading media tag A queued pure-image message opens with a standalone `<media path>` tag, which combineSteerInput keeps atomic. With the previous item ending in a media part, the '\n\n' separator landed as a stranded whitespace-only text part between the media part and the tag, normalizePromptInput rejected the steer, and the already-cleared queue lost the messages. Treat a leading standalone tag as media so the separator is dropped there. * fix: clean staged media lifecycle * refactor(agent-core-v2): narrow the mediaRef root exports and drop a deprecated alias * fix: keep staged media alive through turn * fix(agent-core-v2): reject non-upload ids at the session media store A daemon reference's fileId becomes a storage key in the session media store, but only the file domain validated the id shape — a crafted kimi-file://<id> reaching the request-time resolver's canonical-read fallback could traverse out of the session media dir. Share the file domain's id regex and guard every store entry point: reads miss, materialize declines, and the display path falls back to the hint. * fix(kap-server): project steered prompt content without leaking daemon refs prompt.steered published the raw engine content parts — kimi-file:// refs carrying the absolute materialization path plus the paired <media path> tag — to both the legacy session_event wire (whose schema declares the protocol content shape) and the transcript prompt entity. Route both through one shared prompt-content projection: the upload pair folds into a single {kind:'file'} part, matching the REST prompt list and the no-path-leak rule every sibling surface already follows. * refactor: align daemon-ref naming and drop a duplicate re-export The deprecated videoResolverService alias also re-exported mediaResolvedKey, which made the package root's star exports ambiguous and silently dropped the name. The new transcript contract mirror now uses the canonical daemon-ref vocabulary instead of the deprecated kimi-file spelling. * test(agent-core-v2): pin image abort rethrow, video canonical read-through, release-once Mirror the video abort contract on the new image path (an aborted read cancels the request instead of degrading to a tag), cover the video fallback that uploads the session-canonical bytes after the transient upload is released, and assert the staged-upload release fires exactly once on the intake success path. * fix(kimi-code): bind goal-steer staging leases to the running turn sendMessageInternal read the turn context only after beginSessionRequest had cleared it, so a steer buffered into a running goal turn never got its staging lease bound — the staged daemon upload and cache copies lived until session close instead of being released at the consuming turn's end. Capture the live turn id before the reset (only while a turn is actually streaming; the id outlives its turn otherwise). Also move the staging-lease state machine off the KimiTUI coordinator into a self-contained StagingLeaseTracker with injected effects, drop the duplicate media-tag builder in image-placeholder in favor of the SDK helper, and fix the paste-in-flight comment to match the gate's real granularity. * fix(kap-server): project prompt.queued content without leaking daemon refs The broadcaster projected prompt.steered and stripped turn.started attachments but forwarded prompt.queued raw, leaking kimi-file:// URLs and absolute materialization paths to every subscribed WS connection and the journal. Fold the tag+ref pair into a {kind:'file'} part, same as steered. * fix: keep compressed uploads retrievable and close the steer abort window Two review fixes around prompt media intake: - The compressed re-save was released right after intake (and carried a 1h expiry) while every client read model projects its file id, leaving historical compressed images unfetchable. Keep the re-save as an ordinary upload; roll it back only when preparation or submission fails before the engine takes the prompt. The engine's PromptInput.release hook loses its only producer and is removed. - A prompt aborted while its steer awaited the loop's step assignment was flipped back to 'steered' and its content could still materialize into a later turn. Re-check the reservations after the assignment await and abort the undispatched request when the check fails. * perf(agent-core-v2): memoize inlined image parts across request steps A successful image inline depends only on the immutable upload bytes, so it is memoized per file id (size-bounded) in media.resolved and reused across steps, retries, and media-recovery reprojections instead of re-reading and re-encoding on every request. Degrade forms are never memoized since they depend on the message's tag pairing. Also make the never-empty message placeholder kind-aware (video vs image). * refactor: author media tag+ref pairs in the engine prompt intake Edges (TUI, kap-server REST) now submit bare kimi-file references and the engine intake materializes the bytes, synthesizes the paired media path tag, and falls back to the shared cache dir when the session store is unavailable, replacing per-edge pair construction and duplicate materialization copies. Thread the prompt id from submission through to turn.started (REST prompt_id, WS event, SDK prompt option) so the TUI binds staged-media leases to turns exactly; the origin heuristic stays as fallback and ambiguous claims now surface a staging_lease_invariant telemetry warning. Also lands the pending resendable-extraction fix for cache-hint resubmits after a session switch. * fix: decouple media persistence from prompt intake * refactor(agent-core-v2): project the turn prompt in a single fold pass * test: slim redundant media-ref coverage across layers Fold duplicate pinning of the same media tag+ref rules into shared helpers and it.each tables, and drop assertions that restate behavior already covered at another layer: - drop the kimiFileUrl alias describe (mediaRef.test.ts covers the aliased functions with more cases) - drop pairMediaPathTagRefs describe in favor of the parity fixtures - merge the identical prompt.steered/prompt.queued broadcast tests - parameterize the resolver degradation matrix and prompt intake fixtures (enqueueMedia/gatedImage/expectMediaPair helpers) - drop REST-level context-memory pairing assertions (engine-level intake tests pin the same shapes); keep the caption->system-reminder assertion, the only cover of extractCompressionCaptions - drop the turn-finish-during-intake steer-cancel vector and the switch-session release driver test (unit-level lease tests remain) Net -762 lines; 645 tests green across agent-core-v2, kap-server, transcript, node-sdk, klient, and the TUI. * chore: fix oxlint warnings introduced by image-file-ref changes * fix: harden image file reference lifecycle * fix: close image reference lifecycle gaps * fix: preserve session media paths on replay * chore: streamline image-file-ref changesets * refactor: make daemon media references self-contained, dropping tag+ref pairing A daemon-ref media part now carries everything a read model needs — the kind from the part type and the materialization path from the reference's `?path=` — so prompt intake no longer authors a paired `<media path>` tag, and the pairing/fold machinery (pairMediaPathTagRefs / foldMediaPathTagRefs and their mirror copy) is deleted across the engine, transcript, kap-server, node-sdk, and the TUI. The request-time resolver synthesizes the degrade tag from the reference path whenever bytes cannot reach the provider. Standalone tags stay user-visible text, and never reach the search index or prompt metadata. * fix: reconcile image file references with main after rebase Main removed the agent RPC aggregation layer (agent/rpc) and moved LifecycleScope to app/scopes. Fold the branch's RPC-side behavior into the new structure: PromptPayload carries promptId/disabledTools, and AgentPromptService.submit admits the client-chosen id through the reservation (duplicate rejects before any session state changes) and applies the denylist through toolPolicy. Regenerate the wire/state manifests. * fix(kimi-code): run paste ingestion in the background, wait bounded at submit The paste callback awaited compression + original persistence + the daemon upload while CustomEditor queued every keystroke, so a slow ingestion stalled all typing. Settle the callback once the placeholder lands and track the rest as ImageAttachment.pending; the send path gives a referenced pending ingestion a bounded wait (2s) so paste-then-Enter still submits the compressed/daemon-ref form, and falls back to the inline form when ingestion has not finished. Media-free submits stay fully synchronous. * fix(protocol): mirror prompt_id in the shared prompt submission schema kap-server's local REST schema accepts a client-chosen prompt_id, but the shared promptSubmissionSchema stripped it as an unknown key, so clients validating through @moonshot-ai/protocol lost the id and the turn.started promptId correlation never matched. * fix(klient): normalize file-store errors to public RPC errors on both transports The fileService save/get wire adaptation ran outside the dispatcher's error normalization, so a stale or expired upload id surfaced as the engine's raw Error2 on the memory transport and as a generic 50001 on ipc. Map file.not_found to the public NOT_FOUND RPCError in the shared dispatcher so both transports reject identically, and pin the parity in the conformance suite. * fix(agent-core-v2): keep launching media prompts visible in the queue snapshot startNext shifts the launching record out of pending before its media intake settles, so list()/GET /prompts reported neither an active nor a queued prompt during the intake window even though the submission was accepted and abortable. Report the launching record as still queued, matching the prompt.queued event already published for it. * fix(node-sdk): strip internal promptAttachments from SDK turn.started events The in-process v2 event mapper forwarded the whole domain event, so SDK session.onEvent consumers saw the transcript-projection-only promptAttachments field that kap-server explicitly strips from the WS wire event. Drop it in the mapper so both consumers share the same turn.started field set. * fix(kimi-code): align staging lease id multiplicity with retain count A lease's flat id list conflated two cases: one submission referencing the same image twice (one retain) and a batched steer merging two queued messages sharing the image (two retains). Occurrence-wise release over-consumed in the first case and batch-wise release would under-consume in the second. Dedupe each extraction's ids at the lease creation sites so list multiplicity always equals the retain count, and release one retain per occurrence. * fix(agent-core-v2): check video_in before honoring memoized video uploads The video memo hit path returned a cached ms:// part before the current model's capability check, so switching to a same-provider model with video_in:false sent a video part the model cannot accept instead of degrading to the path tag. Gate on capability first, mirroring the image strategy. * fix(kimi-code): keep recalled queued media staged instead of releasing it Recalling a queued media prompt into the editor is not a discard, but the recall path released the staged files: image attachments lost their daemon upload (resubmit silently downgraded to inline), and a recalled video's cache copy was deleted even though re-materialization needs a source that may already be gone. Recall now consumes only the retain (the next submit re-retains), retires the cache copy to session lifetime, and rebases the video attachment onto that copy. * fix(agent-core-v2): count launching media prompts in prompt.queued queueLength startNext shifts the record into launchingItem before publishQueued computes the count, so a media prompt's prompt.queued reported queueLength 0 even though the prompt is accepted, abortable, and listed as queued. Compute the count from the same snapshot list() exposes. * refactor(agent-core-v2): drop the session media shared-cache fallback Intake keeps the upload-backed reference when the canonical write fails instead of double-writing into an unowned global cache scope; the session media store's reads collapse to the canonical scope, and non-filesystem deployments no longer write every media blob twice. * refactor(agent-core-v2): stop persisting materialization paths in daemon file references The kimi-file:// reference persisted in context memory bundled a durable identity (fileId) with a perishable machine-local absolute path (?path=), which forked sessions and home relocations would stale. The reference now carries only the file id; the display path is derived from the session media store by file id at read time. Parsers tolerate and strip the legacy ?path= query so old records keep resolving. * fix(agent-core-v2): skip atomic-write temp siblings in session media by-id resolution The fs backend stages atomic writes at <key>.tmp.<pid>.<hex> next to the target key, and the media store's prefix-listing predicate matched them, so a lookup racing an unfinished materialize could return the partial copy as the canonical file. * fix(kimi-code): close the staging-lease gap between extraction and dispatch Create the staging lease right after extraction so every pre-dispatch exit releases through the tracker: validation/session failures release it, queueing defers it to the queue item's raw ids/paths, and the cache-hint stash takes over ownership. A forgotten exit now degrades to an unclaimed lease swept at session close instead of a permanently retained upload. The cache-hint restore exits (dismiss, chained restore, session switch during fetch, failed compact/new-session) previously returned only the text to the editor, leaking the extraction's retains and staged cache copies. They now go through queue-recall semantics: retains are consumed, staged copies retire, and recalled videos rebase onto them. * fix(agent-core-v2): bound the inline image memo with a private byte-budgeted LRU A memoized inline image part pins a multi-MB base64 string, and the agent state registry's snapshot/inspect path serializes every registered state in full — so the memo no longer lives in agentState. It is now a private per-file-id LRU with the existing 8MB per-entry cap plus a 64MB total budget; eviction simply re-reads the bytes on the next request. The video memo stays in agentState. * fix(kap-server): fall back to the staged upload on the session media route Prompt intake materializes bytes into the session media store asynchronously and best-effort, but a session_media ref is projected to clients as soon as the prompt is queued — so the download route could 404 during the intake window, and forever after an intake failure. The route now reads the canonical session store first and falls back to the App-scope staged upload, adapting it to the same served shape; only a double miss is a 404. The header note also records that resolving the store resumes cold sessions, an accepted short-term semantic with a TODO for a cold-read channel.	2026-08-17 13:11:28 +08:00
7Sageer	157c84f5d1	docs: fix thinking-effort examples in configuration docs (#2988) ... The secondary-model variant example could not work as written: a bare [models] entry does not inherit the provisioned entry's metadata, and default_effort only takes effect when it is a member of support_efforts, which the kimi-for-coding family does not declare. Base the example on kimi-code/k3 with the full metadata copied, and state both prerequisites. Also align the full-config example's k3 support_efforts with what /login provisions (low/high/max, so the shown thinking effort "high" is valid), and stop describing kimi-for-coding-highspeed as cheap: it is priced higher, so its pool hint now steers toward latency-sensitive tasks.	2026-08-17 12:03:29 +08:00
Haozhe	04d23e2dab	fix(agent-core-v2): unify text/binary classification for UTF-8 multibyte files (#2972)	2026-08-17 11:05:33 +08:00
Luyu Cheng	44a6c70e66	feat(kimi-code): recognize multiple inline skill activations in one prompt (#2935) ... * feat(kimi-code): recognize multiple inline skill activations in one prompt Inline /skill: tokens are recognized anywhere in the prompt (after whitespace, including on following lines) with completion, highlighting, and de-duplication. Submitting goes through session.promptWithSkills, so the engine bundles every activation into the prompt's own user message — one turn, one undo anchor. Replay rebuilds the per-skill cards from the prompt origin's skillActivations and shows only the caller's own parts in the user bubble; undo removes the prompt together with its marked bundle cards; hook results ahead of a bundle are projected inside its window. Enter accepts an inline completion without submitting (pi-tui inlineSlashTrigger), and cache-hint plus /btw pass activations through. * fix(kimi-code): harden bundled skill submissions against review findings - Mark bundle cards by entry id, not by index into a captured array: the transcript window trim may replace the entries array mid-call. - The replay turn limiter no longer cuts between a bundled prompt and the hook results recorded immediately before it; the oldest visible bundle keeps its hook context. - A leading-combo bundle (/skill:a args /skill:b) now queues while busy like any other inline-skill prompt, instead of being rejected by the single-skill slash gate. * fix(kimi-code): fetch one extra replay turn on resume The SDK trims the replay to the requested limit before returning it, so a trim landing between a bundled prompt and its preceding hook results would make them unrecoverable to the TUI-side limiter. Resume now fetches one extra turn of margin; preserveBundleHookResults does the final cut without losing the hook context. * fix(pi-tui): retrigger inline slash completion as the token grows When the terminal delivers `/rev` in one stdin chunk, the slash starts an autocomplete request but the following letters arrived to a null autocomplete state and — unlike a leading slash command — matched no retrigger context, so the stale request was discarded and the menu never appeared. Typing token characters inside an inline slash token now retriggers completion (with a regression test). Also aligns the startup resume tests with REPLAY_FETCH_TURN_LIMIT. * fix(pi-tui): retrigger inline completion on later lines too isSlashMenuAllowed confines the slash-command menu to the first line, so reusing it for the inline-slash retrigger context silently disabled retriggering on every later line — the bare-slash request went stale and the menu never appeared. The inline context now covers a token-opening slash on subsequent lines as well (with a regression test). * fix(kimi-code): activate leading skill tokens in /btw and repeated-token combos - /btw's initial prompt lives entirely in the slash arguments, so a skill token there sits at position 0; scan it with includeLeading so `/btw /skill:review …` actually activates the skill. - Combo-ness is now decided by the raw inline token count rather than the deduplicated activation count, so `/skill:review check /skill:review` submits as a bundled prompt instead of falling through to the single-skill path with the repeated token swallowed into the args. * fix(kimi-code): rewrite media placeholders in leading combo arguments A leading combo's first activation carries the raw slash arguments, so a pasted media placeholder in them reached the engine unresolved — unlike the standalone sendSkillActivation path, which rewrites placeholders into escape-proof plain-text file references first. sendInlineSkillUserInput now rewrites any arg-carrying activation the same way (covering the busy queue and /btw intercept paths too), while the media themselves continue to ride the prompt as extracted parts. * refactor(kimi-code): skill mentions never carry args in bundled prompts Align bundled submissions with the mention model: two or more skill tokens anywhere in the input (the leading one included) make one bundled prompt in which every token activates by name only, and args stay a standalone /skill:<name> args concept. This removes the leading combo's command+args parsing, so the first skill's arguments can no longer leak the next token (displayed as a duplicated prompt under its card), media placeholders no longer need arg rewriting, and newline-separated bundles behave exactly like space-separated ones (parseSlashInput's literal-space separator no longer decides bundle-ness). * fix(kimi-code): recognized builtin and plugin commands outrank the bundle rule The no-args bundle rule claimed any input with two or more skill tokens before checking what led it, so `/btw check /skill:a /skill:b` was submitted to the main agent as a bundled prompt instead of opening the side panel. The intent is now resolved first: builtin and plugin commands always keep their own path regardless of how many skill tokens their arguments mention, while skill-led and newline-led inputs still bundle as before. * fix(pi-tui): retrigger inline completion on colons and register the local divergences External skill tokens are shaped /skill:<name>, but the inline-slash retrigger character classes excluded ':' — typing the colon launched no replacement request, the bare-slash request went stale, and the menu never appeared for prefixed skill names. Colons now retrigger completion like other token characters (with a regression test). Also registers the inlineSlashTrigger and autocomplete-data divergences in the package's re-vendor protection list. * fix(kimi-code): preserve FIFO behind unsteerable bundles and reach indented inline completion - Ctrl-S steering now stops at the first inline-skill bundle: a later queued message (or the editor draft) no longer jumps ahead of the unsteerable bundle into the running turn, so the conversational order survives steering. - The leading-whitespace slash-path suppression now yields to the inline skill context first, so an indented token (` /skill:rev`) completes like its column-0 equivalent instead of being suppressed as a path.	2026-08-17 00:09:18 +08:00
Luyu Cheng	61591bce09	feat(agent-core-v2): bundle multiple skill activations into one prompt submission (#2934) ... * feat(agent-core-v2): support grouped multi-skill prompt submissions Add IAgentSkillService.promptWithSkills: one or more skill activations are validated up front (an unknown or empty submission rejects with no side effects), recorded with a shared submissionId, and enqueued ahead of the prompt through the prompt queue's messagesBefore support, so the whole group materializes atomically as a single turn. Undo cuts, the transcript projection, and the undo precheck treat the group as one unit (stopping at the next anchor even when submission ids collide); hook-result messages are skipped like injections during those walks. Submit hooks run against every message of the group, and user-slash skill activations count as user-submitted content for the UserPromptSubmit hook's origin filter. Surface it through the contract layers: protocol gains submissionId on the user / skill_activation origins and on the skill.activated event (kap-server zod mirrored), klient exposes agentSkillContract.promptWithSkills with parity assertions, and the SDK grows session.promptWithSkills — implemented on the v2 engine and rejecting loudly on the deprecated v1 engine, which is otherwise untouched. * fix(agent-core-v2): reject empty skill lists in grouped prompt submissions - Validate that promptWithSkills receives at least one skill, enforced in the engine and as a non-empty constraint in the klient wire schema. - Restore the released versions and changelog sections for agent-core-v2, klient, and node-sdk that the branch cut had reverted. - Move statement-level narration into the owning file headers per the package comment conventions. - Align the hook-result undo tests with the reachable record ordering (hook results are recorded before the group materializes). * refactor(agent-core-v2): bundle grouped skill activations into the prompt message Replace the submissionId-correlated message group with a single bundled user message: the rendered skill blocks precede the caller's parts in the content, and every activation's metadata rides the prompt origin's new skillActivations field. The bundle is one anchor by construction, so undo needs no group-cutting logic and the messagesBefore prompt seam disappears; the submit hook fires once per submission. skill.activated still fires per skill (transient ops, live-only); resume rebuilds the per-skill view from the prompt origin. Contract chain (protocol, kap-server, klient, node-sdk) drops submissionId accordingly. * fix(agent-core-v2): keep bundled skill blocks out of prompt-facing projections - The transcript cold rebuild expands a bundled prompt's origin skillActivations back into per-skill markers (the live path already projects them from skill.activated events). - turn.started.prompt, the session title excerpt source, and the fork lastPrompt now derive from the caller's own parts, excluding the rendered skill blocks the engine prepends to the bundled content. - Drop the redundant undefined unions from the new origin fields. - Move the activateSkill test narration into the file header.	2026-08-17 00:09:18 +08:00
Haozhe	84da6629b1	refactor(agent-core-v2): decouple workspace from session DI via runtime binding (#2961) ... * refactor(agent-core-v2): decouple workspace from session DI via runtime binding * fix(agent-core-v2): unblock session external hooks and scope workspaceMcp seeds - externalHooksService: inject App-level ISessionManager instead of the unregistered ISessionLifecycleService so SessionStart/SessionEnd hooks actually activate in production; keep sessionId matching and tolerate absent lifecycle events - workspaceMcpService: ignore onWillCreateSession events whose session belongs to another workspace, preventing cross-workspace ISessionMcpHandle seed overrides - update externalHooks integration tests, agent harness, and workspaceMcp tests; add reloadSources coverage in skillCatalog tests * fix(agent-core-v2): honor the bound runtime in prompt context, swarm spawn, and ACP sessions - map system-prompt cwd, directory listing, and additional dirs through RuntimeWorkspaceView, and skip the listing when the bound runtime has no fs capability - pass the caller agent's runtime binding to AgentSwarm child creation and prompt-prefix execution instead of hardcoding local - expose the ACP client filesystem through the ACP session runtime and build its shell/path environment from the probed host instead of hardcoded Linux - dispatch klient facade createChild to sessionManager.createChild so child sessions keep their parent markers * fix(agent-core-v2): resolve routed fs and tool paths with runtime path semantics - WorkspaceFsService resolves via the bound runtime's RuntimePath (extended with basename/dirname) instead of node:path, so mapped roots such as C:\\repo stay runtime-local. - Read/Write/Glob/Grep pass skill roots through mapRoots via RuntimeWorkspaceView input, matching Edit. - acp-server unbinds session runtimes on session/close, not only on delete. - apps/kimi-code drops the /runtime slash command; SDK runtime methods stay. * fix(agent-core-v2): retire idle session controllers, untrack disposed runtime resources, and rebuild fs watches on generation replace * fix(agent-core-v2): resolve oxlint errors in runtime lifecycle fixes * fix(kap-server): untrack download stream from runtime generation on completion * fix(kap-server): drop meaningless void operator on tracked dispose	2026-08-16 20:24:12 +08:00
Haozhe	ee564e5ec9	fix(agent-core-v2): persist token counting ledger so resume restores measured context size (#2969)	2026-08-16 19:31:31 +08:00
tpoisonooo	f492cd7c9e	feat(agent-core): add tower command to orchestrate multi-agents (#2633) ... * feat(packages): implement cowork feat(packages): update throttle control feat(agent-core): rename to /tower feat(agent-core-v2): support tower mode fix(packages): keep tower teardown from stranding submodule worktrees A plain `git worktree remove` refuses worktrees containing initialized submodules even when they are clean, so tower teardown silently left behind exactly the worktrees whose workers had run builds (the failure only reached the tool report, never the activity log). The dirty check is the data-loss gate; once it passes, removal always passes --force (harmless on a clean worktree, and precisely what bypasses git's submodule refusal). Kept and failed removals now also land in the activity log as worktree.keep / worktree.remove.failed. feat(packages): allow the tower to AskUserQuestion, workers still cannot The tower-mode AskUserQuestion deny only ever fired on the tower itself: workers never enter tower mode, and their tower-worker profile simply does not list the tool. Drop the deny so the tower can clarify requirements with the human up front; workers and reviewers stay ask-less and escalate via TowerSend. Auto permission mode still disables AskUserQuestion for everyone. fix(agent-core-v2): import LifecycleScope from #/app/scopes main moved the enum out of #/_base/di/scope; follow the new location in the two tower services. test(agent-core-v2): refresh fullCompaction token expectations main's #2699 counts compaction tokens on the full-request basis, so the tower tool schemas (default registry) and the /tower skill catalog entry (system prompt) shift the pinned numbers: +2789 with the default tool set, +173 with the explicit harness tool list. The 20k-window test keeps its shape with a 22k window so the post-compaction floor still fits. feat(agent-core-v2): tower command support secondary model fix(tower): disable todo-list tool feat(tower): reviewer keep primary model fix(tower): tower worker call for authroization update * refactor(tower): drop agent-core-v1 version * feat(tower): remove builtin.ts * fix(agent-core-v2): verify the recorded base branch before tower merges * fix(agent-core-v2): activate tower missions only after a successful spawn * chore(kap-server): correct the search-service activation comment * fix(tower): allowActivationWhileBusy for all skill * update * update --------- Co-authored-by: konghuanjun <konghuanjun@moonshot.ai>	2026-08-16 15:13:42 +08:00
bj456736	6b72345f8b	feat(tui): print the fork resume command and copy it to the clipboard (#2940) ... * feat(tui): print the fork resume command and copy it to the clipboard * fix(tui): use pushd in the Windows fork resume command so it switches drives cmd.exe's `cd` only updates the target drive's remembered directory, so a terminal on another drive would run `kimi --resume` in the wrong working directory. `pushd` switches drive + directory in both cmd.exe and PowerShell (`cd /d` would break PowerShell). Addresses the Codex review comment. * fix(tui): label OSC 52 clipboard delivery as unverified after fork copyTextToClipboard falls back to an OSC 52 escape when no native clipboard provider works; terminals without OSC 52 support silently drop the sequence, so only native delivery may claim success. Matches the wording convention of /copy. Addresses the Codex review comment. --------- Co-authored-by: bj456736 <bj456736@users.noreply.github.com>	2026-08-15 14:09:43 +08:00
Luyu Cheng	d96cd03770	fix(cli): pre-send warning and clearer error for over-long /goal objectives (#2928) ... * fix(cli): warn on over-long /goal objectives before sending and keep the input - Show a live footer warning in the TUI while a typed /goal objective exceeds the 4000-character limit, measuring paste-expanded text only when the input can be a /goal command. - Restore the rejected /goal input into the editor instead of losing it. - Include the file-reference workaround in the GOAL_OBJECTIVE_TOO_LONG error messages (TUI, goal queue, agent-core, agent-core-v2). * fix(cli): keep the /goal length warning in its own footer slot A transient hint (exit confirm, detach, image paste) that displaced the warning previously left the footer blank after clearing, because no editor change re-applied it. The footer now renders the warning from a dedicated slot whenever no transient hint is active, so the warning returns on its own. * fix(cli): gate the /goal length warning on trimmed text Submitted text is trimmed before slash-command dispatch, so leading whitespace still runs /goal — normalize with trimStart in the gate and in the length check to match. * fix(cli): restore input rejected by the slash-command busy gate An idle-only command submitted while streaming/compacting was rejected after the editor buffer had already been cleared, losing hand-typed input (e.g. an over-long /goal objective that never reached the local validation). * fix(cli): restore input at the post-creation busy re-check The lazy-session race rejects an idle-only command after a first prompt has already started a turn; the editor buffer is long cleared by then, so give the submitted input back like the dispatch blocked branch does. * fix(cli): close the remaining input-loss and gate gaps around /goal - Restore the submitted input when lazy session creation fails before a session-requiring command runs. - Restore only into a still-empty editor after async gates, so a draft typed while creation was pending is never overwritten. - Expand pastes that can complete a partially typed /goal command (e.g. /go[paste #1 …]) in the length-warning gate. * fix(cli): never displace newer UI state with a delayed input restore A session-less /goal submission restores its input only after an async gap (lazy session creation). If the user opened an editor-replacement panel meanwhile, restoring would tear it down (and leave activeDialog inconsistent). Track editorReplacementMounted in TUIState and gate all delayed restores through canRestoreSubmittedInput. * refactor(cli): move canRestoreSubmittedInput into commands/resolve Avoids the goal.ts <-> dispatch.ts runtime import cycle flagged by import/no-cycle; the helper takes a structural host shape instead. * fix(cli): match the slash parser's delimiter in the /goal length warning parseSlashInput splits the command name at a literal space only, so a newline or tab after /goal dispatches as a plain message — the warning must not fire for inputs the dispatcher will not treat as a goal.	2026-08-15 02:55:33 +08:00
qer	a23680e293	docs(changelog): sync 0.36.1 from apps/kimi-code/CHANGELOG.md (#2926)	2026-08-14 21:56:20 +08:00
github-actions[bot]	13d86f8b7b	ci: release packages (#2881) ... Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-08-14 20:51:17 +08:00
qer	d60d8ff7e8	chore: downgrade plan viewer changeset from minor to patch (#2923)	2026-08-14 20:46:50 +08:00
qer	cd489955bb	chore: sync web dist from code-app (#2922) ... code-app: af7ed8fa03278bbe2f988732b3195649e7a6f2bc	2026-08-14 20:36:54 +08:00
qer	6cf315b7bd	fix(pi-tui): stop GFM autolinks at CJK punctuation boundaries (#2917) ... * fix(pi-tui): stop GFM autolinks at CJK punctuation boundaries marked's GFM autolink accepts any non-space characters after the domain and its backpedal strips only ASCII trailing punctuation, so CJK or full-width punctuation right after a bare URL was absorbed into the link text and href (`.../pull/232（本地` rendered as one anchor whose OSC 8 target contained raw CJK and opened a broken address). Register a CjkBoundaryUrlTokenizer (subclass of the upstream StrictStrikethroughTokenizer, which stays byte-identical for re-vendoring) that cuts the autolink match at the first CJK punctuation character before the ASCII backpedal. CJK ideographs inside the URL path itself are preserved. Guarded by new bare-URL CJK cases in test/markdown.test.ts and listed in pi-tui's local-divergence inventory. * fix(pi-tui): keep balanced full-width parens inside autolinked URLs Address review feedback on the CJK autolink boundary: cutting at the first full-width parenthesis anywhere in the match also truncated URLs that legitimately contain balanced full-width parens in their path (e.g. wiki disambiguation pages like .../wiki/中华人民共和国（1949年）). Full-width parens now follow GFM's ASCII-paren rule: a paren-depth scan keeps balanced pairs in the URL and only an unbalanced （ or ） terminates the match. Non-paren CJK punctuation still always terminates it. * fix(pi-tui): keep CJK punctuation inside balanced full-width parens Punctuation inside a balanced full-width parenthetical is deliberate URL content (e.g. .../wiki/中华人民共和国（北京，1949年）), so the non-paren CJK terminator now only applies at paren depth 0. Prose parentheticals contain spaces and never survive marked's match this far, and an unbalanced （ still cuts the match at the open paren.	2026-08-14 20:15:33 +08:00
Grapedge	7475c2e2e3	feat(vscode): switch the extension to the v2 engine with a rollback switch (#2916) ... The extension now runs on the agent-core-v2 engine by default. The interface, sessions, and workflows do not change. Two rollback paths exist, and one function makes the decision (config/vscode-settings.ts): - the kimi.useAgentCoreV1 setting (temporary; a window reload applies the change); - the KIMI_CODE_LEGACY_FLAG environment variable, which wins over the setting and has the same semantics as in the CLI. An engine startup failure shows an explicit error that names the rollback setting. There is no silent fallback. CI runs the extension test suite on both engines: the sharded run covers the default v2 engine, and a new test-vscode-legacy job reruns the suite with KIMI_CODE_LEGACY_FLAG=1. To keep the v2 path identical to v1 for every method the extension uses, this change also completes the v2-backed SDK client and the v2 engine: - Implement session deletion in the v2 SDK client. - Implement fork truncation at a turn index in the v2 engine, with the same rules as v1, and reject a fork while the source session has an active turn. - Stop the session-level /init run when the turn is cancelled, as v1 does. - Read session metadata without the archived field as not-archived, so sessions written by the v1 engine open correctly. The SDK parity suite now covers session deletion, cancel, and fork truncation. The known-difference list for the methods the extension uses is empty.	2026-08-14 17:22:10 +08:00
qer	741708f948	feat(kap-server): add plugin marketplace and capability REST routes (#2868) ... * feat(agent-core-v2): surface a machine-key note from capability installs CapabilityEntry.install now resolves an optional note exposed through CapabilityInstallProgress.note (wire-visible). The webbridge entry returns 'user-skill-migrated' when it migrates a pre-existing standalone skill copy onto the plugin-managed one — clients can localize the migration instead of the skill silently disappearing from the user's directory. * feat(kap-server): add plugin management and capability REST routes Expose the App-scope plugin and capability services over the wire so non-CLI hosts (desktop, web) can manage plugins and built-in capabilities end to end: - GET /api/v1/plugins, POST /api/v1/plugins {source}, POST /api/v1/plugins/{id}:{enable,disable,remove} - GET /api/v1/plugins/marketplace — catalog (pluginMarketplaceUrl server option / KIMI_CODE_PLUGIN_MARKETPLACE_URL env / production default) merged on demand with live install state; updateAvailable only on strict semver catalog > installed (no semver dependency) - GET /api/v1/capabilities, GET /api/v1/capabilities/{id}, POST /api/v1/capabilities/{id}:install with client-polled progress - New wire codes 40418 capability.not_found, 40419 plugin.not_found, 40923 capability.install_in_progress, 40924 capability.unsupported Mutations flow through IPluginService, so they serialize with other install paths and fire onDidReload (session skill catalogs and the capability shelf-install hook converge). * fix(kap-server): map plugin input errors to 4xx and correct the unsupported test code - mapPluginError now translates the domain's validation.failed (40001) and fs.path_not_found (40409) instead of collapsing client-fixable input mistakes (relative source, nonexistent local path) into a 50001 internal error - the non-macOS capability install test expected 40923, which this branch assigns to capability.install_in_progress; the unsupported code is 40924 (macOS runners skip the case, which is why it only fails on Linux/Windows CI) * fix(kap-server): resolve catalog-relative marketplace sources and widen the unsupported-test skip - The production CDN catalog carries sources relative to the catalog URL (./official/*.zip); clients handing them back to POST /plugins would hit the local-path normalizer's 40001. Resolve entry sources against the configured catalog URL so every returned source is directly installable. - The 40924 install-rejection test only skipped macOS, but kimi-cu is also supported on Windows x64 — running it there would start the real installer. Skip on every supported platform. * fix(kap-server): accept the legacy url/downloadUrl marketplace source aliases Custom catalogs that the CLI already accepts can carry an entry's source under url or downloadUrl instead of source; the route's strict schema rejected the whole catalog with 50001. Normalize the aliases before validation (same precedence as the CLI parser) so those catalogs keep working through /api/v1/plugins/marketplace. * fix(kap-server): support local marketplace catalogs and drop conditional spreads - KIMI_CODE_PLUGIN_MARKETPLACE_URL accepts a plain path or file:// catalog in the CLI loader; the route only fetched over HTTP, so local catalogs 50001'd for desktop/web hosts. Read local catalogs from disk and resolve their relative sources against the catalog's directory. - Replace the marketplace mapping's conditional spreads with direct possibly-undefined properties per the repo rule. * fix: surface capability install notes through klient and convert file:// entry sources - The klient capabilities contract omitted install.note, so zod parsing stripped it and facade callers (node-sdk, TUI) never saw 'user-skill-migrated'. Add the field and pin it in the facade test fixture. - A marketplace entry source given as a file:// URL fell through to the relative-branch and came back as a garbage path; convert with fileURLToPath so the advertised source stays installable. * test(kap-server): keep the new route tests portable to Windows x64 - The capabilities list assertion treated every non-macOS host as unsupported, but kimi-cu is supported on Windows x64 — derive the expectation from the same platform predicate. - file:///abs/... is not a valid absolute file URL on Windows (no drive root); build the fixture with pathToFileURL from a temp path instead. * refactor: align the capability note and test helper with repo conventions - agent-core-v2 keeps explanatory docs in the top-of-file block only; the note contract already lives in the capability types header, so drop the two member-level doc blocks. - The plugins route test helper sets the optional fetch body directly instead of via a conditional spread. * fix(kap-server): expand ~ in local marketplace catalog paths The CLI loader expands ~/ against the home directory; the route read the path literally, so KIMI_CODE_PLUGIN_MARKETPLACE_URL=~/catalog.json 50001'd for desktop/web hosts while working in the CLI. Share one localCatalogPath helper (file:// conversion + tilde expansion) between the catalog read and the relative-source resolver. * fix(kap-server): expand home-relative marketplace entry sources A catalog entry with source '~/...' fell through to the catalog-relative branch and came back as <catalog-dir>/~/... — unresolvable by POST /plugins. Expand ~ via the shared helper before the absolute/relative decision. * fix(kap-server): match CLI field semantics for source aliases and stub the Windows home - A blank or non-string source no longer shadows the url/downloadUrl aliases; the first valid (non-blank, trimmed) of source/url/downloadUrl wins, mirroring the CLI parser's stringField. - The tilde test also stubs USERPROFILE so os.homedir() resolves to the fixture home on Windows runners. * fix(kap-server): read a blank marketplace tier as missing The CLI parser trims tier and treats a blank as absent (third-party); the route's enum rejected the whole catalog with 50001. Normalize the tier alongside the source aliases in the same preprocess. * fix(kap-server): derive marketplace versions from GitHub release sources Entries that omit version but encode it in a GitHub release/tag (or tree/commit) source never surfaced updateAvailable. Derive the version from the resolved source — same URL shapes as the CLI parser, validated with the route's strict x.y.z rule (no semver dependency). * fix(kap-server): fail catalog validation on a source with no usable value A whitespace-only source with no valid alias passed z.string().min(1) untrimmed and resolved against the catalog URL into nonsense. Drop the key during normalization so the schema reports the entry as missing its source (same outcome as the CLI's 'must define source'). * fix(kap-server): resolve latest versions for bare GitHub marketplace entries A catalog row whose source is a bare GitHub repo (the production curated rows are shaped this way) kept version undefined, so updateAvailable never fired for exactly the entries most likely to update. Resolve the latest release tag through the /releases/latest redirect — the UI route, not the rate-limited API — same as the CLI, degrading to no version on any failure. * docs(kap-server): note the marketplace version resolution in the plugins route header * feat(kap-server): mark capability wiring rows in the marketplace response A client following only /plugins/marketplace + POST /plugins would install a capability's wiring plugin without its binary runtime, with no wire-level way to tell. Entries whose id matches a capability's wiring plugin now carry capabilityId, so clients route them through /capabilities/{id}:install — the client-side routing pattern the CLI established (the upstream design that replaced the server-side hook). * fix(kap-server): fall back to the source-checkout catalog for the default location When the marketplace location is the built-in default (no server option or env override) and the fetch fails, read the repo checkout's own plugins/marketplace.json — the CLI loader's behavior for offline source-checkout dev. An explicitly configured catalog still fails hard with 50001. Bundled installs have no checkout file, so the fallback simply never fires there. * fix(kap-server): resolve fallback catalog sources against the fallback file readMarketplaceCatalog returned only the JSON, so entries from the source-checkout fallback resolved their relative sources against the (unreachable) CDN URL — coming back as unusable https paths instead of local directories. The reader now returns the location actually read, and source resolution uses it. * fix(kap-server): honor the CLI's marketplace metadata aliases Custom catalogs using name / shortDescription / websiteURL (accepted by the CLI parser) lost those fields to schema stripping, falling back to the entry id. Normalize the aliases in the same preprocess as the source/tier normalization. * fix(kap-server): filter marketplace keywords instead of rejecting the catalog A keywords array with non-string or blank members failed the strict schema and took the whole catalog down with 50001. Normalize to the CLI parser's semantics: non-array reads as missing, arrays keep trimmed non-blank strings only. * fix(kap-server): treat a blank or non-string marketplace version as missing The CLI parser reads version through its lenient stringField and falls through to source-derived versions; the route's schema rejected a numeric version with 50001 for the whole catalog. Normalize version in the preprocess like the other fields — the gh-plugin fixture now carries a numeric version and still derives 2.0.0 from its tag source. * fix(kap-server): trim marketplace entry ids before the install-state join A whitespace-padded id survived validation raw and never matched the installed records (updateAvailable silently lost). Normalize the id in the preprocess — trimmed, blank rejected — matching the CLI's requiredString. * fix(kap-server): gate capability markers to the default catalog A custom catalog (env or server option) may legitimately carry a same-id fork of a capability's wiring plugin; marking it capabilityId would route users to the built-in install. Apply the marker only for the default catalog (including the source-checkout fallback), matching the CLI injecting built-in rows only for the default catalog. * fix(kap-server): compare marketplace versions with real semver The hand-rolled strict x.y.z check rejected valid semver the CLI accepts (v-prefixed, prerelease tags), so updateAvailable diverged between CLI and wire clients. Take the semver package (already in the monorepo via the CLI) for the update check and the two source-derived version validators. * fix(kap-server): validate marketplace entry types and count the dev server as default - Custom catalog rows with an unsupported type (e.g. integration) were stripped by the schema and advertised as installable plugins; the CLI rejects the catalog outright. Model the same plugin/managed/guide vocabulary. - scripts/dev.mjs marks its repo-owned catalog with KIMI_CODE_PLUGIN_MARKETPLACE_FROM_DEV_SERVER=1 — honor the flag in the isDefault check so capability markers and the checkout fallback behave exactly like the CLI under the dev marketplace. * fix(kap-server): join capability rows through their platform wiring plugin id kimi-cu installs its wiring plugin as kimi-cu-win on Windows x64, so a catalog row keyed kimi-cu never matched the installed record there (no installed state, no updateAvailable). The row mapping now knows each capability's wiring plugin ids and joins through them. * fix(kap-server): map plugin load failures to 40001 An install source pointing at a directory/zip with a missing or invalid manifest throws plugin.load_failed — a client-fixable input error that fell through to 50001. Map it to validation.failed alongside the other input mistakes. * build(kap-server): align @types/semver with the workspace version sherif rejects multiple workspace versions of one dependency; the CLI pins @types/semver at ^7.7.0. * refactor(agent-core-v2): share the plugin marketplace client/parser across hosts The kap-server marketplace route grew its own copy of the CLI's catalog loading/parsing logic (lenient aliases, blank-means-missing fields, source resolution, GitHub version derivation) — two implementations of a public, hand-writable format would drift on every catalog change. Move the read/parse/version machinery into the plugin domain as app/plugin/marketplace (pure functions, no DI): the CLI keeps a thin wrapper owning configured-source resolution and its checkout fallback, and the route keeps only the wire concerns (install-state merge, capabilityId markers, error envelopes). plugins.ts drops ~230 lines of duplicated machinery. One deliberate behavior fix rides along: tilde entry sources now expand against the home directory at parse time (the CLI previously passed them through literally, failing later at install validation). * docs(agent-core-v2): fold the marketplace module's member docs into the file header The package convention keeps explanatory comments in the top-of-file block only; the moved parser carried several function/member-level JSDoc blocks from its CLI home. The header now carries the format contract, leniency rules, source/version resolution order, built-in masking semantics, and the fallback gating rule. * docs(agent-core-v2): drop the remaining statement comments in the marketplace module The header carries the rationale (update semantics, GitHub ref shapes, the releases/latest choice); the convention allows nothing beside statements. * fix(kimi-code): import the shared marketplace module by its deep path constant/app.ts is evaluated on every CLI invocation; re-exporting from the agent-core-v2 root would pull the whole engine module graph into startup. The package's wildcard subpath export lets both CLI files take only the pure marketplace module (node builtins + semver). * feat(kap-server): fan plugin and capability lifecycle out as global WS events Clients currently poll the plugins/capabilities REST surfaces and can hold stale rows while another client mutates the set. Publish two global events instead: - event.plugin.changed — fired off IPluginService.onDidReload, so any install/enable/disable/remove from any client reaches every host - event.capability.changed — every capability install progress transition (CapabilityService gains onDidChangeInstall), so rows update live and settle is observable without polling Both ride the existing global fan-out (no subscription needed) and are documented in the wire schema registry. * fix: register the lifecycle events in the wire union and tidy the contract header - event.plugin.changed / event.capability.changed were declared but not part of agentEventSchema, leaving the wire catalog incomplete. - The onDidChangeInstall member doc moves into the capability contract file header (package comment convention). * feat(protocol): mirror the plugin/capability lifecycle events in the shared WS schema Clients and e2e harnesses validating server frames against @moonshot-ai/protocol would reject event.plugin.changed / event.capability.changed. Register both in the shared catalog (TS interfaces, zod schemas, and both unions), matching the model_catalog.changed precedent for global events. * fix(kap-server): prefer the platform wiring plugin when joining capability rows A stale same-id record (e.g. a raw kimi-cu plugin next to the real kimi-cu-win wiring on Windows x64) previously won the join, showing the wrong installed state and update availability. Capability rows now join through the wiring plugin ids in platform preference order before falling back to the catalog id. * fix(kap-server): put the github metadata of plugin summaries on the wire schema GitHub-sourced plugin summaries carry github {owner, repo, ref, installedSha} from the domain; the route serializes raw domain objects, so the field reached clients undocumented. Declare it in pluginSummarySchema so the OpenAPI surface matches reality. * test(node-sdk): cover the new lifecycle events in the exhaustive switch The event-type exhaustiveness test broke when the shared protocol union gained event.plugin.changed / event.capability.changed. * fix(kap-server): mark capability progress events volatile Per-chunk download progress transitions ride the same fan-out as durable frames and were being persisted to the __global__ journal — hundreds of stale frames per install. event.capability.changed is live-only state, so it joins the volatile list alongside event.di.unit_changed; the settle frame stays recoverable via a direct capability read. event.plugin.changed remains durable (rare, and a reconnecting client should replay it). * feat(kap-server): inject built-in capability rows into the default catalog response The checked-in production catalog carries kimi-webbridge but not kimi-cu — the CLI injects built-in rows client-side, so wire clients never saw Kimi Computer Use in /plugins/marketplace. For the default catalog the route now appends supported capabilities the catalog lacks (static descriptors via ICapabilityService.describeCapabilities — no detector probes), marked with capabilityId and a capability:<id> sentinel source so installs still route through the capability surface. * fix(kap-server): run injected capability rows through the install-state join The injected kimi-cu row hardcoded installed: undefined, so an already-installed capability still read as installable. Injection now happens before projection, so injected rows get the same backing-plugin join (installed state, update badge, capabilityId marker) as catalog rows. Also moves the describeCapabilities note into the contract header (package comment convention). * test(kap-server): gate the injected-row assertions on platform support kimi-cu injects only where supported (macOS / Windows x64); on Linux CI the row is correctly absent. * fix(protocol): classify capability progress as volatile in the shared catalog kap-server never journals event.capability.changed (it is in the server-local volatile list); shared-protocol clients reading isVolatileEventType would treat per-chunk progress frames as durable and replayable. Mirror the classification. * fix(kap-server): hide capability rows on unsupported platforms Catalog-carried capability rows (kimi-webbridge in the default catalog) were marked with capabilityId regardless of host support — on an unsupported platform clients would route into an impossible capability install. Rows whose capability is unsupported are now excluded from the default-catalog response entirely (the CLI hides its built-in rows the same way).	2026-08-14 15:45:34 +08:00
7Sageer	249d8faa34	fix(agent-core-v2): mint interaction ids engine-side (#2911) ... * fix(agent-core-v2): mint interaction ids engine-side Self-hosted OpenAI-compatible endpoints may renumber tool call ids on every response (Bash_0, Bash_1, ...). The approval/question/user_tool facades used the provider toolCallId as the interaction id, so a repeated id was silently swallowed by client-side pending-interaction dedupe: the approval prompt never appeared and the turn parked forever (#2908). Interaction ids are now minted by the engine (approval_<uuid> / question_<uuid> / user_tool_<uuid>); the provider toolCallId stays on the payload for correlation. This matches v1 semantics, where the approval id was already a daemon-minted id independent of the tool call id. * fix(agent-core-v2): normalize duplicate provider tool call ids at ingestion Self-hosted OpenAI-compatible endpoints may renumber tool call ids on every response (Bash_0, Bash_1, ...), and every downstream keying assumes an id identifies exactly one call: context rebuild silently drops the second tool result with a duplicated id, the strict projector discards duplicate calls, transcript frames merge, and approval/activity correlation misfires. A per-agent ToolCallIdNormalizer in the llmRequester stream boundary now tracks ids already claimed (seeded from the restored context). The first occurrence passes through unchanged; later occurrences — across responses or within one — are rewritten to a readable <id>__<n> suffix, kept consistent between streamed deltas and the finalized message, and logged for provenance. A failed attempt rolls its claims back so a projection retry re-streams the same logical calls under the same ids. * fix(agent-core-v2): thread the minted approval id through events and status The permission.approval.requested/resolved events only carried the provider toolCallId, so AgentActivityView exposed approvalId = toolCallId and the agent.status.updated approval phase forwarded an id that POST /sessions/{sid}/approvals/{id} cannot resolve — the kernel parks under the minted approval_<uuid>. Mint the interaction id at the agent call site and include it in the approval request payload: the kernel honors the explicit id, the events carry it, and the activity view keys pendingApprovals by it (falling back to the toolCallId for id-less events). * fix(agent-core-v2): surface minted interaction ids in facade listPending The approval/question facades returned only the original payload from listPending(), so once the kernel id stopped deriving from the provider toolCallId, hosts listing pending requests had no id to feed back into decide()/answer()/dismiss() without reaching into the kernel. Merge the parked interaction id into each returned request — the klient contract schemas already carry the optional id field, so the RPC surface becomes round-trippable as well.	2026-08-14 14:47:00 +08:00
weiwei Wang	53909d91e3	fix(kimi-web): cache content-hashed assets (#2865)	2026-08-14 13:08:30 +08:00
Haozhe	cb30a7799d	fix(kap-server): expose parent_tool_call_id and subagent_type in /tasks responses (#2912)	2026-08-14 13:03:56 +08:00
Haozhe	eb72aebeeb	fix(kap-server): remove the 64 MiB web session export limit (#2910)	2026-08-14 11:48:56 +08:00
Haozhe	325913a532	feat(kap-server): expose the subagent registry id in /tasks responses (#2907)	2026-08-14 11:28:07 +08:00
Louis Gu	245e3d56a6	fix(tui): sanitize background task output (#2863) ... Co-authored-by: liruifengv <liruifeng1024@gmail.com>	2026-08-14 11:19:27 +08:00
oocz	102984aa66	fix: settle cancelled MCP OAuth callbacks (#2899) ... Co-authored-by: yuchengzhen <yuchengzhen@moonshot.cn>	2026-08-13 22:56:06 +08:00
Haozhe	1414d46028	refactor(agent-core-v2): fold session lifecycle hooks into sessionLifecycle events (#2896)	2026-08-13 21:03:51 +08:00
7Sageer	5857ba23b0	test(kap-server): deflake three timing-sensitive tests (#2894) ... * test(kap-server): poll the read-model immediate-read assertions The 'prepares the read model at boot and serves immediate reads' test sampled the session list / workspace session_count / paged read exactly once after creating a session. While a mirror flush is in flight its batch is only per-shard atomic and the pending-queue cleanup is not linearized with reads, so a single-sample read landing inside that window can transiently miss or double-count the new session (seen twice on main CI as 'expected false to be true' and 'expected 0 to be 1'). Poll with vi.waitFor instead; the transient lasts at most one in-flight flush (~100ms cadence). * test(kap-server): retry the transcript test temp-dir teardown rm The engine's file log writers flush synchronously on scope dispose but their trailing async close can still create a file under the test home after server.close() resolves, so the afterEach rm occasionally fails with ENOTEMPTY on a loaded CI runner. Retry the rm (maxRetries: 5), matching the existing pattern in questions.test.ts / fs.test.ts. * test(kap-server): drain the in-flight search sync before appending The 'serves the published generation without waiting for a blocked background sync' test appended the delta right after a warm-up search that had kicked a fire-and-forget background sync pass. On a starved CI worker thread that pass can read the file after the append and publish both documents early ('expected 2 to be 1'). settleSync before the append makes 'no pass can index the delta' structural.	2026-08-13 21:02:34 +08:00
7Sageer	0473b3aac1	test(minidb): deflake the evict-lru compaction-churn guard (#2892) ... The stress test asserted stats.compactions > 0 immediately after the write loop, but auto-compaction is fire-and-forget through the maintenance scheduler and the counter only increments once a run fully completes. On a loaded CI runner the loop can finish before the first compaction lands, failing the guard even though nothing is broken. Wait for the first completed compaction with the existing waitFor helper instead: the guard still proves the churn this scenario requires happened, and a genuinely broken auto-trigger now fails via the wait timeout.	2026-08-13 21:00:56 +08:00
Haozhe	67e73f3e76	refactor(agent-core-v2): extract date change feature (#2895) ... Move date-change reminders behind the Feature lifecycle and make state registrations disposable so unloading removes the runtime seed.	2026-08-13 20:58:58 +08:00
7Sageer	c60e3e301d	docs: drop legacy secondary-model content and unify subagent terminology (#2891) ... - Remove the legacy-engine secondary-model recipe section, the KIMI_SECONDARY_MODEL / KIMI_SECONDARY_EFFORT env entries, and the model_preference agent-file field: the default engine never reads them and the legacy engine is deprecated. - Remove the backward-compat note for a lone [secondary_model] model key; the code still reads it, but the docs now only document the current pool scheme. - Reframe the secondary_model section around the subagent model pool instead of a singular secondary model. - Unify zh terminology: 子 Agent -> subagent, 主 Agent -> main agent, covering prose, headings, anchors, the sidebar label, and the docs/AGENTS.md term table.	2026-08-13 19:57:46 +08:00
Haozhe	4425409cea	fix(features): retract contributed service metadata (#2886) ... * fix(features): retract contributed service metadata - tie contributed service discovery to feature disposal - reject duplicate providers for the same scope and service - cover feature unload and debug channel resolution * test(features): preserve contributed service registry - remove the global contributed-service test reset - keep provider cleanup local to each regression test * fix(features): scope service discovery to each app - store feature service metadata in the app-local collection tree - bind debug lookup and test overrides to the owning app root - keep duplicate provider activation atomic within one app	2026-08-13 19:13:00 +08:00