32 commits

Author	SHA1	Message	Date
Haozhe	a09d904140	refactor(agent-core-v2): migrate agent domains to model-as-container architecture (#3103)	2026-08-20 16:06:59 +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
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
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
Haozhe	8c766a6c30	feat(agent-core-v2): add the L3 unit layer and the Feature seam (#2678) ... * feat(agent-core-v2): add the L3 unit layer and the Feature seam - introduce the L3 Service/Fiber unit layer: the Service base class with this.provide/effect/on/get/ref capabilities, the fiber runtime with thenable FiberHandles, collection contribution points, and the per-scope-kind ScopeUnits materialization fold - provide each scope's static registration batch as one atomic provideAll cascade transaction (waiting-area activation, sticky Failed on construction error) - add the DI unit inspection surface: App-scope debug ledger / dependency graph / cascade history services and the kimi-inspect DI view - add the Feature unit seam (IFeatureManager + feature assembly), port plan mode onto it, and add the contributed-command seam (agent-command domain + node-sdk RPC types) - remove the legacy dep-graph tooling - apply the header-only comment convention across src and test: strip non-header narration, keep the file header, tooling pragmas, and NOTE comments * feat(kap-server): gate the event.di.* debug feed to kimi-inspect connections - add an opt-in target set in SessionEventBroadcaster; the global fan-out now skips event.di.* frames for connections that never opted in, so kimi-web and other clients no longer receive the high-churn DI feed - WsConnectionV1 opts a connection in when client_hello carries client_id 'kimi-inspect'; removeGlobalTarget drops the opt-in on close - temporary gate until a client-declared event-type whitelist lands * chore(agent-core-v2): fix oxlint errors in the DI unit layer - build the live-ref container chain without aliasing this (no-this-alias) - snapshot the materialized map with Array.from and document why the copy is required (no-useless-spread) * test(klient): use string scope kinds in the lifecycle handle fakes The engine's LifecycleScope is a string enum now; the facade test doubles still returned the old numeric kinds and failed the handleWireSchema output validation. * build(nix): update the pnpmDeps fetch hash	2026-08-06 18:22:36 +08:00
Haozhe	6ba75a173b	feat(config): add deprecation mechanism and rename loop retry limit (#2572) ... * feat(config): add deprecation mechanism and rename loop retry limit - agent-core-v2 config: declarative section `deprecations` (deprecated TOML keys are ignored and report a warning diagnostic; the file is never rewritten) and env binding `deprecatedEnv` (old var still resolves as a fallback with a warning), surfaced via the new `IConfigService.onDidChangeDiagnostics` event - loop_control: rename `max_retries_per_step` to `max_attempts_per_step` and `KIMI_LOOP_MAX_RETRIES_PER_STEP` to `KIMI_LOOP_MAX_ATTEMPTS_PER_STEP`; `max_steps_per_run` moves onto the same mechanism (no longer silently mapped) - kap-server: push the global `event.config.warning` WS event to every connection whenever the config warning set changes - TUI: show config diagnostics in warning yellow at startup instead of the dim startup notice - docs: config-files/env-vars (en+zh), regenerated config manifest, and the agent-core-dev config guide * feat(cli): validate config.toml against v2 section registry in doctor - add v2/validate-config.ts: validate config.toml with the agent-core-v2 ConfigRegistry, reporting registered-section schema failures as errors and unknown top-level keys / deprecated keys and env vars as non-fatal warnings - route `kimi doctor` config validation through the v2 validator when the KIMI_CODE_EXPERIMENTAL_FLAG master switch is on (lazy dynamic import, keeping the v2 module graph off the default path) - let doctor checks surface non-fatal warning messages on OK results * chore: downgrade loop-control changeset to patch	2026-08-03 20:17:01 +08:00
Haozhe	44d34bbd56	refactor(agent-core-v2): move host runtime args onto IBootstrapService (#2460) ... * fix(agent-core-v2): resolve package self-references in check-import-boundaries Imports spelled @moonshot-ai/agent-core-v2/<path> (the legal `./*` export self-reference) were treated as external packages, letting kosong layer violations through that spelling pass the checker. * refactor(agent-core-v2): move host runtime args onto IBootstrapService - Add HostArgs under BootstrapInput.args / IBootstrapService.args (agentFiles, skillDirs, requestHeaders, displayName, replyStyleGuide), mirroring VS Code's NativeParsedArgs on the environment service - Remove the narrow per-domain runtime-options services and their seed functions: IAgentCatalogRuntimeOptions, ISkillCatalogRuntimeOptions, IHostIdentity - Reduce IHostRequestHeaders to a pure kosong port contract and bridge it from bootstrap args via a new app/kosongConfig adapter, keeping kosong free of app-layer imports - Pass host args through bootstrap() at the composition roots (kap-server, v2 print CLI, node-sdk) instead of seeding services - Persist SDK provider removal as one atomic multi-section config replace * fix(config): persist provider refresh updates atomically - expose atomic multi-section config replacement through klient and SDK - stage provider removals before one atomic write in TUI refresh - briefly drain startup refresh during shutdown	2026-07-31 16:47:34 +08:00
Haozhe	4c4df1bb05	feat(agent-core-v2): persist the terminal turn.ended wire record (#2457) ... * feat(agent-core-v2): persist the terminal turn.ended wire record - add a persisted turn.ended op (turnId, reason, error, durationMs) dispatched from the loop's runTurn finally block, alongside the event - fold the record back in the transcript cold rebuild: terminal state (blocked folded into failed, mirroring the live wire edge), durationMs, error message and endedAt; journals without the record keep the grouping default - restrict the test harness's snapshot waiters to emit entries so the same-named wire record no longer shadows the turn.ended event * chore(agent-core-v2): stabilize unique-symbol keys in the state manifest The checker names a unique symbol key __@name@NNNN, where NNNN is a compilation-global counter that shifts with unrelated type additions and churns the generated manifest. Render the stable __@name form instead. * fix(transcript): map turn.ended around hidden turns in the cold fold RetryStepRequest opens a real engine turn with origin 'retry' but contributes no context messages, and a queued-then-cancelled reservation consumes an engine id without starting. Both make engine turn ids drift from the grouping ordinals, so matching turn.ended by ordinal could stamp a later visible turn with the wrong terminal state. Replay the loop's turn-clock records (turn.prompt / turn.cancel) and map engine ids to ordinals past the hidden ids; the hidden turns' own end records map nowhere and are dropped.	2026-07-31 16:25:43 +08:00
Haozhe	071d56940f	refactor(agent-core-v2): remove the L0-L7 domain layering and clean up comment conventions (#2451) ... * refactor(agent-core-v2): move workspace-domain internals into internal/ dirs - move sessionLifecycle/addressing into internal/ - move workspaceFs errors/fsProcess/fsSearch/rgLocator/runRg into internal/ - move workspaceMcpConfig/config-loader into internal/ - update import paths in services, index.ts, and tests * docs(agent-core-v2): strip non-header comments, make headers file-local - remove all symbol JSDoc and inline // and /* */ comments under src/; file-top header comments and directive comments (eslint, @ts-*) are kept - rewrite file headers to describe only what the file itself does, dropping references to other files and see-X / lives-in / consumed-by relationships - no code changes * refactor(agent-core-v2): remove the L0-L7 domain layering and its lint guard - replace check-domain-layers.mjs with check-import-boundaries.mjs, keeping only the v1-import ban and the kosong subtree rules - rename the lint:domain package script to lint:imports - drop the (Ln) layer label from every file-header identity line - update AGENTS.md, package docs, and the agent-core-dev skill to match	2026-07-31 13:45:33 +08:00
Haozhe	ed7a4cc095	feat(kap-server): add session-less POST /workspace/fs:search route (#2437) ... * feat(kap-server): let fs:search resolve a workspace ref for draft sessions - fs:search accepts a workspace id or absolute root in the session_id slot so the @ file mention works before the session exists - kimi-web searchFiles falls back to the active workspace id in draft state * fix(agent-core-v2): report empty thinking level for unbound main agent - sessionLegacyService.status returns thinking_level '' when the main agent has no bound model (mirroring model: undefined), so clients fall back to the catalog default instead of folding in the wire model's 'off' zero value - add regression test for a never-bound main agent status - add web changesets: draft @ file mention, new-session thinking level * perf(minidb): make text index rebuilds async and non-blocking - TextIndex.build() yields to the event loop during tokenization and batches postings writes (~1 MiB), so large rebuilds no longer hard-block the host process - writes landing mid-build are queued and replayed onto the new base at swap time, keeping the rebuilt index exact - PostingsFile.rebuildSync renamed to async rebuild with a synchronous commit section (beforeRename hook + atomic rename) - onCompacted hook is now awaited (sync or async); open-time compaction runs in the background so open() returns without blocking on the snapshot rewrite and postings rebuild - compaction skips the postings rebuild when the index's write buffer is clean (needsRebuild) - createTextIndex registers before building so concurrent writes feed the build queue; dropTextIndex throws while a build is in flight * refactor(agent-core-v2): rename workspaceHandler to sessionLifecycle - rename IWorkspaceHandlerService to ISessionLifecycleService and move src/workspace/workspaceHandler/ to src/workspace/sessionLifecycle/; update all consumers (gateway, sessionExport, sessionLegacy, sessionLookup, kap-server, klient, node-sdk, kimi-inspect, kimi-code) - rename IStateService to IAppStateService and add the Workspace-scope IWorkspaceStateService, so the state domain spans all four scope tiers - add cascading StateRegistry.inspect(): each tier injects the parent tier's registry and folds App to current scope into one StateInspection tree; check-domain-layers gains a Rule 2b exemption for state-on-state imports * feat(kap-server): add session-less POST /workspace/fs:search route Carry the workspace reference (registered id or absolute root) in the request body and resolve it to the same Workspace-scope fs service the session route uses, so clients no longer borrow the session route's {session_id} slot. kimi-web's @ file mention now calls this route with the workspace ref instead of a session id; the session-route fallback stays for wire compatibility. * refactor(agent-core-v2): register workspace-scope service state into IWorkspaceStateService - move workspaceDirs / workspaceInstructions / workspaceSkillCatalog / workspaceTrust runtime state from bare instance fields into the workspace state container - extend gen-state-manifest.mts to scan app/workspace scopes, emitting AppStateSnapshot / WorkspaceStateSnapshot alongside Session/Agent - regenerate docs/state-manifest.d.ts and update AGENTS.md + agent-core-dev skill - update affected tests to register the state services and assert the new state keys	2026-07-31 12:11:26 +08:00
Haozhe	17dfd49768	feat(agent-core-v2): introduce the Workspace domain and the agent-profile registry extension point (#2366) ... * feat(agent-core-v2): insert Workspace lifecycle scope and remove mutable cwd paths - Insert LifecycleScope.Workspace between App and Session - Delete session/workspaceCommand domain (addAdditionalDir) and node-sdk RPC - Remove profile cwd mutation; cwd is fixed at creation - Make ISessionWorkspaceContext read-only; seed additionalDirs at creation - Remove TUI and vscode /add-dir commands (to return workspace-scoped) * feat(agent-core-v2): add Workspace scope with handler-owned session lifecycle - Add IWorkspaceLifecycleService (App scope): handler registry, create-or-get handlerFor with inflight join - Add workspace/workspaceContext seed and workspace/workspaceHandler (session create/resume/fork as handler child scopes) - Delete App-level ISessionLifecycleService; callers compose index -> handlerFor -> handler via sessionLookup helpers - Slim IBootstrapService; persistence addressing via handler chain (disk layout byte-identical) - kap-server routes rewire internally; /api/v1 wire unchanged, debug surface gains workspace addressing - Pin red line in domain lint: session/agent must not import workspace domains * feat(agent-core-v2): collect workspace resources into the handler scope - Add Workspace-scope catalogs for skills and agent profiles, instructions service, and a shared MCP connection manager (built at materialization, refreshed by watch/plugin events) - Session catalogs keep their APIs but read seeded snapshots and refresh via change events; ISessionMcpService removed - Session create options carry no mcpServers; MCP sources are config file (wins on name conflicts) and plugins only - Agent profile/mcp consume the seeded providers * feat(agent-core-v2): restore add-dir as a workspace-level capability - Add workspace/workspaceDirs: shared additional-dir set with addDir({path, persist}); persist=true writes .kimi-code/local.toml, local.toml watch drives cross-process refresh - ISessionWorkspaceContext becomes a live read view fed by the ISessionWorkspaceInfo seed contract and change events - Restore Session.addAdditionalDir in kimi-code-sdk 1:1, mapping to the workspace service; restore TUI/vscode /add-dir verbatim * feat(agent-core-v2): collect os-level services into the workspace scope - Move fs service, fs watch (shared subscription fan-out), process runner, and a git facade to Workspace scope; sessionFs domain removed - Add IWorkspaceToolPolicy with workspace veto wired through tool activation, execution guard, composed evaluation, and profile prompt projection; injected via ISessionToolPolicyGate seed - kap-server fs routes and fs.watch bridge remap to the workspace services; wire unchanged * refactor(agent-core-v2): clean up workspace-domain leftovers and docs - Drop dead code: v2 mergeCallerMcpServers, the transitional ISessionContext.additionalDirs field, an unreachable guard - Fix stale domain references in comments; correct test names - Give the fs-watch refresh test a realistic wait budget under load - Document the four-scope model and workspace domain in AGENTS.md, agent-core-v2 docs, and the agent-core-dev skill * test(node-sdk): wait for the initial MCP connect to settle in the parity list test v1 connects in the background after create resolves while v2 awaits it inside create, so an immediate list can catch either side still pending under CI load * refactor(agent-core-v2): extract git work-tree discovery into the git domain - add the pure findGitWorkTree probe in app/git/workTree and expose it as IGitService.findWorkTree - switch the git permission policies off the local findLocalGitWorkTreeMarker helper to the DI service - reuse findGitWorkTree for AGENTS.md project-root discovery in agent/profile/context.ts - add findWorkTree coverage to gitService.test.ts * feat(kimi-inspect): add Workspace Services view - add WorkspaceServicesView rail view with a workspace picker on top; proxies resolve workspace-scope Services on the /workspace/:id route - extend ChannelScope, ServiceTarget, and ServicePanelDef scope with 'workspace', routed via client.workspace(id).service - wire the new view into NavRail and App * refactor(agent-core-v2): extract mcpCore and workspaceMcpConfig domains - move the scope-agnostic MCP connection layer (stdio/http/sse clients, connection manager, oauth, config schema, tool naming) from agent/mcp to the new mcpCore domain - move the [mcp] config section to app/mcpConfig and OAuth credential persistence to app/mcpConfig/oauthStore - introduce the workspace/workspaceMcpConfig domain owning the effective MCP server set (mcp.json files + plugin contributions, refreshed by fs watch); workspaceMcp keeps pure connection orchestration - update the plugin domain, session MCP handle, klient/node-sdk contracts, and tests accordingly * refactor(agent-core-v2): remove the fault-injection experimental feature - delete the faultInjection domain (flag definition, IFaultInjectionService contract, FaultInjectionService implementation) - drop the requester-side take() injection point and the constructor dependency from llmRequester - remove the flag-gated test cases and the IFlagService stub they needed - regenerate the state manifest without the faultInjection state keys * feat(agent-core-v2): gate project-level MCP config behind workspace trust Add the Workspace-scope IWorkspaceTrust service: an explicit, per-workspace trust marker persisted under the home (IAtomicDocumentStore, keyed by encodeWorkDirKey(root)) so a checked-out tree cannot pre-trust itself. While a workspace is untrusted, workspaceMcpConfig skips the project-level .mcp.json and .kimi-code/mcp.json files (user-level config and plugin contributions still load); a trust flip reuses the reload path, so project servers connect on trust and disconnect on untrust. Expose the state over kap-server REST: GET /workspaces/{id}/trust, POST /workspaces/{id}/trust, POST /workspaces/{id}/untrust. * feat(kimi-inspect): replace the workspace picker with a directory browser The Workspace Services view now keeps a server-side directory browser in a left sidebar (over IHostFolderBrowser) instead of a <select> of registered workspaces. Entries that are registered workspaces carry a workspace badge plus their IWorkspaceTrust trust state; selecting an unregistered folder registers it on demand via IWorkspaceService.createOrTouch. * fix(agent-core-v2): resolve the effective cwd into the profile binding A default-bound agent recorded no cwd in its profile.bind payload, and no caller configures ProfileServiceOptions.cwd, so the profile service's cwd getter fell through to '' and refreshSystemPrompt() rebuilt the prompt from the server process's cwd: an AGENTS.md edit dropped the workspace instructions (or swapped in unrelated ones). bind() now persists the resolved effective cwd (the input's, or the session's when the input omits it) into profile.bind — the Model's cwd stays creation-fixed and is always set. The getter's last resort is the session's own cwd (the value legacy bindings resolved against) instead of a bare ''. * refactor(agent-core-v2): introduce the contribution/registry/catalog extension point for agent profiles - App-scope IAgentProfileRegistry: any scope can register an AgentProfileContribution keyed by (sourceId, workspaceKey); dedup per source id, change events drive catalog re-projection - workspaceAgentProfileLoader domain owns agent-file discovery end to end (parse / roots / SYSTEM.md / explicit runtime files) with five Workspace-scope loaders (workspace / user / plugin / extra / explicit) tagged with the handler's workspaceId; internals live under internal/ - SessionAgentProfileCatalog projects the registry directly (name dedup, priority adjudication, builtin override rule, inspect()); the workspace-catalog + sessionData seed relay is gone - builtin code contributions register as the 'builtin' entry via BuiltinAgentProfileLoader; plugin agent roots are provided by the plugin domain as PluginAgentRoot - remove cwd from the profile binding chain (BindAgentInput / ProfileBindingSnapshot / AgentConfigData / ProfileModelState / profile.bind op) — it is always the session's frozen cwd; legacy wire.jsonl records replay fine (the schema strips the field) - share markdown frontmatter parsing via _base/text/frontmatter * fix(agent-core-v2): reconcile the workspace refactor with main - restore the branch's klient workspaceId scope extension lost to a file-level conflict resolution (main had no further changes there) - stub the plugin system-prompt dependencies main added to the profile service in the profileOps / skillCatalog tests - correct PLUGIN_SKILL_SOURCE_ID to the App skillSource domain (Agent scope must not import the Workspace domain) - kap-server workspaceLayout test supplies the now-required hostIdentity - regenerate wire/state/config manifests * fix(agent-core-v2): export the agent-file parse primitives the v2 print CLI consumes The internal/ split kept parseAgentFileText / resolveAgentPath off the package entry, but apps/kimi-code's v2 print runner imports them from @moonshot-ai/agent-core-v2 for --agent-file. Export the two symbols by name; everything else under internal/ stays domain-private. * feat(agent-core-v2): return cwd listing for empty fs:search query An empty fs:search query used to fail request validation (query had a minimum length of 1), so @-mention pickers had no starting set right after typing "@". The workspace fs service now answers an empty query with the workspace root's top-level entries — directories first, hidden entries excluded, gitignore and exclude_globs honored — mapped into the search-hit shape (score 1, empty match positions) and capped by limit. The mirrored protocol wire schema is relaxed in sync. * test: cover cron-fired steer context and titled session creation - agent-core-v2: e2e asserting a cron-fired steer turn carries earlier tool results (the CronCreate job id) into the provider request - klient: conformance case creating a titled session through implicit workspace materialization	2026-07-31 00:38:11 +08:00
Haozhe	d36f4c58f6	refactor(agent-core-v2): remove the fault-injection experimental feature (#2399) ... - delete the faultInjection domain (IFaultInjectionService, its Agent-scope implementation, and the fault-injection experimental flag) - drop the llmRequester's per-attempt fault consumption point and the faultToError helper - remove the fault-injection test cases and DI wiring from the requester service tests, and the domain's layer-registry entry - regenerate the state manifest without the faultInjection.* state keys	2026-07-30 14:45:31 +08:00
Haozhe	e556088458	feat(tree-sitter-bash): add a pure-TypeScript bash parser and an agent-core-v2 bashParser service (#2016) ... * feat(tree-sitter-bash): scaffold pure-TypeScript bash parser package Add packages/tree-sitter-bash with the SyntaxNode tree model (UTF-16 code-unit offsets, tree-sitter-bash named-node type names), a parse budget (deadline + node cap) with an aborted ParseResult variant, and a placeholder parse() to be replaced by the real lexer/parser. * feat(tree-sitter-bash): add lexer and core recursive-descent parser Cover the permission-analysis grammar subset: lists, pipelines, commands, words, quotes, expansions, command/process substitution, subshells, the full redirect operator set, heredocs and comments, with tree-sitter-bash named-node type names. Long scan loops check the parse deadline via budget.progress() so large literals cannot exhaust the node cap; parse depth is bounded on all recursion chains. * feat(tree-sitter-bash): support the full bash grammar Add compound commands (if/while/until/for/c-style-for/select/case/ function/compound/do_group), test commands with reference-exact extglob/regex right-hand-side rules, a Pratt expression engine for arithmetic expansion shared across arith/c-for/test modes, arrays and subscripts, declaration/unset commands, ansi-c/translated strings and brace expressions. Reserved words are recognized only in statement position. Case-aware balanced scanning keeps command substitutions intact around case items, expression leftovers are kept as ERROR nodes instead of dropped, and recursion depth is bounded per chain (substitution 150, parse 500, lexer scan 1024). * test(tree-sitter-bash): add differential fixtures, corpus, fuzz and perf suites Turn the ad-hoc wasm comparison work into permanent infrastructure: a differential helper pinning reference-equivalent and known-difference samples against the real tree-sitter-bash wasm (478 match / 79 known-diff fixtures plus the official v0.25.0 corpus), a three-way consistency check between fixtures, the known-difference registry and the README, deterministic seeded fuzz with tree-integrity assertions, and performance smoke tests. Converges 15 further divergence groups found by systematic probing and documents the rest; the full suite is 853 tests in ~4s. * feat(agent-core-v2): add App-scope bashParser service Wrap the pure @moonshot-ai/tree-sitter-bash package as IBashParserService (L1, no dependencies): parse(source, options) returns a wire-safe BashParseResult whose nodes drop the cyclic parent link so trees can cross the RPC boundary. Budget exhaustion surfaces as { ok: false, reason: 'aborted' }, malformed input as hasError — never a throw. * chore: add changeset for the bash parser service * chore: update pnpmDeps hash after adding tree-sitter-bash package * fix(agent-core-v2): register bashParser service with ScopeActivation The registration was written against the removed InstantiationType API (#/_base/di/extensions); switch to ScopeActivation.OnDemand from #/_base/di/scope so the package typechecks and the service registers. * feat(kimi-inspect): add Bash Parser view Add a fourth icon-rail tab that exercises the App-scope bash parser service over the debug RPC surface: a source textarea with a parse budget (timeoutMs / maxNodes), a dropdown of curated examples adapted from the tree-sitter-bash differential fixtures, and an expandable syntax tree with per-node type, UTF-16 range and leaf text, plus hasError / aborted / node-count badges. * fix(agent-core-v2): snapshot bash syntax trees iteratively A long left-associative chain (e.g. an arithmetic expression with a few thousand operands) parses into a tree thousands of levels deep while still within budget; the recursive DTO conversion then overflowed the JS call stack and made parse throw RangeError, breaking the never-throws contract. Convert the tree with an explicit stack, the same approach as the parser's own materialize. * feat(kimi-inspect): add a deep-arithmetic example to the Bash Parser view A thousand-operand left-associative chain fills the textarea with a thousand-level binary_expression tree — the shape that once overflowed the DTO conversion. Deeper chains still parse in-process but cannot cross the JSON RPC transport (V8 call-stack limit in serialization), so the example stays within the wire limit. * chore: update pnpmDeps hash for the rebased lockfile The rebase onto main merged pnpm-lock.yaml, invalidating the recorded fetchPnpmDeps hash; use the hash CI computed for the merged lockfile.	2026-07-28 14:29:08 +08:00
Haozhe	a77ee03829	feat(agent-core-v2): add hostIdentity domain for host-overridable system prompt identity (#2144) ... * feat(agent-core-v2): add hostIdentity domain for host-overridable system prompt identity - add app-scope hostIdentity domain (L3) with productName / replyStyleGuide overrides and hostIdentitySeed for composition roots - render ${product_name} and ${reply_style_guide} in the base system prompt, falling back to CLI defaults when the host provides no override - seed the variables from AgentProfileService via IHostIdentity - expose hostIdentity on kap-server's ServerStartOptions * chore: add changeset for host identity system prompt * fix(agent-core-v2): adapt hostIdentity registration to ScopeActivation The DI refactor on main removed _base/di/extensions (InstantiationType); register with ScopeActivation.OnScopeCreated instead, and regenerate the state manifest for the new SystemPromptContext fields. --------- Co-authored-by: liruifengv <liruifeng1024@gmail.com>	2026-07-27 16:55:41 +08:00
7Sageer	d40d0d305d	refactor(agent-core-v2): make undo domain-owned (#2055) ... * refactor(agent-core-v2): rebuild undo as wire-level journal rewind Replace the compensating context.undo op with a wire-layer rewind primitive: a log.cut control record with a persisted target, applied uniformly by the wire during fold. Turn boundaries become first-class (TurnIndexModel indexing turn.prompt record positions), models declare a temporal classification (rewindable), and a single IAgentRewindService owns the undo pipeline (quiesce -> precheck -> cut -> reconcile) with all entry points converged. - wire: log.cut record, rewindable model flag, re-fold rebuild; OpApplyContext.recordIndex for position-aware reducers - rewind service: aborts the active turn, cancels in-flight compaction, preserves the pending queue, rebases measured tokens, reconciles lastPrompt, tracks conversation_undo - todo list, plan mode, task-notification delivery and the turn index now rewind together with the undone turns - transcript reducer applies cut ranges so snapshot/messages surfaces stay consistent with the model context - REST/RPC/debug undo entry points converge on the rewind service; TUI parses the v2 undo-unavailable error shape - legacy context.undo records keep replaying for old journals * refactor(agent-core-v2): keep undo domain-owned * refactor: enhance /undo functionality for consistency and safety, including todo list rollback and improved event handling * chore: clean up undo changeset artifacts * refactor: rebuild rewind consistency * fix: make conversation undo durable and consistent * fix(agent-core-v2): stabilize undo restoration * fix: keep TUI undo on legacy error contract * refactor(agent-core-v2): drop unused full compaction cancel API Undo now rejects with session.busy while compaction runs instead of cancelling it, so the awaitable cancel() added for the earlier rewind semantics has no callers left. Remove it from the interface and implementation; the RPC cancel path keeps using the task abort controller directly. * fix(agent-core-v2): remove injected context on undo * chore(agent-core-v2): regenerate wire manifest * docs(agent-core-dev): rename rewind to undo in layer table * fix(agent-core-v2): undo prompt-owned image reminders * refactor: remove transcript undo reconciliation * fix(kap-server): map undo busy errors * refactor(agent-core-v2): rename undo participant registry and attribute checkpoint depth - Rename IAgentConversationUndoReconciliationRegistry to IAgentConversationUndoParticipantRegistry (conversationUndoParticipants). - Return the limiting model from checkpointDepth and include it in the SESSION_UNDO_UNAVAILABLE details; report checkpoint_lost instead of compaction_boundary when no compaction explains the missing depth. - Add a registry invariant test: every model reacting to context.* ops must be registered via defineCheckpointedModel or explicitly exempt. * Delete .changeset/fix-undo-injections.md Signed-off-by: 7Sageer <sag77r@hotmail.com> --------- Signed-off-by: 7Sageer <sag77r@hotmail.com>	2026-07-27 11:09:26 +08:00
Haozhe	bf8e967d5c	refactor(agent-core-v2): register tools as scoped services (#2196) ... * refactor(agent-core-v2): register agent tools as DI services with profile-aware activation - replace module-level registerTool + Eager AgentBuiltinToolsRegistrar with registerAgentTool double registration (Agent-scope DI service + contribution table) - add toolActivation domain: AgentToolActivationService filters contributions by the bound Profile's tool policy using declared names, resolves instances lazily via accessor.get, and re-activates on agent.status.updated - rename BuiltinTool to AgentTool service interface; tools become Agent-scope services with decorator-injected dependencies (e.g. AgentTool -> SubagentTool/ISubagentTool) - AgentLifecycleService.create runs one activation pass after restore and profile binding so tools reflect the Profile before the first turn - update tool registrations, scripts, and tests; add toolActivationService tests * refactor(agent-core-v2): centralize builtin tools under agent/tools - move builtin tools from scattered domain folders (plan/tools, goal/tools, os/backends/node-local/tools, task/tools, etc.) into a unified agent/tools/ directory - split each tool into a kebab-case definition file (bash.ts) and a registration file (bashTool.ts) pairing with its prompt markdown - update imports across src, tests, kap-server, and TUI comments * fix(agent-core-v2): keep agent tools out of scope-creation instantiation Main's instantiateAll constructs every registered service at scope creation, but agent tool constructors may legitimately throw when their host capability is absent (e.g. WebSearchTool without a configured provider), and profile-aware activation must stay the only resolution path so the runtime registry holds real instances, never proxies. - add SyncDescriptor.instantiateWithScope (default true) and let registerScopedService opt registrations out of the instantiateAll sweep - registerAgentTool passes the opt-out, restoring lazy activation-driven construction on top of the eager-scope semantics - regenerate docs/state-manifest.d.ts * refactor(agent-core-v2): replace delayed DI with scope activation - add explicit OnScopeCreated and OnDemand activation modes - remove delayed proxy and idle initialization support - migrate service registrations, tests, and DI guidance	2026-07-26 14:32:59 +08:00
Haozhe	7799bd7346	feat(agent-core-v2): add per-scope keyed state container (#2192) ... * refactor(agent-core-v2): instantiate all registered services eagerly at scope creation - add instantiateAll to scope creation: every service registered for a scope tier is constructed when the scope is created, following the static dependency graph; a failing constructor fails scope creation - drop the hand-maintained eager-resolution lists: igniteEagerServices in AgentLifecycleService, the force-instantiated session services in SessionLifecycleService, and the kosong config bridge get in bootstrap - update DI docs and agent-core-dev skill guidance for the new semantics - adjust affected tests (registry hygiene, timer draining, listener ordering) and add scope-tree coverage for eager instantiation * feat(agent-core-v2): add per-scope keyed state container (state domain) - add _base StateRegistry: typed StateKey/defineState descriptors with register/get/set, per-key onDidChange and global onDidChangeAny events, and BugIndicatingError on duplicate or unregistered key access - bind thin per-scope services at each tier: IStateService (App), ISessionStateService (Session), IAgentStateService (Agent), so scoped plain-data state lives in one observable container that dies with the scope - register the state domain in the layer check script and export the new services from the package index - add StateRegistry unit tests and scoped resolution tests * refactor(agent-core-v2): move session-scope service state into ISessionStateService - add StateRegistry.snapshot() with JSON-safe serialization for Map/Set/Date/circular values - migrate plain-data fields of 13 session-scope services (cron, interaction, sessionActivity, agentProfileCatalog, fs, fsWatch, log, metadata, skillCatalog, toolPolicy, workspaceCommand, workspaceContext) to defineState keys registered in sessionState - register SessionStateService in affected tests and add test/state/stubs.ts helper * feat(kimi-inspect): rework chat layout with session pane and tabbed right dock - add SessionPane column next to the sidebar: Services tab (pending interactions + session Service panels) and State tab polling ISessionStateService.snapshot() every second, rendered as a live diff tree - merge the transcript audit panel and the agent inspector into one RightPanel with Audit/Agent tabs that keep panel state across switches - extract InteractionsCard from Inspector into its own component - collapse multiline strings in StateTree into a compact hover-preview button with a viewport-clamped fixed popup - test: cover StateRegistry.snapshot() conversions (Map/Set/circular); pass a session state service to SessionInteractionService in kap-server test fakes - update the AGENTS.md project map for the new layout * refactor(agent-core-v2): move agent-scope service mutable state into agentState Register each Agent-scope service's mutable fields into the agent-state container (IAgentStateService) via defineState keys, and access them through get/set accessors backed by states.get/set. Promise locks, disposables, and other mechanism-only fields stay plain instance fields. - define per-service state keys (e.g. activityView.*, goal.*, toolDedupe.*) and register them in each service constructor - replace direct field reads/writes with states-backed accessors across the touched services - update the affected unit tests for the new IAgentStateService dependency * fix(agent-core-v2): collapse class instances in state snapshots - StateRegistry.snapshot() now stops at custom-prototype boundaries and emits '(ClassName)' markers, so resource graphs reachable from registered values (e.g. tool instances holding service references) can no longer exhaust the heap during export; plain data keeps recursing - add agent-scope state test covering the full assembled agent scope - kimi-inspect: extract the session State card into a shared StateCard and add an agent State tab in RightPanel polling IAgentStateService.snapshot() - document the per-scope state container pattern in the agent-core-dev skill * refactor(agent-core-v2): keep resource-holding state out of the state container - move fields holding live resources (tool entries, managed tasks, turn jobs, prompt records, MCP registrations, profile callbacks) back to plain private fields so the agent state service only holds snapshot-safe plain data - add gen:state-manifest script that statically collects defineState keys and their register call sites into docs/state-manifest.d.ts - add state manifest freshness test and update agent-state docs * chore: add changeset for session-scope state container * docs(agent-core-v2): move eager-instantiation notes into the scope.ts header * fix(kimi-inspect): suppress stale state tree while switching state owner	2026-07-26 10:10:15 +08:00
Haozhe	5240b5c83c	feat(agent-core-v2): add generated config and wire-protocol manifests (#2086) ... * feat(agent-core-v2): add generated config section manifest - add scripts/gen-config-manifest.mts: drains the live registerConfigSection / registerConfigOverlay contributions and renders docs/config-manifest.toml in the on-disk config.toml shape (owner, scope, registered defaults, env bindings, schema fields) - add a gen:config-manifest package script (--check mode included) and a freshness test that rebuilds the manifest and compares byte-for-byte - point the agent-core-dev config skill and the package AGENTS.md at the generated manifest instead of the stale hand-maintained ownership map * feat(agent-core-v2): add generated wire-protocol manifest - add scripts/gen-wire-manifest.mts to generate docs/wire-manifest.d.ts from defineOp registrations (payload interfaces, persist policy, toEvent, cross-reducers) plus a WirePayloadMap - extract shared JSON Schema helpers from gen-config-manifest.mts into scripts/lib/jsonSchema.mts - add gen:wire-manifest script and wireManifest.test.ts freshness check - document the manifest in packages/agent-core-v2/AGENTS.md * fix(agent-core-v2): keep array-of-tables manifest sections fully commented A bare `[hooks]` header parses as a plain table, which array sections reject on load; emit only the commented `[[hooks]]` shape so the manifest matches the on-disk config.toml shape it documents. Addresses a Codex review comment on PR #2086.	2026-07-23 11:17:10 +08:00
Haozhe	188c0fcbf7	refactor(agent-core-v2): decouple kosong from config persistence (#2068) ... * refactor(agent-core-v2): decouple kosong from config persistence - keep the kosong provider/model registries in memory and sync them with config.toml through a new app/kosongConfig two-way bridge: hydrate on startup, push config section changes into the registries, and persist runtime mutations (discovery refresh, OAuth provisioning, default-model pointer changes) back to disk - declare the providers/models/thinking section constants, zod schemas, env bindings, and TOML transforms in a single app/kosongConfig configSection.ts; kosong keeps hand-written types only - pin every schema to its kosong type at compile time via AssertExact<Equal<...>> (_base/utils/typeEquality) - register a transitional auth>kosongConfig exception in the domain-layer checker for the OAuth provisioning flows * chore(agent-core-v2): drop unused IConfigService import from authLegacy * fix(agent-core-v2): reconcile registry with env-pinned default pointers A registry-originated default-model/provider write lands only in the config user layer when an effective overlay pins the section (KIMI_MODEL_NAME pins defaultModel to the reserved env model): the effective value does not move and no change event fires, so the registry diverged from the effective config view — catalog/auth reads reported the user pick while profile resolution kept the pinned model. After persisting, the bridge now re-asserts the effective value into the registry, restoring the pre-refactor behavior where every default-pointer write was arbitrated by the effective view. * fix(agent-core-v2): await persistence before resolving kosong registry mutations ProviderService/ModelService mutations resolved as soon as the in-memory registry updated, while the kosongConfig bridge persisted the change on an unawaited private chain — callers (klient kosong.*, set_default route, OAuth provision, discovery refresh) could observe success before the write reached config.toml, and a restart right after could lose it. - fire registry change events through AsyncEmitter and await delivery in set/delete/replaceAll/setDefaultX, so a mutation resolves only after listeners' waitUntil work completes; loadAll keeps synchronous timing - the bridge hooks its persists into waitUntil, hoists the equality guards into the listeners so config-originated echoes stay fully synchronous, and serializes persists on the chain as before - retry a failed persist with bounded backoff (3 attempts); failures are logged, never rejected to callers, and the in-memory change stands - default-pointer change events now carry an { id } payload (fireAsync requires object events) - add the klient kosong-config stress example covering read-after-write, concurrent bursts, and restart durability	2026-07-23 00:32:10 +08:00
Haozhe	64f053cf46	feat: agent-core-v2 permission/workspace refactors and transcript durability (#2021) ... * refactor(agent-core-v2): extract toolApproval domain from permissionGate - add agent-scoped `toolApproval` domain owning the approval round-trip: builds approval requests, drives the session/approval broker, publishes permission.approval.* events, records session approval rules, and resolves ask continuations - slim permissionPolicy down to the static risk-adjudication chain; drop the dynamic `registerPolicy` mechanism - move harness constraints out of the policy chain into their owning domains as toolExecutor hooks ordered before 'permission': plan-mode guard (plan), swarm batch exclusivity and AgentSwarm approve (swarm), goal-start review (goal), exit-plan review (plan/exitPlanModeReview), and btw deny (session/btw) - delete the now-unused policies (deny-all, plan-mode-guard-deny, plan-mode-tool-approve, goal-start-review-ask, swarm-mode-agent-swarm- approve, agent-swarm-exclusive-deny) - update Permission.md, AGENTS.md, and check-domain-layers for the new domain layout * feat(kimi-inspect): add App Services view for app-scope service reflection - add `services` top-level view (`AppServicesView`) on the NavRail, showing the full-width app-scope Service panel grid; session/agent scopes stay in the Chat view's Inspector - extract shared `ServicePanels` from Inspector and add `methodArgs` helper to build per-method argument editors from channel metadata - support variadic service calls in `panels.ts` (`call(svc, method, ...args)`) - update agent-core-dev skill docs for the toolApproval extraction and the guard/review-off-chain permission design * refactor(agent-core-v2): restructure workspace domains - rename workspaceRegistry to workspace and workspaceLocalConfig to projectLocalConfig - extract id-spelling resolution into the workspaceAliases domain (IWorkspaceAliases) - extract workspace-centric session queries into workspaceSessions (IWorkspaceSessions) - update kap-server routes, klient contracts, and related tests to the new services * feat(transcript): add op-batch sequencing and point-to-point catch-up - wire: transcriptSeqSchema with per-agent batch seq watermark on transcript.reset/ops and the REST transcript response, the transcript_since subscription cursor, and the GET transcript/ops catch-up shape; seq stays optional everywhere so legacy peers fall back to loss-signal-driven refreshes - wire: drop interactionFrame, interactions live on the interaction item in the ops stream - kap-server: TranscriptService assigns consecutive per-agent batch seqs and retains them in a bounded in-memory journal; the transcript_since cursor replays journaled batches instead of a baseline reset, and the baseline reset is now items-empty because history always pages in over REST - kimi-inspect: transcript REST/WS clients track the op-batch watermark and run seq-gap/reconnect catch-up with full-refresh fallback; add the Transcript audit panel (AuditTrail timeline, structural diff, state tree) docked right of the chat - docs: sync AGENTS.md and agent-core-dev skill notes with the new transcript contract * feat(transcript): persist plan revisions and task/interaction facts, add user-messages endpoint - record each ExitPlanMode submission as a versioned plan blob via a reference-only plan.revision op, projected live and cold as a plan.revision marker plus the plan badge (reviewPath, version) - persist task.started/task.terminated (with a bounded output tail) and interaction.request/interaction.resolved ops, and add foldFacts so a cold transcript rebuilds tasks, interactions, todos and goal/plan/swarm meta from the wire journal - add GET /sessions/{session_id}/transcript/user-messages returning all turn-opening prompts grouped per agent * fix(agent-core-v2): anchor external PreToolUse hooks before the permission gate The toolApproval extraction forces the gate to construct early (planService injects it to anchor plan-guard), so the 'permission' hook registered ahead of 'externalHooks' and a policy ask waited on the approval broker before PreToolUse could block, hanging the turn. Fetch the gate first in registerListeners and register the PreToolUse hook with before: 'permission', falling back to appending when the gate is stubbed without its hook. * refactor(agent-core-v2): replace ordered onBeforeExecuteTool hook with veto-event pattern - introduce BeforeToolExecuteEvent with veto/allow/pass/waitUntil statements - add BeforeToolExecuteEmitter with two-pass fire (immediate then deferred) - split readiness work into separate onWillExecuteTool participation event - migrate all domain listeners: permissionGate, plan, goal, swarm, btw, externalHooks, toolDedupe, mcp - remove IAgentPermissionGate force-injection for hook ordering - update docs, tests, and domain-layer check to match * refactor(agent-core-v2): unify veto payload on ExecutableToolResult - veto() and waitUntil factories now carry a plain ExecutableToolResult: isError reads as a denial, anything else as a short-circuit; the block/reason/syntheticResult weak union is gone - add denyToolExecution(reason) helper for the common denial shape, and narrow the fire/authorize return to BeforeExecuteDecision ({ veto } or { executionMetadata }) - narrow the policy 'result' resolution to { kind: 'result'; result } - settle vetoed calls through a single normalize/merge path in the executor * fix(agent-core-v2): pull up IAgentPermissionGate in agent activation The permission gate only subscribes `onBeforeExecuteTool` from its constructor. The veto-event refactor removed the ordering-driven force-injections that used to pull it up, so without an explicit resolution tool execution would run without policy adjudication. * refactor(agent-core-v2): fold systemReminder domain into contextMemory appendTagged - add `appendTagged(content, tag, origin)` to `IAgentContextMemoryService`, storing content pure with a `tag` field on `ContextMessage` - apply the XML tag at projection time in `contextProjector` via the new `tag.ts` helpers (`wrapTag` / `applyTagToContent`) - delete the `systemReminder` domain and migrate all call sites (contextInjector, goal, plugin, prompt, swarm, btw, sessionInit, toolSelectAnnouncements) to `appendTagged` - build toolDedupe reminder strings with `wrapTag` * refactor(klient): merge providers/models/catalog into global.kosong facade Converge three separate facade namespaces (global.providers, global.models, global.catalog) into a single global.kosong facade that exposes two domain concepts: provider (CRUD) and model (read-only view). Add streaming generate() method for direct LLM calls through the facade. - Define ProviderAuth (api-key | oauth), ProviderInput, AnonymousProviderInput, GenerateInput, GenerateParams, GenerateEvent as klient-owned public types - Extend KlientChannel with stream() for AsyncIterable transport - Add streaming IPC protocol (stream/stream_data/stream_end/ stream_error/stream_cancel frame types) - Add StreamingProcedureContract, ScopedStreamCaller, and per-chunk zod validation in the contract layer - Implement generate via dispatcher special-case routing to IModelCatalog.getRequester().request() - Rename events: providers.changed -> kosong.providers.changed, models.changed -> kosong.models.changed, catalog.changed -> kosong.changed - Remove GlobalProvidersFacade, GlobalModelsFacade, GlobalCatalogFacade, and ModelRecord from public exports - Update all tests, examples, and README BREAKING CHANGE: global.providers, global.models, and global.catalog replaced by global.kosong; event names changed; ModelRecord no longer exported. * feat(transcript,kimi-inspect): add tag field to text frames and improve session creation transcript: - add optional `tag` field to TextFrame, textFrameSchema, and HistoryMessage - propagate tag through contextTranscript MutableMessage kimi-inspect: - render tagged frames with violet badge and distinct styling in ChatView - skip cwd prompt for workspace-based session creation in Sidebar - auto-bind default model on new sessions via resolveDefaultModel * refactor(transcript): rename wire/ directory to contract/ The transcript package's REST/WS schemas and event types lived in src/wire/, which collided with the engine's persisted wire.jsonl record vocabulary. Rename it to src/contract/ so "wire" unambiguously refers to wire.jsonl records (foldWireRecordFacts, HistoryWireRecord stay unchanged). - rename src/wire/{schema,events}.ts to src/contract/ - update index exports and test imports accordingly - reword comments: "wire shape" -> "contract shape", "on the wire" -> "in ops" / "in transit" / "on the WS channel" / "transcript API" - events.ts: "transcript frame" -> "transcript event" for WS envelope messages, avoiding confusion with TranscriptFrame - kap-server tests: TranscriptWire/TurnWire/FrameWire/OpsCatchupWire/ UserMessagesWire -> *Contract - update AGENTS.md references * refactor(transcript): rename wire/ directory to contract/ The transcript package's REST/WS schemas and event types lived in src/wire/, which collided with the engine's persisted wire.jsonl record vocabulary. Rename it to src/contract/ so "wire" unambiguously refers to wire.jsonl records (foldWireRecordFacts, HistoryWireRecord stay unchanged). - rename src/wire/{schema,events}.ts to src/contract/ - update index exports and test imports accordingly - reword comments: "wire shape" -> "contract shape", "on the wire" -> "in ops" / "in transit" / "on the WS channel" / "transcript API" - kap-server tests: TranscriptWire/TurnWire/FrameWire/OpsCatchupWire/ UserMessagesWire -> *Contract - update AGENTS.md references * Revert "refactor(agent-core-v2): fold systemReminder domain into contextMemory appendTagged" This reverts commit 55afaa3d96f729c4f73a71f1fbd23d3f6087453b. Restore the systemReminder domain: reminders go back to being baked into message text at write time, and ContextMessage loses the `tag` field (projection-time wrapping is removed with it). * feat(transcript): add wire-equivalent detail, dedupe session events - transcript: add step usage/timing/retry, turn durationMs/error/usage, tool inputText/progress, task resultSummary/error, meta.agent status, a global prompts entity, and the 'hook' marker - kap-server: project the new fields in coreEventMap and suppress transcript-projected session events on connections subscribed to the transcript protocol (live fan-out and cursor replay) - kimi-inspect: mechanical type sync for the new snapshot prompts field * fix(klient): resolve lint errors in ipc channel stream and e2e matrix test	2026-07-22 19:21:56 +08:00
Haozhe	c6291c3ad7	feat(v2-print): align kimi -p run lifecycle with the default engine (#2017) ... * feat(v2-print): align kimi -p run lifecycle with the default engine (13 files) - add applyPrintModeConfigDefaults in agent-core-v2: fill print-mode config defaults (bash task timeout / max steps per turn / subagent timeout all unbounded) into the memory layer, respecting user-set keys - applyPrintBackgroundPolicy: keep the run alive while cron tasks have future fires so their steered turns can run, with an anti-spin guard for wedged ticks; goal/cron waiting shares the steer ceiling budget - default print background mode changed from exit to steer - add task.bashTaskTimeoutS config key and wire it into BashTool's detachTimeoutMs - v2 print runner now forwards turn.step.retrying events to writeRetrying - allow subagent timeoutMs = 0 (no timeout) * test(agent-core-v2): remove duplicate loop config imports in config test	2026-07-22 19:21:39 +08:00
7Sageer	ce0e3ceb04	feat: support custom agent files (#1735) ... * feat: support custom agent files Discover Markdown+frontmatter agent definitions from user, project, and configured directories; merge them into a session-level profile catalog (priority: builtin < user < extra < project < explicit). Custom agents work as subagents via the Agent tool and as the main agent. - agent-core-v2: new agentFileCatalog domain (discovery/parsing/profile factory, mirroring skillRoots/parseFrontmatter) and sessionAgentProfileCatalog merged view; AgentProfile.tools becomes optional (undefined = all tools) and gains disallowedTools deny list, evaluated in profileService.isToolActive and persisted in session wire records so resume keeps the gate even if the file is gone - CLI: restore --agent/--agent-file for the v2 print runner (KIMI_CODE_EXPERIMENTAL_FLAG); the v1 TUI rejects them with a clear v2-only error - kap-server/protocol: optional profile field on prompt submission with first-bind semantics (same-name no-op, different name rejected) - docs: custom agents section (en/zh) + config/CLI references + changeset * chore: shorten custom agents changeset * fix(agent-core-v2): stringify caught errors in agent catalog log calls * docs: drop v2 engine notes from custom agents docs * fix: align custom agent binding semantics across engine and edges - agent-core-v2: bind now owns the first-bind invariant — switching profiles after bind throws profile.already_bound (checked again in the synchronous segment before the first wire dispatch, so concurrent binds cannot both pass); unknown names throw profile.unknown; same-name rebinds keep the persisted thinking effort. - kap-server / CLI: edges degrade to error mapping / same-name no-op instead of their own divergent guards. - agent files: reject non-string mode values, honor disallowedTools in the append-mode Skill probe, pass --agent-file through unresolved so the engine can expand ~, reject empty --agent-file values. - session catalog: ready is recoverable via reload() after a fatal source failure, and agent-file discovery is kicked at session materialize so resumed sessions see file agents from the first turn. - docs: first-bind semantics, name: agent override, tools: [] meaning, --agent-file last-wins. * fix: tighten custom agent behavior * fix: address custom agent review findings * fix(agent-core,agent-core-v2): keep active-tool wire records replayable by v1 Binding a profile without a tool allowlist (the default for file-defined custom agents) persisted a tools.set_active_tools record with no `names` key. v1 clients discover v2 sessions through the shared session index and replay newer wire versions without migration, so the record crashed v1 resume with a TypeError and wedged the session permanently. The v2 engine no longer writes the record when the base set is already "every tool active" (its absence encodes the same state), and v1 replay now skips records that lack `names` as defense in depth for wires already written by preview builds. A same-name rebind that resets an allowlist to "all tools" has no v1-safe encoding and is left as a documented gap (no production caller today); a future tools.reset_active_tools Op is safe because v1 silently no-ops unknown record types. * fix(agent-core-v2): tolerate unreadable directories in agent-file discovery A single unreadable subdirectory (EACCES anywhere in the scanned tree) previously aborted the whole discovery pass, zeroing every agent of that source on every session start with one path-less warning. The walker now skips-and-warns per directory below the root (mirroring the skill discovery it parallels), root-level failures are isolated per root so one bad root no longer takes its siblings down, and only a genuinely transient whole-fs outage (os.fs.unavailable) still propagates so the session catalog keeps its previous contribution. Source-level warnings now name the offending path, and repeated skip warnings are capped with a summary that samples the suppressed paths. Also consolidates the path primitives (~ expansion, base-relative resolution, realpath type probes) shared by the root resolvers, the walker, and the explicit-file source into agentFileCatalog/paths.ts, and tightens parser diagnostics: frontmatter null is treated as absent, and a present-but-wrong-typed name/description reports a type error instead of "missing". * fix(agent-core-v2): warn when a same-name builtin suppresses a file profile A directory-discovered agent file colliding with a builtin profile without override: true was silently dropped at merge time. The suppression now logs a warning naming the profile and the opt-in. * refactor(agent-core-v2): pass skillActive explicitly to renderSystemPrompt The third parameter was a full tool list used only for includes('Skill'), which forced the agent-file profile factory to answer a boolean question with sentinel lists. The template now takes an explicit skillActive flag; a skillActiveFor helper keeps builtin call sites derived from their tool arrays. * refactor(agent-core-v2): fall back to the configured default model in bind BindAgentInput.model is now optional: the engine resolves a missing model against the configured defaultModel and throws model.not_configured when neither is set, so edges no longer each re-implement the fallback. * fix(agent-core-v2,kap-server): reject unsupported thinking atomically at first bind A REST prompt carrying profile + an unsupported thinking effort bound the session first and failed setThinking after, wedging the session on an identity the user never successfully used. The effort is now validated up front when the caller marks it as an explicit request (strictThinking): the bind rejects before any await or state mutation, and the requested effort rides along in the bind instead of a separate setThinking. Internal spawn/fork paths pass inherited thinking without the flag and keep the previous clamp behavior — a persisted effort that drifted out of the model's support list must not break subagent spawning. The route's now-redundant model fallback is dropped in favor of the engine-side default. * fix(agent-core-v2): await the agent profile catalog at session materialize The catalog's ready promise was only kicked, so a resumed session's first turn could render the Agent tool description without the file-defined agent types. Discovery is local-fs and cheap, so materialize now awaits it; ready only rejects for a fatal explicit-source error, which is exactly the case that should fail fast. A failure there now also removes and disposes the half-materialized handle instead of leaving it registered in the session cache. * test: cover the --agent-file fatal path and tidy profile registration hygiene The v2 print CLI now has a test asserting an invalid --agent-file fails before any turn. The denylist profiles in binding.test.ts register in a beforeAll (idempotent, scoped to the describe's run window) instead of at module scope during collection. * docs: align custom agent docs with v2-engine gating --agent/--agent-file are rejected without the v2 engine, so restore the requirement in the Agents and Command Reference pages (and use KIMI_CODE_EXPERIMENTAL_FLAG=1 in the examples), note that tool lists only shape model-visible disclosure (permission rules are the enforcement layer), and remind authors of delegation-bound agents to state the handoff contract in the prompt body. * test(agent-core-v2): revert unrelated style churn in fs/workspace tests Keep these files' diff limited to the realpath fakes the feature needs; the lint-preference rewrites belong to a separate cleanup. * feat(agent-core-v2): add permanent system prompt override via SYSTEM.md Read $KIMI_CODE_HOME/SYSTEM.md on every startup and inject it as the default main-agent profile (name "agent", override: true), replacing the builtin default system prompt while inheriting builtin tools and description. Missing or empty files are ignored; unreadable files warn and fall back to the builtin profile. The body supports variable substitution (${skills}, ${agents_md}, ${cwd}, ${cwd_listing}, ${os}, ${shell}, ${now}); unknown variables pass through verbatim. Priority: --agent-file / --agent / project override > SYSTEM.md > same-name user-scope scan files. * feat(agent-core-v2): gate tools globally and accept session disabledTools Add a [tools] config section: "enabled" acts as a global allowlist (empty = unconstrained), "disabled" as a denylist applied on top, both intersected with the active profile's policy in isToolActive (mcp glob supported). Plumb a session-persistent disabledTools parameter through the stack: v2 RPC PromptPayload, REST "disabled_tools" (protocol and kap-server parallel schemas), klient contract/facade, and node-sdk. The server applies it via profileService.setSessionDisabledTools, which replaces the client-owned denylist, keeps the profile's own deny, persists across resume, and rejects calls before a profile is bound with profile.not_bound (mapped to 40001). v1 core-api gains a type-only field and ignores it. * fix: enforce session tool policy across agents * fix(agent-core-v2): enforce tool policy at execution * fix(agent-core-v2): align subagent tool descriptions with policy * fix(agent-core-v2): harden custom agent policy state * fix(agent-core-v2): harden custom agent lifecycle * refactor(agent-core-v2): persist profile binding in a single profile.bind record * fix(agent-core-v2): skip unreadable paths during agent file discovery * fix(agent-core-v2): exempt select_tools from the executor policy guard - share one composed profile/global/session tool-policy evaluation between the executor gate and prompt rendering instead of two verbatim copies - tolerate context-build failure in system prompt refresh instead of rejecting callers (config watcher void-fire, session policy fan-out) * test(agent-core-v2): resolve profile and tool-policy SUTs by interface - drop the Object.assign patching of tool-policy methods onto the shared profile service; rename describes so the SUT ownership is accurate - classify profile.bind as v2-only with the accepted v1-replay tradeoff documented, un-red the wire vocabulary guard test - cover the select_tools guard exemption with an executor-level test * fix(agent-core-v2): enforce explicit select_tools policy * feat(agent-core-v2): accept Claude-style tool lists and rename agent-file mode to promptMode * feat(agent-core-v2): unify prompt templating on ${var} - Replace the nunjucks renderer with a single ${var} regex renderer (unknown placeholders pass through verbatim) and drop nunjucks from agent-core-v2. - Merge the variable tables into one catalog shared by the builtin system.md, SYSTEM.md, and agent file bodies; adds additional_dirs_info plus code-composed blocks (windows_notes, additional_dirs_section, skills_section). - Replace the agent-file promptMode field with ${base_prompt}: bodies are always rendered as templates, and ${base_prompt} expands to the effective default profile prompt (honoring the SYSTEM.md override). - Migrate the builtin system.md, goal reminders, compaction instruction, and tool description templates to the same syntax. * docs: complete agent priority chain and link SYSTEM.md precedence * test: fix invalid custom agent fixture * fix(cli): reject multiple agent selectors * feat(agent-core-v2): add subagents allowlist to agent files * fix(agent-core-v2): persist the subagent allowlist in the profile binding The delegation allowlist now rides the profile.bind record like the tool denylist, so a resumed session keeps enforcing it even when the source agent file was deleted or changed. Agent/AgentSwarm resolve the caller's allowlist from the persisted binding data instead of looking the profile up in the live catalog. * feat(agent-core-v2): warn on tool patterns that never match Profile bind/apply and [tools] config changes now statically flag entries that can never activate anything — wildcards without the mcp__ prefix (a bare * in an allowlist disables everything, in a denylist nothing), incomplete mcp__ literals, and names no registered or builtin-profile tool has — via a tool-pattern-no-match warning event, once per pattern, instead of letting the tool set silently shrink. The known-name vocabulary is the live registry plus literal names from the builtin profiles, so flag-gated tools stay known and a typo in one agent file cannot legitimize the same typo in another. * docs: align --agent-file docs with the single-selector CLI The flag accepts exactly one file and conflicts with --agent, but the docs still described the earlier repeatable, composable design. * docs: note the agent-file trust model and never-matching tool patterns Spell out that project-scoped agent files can replace the default main agent's whole system prompt (unlike AGENTS.md reference injection), and list the three tool-pattern shapes that never match and now raise a warning. * chore: slim changeset wording to user-facing language Drop wire record names, enforcement mechanics, and template syntax from the entries; split the v1 resume fix into its own patch changeset; add a patch entry for the tool-pattern warnings. * chore: shorten changeset entries to one-line summaries * Delete .changeset/v1-resume-v2-sessions.md Signed-off-by: 7Sageer <12210216@mail.sustech.edu.cn> * test: drop class-instance spread in sessionLifecycle test stub * chore: clear the comments --------- Signed-off-by: 7Sageer <12210216@mail.sustech.edu.cn>	2026-07-21 15:01:43 +08:00
Haozhe	6dd4fd3368	refactor(agent-core-v2): rebuild the model wire layer on the kosong architecture (#1970) ... * refactor(v2): land kosong contract layer (L0 wire contract) * refactor(v2): land kosong protocol layer (L1 traits and base registry) * refactor(v2): land kosong provider layer (bases, trait composers, kimi definition) * refactor(v2): land kosong model and catalog layers * refactor(v2): migrate engine callers to kosong, drop old llmProtocol layer * test(v2): migrate agent-core-v2 tests and harness to kosong * refactor: sync peripheral packages to kosong architecture * refactor(v2): replace provider dialects with per-protocol definitions * refactor(v2): merge the vertexai protocol into google-genai via providerOptions * refactor(v2): remove vendor-name gates outside the kosong layer * feat(v2): add model resolution inspection and connectivity ping * refactor(v2): remove the unused platform config layer * test(klient): pin invalid-input behavior across providers in e2e * refactor(agent-core-v2): merge kimi traits, split bases by protocol - merge the seven kimi trait modules into kimi.contrib.ts as two trait objects: kimiOpenAITrait (all native-transport hooks) and kimiAnthropicTrait (thinking only) - move bases/* implementations into per-protocol directories (openai/, anthropic/, google-genai/) and rename openai.contrib.ts to openai-legacy.contrib.ts - add per-directory index.ts registration barrels (import = registration) and exempt them in check-domain-layers.mjs alongside *.contrib.ts * refactor(agent-core-v2): reorganize model and request-layer types - consolidate shared model types (ModelOverrides, CompletionBudgetConfig/Params, ResolvedModelAuthMaterial, ThinkingDefaults/ModelThinkingMetadata) into kosong/model/model.types.ts and drop modelOverrides.ts - rename L2 request types to the ModelRequest* prefix: LLMEvent -> ModelRequestEvent, LLMRequestInput -> ModelRequestInput, LLMCallParams -> ModelRequestParams - extract ModelRequestTiming to replace three duplicated copies of the stream-timing shape - rename L3 llmRequester types with the Agent prefix to match IAgentLLMRequesterService (AgentLLMRequestOverrides/Finish/Task/Source/ PartHandler/LogFields) - delete the unused LLMRequestParams type * refactor(agent-core-v2): fold kosong/catalog into kosong/model - merge IModelCatalogService's enumeration surface (listModels / listProviders / getProvider / setDefaultModel and the wire shapes) into IModelCatalog; delete kosong/catalog/modelCatalog.ts - move the remote refresh path to the new IProviderDiscoveryService (discovery.ts + discoveryService.ts, renamed from catalog/modelCatalogService.ts) - relocate configSection / errors to discoveryConfigSection.ts / errors.ts; DEFAULT_MODEL_SECTION now lives in kosong/model/model.ts - drop the L3 catalog layer from check-domain-layers.mjs - kap-server routes / refresh scheduler / channelRegistry follow the split; klient renames the contract modelCatalogService to modelResolver and adds providerDiscovery; kimi-inspect reads via IModelCatalog - modelRequesterImpl: drop the streamedAnyPart backfill, onMessagePart already delivers every part - tests: remove the app/modelCatalog and kosong/catalog suites, add the kosong/model catalog and discovery suites * feat(klient): trim trailing undefined args and add boundary smoke probes - add trimTrailingUndefined helper so optional trailing args no longer cross the wire as null in http/ipc transports, which defeated server-side default parameters - add model-requester-boundary smoke probe for ChatProvider error wrapping behavior against real config and a local stub - add kimi-select-tools smoke probe verifying the kimi-only wire encoding of dynamic tool declarations - extend smoke.ts with a models set/get/delete round-trip, catalog list assertions, and update AGENTS.md with the new scripts * fix(agent-core-v2): declare openai chat hooks as function properties Method-shorthand members on OpenAIChatCompletionsHooks tripped typescript-eslint(unbound-method) at every extraction site (`const hook = this._hooks?.convertMessage` and friends), failing the repo-wide lint job. Every implementation is a plain closure composed by openaiHooks.ts, so declare the members as function-typed properties, which matches the actual semantics and clears the four errors. * fix: repair stale references surfaced by the origin/main rebase - agent-core-v2: point vacuousContent's ContentPart import at kosong/contract - kap-server: rewrite the transcript test seed as IModelCatalog (IModelResolver is gone) - klient: inline onceEvent/waitFor after the http transport helpers were dropped - kimi-inspect: remove useLiveEvent from ModelCatalogView; catalog polls on a slow interval * chore: downgrade the kosong architecture changeset to patch	2026-07-21 13:03:54 +08:00
Haozhe	a41a09c33c	feat(cli): replace the kimi server command tree with kimi web and share one home across servers (#1826) ... * feat(kap-server): enable multi-server shared home by default - always register kap-server instances under server/instances and drop the legacy single-instance lock (acquireLock/getLiveLock/ServerLockedError) - remove the multi_server experimental flag and its KIMI_CODE_EXPERIMENTAL_MULTI_SERVER env var from agent-core-v2 - discover running servers via the instance registry in server ps/kill/rotate-token, kimi web daemon reuse, and the desktop app - remove the pending minidb changesets * feat(cli): add per-instance targeting to server kill and ps - `kimi server kill [serverId]` stops only the matching instance; without an id it still stops the longest-running one, and an unknown id errors with the live server ids listed - `kimi server ps` lists connections grouped per server id (`--json` nests them under a per-server object); an unreachable instance degrades to a per-server note instead of failing the whole listing - update the zh/en command reference and the multi-server changeset * feat(cli): replace kimi server with the kimi web command tree - `kimi web` now runs the local server in the foreground and opens the browser; the background daemon (ensureDaemon / spawn / idle-exit) is removed, so repeated runs simply start another instance on the next free port - drop the OS-service lifecycle (install/uninstall/start/stop/restart/ status) together with kap-server's svc layer - `kimi web kill [serverId]`, `kimi web ps`, and `kimi web rotate-token` manage instances from the registry - the TUI /web command now connects to an already-running instance instead of spawning a background daemon - update the zh/en command reference, dev scripts, and tests * feat(cli): route kimi server invocations to a deprecation notice Any `kimi server …` call — bare or with any legacy subcommand/flags — now prints a deprecation notice pointing at `kimi web` and exits 1, instead of failing with an opaque "unknown command". The shim is scheduled for removal in the next major version. * feat(cli): add the `all` keyword to kimi web kill `kimi web kill all` stops every live instance in the registry (ULIDs can never collide with the keyword). Each instance still gets the API shutdown + SIGTERM/SIGKILL treatment; a failure on one instance does not stop the sweep and is reported at the end. * docs(changeset): drop the web-foreground-default changeset The kimi web command tree replaces the foreground-default behavior this entry describes: --background, daemon reuse, and the version-mismatch hint no longer exist, so the pending entry would contradict the actual release notes. * docs(changeset): tighten the multi-server entry wording * feat(cli): let /web pick a running server or start a new one The /web picker now lists the live instances from the registry with their versions (flagging a CLI mismatch) instead of only connecting to the longest-running one, and offers starting a new server: that one runs in the foreground attached to the terminal after the TUI exits, via the restored exit-takeover wiring. formatReadyBanner is exported and adapts its Stop hint to Ctrl+C for the attached case. * feat(cli): skip the /web picker and start a new server when none is running	2026-07-19 11:43:46 +08:00
_Kerman	df75a0f5c2	refactor(agent-core-v2): derive session busy from agent activity (#1751)	2026-07-15 23:33:58 +08:00
_Kerman	27236bd75f	refactor(agent-core-v2): drop the @moonshot-ai/protocol dependency (#1745)	2026-07-15 16:03:19 +08:00
_Kerman	26d499bca7	refactor(agent-core-v2): consolidate wire services (#1680)	2026-07-14 19:51:29 +08:00
_Kerman	3215129860	refactor(agent-core-v2): split agent lifecycle into existence, subagent, and session MCP domains (#1624)	2026-07-14 14:13:41 +08:00
Haozhe	0e1c51cb0e	style(agent-core-v2): remove non-header comments (#1656) ... Enforce the package comment convention that comments live only in the top-of-file block: strip mid-file doc, prose, and trailing comments while preserving header blocks and eslint/oxlint/@ts-* suppression comments. No code tokens are changed.	2026-07-14 10:50:22 +08:00
Haozhe	1c85f94472	feat(agent-core-v2): gate image formats and add media recovery resends (#1626) ... * feat(kap-server): drop WS heartbeat; never terminate idle connections - remove ping interval / pong timeout / socket.terminate() from both the v1 (WsConnectionV1) and v2 (WsConnection) WebSocket connections - v2 protocol: drop pong from the client message schema, remove PingMessage and ReadyMessage.heartbeatMs; the ready frame is now bare { type: 'ready' } - v1 protocol: remove buildPing/PingFrame and ServerHelloPayload.heartbeat_ms; server_hello no longer advertises a heartbeat - drop pingIntervalMs/pongTimeoutMs options from registerWs/registerWsV1 * feat(agent-core-v2): gate image formats and add media-stripped resend - add image-format-policy as the single source of truth for the provider-accepted image MIME set (PNG/JPEG/GIF/WebP), with MIME normalization, data-URL parsing, byte sniffing, and refusal notices - enforce the format gate at every ingestion point: ReadMediaFile refuses unsupported formats with per-OS conversion guidance, MCP tool results and prompt step requests drop them for a text notice, and kap-server prompt routes gate inline, uploaded, and remote-URL images on the sniffed bytes - resend once with every media part replaced by a text marker when the provider rejects an image's format, and keep later steps of the same turn on the media-stripped projection (v1 parity) - commit the WebP decoder wasm as a base64 module for the bundled CLI, with a regenerate script * feat(agent-core-v2): add media-degraded 413 resend and WebP re-encoding - resend once with the media-degraded projection after an HTTP 413 body-size rejection: all but the two most recent media parts are replaced by text markers, and later steps of the turn stay degraded (stripped still wins over degraded) - generalize stripAllMediaParts into degradeOlderMediaParts; the media-stripped resend is now the keepRecent=0 case - re-encode non-animated WebP through the wasm decoder and the PNG/JPEG ladder instead of passing oversized WebP through (animated WebP still passes through whole) - stop lossless PNG rescaling at a 1000px floor and switch to the JPEG ladder below it, so small byte budgets stay readable - add the @jsquash/webp dependency * feat(agent-core-v2): add flag-gated fault injection for recovery testing - add the faultInjection domain: a one-shot arm/take latch that raises a deterministic provider failure (HTTP 413 body-size or image-format 400) before the provider is contacted, so the media-degraded / media-stripped recovery resends can be exercised end-to-end against a real provider - gate arming behind the new fault-injection experimental flag (KIMI_CODE_EXPERIMENTAL_FAULT_INJECTION), off by default - expose IAgentPromptService and IFaultInjectionService over the kap-server /api/v2 RPC channel - add a klient example that drives the REST ingestion gate and both recovery resends against a live server	2026-07-13 22:11:46 +08:00
_Kerman	01dd63207d	refactor(agent-core-v2): consolidate the tool domain into src/tool (#1599)	2026-07-13 17:19:37 +08:00
Haozhe	ceb158dc54	feat(v2): land agent-core-v2 engine and kap-server behind experimental flag (#1441) ... * fix: adapt grep tool to agent-core-v2 * fix(agent-core-v2): enrich PATH from the user's login shell at startup - port probeLoginShellPath/mergeLoginShellPath/applyLoginShellPath into _base/execEnv/loginShellPath.ts as a pure helper (no DI) - export execFileText from environmentProbe for reuse by the probe - run applyLoginShellPathFromNode concurrently with the host probe in HostEnvironmentService, mirroring kaos LocalKaos.create() Aligns agent-core-v2 with kaos 021786f5 so the Bash tool finds user-installed tools (e.g. Homebrew's gh) when kimi-code is launched from a GUI or non-login shell. * fix(agent-core-v2): prefer persisted cwd on resume * feat(agent-core-v2): support structured response formats * fix: restore v2 grep telemetry and tests * fix: preserve v2 compaction boundary * fix(agent-core-v2): align agent and swarm tool behavior * feat(ws-v1): add per-agent event subscription filter - protocol: add optional agent_filter to client_hello and subscribe - kap-server: carry per-subscription agent allowlists through the broadcaster and connection, narrowing live fan-out and replay to selected agents while keeping a single global sequence and bypassing the filter for global events - agent-core-v2: degrade MiniDbQueryStore to a no-op read model when the query-store lock is held by another process instead of crashing the host * feat(web): prefix skill slash commands with skill: to distinguish them from built-in commands (#1492) * ci: release packages (#1468) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * docs(changelog): sync 0.23.2 from apps/kimi-code/CHANGELOG.md (#1496) * chore: add changeset for agent swarm parity * fix: align v2 compaction prompt * fix: recover v2 compaction from plain 413 * fix: report v2 compaction retry telemetry * fix: align MCP discovery and output with v1 * fix: align v2 compaction auth guards * fix: align v2 grep behavior with v1 * chore: remove agent swarm changeset * fix(agent-core-v2): restore task resume parity * feat(agent-core-v2): record llm request traces * fix(agent-core-v2): align AskUserQuestion tool chain with v1 - translate wire ids back to question text / option labels when resolving a question over REST, joining multi-select labels with ', ' - enforce unique question texts / option labels and non-empty strings at both the schema and the execution path - cancel pending questions on turn abort or background task stop by dismissing the parked entry (resolves null, v1 broker semantics) - restore the unsupported-client fallback and dismissed-error handling - pass empty header / option description through verbatim and align the model-facing tool description byte-for-byte with v1 - drop the synthetic expires_at field from the question wire shape * fix(agent-core-v2): preserve compaction hook session * test(agent-core-v2): cover concurrent agent background limit * fix(agent-core): report EXIF-rotated image dimensions and raise edge cap to 3000px (#1460) * fix(agent-core): report EXIF-rotated image dimensions and raise edge cap to 3000px Image compression now reports original dimensions in the decoded (EXIF-rotated) space, matching the coordinate system of the sent image and of ReadMediaFile region readback; previously portrait JPEGs (orientation 5-8) got swapped width/height in captions. The longest-edge downscale cap rises from 2000px to 3000px, and the default jimp resize path is documented as the anti-aliased area-average one so it is not accidentally switched to a point-sampled interpolation mode. * test: shrink oversized image fixtures to fit CI timeouts The 3600x3600 fixtures introduced for the 3000px edge cap nearly doubled the pixel area jimp has to decode and deflate, pushing the slowest compression tests past the 5s vitest timeout on CI runners. 3600x1800 keeps every fixture over the cap while restoring roughly the workload of the old 2600x2600 fixtures that CI handled comfortably. * test: pin anti-aliased downscale quality with executable guards A 1px checkerboard probe pins the compressor to full-coverage averaging at integer and fractional ratios, with jimp's point-sampled BILINEAR mode kept as the executable aliasing counter-example (it collapses the 50%-gray pattern to solid black at 4:1). Also guards the other classic downscale bugs: transparent-pixel color bleed, mean-brightness drift, iterative recompression degradation, and zero-size collapse on extreme aspect ratios. * fix(agent-core): report decoded EXIF-rotated dimensions in ReadMediaFile notes The media note derived its original-dimensions line from the header sniff, which reports pre-rotation values for EXIF orientation 5-8 JPEGs. The sent image and region readback both live in the decoded (rotated) space, so portrait photos got axis-swapped coordinate guidance. Once a decode has happened — compression or crop — its dimensions now overwrite the sniffed ones. * fix(agent-core): improve handling of EXIF orientation in image dimensions and metadata * fix(agent-core): sniff EXIF orientation and step budget fallback through 2000px Two follow-ups to the EXIF and 3000px-cap changes: sniffImageDimensions now reads the JPEG EXIF Orientation tag (pure header parse, both byte orders) and reports display-space dimensions for orientations 5-8. Passthrough images — never decoded — previously kept the pre-rotation header size in compression results and media read notes, disagreeing with the decoded space that region readback uses. encodeWithinBudget steps the over-budget fallback through 2000px before the 1000px last resort. Raising the cap to 3000px had left a regression window: an image whose 2000px encode fits the byte budget was sent at 1000px where the old 2000px cap used to send it at 2000px. * fix(kimi-code): record pasted image dimensions in display space The TUI paste path recorded attachment and original dimensions from its raw header parser, which ignores EXIF orientation. For a portrait JPEG the submit-time caption then contradicted the sent image's aspect and region readback coordinates were axis-swapped. Dimensions now come from the compression result, which reports display space on both the compressed and passthrough paths; parseImageMeta remains only the format/mime gate. * feat(agent-core): add image compression and crop telemetry Every image ingestion path now reports an image_compress event — outcome (compressed / passthrough fast, guard, unsupported, unhelpful, error), input/output formats, byte and pixel sizes, EXIF transposition, and duration — and region readback reports an image_crop event with a failure classification and the region's share of the original area. Wiring is per call site via a new CompressImageOptions.telemetry option, so the outcome split and timing are measured inside the compressor while each caller only names its source: ReadMediaFile (tool construction, like GrepTool), MCP tool results (McpOutputOptions), server prompt ingestion (ICoreProcessService now exposes the host telemetry client), ACP prompts (session track adapter), and TUI paste (host.track adapter). Properties are numeric/enum only — never paths or content — and a throwing client can never affect the compression result. * fix(agent-core): run the full JPEG quality ladder at fallback sizes The fallback rescales encoded only at quality 20, so a JPEG whose ladder failed at the fitted size collapsed straight to the lowest quality even when the smaller size left budget headroom for a higher rung (the realistic window is the 1000px step, where the 4x pixel drop pays for q80/q60). Each fallback edge now walks the same q80-to-q20 ladder as the fitted size. * test: shrink heavy JPEG fixtures and add explicit timeouts The fallback-ladder test runs ~11 pure-JS JPEG encodes and the EXIF paste test decodes, rotates, and re-encodes a 6.5MP frame; both sat at the edge of the 5s vitest timeout on CI runners. Narrower fixtures cut the pixel area (the ladder test keeps its width above 2000px so the full fallback chain still runs) and explicit 15s timeouts absorb runner variance. * fix(server): scope prompt image compression telemetry to the session The prompt-ingestion image_compress events were emitted with the bare host telemetry client, while every agent-side source inherits a session-scoped client — so prompt_inline/prompt_file events could not be correlated with their session. The route now wraps the client with withTelemetryContext({ sessionId }) like rpc/core-impl does for session telemetry. * chore(changeset): consolidate image compression changesets One entry covering the cap raise and the EXIF dimension fix, listed for both the CLI and the SDK so the SDK changelog's compression description (previously pinned at 2000px) stays accurate. * fix: count goal creation turn (#1477) * feat(kosong): support structured response formats (#1397) * fix: clarify goal blocked audit guidance (#1481) * feat(agent-core): discard loaded tool schemas on compaction (#1471) Align progressive tool disclosure with the discard-on-compaction model: compaction no longer rebuilds loaded dynamic tool schemas. The boundary announcement re-lists every loadable name, the model re-selects what it still needs, and a from-memory call to a no-longer-loaded tool is rejected by preflight with select guidance. This removes the keep-all rebuild and its half-trigger budget heuristics entirely: the post-compaction floor is back to users + summary, which is structurally outside the auto-compaction trigger band, and the guard baseline degenerates to summary + reinjected reminders. Every downstream mechanism already treated the empty loaded set as its consistent base state (ledger scan, pending clear at the compaction boundary, deferred extras, preflight wording), so this is a strict simplification. Co-authored-by: fengchenchen <fengchenchen@moonshot.ai> * fix(kimi-code): exit 1 when a headless (-p) turn fails (#1483) Headless (`kimi -p`) failures could exit with code 0 when the event loop drained during the shutdown cleanup (e.g. telemetry's unref'd retry backoff when the network is blocked), because the rejection never reached the process.exit(1) call. Set the failure exit code before any await in both the run-prompt catch and the main catch, and keep the cleanup timeout ref'd so the loop stays alive long enough for the rejection to propagate. * feat(plugins): add Vercel plugin to marketplace (#1489) * feat(web): support Enter key to confirm archive and other dialogs (#1490) * feat(web): redesign cron reminder as a message bubble (#1480) * feat(web): redesign cron reminder as a message bubble Restyle the cron trigger notice as a right-aligned user-style message bubble that shows the scheduled prompt in full (wrapping across lines), with a small meta row beneath it for the schedule, status, job id and run time. Extract a shared MessageTime component used by both user messages and the cron reminder so the timestamp format and click-to-expand behavior stay consistent, and give the CronCreate/CronList/CronDelete tools distinct calendar icons. * refactor(web): render cron reminders only as standalone turns Remove the embedded cron block path from the web transcript projector so cron reminder fires always render through the standalone right-aligned bubble path. * chore(web): simplify cron redesign changeset * fix(web): composer model switch also updates global default model (#1491) * fix(web): composer model switch also updates global default model The composer model switcher still switches the active session's model via POST /sessions/{id}/profile (awaited, so the model pill reflects the result), and additionally fires POST /api/v1/config with { default_model } as a fire-and-forget side effect so new sessions inherit the chosen default. The config request is skipped when the model already matches the current default. * fix(web): route ModelPicker overlay selection through the default-model update The overlay opened from the composer's "More models" row (and /model) is a continuation of the same switch flow, so its selection now also bumps the global default model instead of only switching the active session. * fix(web): only persist the default model after a confirmed session switch setModel now returns whether the switch was accepted (true for the draft path), so the composer flow no longer writes a stale or invalid model alias into the global config when the session-level switch failed and rolled back. * feat(web): prefix skill slash commands with skill: to distinguish them from built-in commands (#1492) * ci: release packages (#1468) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * fix(agent-core-v2): restore native append for Write append mode - add IHostFileSystem.appendText backed by fs.appendFile (O_APPEND) - route WriteTool append through it instead of read-then-rewrite, so existing content is never read, truncated, or clobbered by concurrent writers and a crash mid-append can only lose the new bytes - update typed host-fs test fakes and WriteTool append assertions * fix(agent-core-v2): align task tool prompts with v1 * fix(agent-core-v2): align compaction empty retry * fix(agent-core-v2): restore web search source site and citation reminders - surface source site: add WebSearchResult.siteName, map site_name in the Moonshot provider, and render the Site: line in tool output - restore the per-search inline citation reminder alongside the results - align web-search.md with v1: source-site/result-summary guidance and the static citation reminder * fix(agent-core-v2): route task timeouts through SIGTERM grace + SIGKILL - add terminateWithGrace shared by stop, timeoutMs, detachTimeoutMs, and track deadlines: cancel/SIGTERM -> 5s grace -> forceStop (SIGKILL) - coerce a post-abort self-settled `killed` to `timed_out` so a deadline stays reported as timed_out, matching v1 settlementForOutcome - add manager tests for SIGTERM-ignored escalation, graceful-exit within the grace window, and detachTimeout teardown * fix(agent-core-v2): restore fs.grep streaming early-kill and symlink reporting - stream `rg --json` in fs.grep and SIGKILL once max_total_matches/max_files is reached, restoring v1 early-stop instead of buffering the whole output - report symlinks as kind 'symlink' in fs search/list/stat via lstat and never descend into symlinked directories - remove the unused os grepSearch helper (dead, non-streaming, bypassed ISessionProcessRunner) * test(agent-core-v2): align truncated compaction retry * fix(agent-core-v2): align MCP tool results with v1 * fix(agent-core-v2): align blocked compaction failures * fix(agent-core-v2): align manual compaction tool projection * fix(agent-core-v2): preserve tail in windowed compaction * fix(agent-core-v2): read todos from wire model, sanitize replay - make SessionTodoService a stateless facade over the main agent's TodoModel: getTodos reads wire.getModel(TodoModel) live, setTodos only dispatches a todo.set op, and onDidChange is bridged from wire.subscribe(TodoModel); the in-memory list copy is gone so the live and post-replay views cannot drift - sanitize todo.set payloads in apply via readTodoItems, so replayed or hand-written records cannot poison the model or downstream renders - update todo tests to a sanitizing/notifying/replaying wire stub and cover malformed todo.set replay and main-absent reads - record the main-agent-wire persistence debt for the ISessionWireService move * fix(agent-core-v2): port v1 Bash tool output cap, saved-output reference, and background gating (#1503) * fix: align v2 task observable behavior * fix: v2 full compaction * fix(agent-core-v2): align task wait timeout behavior * chore: webSearch & FetchUrl Sync #1260 * fix: align background agent guidance * fix(agent-core-v2): align full compaction with v1 * fix(agent-core-v2): align v1 wire records * fix(agent-core-v2): remember observed compaction context window * fix: align Agent / AgentSwarm * fix(agent-core-v2): port v1 parity fixes for hooks, anthropic, thinking config and add-dir (#1504) * fix(agent-core-v2): hide console window when running hooks on Windows Port the v1 hooks runner fix: extract buildHookSpawnOptions and pass windowsHide:true so hook child processes no longer flash a console window on Windows, mirroring the node-local process host defaults. Includes the same regression tests as v1. * fix(agent-core-v2): port anthropic max_tokens ceiling and override fixes Port two v1 kosong fixes to the v2 anthropic provider: - Fall back to the nearest lower catalogued minor when resolving the Claude output ceiling, and catalogue Opus 4.8's documented 128k cap, so an uncatalogued minor no longer drops to the family baseline. - Treat an explicit defaultMaxTokens as the final max_tokens value instead of clamping it to the built-in ceiling. Mirrors the v1 regression tests in a new anthropic-max-tokens test file. * refactor(agent-core-v2): converge thinking config to enabled/effort Port the v1 thinking-config overhaul (#1132's config side) to v2: - ThinkingConfigSchema becomes { enabled, effort, keep }; the mode enum, the separate defaultThinking section, and the KIMI_MODEL_THINKING_MODE / KIMI_MODEL_DEFAULT_THINKING env bindings are removed. - The effort resolver drops the mode/defaultThinking branches and no longer normalizes a requested 'on' to a concrete effort in core; 'on' is taken verbatim and normalization stays at the UI boundary. - OAuth login/refresh and catalog refresh now persist the thinking.enabled value computed by the shared oauth apply/restore logic instead of dropping it and writing the removed default_thinking key, so [thinking] enabled = false actually disables thinking and the login default survives on disk. Mirrors the v1 resolver regression tests and adds a persistence regression for the refresh path. * docs(agent-core-v2): fix stale loop-event comments after wire parity The v1.4 wire-parity alignment switched the v2 live loop to stream turns as context.append_loop_event records, but three comments still described the old world (restore-only Op, "v2 never emits loop events"). Update them to match the actual write path: non-loop appends use append_message, the loop persists loop events byte-compatible with v1, and the fold runs both at live dispatch time and on replay. * fix(agent-core-v2): load workspace additional dirs on session create and resume The /add-dir command persisted remembered dirs to .kimi-code/local.toml, but session materialization never read them back and offered no caller additionalDirs entry point — a remembered dir silently stopped applying to new, resumed, and forked sessions. Mirror v1's createSession/resumeSession: merge the project-local local.toml dirs with caller-supplied additionalDirs (relative paths resolve against workDir) and seed the session workspace context in materializeSession, so create/resume/fork all pick them up. A broken local.toml fails the create loudly with CONFIG_INVALID, same as v1. Tests mirror v1's runtime coverage for the load/merge/dedupe/resume/fork scenarios. * fix(kimi-code): forward create-session additional dirs from the v2 harness The in-process v2 print-mode harness dropped the SDK CreateSessionOptions additionalDirs when calling ISessionLifecycleService.create, so --add-dir never reached the v2 resolver. Pass it through. * fix(agent-core-v2): align full compaction observability * fix(agent-core-v2): remove compact hook trigger state * feat(agent-core-v2): enhance agent lifecycle with context size tracking and concurrency checks * fix(agent-core-v2): align media reads with v1 note channel and EXIF handling (#1505) * fix(agent-core-v2): align media reads with v1 note channel and EXIF handling Port two agent-core changes into agent-core-v2: - Move the ReadMediaFile media summary from an inline <system> text part onto the tool result's note side channel, so raw <system> markup never renders in UIs (matching the MCP output path). - Report image dimensions in the decoded EXIF-rotated space: the header sniff now reads the JPEG Orientation tag, and once a decode happened (compression or crop) its dimensions overwrite the sniffed ones, so portrait photos no longer get axis-swapped coordinate guidance. - Raise the longest-edge downscale cap from 2000px to 3000px, step the over-budget fallback through 2000px before the 1000px last resort, and run the full JPEG quality ladder at fallback sizes. - Report image_compress / image_crop telemetry for media reads (source read_media), with EXIF transposition and crop failure classification. The tool description also regains the downsampling recovery guidance (region / full_resolution readback) that the v2 copy predated. * fix(agent-core-v2): align v1 wire records * fix(agent-core-v2): hide compression captions and register media tools in production Port the remaining v1 media gaps into agent-core-v2: - Reroute inline image-compression captions out of user messages: the prompt service splits them at the append chokepoint (prompt and steer flush) and delivers them through the built-in system-reminder injection (origin {kind: 'injection', variant: 'image_compression'}), which every UI hides. Session titles/lastPrompt strip the caption the same way. The model still receives the full note. - Register ReadMediaFile in production: media tools cannot use the module-level contribution table (capabilities are unknown until a model binds), so a new Eager agent-scope registrar re-runs registerMediaTools on every agent.status.updated where the model alias or its media capabilities changed, rebinding the video uploader and dropping the tool when the model loses media input. * fix(agent-core-v2): port v1 parity fixes for hooks, anthropic, thinking config and add-dir (#1504) * fix(agent-core-v2): hide console window when running hooks on Windows Port the v1 hooks runner fix: extract buildHookSpawnOptions and pass windowsHide:true so hook child processes no longer flash a console window on Windows, mirroring the node-local process host defaults. Includes the same regression tests as v1. * fix(agent-core-v2): port anthropic max_tokens ceiling and override fixes Port two v1 kosong fixes to the v2 anthropic provider: - Fall back to the nearest lower catalogued minor when resolving the Claude output ceiling, and catalogue Opus 4.8's documented 128k cap, so an uncatalogued minor no longer drops to the family baseline. - Treat an explicit defaultMaxTokens as the final max_tokens value instead of clamping it to the built-in ceiling. Mirrors the v1 regression tests in a new anthropic-max-tokens test file. * refactor(agent-core-v2): converge thinking config to enabled/effort Port the v1 thinking-config overhaul (#1132's config side) to v2: - ThinkingConfigSchema becomes { enabled, effort, keep }; the mode enum, the separate defaultThinking section, and the KIMI_MODEL_THINKING_MODE / KIMI_MODEL_DEFAULT_THINKING env bindings are removed. - The effort resolver drops the mode/defaultThinking branches and no longer normalizes a requested 'on' to a concrete effort in core; 'on' is taken verbatim and normalization stays at the UI boundary. - OAuth login/refresh and catalog refresh now persist the thinking.enabled value computed by the shared oauth apply/restore logic instead of dropping it and writing the removed default_thinking key, so [thinking] enabled = false actually disables thinking and the login default survives on disk. Mirrors the v1 resolver regression tests and adds a persistence regression for the refresh path. * docs(agent-core-v2): fix stale loop-event comments after wire parity The v1.4 wire-parity alignment switched the v2 live loop to stream turns as context.append_loop_event records, but three comments still described the old world (restore-only Op, "v2 never emits loop events"). Update them to match the actual write path: non-loop appends use append_message, the loop persists loop events byte-compatible with v1, and the fold runs both at live dispatch time and on replay. * fix(agent-core-v2): load workspace additional dirs on session create and resume The /add-dir command persisted remembered dirs to .kimi-code/local.toml, but session materialization never read them back and offered no caller additionalDirs entry point — a remembered dir silently stopped applying to new, resumed, and forked sessions. Mirror v1's createSession/resumeSession: merge the project-local local.toml dirs with caller-supplied additionalDirs (relative paths resolve against workDir) and seed the session workspace context in materializeSession, so create/resume/fork all pick them up. A broken local.toml fails the create loudly with CONFIG_INVALID, same as v1. Tests mirror v1's runtime coverage for the load/merge/dedupe/resume/fork scenarios. * fix(kimi-code): forward create-session additional dirs from the v2 harness The in-process v2 print-mode harness dropped the SDK CreateSessionOptions additionalDirs when calling ISessionLifecycleService.create, so --add-dir never reached the v2 resolver. Pass it through. * fix(agent-core-v2): report video_upload telemetry for media reads Port the v1 video-upload telemetry wrapper into createVideoUploader: every upload emits a video_upload event with outcome (success/error), byte size, mime type, duration, and the caller's static props (model alias, protocol tags), and a throwing telemetry client never affects the upload outcome. The media-tools registrar supplies the sink and props from the bound model. Also restores two v1 rationale comments in ReadMediaFile (original-size reporting and the full_resolution hard refusal) that were dropped during the earlier port. --------- Co-authored-by: 7Sageer <7sageer@djwcb.cn> Co-authored-by: liruifengv <liruifeng1024@gmail.com> * refactor(agent-core-v2): remove the microCompaction domain - delete the microCompaction domain (service, wire model/op, config section, experimental flag) and its dedicated tests - stop truncating old tool results in the context projector and drop the projector's now-unused instantiation dependency - remove the domain from the layer map, package exports, and the DI x Scope dependency diagram - retarget the flag-registry test and skill examples at a neutral flag * fix(contextProjector): surface projection repairs via log warning - add ProjectionAnomaly + onAnomaly sink through the project / projectStrict passes (reorder, synthesize, orphan / duplicate drop, leading drop, merge, blank-text drop) so the pure projection reports every wire-repair it applies - AgentContextProjectorService injects ILogService and emits a single signature-deduped 'repaired the request to keep it wire-valid' warning, excluding trailing-tail synthesis, matching agent-core parity - cover the trace and its dedup in the projector tests * fix(agent-core-v2): fix cron killswitch, lost deliveries, id clashes - killswitch: read KIMI_DISABLE_CRON live by re-applying the ConfigService env overlay on every get(); CronCreate reads it via ISessionCronService instead of a value frozen at tool registration - delivery: resolve fire delivery on promptService.steer().launched so a rejected launch retains one-shot tasks for retry instead of deleting them; tick() is now async and awaits delivery before advancing cursors - ids: switch cron task ids to ULIDs (from 32-bit hex) so two sessions sharing a workspace cannot overwrite each other's persisted task; CronDelete and persistence accept both ULID and legacy 8-hex ids - display: CronCreate reports nextFireAt through the service so it honors KIMI_CRON_NO_JITTER and matches the scheduler and CronList - migration: adopt shape-valid tasks with no sessionId tag on loadFromStore and stamp the tag back to disk - persistence: create cron directories 0700 and files 0600 via FileStorageService dirMode/fileMode Gate SessionCronService startup on config.ready and resolve clocks after ready so config is never read before it is loaded; start() is now async. * feat(fs-watch): add workspace fs watch with v1-compatible WS delivery - os layer: add IHostFsWatchService over chokidar (raw create/modify/delete, .git ignored) - session layer: add ISessionFsWatchService, a workspace-confined, debounced, .gitignore-aware FsChangeEvent feed - kap-server: add FsWatchBridge pushing event.fs.changed over /api/v1/ws (watch_fs_add/remove, volatile, per-connection filter), byte-compatible with v1 - tests: os/session unit tests and kap-server fs-watch e2e * refactor(agent-core-v2): run external hooks through IHostProcessService - inject IHostProcessService into ExternalHooksRunnerService and thread it through runMatchedHooks to runHook instead of spawning node:child_process - route hook termination through the service's cross-platform process-tree kill - settle on the exit code plus drained stdout/stderr so fast-exiting hooks keep their trailing output - hide the child console window on Windows via the service default - update externalHooks tests for the new dependency * fix(agent-core-v2): strict-decode Edit reads, align with v1 - read the Edit target with errors:'strict' so a non-UTF-8 file fails the edit instead of being silently rewritten as U+FFFD (matches v1 kaos) - declare readWriteFile access since Edit reads before it writes, matching v1 - render edit.md directly instead of through renderPrompt: it has no template vars, and raw avoids treating literal {{ }} as a template - restore the replace_all usage example in edit.md (v1 #1102) - add a regression test asserting a non-UTF-8 file fails the edit and keeps its bytes untouched * fix(agent-core-v2): dedupe AgentMeta legacy field declarations * refactor(agent-core-v2): persist wire records natively in the v1 vocabulary Remove the persist-time v1 rewrite layer (serializeV1WireRecord): ops now write v1-shaped records directly, live-only state is declared persist:false on the op instead of being stripped at write time, and the swarm-exit reminder pop replays from the swarm_mode.exit record via a cross-model reducer. Fixes resumed sessions losing the todo list, drifting turn counters after retries, and removed reminders reappearing on resume. * refactor(agent-core-v2): move ReadTool status block to note side channel - ReadTool.finishReadResult now returns rendered lines as `output` only and rides the `<system>` status block on the model-only `note` side channel - drop the finishOutput helper that concatenated content and status - update read.test.ts expectations to assert `note` separately from `output` * refactor(agent-core-v2): split blob service helpers, rewrite tests - extract rewriteMediaUrls and blobref parse/format helpers to dedupe URL rewriting - move the byte-bounded LRU cache into a module-private ByteLruCache with focused unit tests, dropping the protected maxCacheSize test seam - rewrite blob service tests against the contract on in-memory storage, removing cache-internals cases * fix: make release-e2e scenarios pass under agent-core-v2 Three independent fixes for release-e2e failures that only appeared with the experimental v2 engine (KIMI_CODE_EXPERIMENTAL_FLAG): - agent-core-v2: register the KIMI_MODEL env overlay statically so it takes effect even when ModelService is not instantiated (the DI layer does not auto-instantiate Eager services). Fixes wire-llm-request-trace. - cli: omit the leading system.version meta line in stream-json prompt mode so the role sequence stays clean. Fixes stream-json-cron. - agent-core-v2: honor --skills-dir via a new explicit skill source seeded from the host. Fixes interactive-skills-dir. Cherry-picked from 2a7232737 (v2-migration), excluding the node-sdk V2Host change (not applicable on this branch). * refactor(agent-core-v2): drop replay-only wire ops Remove the three replay-only Ops that were kept for pre-alignment / 1.5 sessions, now that v2 persists natively in the v1 vocabulary: - turn.launch (replaced by turn.prompt) - todo.set (replaced by tools.update_store with key 'todo') - context.splice (replaced by context.append_message / append_loop_event) Also drop the dead code that handled them (transcript reducer, task-origin extraction, blob dehydration, harness helpers) and migrate the affected tests to the v1 record types. The live write path already emitted only v1 records, so wire.jsonl output is unchanged. * Revert "fix: make release-e2e scenarios pass under agent-core-v2" This reverts commit ec9dae72ab. * fix(agent-core-v2): use a fresh TextDecoder per append-log read The module-level TextDecoder is stateful in stream mode: it buffers a trailing incomplete multi-byte sequence until the next decode. Sharing it across reads let leftover state from an earlier read that returned early (e.g. ensureWireMetadata bailing on the leading metadata record) leak into the next read and prepend a U+FFFD to its first line, corrupting the metadata envelope and breaking session fork with "corrupted line 1". Give each read its own TextDecoder so decoder state never leaks between reads. * fix(agent-core-v2): register KIMI_MODEL env overlay statically The KIMI_MODEL_* effective overlay was registered by ModelService on construction, but the DI layer does not auto-instantiate Eager services, so the overlay never took effect when nothing resolved IModelService. This broke the release-e2e wire-llm-request-trace scenario, where KIMI_MODEL_NAME must synthesize the env model and its thinking capability. Move registration to module load via a new configOverlayContributions collector, drained by ConfigRegistry on construction — mirroring the existing configSectionContributions pattern. ModelService no longer depends on IConfigRegistry. * docs(agent-core-v2): clarify live-only op semantics * fix(agent-core-v2): preserve oversized tool results * chore: remove full compaction complete data type * fix(agent-core-v2): align foreground output cap * fix(agent-core-v2): gate skill prompt injection * chore(skills): bundle review and test lenses into kc-review - add agent-core-review umbrella skill with slop and test sub-skills - move write-tests rules into agent-core-review/test and drop the standalone skill * feat(v2): auto-mint session ids and harden print-mode background drain - make CreateSessionOptions.sessionId optional; SessionLifecycleService.create and fork now mint `session_<lowercase-uuid>` via a shared createSessionId helper, so edge layers stop minting their own ids (drop randomUUID in the v2 harness, ulid in kap-server) - rework V2Session.waitForBackgroundTasksOnPrint to re-enumerate each round, suppress terminal notifications while waiting, and bound the drain by [task].print_wait_ceiling_s (default 1h) instead of a hardcoded 30s cap, so kimi -p can run long tasks to completion without being steered into a new turn - add v2-session unit tests; seed session/agent/bootstrap context in the tool-dedupe harness for the real executor * fix(agent-core-v2): refresh system prompt after compaction * docs(agent-core-review): limit kc-review skill to agent-core-v2 Clarify that the kc-review lenses apply only to packages/agent-core-v2 (the DI x Scope engine), not to the legacy packages/agent-core or other packages. * fix(agent-core-v2): align model-facing prompts * fix(agent-core): report EXIF-rotated image dimensions and raise edge cap to 3000px (#1460) * fix(agent-core): report EXIF-rotated image dimensions and raise edge cap to 3000px Image compression now reports original dimensions in the decoded (EXIF-rotated) space, matching the coordinate system of the sent image and of ReadMediaFile region readback; previously portrait JPEGs (orientation 5-8) got swapped width/height in captions. The longest-edge downscale cap rises from 2000px to 3000px, and the default jimp resize path is documented as the anti-aliased area-average one so it is not accidentally switched to a point-sampled interpolation mode. * test: shrink oversized image fixtures to fit CI timeouts The 3600x3600 fixtures introduced for the 3000px edge cap nearly doubled the pixel area jimp has to decode and deflate, pushing the slowest compression tests past the 5s vitest timeout on CI runners. 3600x1800 keeps every fixture over the cap while restoring roughly the workload of the old 2600x2600 fixtures that CI handled comfortably. * test: pin anti-aliased downscale quality with executable guards A 1px checkerboard probe pins the compressor to full-coverage averaging at integer and fractional ratios, with jimp's point-sampled BILINEAR mode kept as the executable aliasing counter-example (it collapses the 50%-gray pattern to solid black at 4:1). Also guards the other classic downscale bugs: transparent-pixel color bleed, mean-brightness drift, iterative recompression degradation, and zero-size collapse on extreme aspect ratios. * fix(agent-core): report decoded EXIF-rotated dimensions in ReadMediaFile notes The media note derived its original-dimensions line from the header sniff, which reports pre-rotation values for EXIF orientation 5-8 JPEGs. The sent image and region readback both live in the decoded (rotated) space, so portrait photos got axis-swapped coordinate guidance. Once a decode has happened — compression or crop — its dimensions now overwrite the sniffed ones. * fix(agent-core): improve handling of EXIF orientation in image dimensions and metadata * fix(agent-core): sniff EXIF orientation and step budget fallback through 2000px Two follow-ups to the EXIF and 3000px-cap changes: sniffImageDimensions now reads the JPEG EXIF Orientation tag (pure header parse, both byte orders) and reports display-space dimensions for orientations 5-8. Passthrough images — never decoded — previously kept the pre-rotation header size in compression results and media read notes, disagreeing with the decoded space that region readback uses. encodeWithinBudget steps the over-budget fallback through 2000px before the 1000px last resort. Raising the cap to 3000px had left a regression window: an image whose 2000px encode fits the byte budget was sent at 1000px where the old 2000px cap used to send it at 2000px. * fix(kimi-code): record pasted image dimensions in display space The TUI paste path recorded attachment and original dimensions from its raw header parser, which ignores EXIF orientation. For a portrait JPEG the submit-time caption then contradicted the sent image's aspect and region readback coordinates were axis-swapped. Dimensions now come from the compression result, which reports display space on both the compressed and passthrough paths; parseImageMeta remains only the format/mime gate. * feat(agent-core): add image compression and crop telemetry Every image ingestion path now reports an image_compress event — outcome (compressed / passthrough fast, guard, unsupported, unhelpful, error), input/output formats, byte and pixel sizes, EXIF transposition, and duration — and region readback reports an image_crop event with a failure classification and the region's share of the original area. Wiring is per call site via a new CompressImageOptions.telemetry option, so the outcome split and timing are measured inside the compressor while each caller only names its source: ReadMediaFile (tool construction, like GrepTool), MCP tool results (McpOutputOptions), server prompt ingestion (ICoreProcessService now exposes the host telemetry client), ACP prompts (session track adapter), and TUI paste (host.track adapter). Properties are numeric/enum only — never paths or content — and a throwing client can never affect the compression result. * fix(agent-core): run the full JPEG quality ladder at fallback sizes The fallback rescales encoded only at quality 20, so a JPEG whose ladder failed at the fitted size collapsed straight to the lowest quality even when the smaller size left budget headroom for a higher rung (the realistic window is the 1000px step, where the 4x pixel drop pays for q80/q60). Each fallback edge now walks the same q80-to-q20 ladder as the fitted size. * test: shrink heavy JPEG fixtures and add explicit timeouts The fallback-ladder test runs ~11 pure-JS JPEG encodes and the EXIF paste test decodes, rotates, and re-encodes a 6.5MP frame; both sat at the edge of the 5s vitest timeout on CI runners. Narrower fixtures cut the pixel area (the ladder test keeps its width above 2000px so the full fallback chain still runs) and explicit 15s timeouts absorb runner variance. * fix(server): scope prompt image compression telemetry to the session The prompt-ingestion image_compress events were emitted with the bare host telemetry client, while every agent-side source inherits a session-scoped client — so prompt_inline/prompt_file events could not be correlated with their session. The route now wraps the client with withTelemetryContext({ sessionId }) like rpc/core-impl does for session telemetry. * chore(changeset): consolidate image compression changesets One entry covering the cap raise and the EXIF dimension fix, listed for both the CLI and the SDK so the SDK changelog's compression description (previously pinned at 2000px) stays accurate. * fix: count goal creation turn (#1477) * feat(kosong): support structured response formats (#1397) * fix: clarify goal blocked audit guidance (#1481) * feat(agent-core): discard loaded tool schemas on compaction (#1471) Align progressive tool disclosure with the discard-on-compaction model: compaction no longer rebuilds loaded dynamic tool schemas. The boundary announcement re-lists every loadable name, the model re-selects what it still needs, and a from-memory call to a no-longer-loaded tool is rejected by preflight with select guidance. This removes the keep-all rebuild and its half-trigger budget heuristics entirely: the post-compaction floor is back to users + summary, which is structurally outside the auto-compaction trigger band, and the guard baseline degenerates to summary + reinjected reminders. Every downstream mechanism already treated the empty loaded set as its consistent base state (ledger scan, pending clear at the compaction boundary, deferred extras, preflight wording), so this is a strict simplification. Co-authored-by: fengchenchen <fengchenchen@moonshot.ai> * fix(kimi-code): exit 1 when a headless (-p) turn fails (#1483) Headless (`kimi -p`) failures could exit with code 0 when the event loop drained during the shutdown cleanup (e.g. telemetry's unref'd retry backoff when the network is blocked), because the rejection never reached the process.exit(1) call. Set the failure exit code before any await in both the run-prompt catch and the main catch, and keep the cleanup timeout ref'd so the loop stays alive long enough for the rejection to propagate. * feat(plugins): add Vercel plugin to marketplace (#1489) * feat(web): support Enter key to confirm archive and other dialogs (#1490) * feat(web): redesign cron reminder as a message bubble (#1480) * feat(web): redesign cron reminder as a message bubble Restyle the cron trigger notice as a right-aligned user-style message bubble that shows the scheduled prompt in full (wrapping across lines), with a small meta row beneath it for the schedule, status, job id and run time. Extract a shared MessageTime component used by both user messages and the cron reminder so the timestamp format and click-to-expand behavior stay consistent, and give the CronCreate/CronList/CronDelete tools distinct calendar icons. * refactor(web): render cron reminders only as standalone turns Remove the embedded cron block path from the web transcript projector so cron reminder fires always render through the standalone right-aligned bubble path. * chore(web): simplify cron redesign changeset * fix(web): composer model switch also updates global default model (#1491) * fix(web): composer model switch also updates global default model The composer model switcher still switches the active session's model via POST /sessions/{id}/profile (awaited, so the model pill reflects the result), and additionally fires POST /api/v1/config with { default_model } as a fire-and-forget side effect so new sessions inherit the chosen default. The config request is skipped when the model already matches the current default. * fix(web): route ModelPicker overlay selection through the default-model update The overlay opened from the composer's "More models" row (and /model) is a continuation of the same switch flow, so its selection now also bumps the global default model instead of only switching the active session. * fix(web): only persist the default model after a confirmed session switch setModel now returns whether the switch was accepted (true for the draft path), so the composer flow no longer writes a stale or invalid model alias into the global config when the session-level switch failed and rolled back. * feat(web): prefix skill slash commands with skill: to distinguish them from built-in commands (#1492) * ci: release packages (#1468) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * fix: surface provider auth error for unavailable models (#1506) * fix: surface provider auth error for unavailable models When an OAuth-managed model returns 401 after a forced token refresh, the token is valid but the provider rejected it for that model (the account lacks access). Emit provider.auth_error carrying the provider's message instead of auth.login_required with a misleading "OAuth login expired. Send /login" prompt. * fix(agent-core): preserve provider auth errors through compaction Treat provider.auth_error like auth.login_required in the compaction path so an auth rejection during compaction surfaces the provider's message instead of being wrapped as a generic compaction failure. * ci: release packages (#1507) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * docs(changelog): sync 0.23.3 and shorten OAuth error entry (#1509) * feat(kimi-web): add status-aware browser notifications (#1479) * feat(kimi-web): add approval notification storage key and i18n copy * feat(kimi-web): add approval notification helpers and tests * feat(kimi-web): wire approval notifications and guard completion alerts * fix(kimi-web): extract shouldNotifyCompletion helper and add tests * feat(kimi-web): add approval notification settings toggle * chore(kimi-web): add changeset and tidy notification module comment - Align approval notification tag with spec (kimi-approval-${approvalId}) - Update module header to describe all three notification kinds * fix(kimi-web): make notifications fire reliably - Key completion notification tags by turn (sid + promptId) and question tags by request id, so a stale notification left in the notification center no longer swallows every follow-up alert in the same session - Suppress notifications only while the window is actually focused, not merely visible (document.hasFocus() on top of visibilityState) - Play the attention sound when a tool needs approval, matching the completion and question sounds * chore(kimi-web): simplify changeset * fix(agent-core-v2): serialize concurrent model catalog refreshes Port v1 #1207's _refreshChain so a scheduled refresh and a manual one (or two overlapping manual ones) never race on reading/patching the persisted config. Applied to both refresh entry points: ModelCatalogService.refreshProviderModels (scheduler + all/single-provider) and OAuthService.refreshOAuthProviderModels (OAuth-only, a separate service in v2). * fix(agent-core-v2): dedupe workspace registry entries by root Port v1 #1221: collapse registered workspaces that share a root in list(), preferring the entry whose id matches the current canonical encodeWorkDirKey, so a legacy workspaces.json (v1-compatible) does not render the same folder twice through GET /workspaces. * fix(agent-core-v2): apply KIMI_CODE_CUSTOM_HEADERS and host identity headers Port v1's provider-manager outbound header logic to agent-core-v2 so `KIMI_CODE_CUSTOM_HEADERS` and host identity headers are applied to outbound LLM requests, closing the migration gap from #1186: - env `KIMI_CODE_CUSTOM_HEADERS` is the lowest-precedence header layer; - host identity headers (User-Agent + X-Msh-*) are sent for Kimi providers, only the User-Agent for every other provider — a Kimi provider routed through the Anthropic protocol still gets the full set, matching v1; - provider `customHeaders` always win on conflict. Host headers are seeded by the CLI via `createKimiDefaultHeaders` and a new `IHostRequestHeaders` App-scope token (defaulting to empty), so the model resolver can layer them without the host threading them through every call site. * chore(agent-core-review): rename skill from kc-review to agent-core-review * feat(kap-server): surface originating stack trace on error envelopes - add optional `stack` field to errEnvelope and the envelope schema/interface; omitted when undefined so the wire shape stays byte-identical for callers without a stack - thread `err.stack` through route error mappers plus the global and transport error handlers - preserve `details` on `session.undo_unavailable` while adding its stack - update tests to assert stacks are surfaced, reversing the prior no-leak contract * fix: align v2 media and task compaction handling * feat(agent-core-v2): sync shell mode and skill config parity (#1514) * feat(agent-core-v2): record shell command context - add ShellCommandOrigin and compaction handoff disposition - extract IAgentShellCommandService from AgentRPCService - keep AgentRPCService as a thin shell:run facade * fix(agent-core-v2): align skill priority and sync docs - restore project > user > plugin > builtin skill precedence - sync Skill tool description and parameter docs from v1 - update write-goal and custom-theme builtin skill copy * fix(agent-core-v2): restore undo and thinking telemetry - track conversation_undo after undoHistory - emit thinking_toggle with enabled/effort/from payload - add coverage for both telemetry events * feat(agent-core-v2): add skill directory config - add extraSkillDirs and mergeAllAvailableSkills config sections - introduce extra skill source and shared source priorities - align kap-server workspace skill preview with session catalog * feat(agent-core-v2): support explicit skill dirs - add ISkillCatalogRuntimeOptions for SDK-style explicit skill dirs - suppress default user/project discovery when explicitDirs are set - resolve explicit dirs per session workDir via explicitFileSkillSource * fix(agent-core-v2): fix configured skill dir resolution - expand ~ using OS home for configured skill dirs - honor explicitDirs in kap-server workspace skill preview * fix(agent-core-v2): await config ready before skill discovery - wait for config.ready before reading extraSkillDirs - wait for config.ready before reading mergeAllAvailableSkills - cover extra skill dir loading behind config readiness * fix(agent-core-v2): keep skill config live after changes - await config.ready in kap-server workspace skill preview - reload user and workspace skill sources when mergeAllAvailableSkills changes * fix(agent-core-v2): align goal budget handling * fix(agent-core-v2): forbid model goal pauses * fix(agent-core-v2): cap detached process output * fix(kimi-code): drain v2 print subagents before exit * fix: restore kap-server video upload compatibility * fix(agent-core-v2): charge only output tokens against goal token budgets Goal parity gap G2: v1 charges only per-step output tokens against a goal's tokenBudget, while v2 summed all four usage buckets (cache read, cache creation, other input, output), exhausting budgets orders of magnitude faster under prompt caching and skewing persisted tokensUsed counters. Align goal token accounting to output-only and drop the unused tokenUsageTotal helper. * fix: align server-v2 media file handling * feat(agent-core-v2): allow coder profile to use MCP tools * refactor(agent-core): introduce activity kernel and migrate turn lane - add `activity` domain: `IAgentActivityService` (Agent turn lane machine), `ISessionActivityKernel` (Session admission, PR1 placeholder), and the `ActivityLease` that owns the turn `AbortSignal` - turnService launches and cancels through the kernel lease; `Turn` now exposes `signal` instead of `abortController` - agentLifecycle.remove drives `beginDisposal`/`settled` and waits for the in-flight turn to drain before releasing the agent scope - add `activity.*` error codes; deprecate `turn.agent_busy` in favor of `activity.agent_busy` * refactor(sessionLegacy): remove fork/compact/abort/archive pass-throughs These four legacy session actions were thin delegations to the native v2 services (ISessionLifecycleService.fork/archive, IAgentFullCompactionService.begin, IAgentRPCService.cancel) with no v1-only projection to centralize. Drop them from ISessionLegacyService and call the native services directly from the kap-server sessions route. updateProfile, createChild, listChildren, undo and status stay in the adapter since they carry real v1 adaptation logic. * refactor(cli): run print-mode v2 on native agent-core-v2 services - add native v2 print runner (v2/run-v2-print.ts) that consumes agent-core-v2 DI services and awaits Turn.result directly - extract shared print-mode rendering into prompt-render.ts for v1 and v2 - remove the V2PromptHarness/V2Session shim and v2->v1 event translation - decouple initializeCliTelemetry from PromptHarness (homeDir/auth/track) - add IAgentPromptLegacyService.submitAndSettle for authoritative completion * refactor(session): serve v1 undo and children via native v2 services - make IAgentPromptService.undo throw session.undo_unavailable with a structured reason; move the precheck into contextMemory - add ISessionLifecycleService.createChild (fork + child markers) and ISessionIndex.list({ childOf }) - slim ISessionLegacyService to updateProfile/status (drop createChild, listChildren, undo) - rewire kap-server session routes to the native services and map SESSION_UNDO_UNAVAILABLE * refactor(cli): drop v1 sdk and telemetry deps from v2 print - run-v2-print: use core ITelemetryService + CloudAppender instead of kimi-telemetry; remove kimi-code-sdk import (auth via IOAuthToolkit, config path from bootstrap, hook result via structural type) - prompt-render: replace SDK HookResultEvent with a structural type so the shared renderer does not depend on the v1 SDK event shape - telemetry: revert initializeCliTelemetry to its original signature now that v2 no longer calls it; keep v1 callers and assertions untouched - update run-prompt and v2-run-print tests for the new wiring * feat(activity): add session lane machine and agent snapshot projector - implement SessionActivityKernel lane machine (restoring→active⇄quiescing→closing→disposed) with admission table, atomic quiesce+drain, beginClosing/settled, markActive - start AgentActivityService lane at initializing; add markReady driven by agentLifecycle.create after bootstrap - project LaneModel + EventBus facts into structured AgentActivitySnapshot (ActivityModel / setActivitySnapshot Op) with pending-approval and active-tool-call sets; emit agent.activity.updated - add IAgentTurnService.launchWithLease; goal continuation acquires the lane before appending its prompt - resolve pending interactions on turn.ended to avoid stranded awaiting_approval - fullCompaction registers a background activity and checks the activity lane - extract contextMemory publishSplice / isFullyUndoable / recoverFoldedLength helpers - kap-server: map activity snapshot into legacy status and sessionEventBroadcaster * fix(agent-core-v2): truncate over-long goal completion criteria Goal parity gap G11: v1 silently truncates a goal's completionCriterion to 4000 characters (the objective cap) before persisting, so an over-long criterion never fails creation and cannot bloat every goal reminder and record. v2 only trimmed whitespace and persisted arbitrary lengths verbatim. Cap the normalized criterion at MAX_GOAL_COMPLETION_CRITERION_LENGTH to match v1. * fix(agent-core-v2): add goal error catalog info metadata Align the GoalErrors domain with V1 by attaching the info block for the seven goal.* error codes (title, retryable, public, action hints) so errorInfo() surfaces them. Entries copied verbatim from the V1 error catalog. Gap: G43 * chore(nix): update pnpm deps hash * fix(agent-core-v2): retain queued steers when a turn ends cancelled or failed Align the prompt layer with V1's steer-buffer semantics: buffered steer input now survives a turn that ends cancelled or failed and is flushed into the next launched turn by the existing beforeStep hook, instead of being silently dropped. The turn-result observation in the prompt service existed only to perform that discard, so it is removed along with the now-trivial launch wrapper; explicit clear() still discards the queue. Gap: G24 * fix(agent-core-v2): remove ask-user background mode * fix(kap-server): align archived session restore * chore(lint): fix type-aware lint errors * chore(agent-core-v2): drop stray doResume debug log * fix(agent-core-v2): defer prompts and steers while a full compaction is in flight Align with V1's compaction gating: input arriving while a full compaction holds the context (and no turn is active) used to launch a turn immediately, appending assistant output that forced the in-flight compaction to cancel. The prompt service now buffers such input and replays it from a new onDidFinishCompaction hook that the compaction worker runs in a finally, so the buffer drains on completion, cancellation, and failure alike — the first deferred item launches a turn and the rest join the steer queue. The compaction service is resolved lazily instead of constructor- injected: materializing it during prompt-service construction reorders loop-hook registration and moves the full-compaction beforeStep hook ahead of the hooks that let a freshly launched prompt land in context before the auto-compaction check snapshots history. Gap: G23 * fix(agent-core-v2): re-inject the goal reminder after full compaction Align with V1: after a compaction rewrites the context, re-arm the per-turn context injectors and run them before the compaction is marked complete, so the first post-compaction request — including a replayed deferred prompt's — already carries the goal reminder the summary folded away. The injector service exposes injectAfterCompaction, which re-arms the new-turn flag and injects immediately; the compaction worker calls it after the system-prompt refresh and raises the post-compaction token floor to include the re-injected reminders (the pre-injection floor stays as the fallback when reinjection throws), so the nothing-new-since-compaction guard does not re-trigger against a shape that cannot shrink. The injector is resolved lazily from the compaction service to keep loop-hook registration order untouched across the dependency cascade. Matches V1 verbatim including the existing quirk where an idle manual compact yields a second reminder copy on the next turn's per-turn injection; the parity test pins that behavior. Gap: G14 * test(agent-core-v2): cover goal pause classification for provider errors Port the missing end-to-end coverage: goal-driven turn failures pause the goal with the exact per-class reason strings — provider rate limit, provider connection error, provider authentication error, provider safety policy block, and model configuration error (including the forced 'LLM not set' substitution). Failures are driven through a real turn with a throwing generate stub so the raw-error classification feeding the pause reason is exercised, not just the mapper. No source changes: the existing classification already matches the reference strings verbatim. Gap: G35 * feat: add progressive tool disclosure * feat(cli): gate print-mode v2 behind KIMI_MODEL_EXPERIMENT_FLAG - add KIMI_PRINT_V2_ENV / isPrintV2Enabled so `kimi -p` routes to the native agent-core-v2 runner through its own switch - keep `kimi server run` server-v2 routing on isKimiV2Enabled (KIMI_CODE_EXPERIMENTAL_FLAG), decoupling the two - update print-mode tests and comments to reference the new switch * feat(cli): add KIMI_MODEL_OUTPUT_FORMAT for print-mode default - resolve the effective `-p` format via resolveOutputFormat: the --output-format flag wins, then KIMI_MODEL_OUTPUT_FORMAT (prompt mode only), then text - ignore the env outside prompt mode and reject invalid values eagerly through the friendly validation path - apply the resolver on both the v1 and v2 print runners * fix(agent-core-v2): count the goal-creating turn as the first goal turn Goal parity gap G5: when the model creates or resumes a goal mid-turn, v1 counts that ordinary turn as goal turn 1 at turn end (with a budget re-check before the continuation driver takes over) and charges its remaining step output tokens against the token budget. v2 only flagged turns whose goal was already active at launch, leaving turnsUsed and tokensUsed off by one turn in the model-initiated flow. Adopt the live turn as a goal starter turn on activation: charge its post-creation step output, count it once at turn end via incrementTurn, and block instead of launching a continuation when that count exhausts the turn budget. * fix(agent-core-v2): remove model-initiated paused status from UpdateGoal Goal parity gap G6: v1 reserves pausing for the user and runtime — its UpdateGoal tool only accepts active/complete/blocked and rejects other statuses with an invalid-status error. v2 still carried a leftover 'paused' enum option, a model pauseGoal branch, and matching tool description wording from before v1 removed them. Drop the paused option, port v1's runtime invalid-status guard, and align the tool description with v1's. * fix(agent-core-v2): deliver goal outcome prompts through the UpdateGoal tool result Goal parity gap G7: when the model completes or blocks a goal, v1 returns the outcome prompt (stats plus final-message instructions) as the UpdateGoal tool result with stopTurn, keys the one-shot final- message continuation on that terminal tool result, and guards it with the per-turn step budget so a capped turn ends 'completed' instead of dying on max steps. v2 still used a pre-change leftover channel: terse tool outputs plus goal_completion_summary / goal_blocked_reason system reminders and a last-message-reminder continuation with no step-budget check. Return the outcome prompts as tool output, drop the reminder appends and their detection, key the continuation on the terminal UpdateGoal result observed via the tool executor hook, and mirror v1's hasStepBudgetRemaining guard. Also closes audit gaps G17 (max-steps death) and G27 (actor-conditional reminders). * fix(agent-core-v2): fail UpdateGoal as a tool error when no goal matches Goal parity gap G8 (with user modification): v1 returns friendly success-flagged no-op outputs when UpdateGoal targets a missing or non-active goal, while v2 either let GOAL_NOT_FOUND escape from resumeGoal or reported false success with stopTurn for complete and blocked on a non-active goal. Per the user's decision these cases now return error-flagged tool results in the same shape as the Edit tool's old-string-not-found failure - v1's message texts ('Goal not resumed: no current goal.', 'Goal not completed: no active goal.', 'Goal not blocked: no active goal.') with isError and no stopTurn, so the model sees a non-fatal failure and the turn continues normally. * fix(agent-core-v2): settle active goals when the continuation relaunch fails Goal parity gap P-B: the turn-ended subscriber that relaunches goal continuation turns discarded every rejection, so a failed launch (for example losing a race to a queued prompt) stranded the goal in status active with nothing driving it. Keep the event-driven per-turn continuation model but settle deterministically on failure: any rejection out of the turn-ended handling now pauses the active goal as actor system with reason 'Paused after goal continuation failure: <message>', emitting the normal goal.updated event; the settle itself never throws into the event bus. The busy-skip needs no settle: the turn service clears its active turn before publishing turn.ended, so the other live turn's own end reliably re-runs the relaunch check. * fix(agent-core-v2): restore the fork-cleared goal system reminder Goal parity gap G12: after a session fork, v1 tells the model the fork has no current goal so it ignores stale active-goal reminders copied from the source session; v2 cleared the goal silently through the forked wire op and dropped the reminder. Track the fork boundary in a derived (never persisted) wire model folded on both dispatch and replay: a forked record that clears a copied goal marks the reminder pending, and the post-replay pass appends v1's verbatim reminder text with origin goal_fork_cleared exactly once - the appended reminder record acknowledges the pending flag on later replays, so resumes never duplicate it. Forks of sessions without a goal append nothing. The forkGoal op itself stays pure. * fix(agent-core-v2): preserve turn result details (#1531) * feat(agent-core-v2): align defaultProvider fallback and clear-on-delete - ModelResolverService falls back to the top-level defaultProvider config when a model pins neither providerId/provider nor an inline baseUrl (v1 parity). - ProviderService.delete clears defaultProvider when removing the provider it points at, replacing v1's scattered call-site cleanups. - defaultProvider rides as an unregistered top-level scalar config section, mirroring defaultModel (no schema, generic snake/camel passthrough). * feat(agent-core-v2): synthesize legacy prompt lifecycle events - emit prompt.completed/aborted/steered on the per-agent IEventBus so the v1-compatible WS edge can forward them (v2 core only emits turn.ended) - bridge per-agent turn.ended into SessionInteractionService.cancelPendingForTurn via AgentLifecycleService (bus is Agent-scoped, no direct injection) - extract agent create() helpers: assertCanCreate, buildAgentScopeExtras, igniteEagerServices, bindBootstrap - finish assistant writer on PromptTranscriptWriter.flushAssistant - ungate live session status idle->running->idle e2e test (v2 backend pulls real status) * chore(agent-core-v2): align cron and skill prompts with agent-core Drop the KIMI_CRON_NO_JITTER / KIMI_CRON_NO_STALE notes from the CronCreate and CronList descriptions and the MAX_SKILL_QUERY_DEPTH sentence from the Skill description, matching agent-core (v1) where these were trimmed from the model-facing text in #1102. Code behavior is unchanged; the env bypasses and the depth cap still exist in both implementations. ULID/8-hex wording is left as-is for now. * chore(agent-core-v2): drop legacy 8-hex mention from cron prompts CronDelete and CronList descriptions now describe the task id as a ULID only, removing the "(or legacy 8-hex)" qualifier from the model-facing text. Code and tests are unchanged. * chore(agent-core-v2): reorganize tests to mirror src layout Move every file under test/ so its path mirrors the corresponding file under src/ one-to-one (agent/, session/, app/, os/, persistence/, _base/, activity/, wire/), and rename test files to match the basename of the source file they cover. Test-only infrastructure with no src counterpart (harness, snapshot, lint, dep-graph, tools/fixtures) stays at the top level. Rewrite imports after the move: src references use the #/ alias, while test-to-test and cross-package relative imports are recomputed for the new locations. No behavior changes. * feat(config): add default permission/plan mode and yolo alias - register `defaultPermissionMode` and `defaultPlanMode` config sections - apply `defaultPermissionMode` when creating the main agent - enter plan mode on fresh sessions when `defaultPlanMode` is true - fold `yolo: true` into `default_permission_mode` on kap-server config write, derive `yolo` on read (yolo stays wire sugar, never a persisted domain) * feat(agent-core-v2): add background mode to AskUserQuestion Align with v1: the model can pass `background: true` to get a task_id immediately while the question waits in the background for the user's answer; completion is delivered to the agent automatically through the task service's terminal notification. - New QuestionBackgroundTask (AgentTask kind 'question') that runs the question request on a detached task and settles completed/failed/killed. - AskUserQuestionTool gains the optional `background` schema field, the description suffix, an IAgentTaskService dependency, and a background execution branch whose output block matches v1 verbatim. - Tests: harness injects a task-service stub, two legacy 'no background' assertions are flipped to the v1-aligned behavior, and three background cases (immediate task_id, settle completed, abort killed) are added. * fix(agent-core-v2): synthesize default baseUrl for env-model provider Align with v1: when KIMI_MODEL_NAME is set without KIMI_MODEL_BASE_URL, the reserved __kimi_env__ provider now gets a per-type default baseUrl (kimi -> api.moonshot.ai/v1, openai -> api.openai.com/v1; anthropic is left unset so the SDK picks its default). Previously v2 left baseUrl empty and later threw "missing a base URL" for the openai env-model path, regressing v1's out-of-the-box behavior. An explicit KIMI_MODEL_BASE_URL still wins. * fix(agent-core-v2): restore UpdateGoal completion/blocked prompts and no-goal fallbacks Align with v1: completing or blocking a goal now returns the dynamic summary/blocked-reason prompt (buildGoalCompletionSummaryPrompt / buildGoalBlockedReasonPrompt, already present in outcome-prompts.ts but unused) instead of the static "Goal marked complete/blocked." text, and all three statuses report the "no active/current goal" fallback when there is nothing to transition. * feat(agent-core-v2): add [image] config section for image compression - add media-owned `image` config section (`max_edge_px`, `read_byte_budget`) with `KIMI_IMAGE_MAX_EDGE_PX` / `KIMI_IMAGE_READ_BYTE_BUDGET` env bindings (env > config.toml > default) - add Agent-scope `ImageConfigBridge` that pushes the env-resolved section into the image-compress resolver seam on load and on change, so all call sites honor config without per-call wiring - resolve `maxEdge` / read-byte-budget defaults in image-compress via the new seam; keep the support module config-agnostic - apply the read-image byte budget in ReadMediaFile's default downscale path (previously fell back to the 3.75 MB provider ceiling) * fix(agent-core-v2): align image compression defaults with v1 (#1508) Port v1 #1508 into v2: lower the longest-edge downscale cap back to 2000px (v2 was stuck on the 3000px it had ported from an earlier v1 change) and make it overridable, add the 256 KB read-image byte budget used by ReadMediaFile, and widen the over-budget fallback ladder to [2000, 1000, 768, 512, 384, 256]. - MAX_IMAGE_EDGE_PX 3000 -> 2000, with KIMI_IMAGE_MAX_EDGE_PX env and a config-pushed value resolved via resolveMaxImageEdgePx. - READ_IMAGE_BYTE_BUDGET=256KB with KIMI_IMAGE_READ_BYTE_BUDGET env and resolveReadImageByteBudget; ReadMediaFile's default compress path now uses it (region / full_resolution still honor IMAGE_BYTE_BUDGET). - Test expectations that hard-coded 3000px / 1500px updated to 2000 / 1000 to match the v1 behavior. The [image] config.toml section is intentionally not added: the env vars already cover the override path, and wiring a config section plus a runtime push would add v2-specific scaffolding beyond v1. * fix(agent-core-v2): restore HEIC/HEIF conversion guidance in ReadMediaFile Align with v1: a HEIC/HEIF read is now refused up front with an os-specific conversion command (sips / heif-convert / ImageMagick) so the unsupported format never reaches the provider (which would reject the whole session once it lands in history). The two guidance builders are ported verbatim from v1, and the check sits after the image-capability guard (using IHostEnvironment.osKind). Also give the existing EXIF-rotation test a longer timeout: it does heavy jimp encode/decode and was flaking around the default 5s boundary. * feat(agent-core-v2): wire startBtw into the agent RPC API Align with v1: expose `startBtw` on AgentAPI and delegate it to the existing ISessionBtwService (already implemented and DI-registered as SessionBtwService), so the /btw slash command can fork a side-question child agent once the server runs on v2. * chore(agent-core-v2): tidy misplaced and throwaway test files - Remove resume-debug.test.ts: a one-off diagnosis script with a hardcoded local path, not a real test. - Move streamTiming.test.ts to app/model/modelImpl.test.ts: it only exercises buildStreamTiming in app/model/modelImpl.ts. - Rename wire/store.test.ts to wire/wireServiceImpl.test.ts to match the module it covers (there is no store.ts in src). * fix(agent-core-v2): restore JSON Schema format validation in tool-args Align with v1: replace the hand-rolled subset validator with v1's Ajv- based implementation (draft-07/2019/2020 + ajv-formats), so tool-call argument validation once again honors the JSON Schema `format` keyword (and the full keyword set), not just the previously hard-coded subset. - args-validator.ts is now byte-identical to v1 (93 lines, replacing the 289-line hand-rolled subset). - Adds ajv@^8.18.0 and ajv-formats@^3.0.1 (same versions as v1) plus the pnpm-lock.yaml update. - The two call sites (compileToolArgsValidator -> validateToolArgs) keep working unchanged; a small test locks in format / required / additionalProperties / subset behavior. * fix(agent-core-v2): restore JSON Schema format validation in tool-args Align with v1: replace the hand-rolled subset validator with v1's Ajv- based implementation (draft-07/2019/2020 + ajv-formats), so tool-call argument validation once again honors the JSON Schema `format` keyword (and the full keyword set), not just the previously hard-coded subset. - args-validator.ts is now byte-identical to v1 (93 lines, replacing the 289-line hand-rolled subset). - Adds ajv@^8.18.0 and ajv-formats@^3.0.1 (same versions as v1) plus the pnpm-lock.yaml update. - The two call sites (compileToolArgsValidator -> validateToolArgs) keep working unchanged; a small test locks in format / required / additionalProperties / subset behavior. * chore(agent-core-v2): drop legacy 8-hex mention from CronDelete/CronList tool source Match the prompt change in 5cc8e520f: the CronDelete parameter description and invalid-id error now say "ULID" only (not "ULID or legacy 8-hex"), and the CronList id doc comment likewise. The validation regex is unchanged so loading any legacy 8-hex tasks from disk still works. * chore(agent-core-v2): remove resume-roundtrip test It round-tripped restore over a hardcoded local dataset (kimi-code-mini-bench/.vitest-results) that is not in the repo, so it vacuously passed everywhere else. Removed at the original author's request. * test(agent-core-v2): raise timeout for slow image-compress invariant test The fuzz-style invariant test now drives the full v1 fallback ladder ([2000, 1000, 768, 512, 384, 256]) for over-budget inputs, which takes longer than the default 5s boundary in this environment. Give it 30s. * chore(agent-core-v2): rename ambiguous test files - agent/task/manager.test.ts -> taskManager.test.ts (no manager.ts in agent/task; disambiguate from taskService.test.ts). - app/cron/persist.test.ts -> cronTaskPersistenceService.test.ts (mirrors the module it covers; agent/task/persist.test.ts mirrors agent/task/persist.ts, so it is left as-is). - agent/contextMemory/message.test.ts -> message-history.test.ts (its describe is 'message history (IAgentContextMemoryService)'; the dir already names the domain). * fix(agent-core-v2): preserve usage for aborted steps * fix(agent-core-v2): resume-safe session reads and in-memory transcript - sessionLifecycle: get/list no longer return a session whose cold resume is still in flight, so callers never observe a half-initialized handle; resume remains the way to await a fully restored handle - messageLegacy: reduce the transcript from the main agent's in-memory wire journal instead of re-reading wire.jsonl; AgentWireRecordService now keeps the journal current with live dispatch so cold and live sessions both read a consistent, full transcript * chore(agent-core-v2): drop stale micro-compaction references in comments micro-compaction only exists in legacy agent-core; v2 has no such mechanism. Update two comments that still cited it: - fullCompactionService: the real reason not to project here is that llmRequester already projects once. - swarmService: context.spliced consumers no longer include micro-compaction bookkeeping. * fix(agent-core-v2): report skill discovery diagnostics * test(agent-core-v2): align plan mode parity fixtures * fix: distinguish task output timeout from cancellation * chore: fix test name * fix(agent-core-v2): flush the wire persist queue before the record log Since d5e1d76fc every wire append rides the async persist queue whenever a blob service is registered, but AgentWireRecordService.flush() only awaited the log store. Callers - including the session-close path - could complete a flush while records were still in flight on the queue, and record-order assertions in tests raced it. Await the wire service flush, which drains the persist queue, before flushing the log. * test(agent-core-v2): align the goal reminder boundary test with the continuation driver The per-turn-boundary reminder test predates the goal continuation driver and never passed: its second explicit prompt raced the auto-launched continuation turn, which correctly holds the turn lane. Treat the continuation turn as the second boundary and end it deterministically by completing the goal through UpdateGoal, keeping the once-per-boundary (never per-step) assertion. * fix(agent-core-v2): stop goal turns gracefully when a hard budget is exhausted Previously a goal whose hard budget was reached mid-turn was only flipped to blocked while the turn kept running unbounded: the loop continues unconditionally after a tool-calls step, and steer flushes or Stop hooks could extend the turn indefinitely past the budget. Now, when the over-budget step requested tool calls, a goal_budget_stop system reminder is appended after the tool results telling the model the goal is blocked (resumable via /goal resume), to stop immediately, that further tool calls will be rejected, and to write a brief final status message. The model gets exactly one grace step, during which tool calls are answered with a soft rejection instead of executing. After the grace step - or when the over-budget step had no pending tool calls - a new AfterStepContext.stopTurn flag ends the turn, honored by the loop with precedence over tool_calls and hook-set continue so nothing can extend past the stop. The grace grant also respects maxStepsPerTurn so it can never turn a budget stop into a max-steps turn failure. Turn launch is gated as well: a prompt arriving while the active goal is already over budget (e.g. after resuming an exhausted goal) blocks the goal before the turn is marked goal-driven, so turnsUsed no longer drifts, no spurious goal_continued telemetry fires, and the prompt runs as an ordinary turn with the blocked-goal note injected. This deliberately diverges from agent-core v1, which hard-stops with zero grace and answers a prompt on an exhausted goal with a synthetic model-less turn: budget overshoot is now bounded at one closing step in exchange for consumed tool results and a user-facing wrap-up message. * fix(agent-loop): stop looping on bare tool_calls signal - remap tool_calls finishReason to 'other' when the provider emitted no tool call structure - prevents re-issuing the model call until maxSteps on a bare tool_calls signal - add loop test covering the v1 'unknown' turn-lifecycle behavior * fix(kap-server): emit legacy background.task.* alias on /api/v1 ws The v2 engine emits background-task lifecycle as `task.started` / `task.terminated`, but v1 consumers (kimi-code TUI / `kimi -p`, node-sdk) only handle `background.task.*` and silently dropped every task event when talking to server-v2, while kimi-web handles the native spelling and has the legacy one registered as known-but-unhandled. Fan the legacy spelling out next to the native event in SessionEventBroadcaster, reusing the same volatility so replay, journal and the per-agent filter stay coherent between the two. kimi-web keeps the native event and ignores the alias; the native /api/v2 stream is left unchanged. Add a SessionEventBroadcaster test asserting both spellings are emitted. * feat(agent-core-v2): port /init command from v1 - add Session-scope ISessionInitService that spawns the coder subagent, mirrors the run onto the main agent, reloads AGENTS.md and appends an init-variant system reminder, then flushes records - add SESSION_INIT_FAILED error code and register the sessionInit domain in the layer map, package index and DI dependency graph - drop the stale "flat (no subdirectories)" rule from the agent-core-dev skill * feat(api-v2): add klient SDK and reflection-based channel registry - replace per-method actionMap (resource:action) with a channel registry: each Service registers once by decorator id and all methods are invoked by reflection - routes move from /api/v2/:sa to /api/v2/:service/:method across HTTP routes and the WS protocol - add @moonshot-ai/klient: typed core/session/agent client over the HTTP channel that reuses agent-core-v2 service interfaces - register klient in flake.nix and pnpm-lock; refresh kap-server tests, e2e, and the apiSurface snapshot * refactor(agent-core-v2): drive turns by draining a StepRequest queue - add StepRequest / StepRequestQueue: the loop drains one batch per step, folding mergeable requests (steers) into the driver's step; a step that ran tools enqueues a ContinuationStepRequest, a plain message enqueues none, so the turn completes when the queue empties - replace AfterStepContext.continue with explicit enqueue; a failed step is retried by head-inserting its driver request - move prompt's private steer queue onto the loop via PromptStepRequest / SteerStepRequest / RetryStepRequest, which materialize their context messages at pop time (image-compression captions reroute to reminders on materialization) - goal and externalHooks orchestrate continuations by enqueueing requests instead of setting ctx.continue; a request's message only lands when the loop pops it, so skipped or aborted launches leave no orphan messages - remove the now-unused CancellationError - delete the reworked turn tests (turn.test.ts, turn-ready.test.ts) and the cron test suites * refactor(agent-core-v2): translate provider errors at the model boundary - add translateProviderError in app/protocol/errors and apply it once in ModelImpl.request: raw provider failures become coded KimiErrors with the raw error preserved as cause and HTTP fields in details; abort shapes pass through untouched - move provider-error mapping out of _base/errors/serialize so _base no longer imports llmProtocol; toErrorPayload/fromErrorPayload now round-trip cause chains recursively, capped at depth 8 - move context.overflow from LoopErrors to ProtocolErrors (wire code unchanged); move LoopError and the max-steps helpers into loop/loop.ts - consolidate isAbortError into _base/utils/abort, dropping the duplicates in retry, cloudTransport, and the question/subagent task tools - add unwrapErrorCause; classify retryability and HTTP status on the unwrapped cause in llmRequester and full-compaction - align task-notification tests with enqueue-only delivery: drain the loop queue with one turn and assert on task.notified instead of prompt steer - protocol: add recursive cause to KimiErrorPayload with a lazy zod schema * docs(agent-core-dev): add commit-align workflow, drop DI dependency map - add commit-align.md subskill: triage one main-branch commit against v2 (aligned / partial / missing / not-applicable) and link it from SKILL.md - delete docs/di-scope-domains.puml and the rendered svg, and drop the keep-the-map-in-sync requirement from verify.md, align.md, commit-align.md, and packages/agent-core-v2/AGENTS.md * refactor(agent-core-v2): move turn lifecycle into agent loop - make loop admission, cancellation, and completion own turn execution - extract step retry into a loop error recovery service - preserve failed-step context and expose retry delay events * refactor(agent-core-v2): centralize loop turn scheduling - add queued turn and step lifecycle handles with explicit admission modes - move continuation and retry scheduling behind the loop service - consolidate legacy prompt scheduling into the prompt domain - align kap-server routes and tests with the new loop contract * feat(klient): add WebSocket transport for calls and event streams - add WsSocket: persistent /api/v2/ws transport with hello handshake, heartbeat answers, per-call timeouts, and auto-reconnect that re-subscribes active listens; bearer token rides the kimi-code.bearer.<token> subprotocol for browser compatibility - add WsKlient / WsChannel exposing core/session/agent scopes and listen(event, handler) over the shared socket - add Klient#ws() lazy singleton with WebSocketImpl injection - bind global fetch in HttpChannel to avoid "Illegal invocation" in browsers * refactor(agent-core-v2): unify hook names to on{Will,Did}Xxx convention - loop: beforeStep -> onWillBeginStep, afterStep -> onDidFinishStep - toolExecutor: onWillExecuteTool -> onBeforeExecuteTool (ToolWillExecuteContext -> ToolBeforeExecuteContext) - prompt: onWillSubmitPrompt -> onBeforeSubmitPrompt - permissionMode: onChanged -> onDidChangeMode - wireRecord: onRestoredRecord -> onDidRestoreRecord, onResumeEnded -> onDidFinishResume - terminal: onData -> onProcessData, onExit -> onProcessExit * feat(kap-server): synchronously refresh all providers before listing models - GET /api/v1/models now awaits refreshProviderModels({ scope: 'all' }) before returning the model list, so the response always reflects the latest provider model metadata - refresh failures are logged and swallowed, falling back to the persisted catalog instead of failing the request * refactor(agent-core-v2): convert one-way notification hooks to Events Replace fire-and-forget OrderedHookSlot hooks with Emitter/Event-based notifications for consumers that only observe, never intercept: - usage: hooks.onDidRecord -> onDidRecord event - permissionMode: hooks.onDidChangeMode -> onDidChangeMode event - fullCompaction: hooks.onDidFinishCompaction -> onDidFinishCompaction event - wireRecord: hooks.onDidFinishResume -> onDidFinishResume event - agentLifecycle: hooks.onDidStopAgentTask -> onDidStopAgentTask event, announced via new notifyAgentTaskStopped() called by mirrorAgentRun Interception-capable slots (onWillStartAgentTask, onWillCompact, onDidRestoreRecord) stay as ordered hooks. * fix(agent-core-v2): route FetchURL through the Moonshot fetch service when logged in When the managed Kimi provider has an oauth ref, WebFetchService builds a MoonshotFetchURLProvider (bearer token + host identity headers) with the local fetcher as fallback, re-reading login state on every call; logged-out setups keep the local fetcher. * fix(agent-core-v2): forward host identity headers with WebSearch requests WebSearchProviderService now passes the host's IHostRequestHeaders (User-Agent + X-Msh-* device identity) as default headers to the Moonshot search provider, mirroring v1's kimiRequestHeaders. * fix(cli): seed host identity headers into the experimental v2 server The v2 boot path (kimi server run with the experimental flag) now seeds the CLI's Kimi identity headers (User-Agent + X-Msh-* device identity) into the engine through kap-server's seeds option, so outbound model, WebSearch, and FetchURL requests carry the same identity as direct CLI runs. kap-server's own package version is 0.0.0, so the identity has to come from the CLI. * feat: validate workspace roots and auto-launch task notification turns - task: idle terminal notifications now use activeOrNewTurn admission, launching their own turn instead of waiting for the next user prompt (matches v1 turn.steer) - workspaceRegistry: createOrTouch rejects missing or non-directory roots with fs.path_not_found, so a phantom cwd never reaches session creation - kap-server: map FS_PATH_NOT_FOUND to protocol error 40409 on the session and RPC surfaces - server-e2e: migrate the v2 smoke test from the local ServerClient to the typed Klient - misc: switch loop/prompt clear() iteration to .slice(), align terminal event handler names, and tidy klient examples * fix(kap-server): emit idle/aborted session status on turn end The v1 WS broadcaster only re-emitted event.session.status_changed(running) on turn.started and never emitted the idle/aborted transition on turn.ended. kimi-web treats that event as the single source of session status (its turn.ended projector deliberately does not synthesize idle), so a session stuck at 'running' after the turn finished — most visibly for background tasks, where ISessionActivity keeps reporting non-idle while the detached task lives and even a REST pull never corrected it. Re-emit event.session.status_changed after turn.ended on the same dispatch queue, mapping reason cancelled/failed/blocked to aborted and otherwise idle (previous_status 'running'), matching v1's _computeStatus. Update the broadcaster tests and harden the wsV1Resync test helper so non-matching frames no longer strand a waiter's timeout. * feat(ws): add Service event streaming with waitUntil handshake - listen messages accept a service name; kap-server resolves the Service via resolveService and subscribes through its onUpperCase member - add listen_result acknowledgement and per-listen error reporting (onDidListenError) so failed subscriptions surface to the client - support onWill-style events: payload carries eventId/signal/waitUntil, the client replies with event_result and the server can event_cancel - klient proxy maps onUpperCase members to channel.listen; WsChannel shares one remote subscription across first/last listeners - channel.call now forwards the complete argument array * feat(agent-core-v2): add typed telemetry event registry - register business telemetry events with compile-time property contracts - redact sensitive values and reject invalid cloud properties - centralize cloud appender construction and version context * feat(kap-server): add channel introspection endpoint - add describeChannels() to channelRegistry: scope derived from the scoped DI registry, public methods/getters enumerated from the prototype chain (framework plumbing and events excluded) - export ChannelDescriptor / ChannelMethodDescriptor from the contract - serve GET /api/v2/channels so clients (kimi-inspect) can render a dynamic service browser without handwritten method lists - cover with rpc test, e2e channel registry test, and API surface snapshot * feat(kap-server): expose declared parameter names in channel descriptors - add `params` field to ChannelMethodDescriptor, parsed from function source - extract declared parameter list via Function#toString with paren-depth tracking - cover param introspection in rpc and server-e2e channel registry tests * fix: adapt v2 print runner and tests to enqueue prompt API - run-v2-print: drive turns via IAgentPromptService.enqueue() and handle.launched; detect hook-blocked prompts via handle.completion; read the LoopRunResult type discriminator in formatNativeTurnFailure - bootstrap stubs: add clientVersion required by IBootstrapService - v2-run-print test: mock enqueue, stub IBootstrapService for createCloudAppender, add track2 to the telemetry stub - node-sdk test: cover prompt.completed/aborted/steered in the exhaustive event switch * feat(agent-core-v2): introduce graded error taxonomy for os, storage, and wire layers - add `os.fs.*` codes with `HostFsError` and the `toHostFsError` boundary translator - add `os.process.*`, `storage.*`, and `wire.*` domains with coded error classes - register new codes in the protocol `KimiErrorCode` union - translate raw OS and parse failures into domain codes across services, persistence backends, and kap-server transport - rename `KimiError` to `Error2` in the v2 base errors - remove obsolete kimi-csdk init example * test(agent-core-v2): wait for MCP connectAll instead of a fixed tick The MCP initial-connect assertion used a single setTimeout(0) tick, but connectAll is gated on Promise.all([resolveSessionMcpConfig(...), enabledMcpServers()]); the session-config side walks the real filesystem (project-root search + mcp.json reads), which does not settle within one macrotask under CI load. Use vi.waitFor so the test is robust on CI. * fix(minidb): publish WAL value pointers only after the frame is durable In valueMode 'disk' the write path installed a disk ValueLoc using the predicted WAL offset before the frame's bytes were flushed (appendLoc returns the offset synchronously; the writev lands on a later tick). Under load a concurrent compaction snapshot could read a pointer past the WAL end and fail with a short read. Apply the record as an in-memory ref first and only publish the disk pointer after appended.done resolves, guarded against WAL rotation and stale record seqs. * fix(kap-server): report missing agents as agent.not_found - resolveScope now throws Error2 for missing session/agent instead of returning undefined, distinguishing agent.not_found from session.not_found - map AGENT_NOT_FOUND onto the session-not-found protocol envelope for v1 parity * refactor(cli): gate print-mode v2 on KIMI_CODE_EXPERIMENTAL_FLAG - remove KIMI_PRINT_V2_ENV / isPrintV2Enabled and the dedicated KIMI_CODE_EXPERIMENT_FLAG switch - route `kimi -p` to the agent-core-v2 runner via isKimiV2Enabled, the same master switch that gates server-v2 * fix(agent-core-v2): map hostFs/storage error codes at server boundaries - unwrap the HostFsError cause before matching EISDIR in FileEditService, restoring the "is not a file" edit output broken by the error taxonomy - map os.fs.* codes to the closest v1 wire codes in the kap-server fs route and /api/v2 transport instead of collapsing to INTERNAL_ERROR - map storage.io_failed / storage.locked to PERSISTENCE_FAILURE in the /api/v2 transport * fix(agent-core-v2): serialize config writes and reloads A User-target set/replace mutates raw/rawSnake, awaits persist(), then rebuilds effective, while a reload() replaces all three wholesale from disk. Without serialization a reload whose file read resolves inside a write's persist window (before the atomic rename lands) restores the stale pre-write state, so the write's post-persist rebuild drops the just-written domain from effective. This surfaced as POST /config responses missing the field they had just written when the startup model-catalog refresh's reload() raced the write. Run User-target writes and reloads through a promise chain so they can no longer interleave. * feat(agent-core-v2): align telemetry with the v1 wire format - rename tool_call_dedupe_detected to tool_call_dedup_detected - emit turn_ended on every turn end; add mode/provider/protocol tags and interrupt_reason to turn_started/turn_interrupted - enrich api_error with alias, protocol tags, and input_tokens - tag tool_call with dup_type via an executor-side map (avoids the executor/dedupe DI cycle) - rename compaction usage fields to input_tokens/output_tokens - add context_projection_repaired, session_started, and session_load_failed events * feat(agent-core-v2): add lifecycle transition machine - add guarded synchronous and asynchronous state transitions - support commit, rollback, cleanup, and compensation actions - cover transition conflicts, action ordering, and failure aggregation * fix(agent-core-v2): harden plugin load, install, and update check paths - Degrade plugin consumption reads to empty when installed.json fails to load, surface plugin.load_failed with a repair hint on management calls, and recover after an explicit reload; serialize the initial load and mutations so concurrent first callers share one load. - Clean up zip temp dirs on every failure path, report the original source in zip/github manifest errors, and roll back to the previous managed copy when an install or persist fails. - Restore managed Kimi endpoint env injection for stdio plugin MCP servers. - Check plugin updates concurrently with per-repo failure isolation and 10s timeouts, track branch installs by commit SHA, and stop false update reports for tag/SHA pins. - Throw plugin.not_found from getPluginInfo and the manager's not-installed paths. - Count plugin skills through the real skill discovery path. - Re-sync context injection positions after silent wire replay so cold resumes do not duplicate injections, and fire plugin session-start reminders only when the plugin skill source finishes refreshing. * fix(agent-core-v2): use the v2 coded error type for plugins * fix(cli): align print session with background completion API * fix(kap-server): stabilize catalog and session status updates - keep model catalog reads free of provider refresh side effects - broadcast deduplicated session lifecycle and interaction statuses - cover catalog loops and global session status fan-out * test: stabilize CI integration cleanup --------- Co-authored-by: _Kerman <kermanx@qq.com> Co-authored-by: 7Sageer <7sageer@djwcb.cn> Co-authored-by: qer <wbxl2000@outlook.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Kaiyi <me@kaiyi.cool> Co-authored-by: Luyu Cheng <2239547+chengluyu@users.noreply.github.com> Co-authored-by: STAR-QUAKE <99738745+starquakee@users.noreply.github.com> Co-authored-by: fengchenchen <fengchenchen@moonshot.ai> Co-authored-by: liruifengv <liruifeng1024@gmail.com>	2026-07-12 21:44:04 +08:00