25 commits

Author	SHA1	Message	Date
Haozhe	8267bb8fce	feat(kap-server): add workspace fs:suggest file completion endpoint (#3019)	2026-08-18 11:53:48 +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	84da6629b1	refactor(agent-core-v2): decouple workspace from session DI via runtime binding (#2961) ... * refactor(agent-core-v2): decouple workspace from session DI via runtime binding * fix(agent-core-v2): unblock session external hooks and scope workspaceMcp seeds - externalHooksService: inject App-level ISessionManager instead of the unregistered ISessionLifecycleService so SessionStart/SessionEnd hooks actually activate in production; keep sessionId matching and tolerate absent lifecycle events - workspaceMcpService: ignore onWillCreateSession events whose session belongs to another workspace, preventing cross-workspace ISessionMcpHandle seed overrides - update externalHooks integration tests, agent harness, and workspaceMcp tests; add reloadSources coverage in skillCatalog tests * fix(agent-core-v2): honor the bound runtime in prompt context, swarm spawn, and ACP sessions - map system-prompt cwd, directory listing, and additional dirs through RuntimeWorkspaceView, and skip the listing when the bound runtime has no fs capability - pass the caller agent's runtime binding to AgentSwarm child creation and prompt-prefix execution instead of hardcoding local - expose the ACP client filesystem through the ACP session runtime and build its shell/path environment from the probed host instead of hardcoded Linux - dispatch klient facade createChild to sessionManager.createChild so child sessions keep their parent markers * fix(agent-core-v2): resolve routed fs and tool paths with runtime path semantics - WorkspaceFsService resolves via the bound runtime's RuntimePath (extended with basename/dirname) instead of node:path, so mapped roots such as C:\\repo stay runtime-local. - Read/Write/Glob/Grep pass skill roots through mapRoots via RuntimeWorkspaceView input, matching Edit. - acp-server unbinds session runtimes on session/close, not only on delete. - apps/kimi-code drops the /runtime slash command; SDK runtime methods stay. * fix(agent-core-v2): retire idle session controllers, untrack disposed runtime resources, and rebuild fs watches on generation replace * fix(agent-core-v2): resolve oxlint errors in runtime lifecycle fixes * fix(kap-server): untrack download stream from runtime generation on completion * fix(kap-server): drop meaningless void operator on tracked dispose	2026-08-16 20:24:12 +08:00
Haozhe	4739284fb9	refactor(features): extract session init feature (#2887) ... - move the session init domain under features - contribute the session service through SessionInitFeature - cover feature withdrawal and restoration	2026-08-13 18:12:08 +08:00
Haozhe	314b39489e	refactor(agent-core-v2): extract swarm into a scope-organized feature (#2874) ... * refactor(agent-core-v2): extract swarm into a scope-organized feature - move src/agent/swarm, src/session/swarm, and src/agent/tools/agent-swarm into src/features/swarm/{agent,session,tools/agent-swarm}; swarmOps.ts stays a static import=register wire channel at the feature root - add SwarmFeature carrying the three runtime registrations (IAgentSwarmService, ISessionSwarmService, IAgentSwarmTool) with ScopeActivation.OnScopeCreated preserved - switch src/index.ts to precise leaf exports and update import sites, including the kap-server and kimi-inspect deep-path imports - move tests to test/features/swarm and re-assert service overrides in the test harness so stubs keep winning over feature contributions * fix(agent-core-v2): keep feature-contributed tools in Agent tool descriptions SubagentTool.knownToolReferences() now reads the full AgentToolContribution collection (static registrations and feature contributions alike) instead of the static contribution table. A caller profile that does not activate a feature-contributed tool (e.g. AgentSwarm) no longer drops it from the per-profile tool listings the description advertises for spawned profiles when a workspace/session restriction forces explicit enumeration. Add a regression test with a caller profile lacking AgentSwarm under a global tool restriction. * refactor(kap-server): lift session profile updates to the route edge - add sessionProfile.ts/sessionAgentConfig.ts route helpers that resume the session and dispatch title/metadata and the agent_config patch to the native v2 services directly - drop updateProfile from ISessionLegacyService, leaving only the status rollup and the goal read in the legacy adapter - wire shape and client-visible behavior unchanged	2026-08-13 13:35:49 +08:00
Haozhe	23e68eee8b	refactor(agent-core-v2): remove the agent RPC aggregation layer (#2871) ... * refactor(agent-core-v2): remove the agent RPC aggregation layer - delete src/agent/rpc/ (AgentRPCService, IAgentRPCService, core-api, prompt-metadata, types) and sink each method's orchestration into its owning domain service - prompt: new submit/submitSteer composing disabledTools gating, MAIN-only session metadata, and engine-side {turn_id} settlement - skill: activate now returns PromptLaunchResult and writes session metadata internally (MAIN-only, unified across prompt/steer/skill/ pluginCommand); node-sdk and kap-server drop their edge-side writes - pluginCommand: new agent-scope domain owning command activation and the plugin_command.activated domain event - permissionMode/loop/fullCompaction: new setModeAndBroadcast / cancelFromUser / cancel; setMode and loop.cancel stay pure for internal callers - klient: agentRpcContract split into per-domain contracts; facade re-routes to domain channels with its public API unchanged - node-sdk, kap-server, kimi-inspect and the v2 test harness now call domain services directly; ctx.rpc keeps its name as a composed adapter - externally visible: the agentRPCService debug channel is gone and session metadata writes are now MAIN-agent-only (see changeset) * refactor(agent-core-v2): move disabledTools gating out of the prompt domain Prompt should not own session tool policy: submit no longer accepts or applies disabledTools. The klient facade keeps its prompt({ disabledTools }) API and composes it edge-side — applying agentToolPolicyService setSessionDisabledTools before calling agentPromptService.submit, the same way kap-server's prompt route already does. Over klient, a profile-less engine now surfaces the raw profile error instead of request.invalid. Also restores the RPC-removal changeset, which did not make it into the previous commit. * chore(agent-core-v2): drop the RPC-removal changeset * refactor(klient): drop disabledTools from the prompt entry entirely The prompt path no longer carries session tool gating on any surface: the klient facade prompt() loses the disabledTools field and calls agentPromptService.submit directly, and the node-sdk SessionPromptRpcInput stops accepting or forwarding it (v1 always ignored the field). Session tool gating remains available through IAgentToolPolicyService.setSessionDisabledTools, composed at the edge the way kap-server's prompt route does; the klient toolPolicy contract added for facade-side composition is removed as unused.	2026-08-13 10:57:01 +08:00
Haozhe	860354976e	feat(agent-core-v2): add event-subscription introspection (#2806) ... - name Emitters and surface their subscriptions as on:<name> ledger labels through a named EventSubscription class and IDisposableDebugLabel - add IDebugEventsService.subscriptions(), merging unit-book entries with per-bus listener counts, contributed at App scope by the new debugEvents feature - kap-server debug dispatcher falls back to the global decorator registry so runtime-contributed services stay callable - kimi-inspect: add an Events panel to the DI view	2026-08-11 14:55:08 +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	510fbe7ec5	refactor(kap-server): wrap /api/v2/sessions in the v1 response envelope (#2644) ... - return the domain-grouped page payload inside { code, msg, data, request_id } and carry business outcomes in code (40001 invalid params with details, 40922 page_token mismatch) instead of raw HTTP statuses plus an { error: { code, message } } body - add ErrorCode.PAGE_TOKEN_MISMATCH (40922) - register the route via defineRoute (shared runtime validation and envelope-wrapped OpenAPI docs); fold include-domain validation into the query schema and replace the preprocess/doc-twin pair with scalar-or-array union params - update the kimi-inspect client to unwrap the envelope and sync the two AGENTS.md guides	2026-08-05 18:20:00 +08:00
Haozhe	6f1cd7ca22	feat: add v2 sessions API and spreadsheet-like session table in kimi-inspect (#2640) ... - kap-server: add GET /api/v2/sessions with a domain-grouped response (workspace / meta / activity, opt-in git), status / archived / updated_after filters, three sort orders, and fingerprint-bound opaque cursor pagination - kimi-inspect: rebuild the chat sidebar as a spreadsheet-like session table on the v2 endpoint — preset views (All / Opened / Archived / By workspace / Git), column visibility config, header sort toggles, cursor-paged Load more, and localStorage-persisted panel prefs - live activity frames from the WS hub override the REST status badge; session created / meta-updated events invalidate the v2-sessions query	2026-08-05 17:28:11 +08:00
Haozhe	2a4990182d	docs: slim root AGENTS.md, move deep package docs to package guides (#2626) ... - move the kimi-inspect, kap-server, transcript, and minidb project-map entries into new package-level AGENTS.md files - move the standalone Agent class rule to packages/agent-core/AGENTS.md - merge root-only agent-core-v2 facts (MCP persistence, trust routes, seed contract examples) into packages/agent-core-v2/AGENTS.md - compress the remaining long project-map entries to summaries with pointers, and add an anti-bloat rule for map entries - drop the stale server-e2e entry; the package no longer exists	2026-08-05 13:43:33 +08:00
Haozhe	119a33f7f1	feat(minidb): persistent index generations and lifecycle hardening (#2604) ... * perf(minidb): skip idle everysec fsyncs and add lifecycle stats - everysec WAL now fsyncs on the timer only while dirty (tracked by a write/sync generation watermark); close() keeps its unconditional final sync, and background sync failures surface via walFsyncErrors plus a sticky lastWalFsyncError instead of being silently swallowed - add WAL queue/group-commit counters (walQueuedBytes, walMaxQueuedBytes, walGroupCommits, walGroupCommitFrames) and lifecycle phase stats: recovery bytes/frames/duration, index/text rebuild durations, compaction total/snapshot/rotation/postings durations, rotation pause, and query candidates/decoded/sorted rows; add a syncIntervalMs open option threaded through compaction WAL rotation - rewrite the bench on fixed-seed synthetic data with a stable machine-readable JSON report (cold open 10k/50k/100k, word/ngram search, idle-fsync acceptance, 100k compaction, event-loop delay, peak heap/RSS per scenario) and pin the schema in test/bench-json.test.ts; add app-side baselines with loose complexity budgets in sessionIndex and searchService tests - fix ClusterDb lock-pool closeAll() leaking in-flight shard opens and drain the query store's async close on server shutdown, eliminating the ENOTEMPTY directory-teardown race * perf(minidb): bound startup rebuild and steady-state hot paths - rebuild all derived indexes in one shared store walk: a single decode per record fans out to staged builders, dt rebuild reads record metadata only, and index-less opens no longer decode at all - rank full-text results with a bounded min-heap plus a stable key tie-break instead of sorting every candidate - remove/overwrite text docs via a docID -> delta-terms reverse map instead of scanning the whole delta vocabulary - validate unique batches incrementally against touched postings instead of copying the full per-index owner map - reap due TTL entries from the expiry heap on the write path instead of a full-store sweep per write * feat(session-index): add minidb read model with keyset pagination - add ISessionIndex read-model lifecycle (prepare/status, ready/degraded states) behind the persistence_minidb_readmodel experimental flag - add ISessionIndexMirror write side recording fresh summaries into a bounded, coalescing queue after the authoritative document is durable - replace the offset cursor with before/after keyset pagination; rename list/countActive to listRecent/count - extend IQueryStore with ordered columns and pageByColumn, plus getMany/listKeys/dropCollection - wire the read model through kap-server routes and start, and update the klient sessions contract - index every session for global search instead of the 500 most recent * feat(kap-server): bound search sync lifecycle, pagination, and query budgets - split search requests from sync work: searchIndex() no longer awaits runSync/reopen/reindex; a single-flight sync coordinator with debounce and backpressure runs in the background, stale generations keep serving with explicit stale/degraded state, and refresh/sync/reindex failures surface via lastRefreshError instead of being swallowed - scope file-meta keys by session id (\0meta\file\<sessionId>\<hash>) with lazy + one-shot background migration from the legacy hash-only keys, so one session sync only touches its own meta rows - make authoritative scans incremental (mtime/ino/size rescan conditions, unchanged files no longer rewrite meta) and read wire deltas in 1 MiB chunks instead of whole-file buffer + split - replace offset pagination with versioned v2 keyset page tokens (fingerprint + index generation + sort boundary); generation changes fail old tokens with invalid_page_token, legacy v1 offset tokens are served once and upgraded, and pages collect via bounded top-K instead of full sort + offset skip - add query budgets enforced at the postings/score stage: max query terms, literal length cap, postings visit budget (minidb searchBounded/maxVisits with prefix decoding that never fabricates hits and skips the postings LRU), candidate caps, deadline and text budget; truncation is reported via incomplete reasons candidate_cap/postings_budget/deadline - reopen read-only dbs by opening the next handle before closing the previous one so a failed refresh keeps the old generation serving; failed opens now self-heal through search traffic 100k-message bench: first page p95 < 300ms and page-100 cost on par with page 1; event-loop delay during queries stays sub-millisecond. * fix(minidb): poison, roll back, and recover the WAL on write failures - give WAL writes a commit point: a failed flushBatch poisons the WAL (WAL_POISONED, tracked separately as walWriteErrors vs walFsyncErrors), rejects queued frames in reverse enqueue order, and stops scheduling further batches; everysec background sync failures stay non-rejecting per stage-1 semantics - recover in place to a known-safe point: a serialized recovery chain truncates the WAL back to the first un-acked frame, rebuilds size/nextOffset, and clears the poison; writes queue behind the recovery gate (zero-cost when idle), a failed truncate flips the instance into an explicit writeDisabled state, and a stale truncate offset (WAL file replaced by a rotation) skips the truncate - roll failed flush groups back as a unit: frames are stamped with their batchId, MiniDb keeps per-group earliest pre-state, and the first rejection restores every key of the group (rejected writes no longer reappear after reopen, and in-memory state matches reopen for any failure interleaving); the per-op seq guard remains for cross-group and rotation-retry races - wrap applyOp and the following in-memory mutations so a contract violation poisons the WAL and rolls the group back instead of escaping as a half-commit; frames never enqueued (seal race) roll back per-op without poisoning - tag errors past the commit point with ambiguous: true so callers can distinguish "definitely not applied" from "maybe applied but revoked" - close() waits for the recovery chain to go idle and backup() fences behind in-flight recovery before copying files Controlled A/B bench (22 alternating iterations, 100k concurrent sets): write-path throughput regression is within the 2% budget. * fix(minidb): turn the file lock into an instance-owned serialized lease - distinguish lock ownership by instance instead of pid: every acquire mints a pid:uuid token carried by lock/bid/watch files, inspect().mine compares tokens, liveness still follows pid, tokenless legacy files keep the old stale-takeover path, and hasLiveForeignWatch excludes self by token so same-process contenders see each other (closing the double-win takeover and the cross-instance release); a live same-pid lock is still respected, and re-acquiring a held lock is idempotent - serialize acquire/renew/release through a per-instance promise-chain mutex: renew re-checks held inside the chain and release waits for an in-flight renew, eliminating the renew/rename-after-unlink ghost lock - make MiniDb.close() a state machine (open/closing/closed) with a shared closePromise: cleanup runs per-resource try/catch in dependency order (text indexes, store, valueReader, WAL, lock), aggregates every cleanup error into an AggregateError, stays in 'closing' on failure so a retry finishes the cleanup, and no longer leaks the lock when the WAL close fails; a rejected in-flight compaction no longer escapes the cleanup pass * fix(minidb): keep readers on one consistent file generation - add an internal persistent-files module as the single source of truth for the persisted file set (snapshot, WAL, sidecars, postings pattern, fingerprint subset); lock-pool fingerprints, persistentFiles, open stale-tmp cleanup, and backup/restore filtering all derive from it, and fingerprints upgrade to dev:ino:size:mtimeMs so compound sidecar changes can no longer hide from cluster readers - pair snapshot and WAL generations during recovery (transitional stat-pairing until stage-5 manifests): each pass anchors the fds it scans, re-stats afterwards, tolerates append-only WAL growth, retries bounded times on generation churn with a clean store reset, and throws RECOVERY_GENERATION_CHURN when churn exceeds the budget; the disk-mode ValueReader attach re-validates inodes so stale offsets never read a replaced file - make the rotation directory fsyncs strict: failures abort the rotation through the existing rollback path instead of being swallowed, while platforms without directory fsync degrade once with a warn and stats.dirFsyncUnsupported * fix(minidb): serialize index-definition sidecar mutations, persist before publish - extract the promise-chain mutex into a shared createSerializer() and give each sidecar family (secondary/compound/text) its own chain: create/drop run uninterruptibly (memory change + rebuild + persist), different families stay independent, and the data write path never shares these chains - reverse the publication order to staged -> persist -> publish: a create stages the definition, rebuilds via the staged builder, persists the sidecar including the new definition, then publishes atomically; any failure discards the staged state leaving live and sidecar untouched (no phantom indexes, retry-safe); a drop persists the sidecar without the definition before removing it live; text index create/drop adopt the same pattern, replacing the hand-rolled unwind, and a dropping marker keeps compaction postings rebuilds out of the persist window - feed staged indexes from the incremental write path (add/remove/ checkUnique/checkUniqueBatch visit live+staged) so writes landing in the persist window are not lost at publish; queries still see live only - harden writeFileAtomic: instance-unique tmp names (.tmp-pid-seq), a strict fsyncDir after rename so a successful persist is crash durable, and whitelist-based stale-tmp cleanup that never touches lock tmp files * fix(minidb): validate writes before any side effect, canonicalize values once - canonical value at the write boundary: the json codec re-parses the encoded bytes once and every downstream consumer (unique checks, secondary/compound/text indexes, dt extraction) sees exactly the persisted representation, so getter/toJSON/Proxy documents can no longer diverge between the index view and the storage view - reorder the set/batch pipeline so every fallible check happens before any visible side effect: prepare (key/ttl checks, encoding, canonical decode, index field extraction, tokenization) -> unique checks -> ensureMemoryFor eviction -> commit; a constraint failure now leaves the database untouched (no more evicted victims on rejected inserts), and applyOp is structurally pure against pre-validated data - tokenize at the prepare boundary: TextIndex gains prepareAdd/ addPrepared and the buildQueue carries validated key+tokens mutations instead of raw docs, so a throwing custom tokenizer can no longer poison the live view or the queue, and custom-tokenizer output is rejected per token over 0xffff bytes before it can permanently break postings rebuilds; prepared tokens are keyed by index instance so a same-name drop+create mid-write re-tokenizes instead of crossing tokenizers - strict batch structure validation: scanBatchOpRefs/decodeBatchOps reject unknown op types, out-of-bounds lengths, and trailing bytes (offset must equal body length), so a valid-CRC but malformed batch is skipped as a unit and counted via RecoveryInfo.corruptBatches instead of being partially applied Bench vs the stage-1 baseline: json write throughput regression is within the 5% budget (median ~2-4% depending on the measurement). * feat(minidb): add OpTracker drain primitive and atomic backup, harden tests - introduce the internal OpTracker (close gate + in-flight counter with enter/leave/close/whenIdle and reference-counted pause/resume) and drive every shutdown/drain path from it: WAL background syncs are tracked so close() waits out an in-flight sync before closing the fd, cluster lock-pool closeAll() closes the gates and drains busy callbacks before closing handles, and MiniDb writes pass a write gate - make backup() atomic with a defined linearization point: pause the write gate, drain in-flight writes (every acknowledged write is now included), copy to a sibling temp dir with per-file fsyncs, write the manifest last as the commit marker, and rename into place; failures clean up and leave no partial backup, and concurrent writes are rejected with BACKUP_IN_PROGRESS - reap emptied compound-index groups on remove (the groups map no longer grows monotonically), move the open-time mkdir behind the readOnly check so a read-only open of a missing directory fails with ENOENT instead of creating it, and never run a destructive rebuild for a read-only open failure (explicit or onLockFail fallback) - consolidate every review fault-injection repro into the formal suite behind deterministic barrier helpers (programmable writev/sync/ rename/tokenize hooks) and convert the six timing-based tests to barrier/tick-driven assertions; the .tmp repro scripts are removed The converted timing tests and the full suite pass 50 repeat runs (including under CPU load injection) with zero flakes. * feat(minidb): persist derived indexes as atomic generations, open from WAL delta - checkpoint the store, dt/secondary/compound indexes, and text dictionary/postings/docs into immutable generations under generations/g-NNNNNN published atomically (tmp build, per-file checksums and fsyncs, dir rename, CURRENT swap, strict dir fsyncs); the manifest records the format version, WAL/snapshot checkpoint anchors, per-index definition hashes, and codec/value-mode compatibility - open now loads the published generation and replays only the WAL delta after its checkpoint: no full value decode, corpus tokenization, or postings rewrite on a normal reopen (warm opens are 3.5-13.8x faster at 100k/1M records); a definition change rebuilds only the affected index, and corrupt generation files fall back to the previous generation or the legacy full recovery without ever touching the authoritative snapshot/WAL - build generations transactionally with compaction (rotation plus derived state publish as one unit, replacing the synchronous rebuildTextPostings tail), capture concurrent writes through a sealed op queue with byte/op caps, hard-link clean postings and the snapshot into the new generation, and repoint every live text base into the CURRENT generation after publish - cluster/read-only refresh watches CURRENT and the WAL watermark: pure generation publishes keep readers on incremental catch-up while rotations reopen onto the new generation; writers building the next generation never disturb readers of the current one - legacy databases open through the old path unchanged and gain their first generation in the background; OpenOptions.indexGenerations: false fully restores the pre-generation behavior * feat(minidb): workerize text-index builds and split MiniDb into facets - split the monolithic src/index.ts into facet modules (mini-db, types, value-codec, memory-guard, backup, query-engine, text-registry, wal-group, generation-builder/loader, write-path, read-path, index-admin, lifecycle, stats) and move text-index.ts to text-index/ - run corpus-scale text-index builds off the main thread via the bounded worker engine (src/worker/), exported through the new worker-runtime subpath, with inline fallback for small corpora and rollback switches - defer the open-time fallback text rebuild into a maintenance task; searches on a not-yet-committed base raise TextIndexBuildingError - add the unified maintenance scheduler, bounded async read surface, and a maintenance bench - kap-server search: switch to searchBoundedAsync and serve the building page while the index base rebuilds after fallback recovery - kimi-code: install the SEA-bundled minidb text-build worker at startup, bundle it via the native asset scripts, and add the startup-trace util plus the KIMI_TUI_INPUT_LATENCY debug probe * fix(minidb): treat win32 EPERM as unsupported directory fsync - extract isUnsupportedDirectoryFsyncError and cover win32 EPERM - drop the one-shot console.warn; stats.dirFsyncUnsupported carries the degraded state * fix(kap-server): harden search-index dispose and drain lifecycle - dispose() now closes an OpTracker gate and drains in-flight sync/refresh passes before closing the db, so no background write can hit a closed handle; the deleteSessionDocs loop and trailing stats write skip once the gate closes (review #20) - drainGlobalSearchDisposals loops to a fixpoint so disposals registered while a drain is in flight are also awaited (review #21) - pin the post-open failure semantics with a regression test: a failed text-index setup closes the handle and the next open reacquires the writer lock instead of self-locking read-only (review #19) - export OpTracker from the minidb root for the search service's drain * chore: fix oxlint type-aware lint errors	2026-08-04 20:38:42 +08:00
Haozhe	21185447fe	feat(agent-core-v2): add tokenCounting service with strategy config and measured anchors (#2563) ... * feat(agent-core-v2): add tokenCounting service with strategy config and measured anchors - add IAgentTokenCountingService as the single owner of token counts: context size, full-request size, and estimate primitives, replacing the scattered contextSize/tokenEstimate/fullCompaction paths - add [token_counting] config section with strategy = measured+estimated (default) / measured / estimated, plus the KIMI_TOKEN_COUNTING_STRATEGY env override; measured zeroes all estimates, estimated ignores anchors - keep a live measured-anchor ledger in TokenCountingModel: each LLM exchange writes a real anchor, undo truncates the ledger so the surviving prefix restores its REAL measured size instead of a re-estimate, and compaction rebases to a single anchor that blends the compaction exchange's measured summary output tokens - skip writing an anchor when the stream reports no usage event instead of anchoring emptyUsage() zeros, which zeroed the context size and silenced compaction for providers without usage reporting - return the strategy-resolved size (not measured) from rpc getContext so the tokenCount contract stays correct under the estimated strategy - migrate all consumers (contextMemory, fullCompaction, llmRequester, rpc, mirrorAgentRun, sessionLegacy, kap-server legacyStatus, node-sdk, kimi-inspect) to the new service; edge bridges no longer read the wire model directly - document [token_counting] and KIMI_TOKEN_COUNTING_STRATEGY in the bilingual config reference * fix(kap-server): omit maxContextTokens instead of pushing 0 when unknown - readLegacyStatus falls back to the default model's context limit when no model is bound, and omits maxContextTokens entirely when the limit is unknown (0 is the engine's UNKNOWN_CAPABILITY marker, not a real limit) - profileService no longer emits maxContextTokens in agent.status.updated when the bound model alias does not resolve * fix(agent-core-v2): resolve token_counting strategy only at the reporting edge - keep measured anchors and heuristic estimates both recorded and feeding internal logic (compaction triggers, budgets, overflow backoff) regardless of the configured strategy - add IAgentTokenCountingService.statusSize() as the single strategy-resolved outward reading and route the WS/REST/RPC status surfaces through it - fix the context-size display falling back to provider-reported usage under the estimated strategy - fix compaction overflow backoff retrying identical messages until failure under the measured strategy (the strategy-gated estimator read as 0)	2026-08-04 09:44:21 +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	ceaa96942b	feat(kap-server): add global message search with literal and live-session modes (#2321) ... * feat(kap-server): add the /api/v1/search global message search endpoint Cross-session full-text search over user messages, assistant text and session titles, backed by a minidb index under <home>/search-index with a single-writer lock election and read-only WAL catch-up for other processes. Hits carry transcript anchors (turn ordinal and step id) so clients can jump straight to the matching turn or step. * feat(kimi-inspect): add a search view with chat-timeline navigation The left rail gains a Search view over the global search endpoint, with role and sort filters and cursor pagination. Clicking a hit switches to the chat view and navigates to its session, agent, turn and step — the channel pages the turn into the loaded window, scrolls it into view and flashes the target briefly. * chore(kimi-code): start the dev server without built web assets The repo's dev server scripts (dev:server, dev:kap-server, dev:kap-server:multi, dev:server:restart) now set KIMI_CODE_DEV_SERVER=1. When it is set and dist-web/index.html is missing, kimi web starts the API server without the bundled web UI instead of failing at startup, so backend dev no longer requires a kimi-web build. * feat(kap-server): add literal substring search and a live session route - minidb: text indexes accept an injectable tokenizer/queryTokenizer, and a hashed 2/3-gram tokenizer (NFKC + lowercase, code-point windows) backs substring search; tokenizer names persist in db.textindexes.json with backward-compatible defaults - /api/v1/search gains mode: 'literal' — n-gram candidates confirmed against the original text (zero false positives), with an 'candidate_cap' incomplete flag when the candidate set truncates - container.session_id queries against a session live in this process scan the in-memory transcript store instead of the index (both modes); the response's source: live|index field names the serving route and rides in the page-token fingerprint - kimi-inspect: exact-match toggle and source badge in the search view, plus an in-chat session search bar with jump-to-hit navigation * test(kimi-inspect): avoid stringifying BodyInit in search api tests	2026-07-28 21:47:50 +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	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	d751b6796c	feat(kap-server): global session work status, transcript subscribe_v2, and plan endpoint (#2094) ... * feat(session): add core work aggregate and consume it at WS/REST edges - agent-core-v2: add the sessionActivity domain (ISessionActivityView, Session scope) folding each agent's activity view and the interaction kernel into busy / main_turn_active / pending_interaction / last_turn_reason, firing cause-tagged change events only on real tuple changes - kap-server: resolveSessionFacts reads the core view; the WS broadcaster drops its per-agent fold/dedup and delegates to the view, deferring turn_ended emissions until after the turn.ended frame so busy:false never precedes it; global events now fan out to every established connection via addGlobalTarget without any subscription - kimi-inspect: add src/activity (GlobalEventsWs + SessionActivityHub + useSessionActivities) consuming the global push; the Sidebar renders running / approval / question / failed badges per session * feat(kap-server): decouple transcript stream from agent_filter - transcript frames (transcript.reset/ops) are governed by the per-agent transcript grades alone and bypass the legacy agent allowlist; the filter still gates session_event delivery - client_hello is handshake-only in code: hello and subscribe share one attach path, and hello's inline subscription fields are deprecated (subscriptions made optional) in both protocol packages - flush deferred work_changed(busy:false) from a microtask so it always lands after the matching turn.ended frame * fix(kimi-inspect): restore session activity hub in the browser - bind the default fetch in SessionActivityHub: a member call hits the browser's Illegal invocation (receiver is not the global object), and the swallowed error left the REST seed never firing, so the Sidebar badges never populated on refresh - create the hub in useEffect + useState instead of useMemo: under StrictMode the first mount's cleanup closes the memo-created hub for the rest of the page's life * chore: add changeset for the global session work status push * feat(kap-server): add transcript plan endpoint for ExitPlanMode calls - add GET /sessions/{id}/transcript/plan projecting one ExitPlanMode call's plan info (content, path, options, review outcome) from the first available fact: the linked approval interaction's request display, the live tool frame's display, or the tool result output - add TOOL_CALL_NOT_FOUND (40416) error code - add transcriptPlanResponseSchema to the transcript contract - cover live, auto-mode, cold-rebuild, and error paths in tests - update the API surface snapshot and AGENTS.md * feat: move transcript subscriptions to subscribe_v2 and extend the plan endpoint - add subscribe_v2 / unsubscribe_v2 WS control frames as the only carrier of per-agent transcript grades and the transcript_since cursor; client_hello / subscribe no longer accept transcript fields - serialize control-frame handling per connection so interleaved attaches cannot overwrite fresher subscription state - make tool_call_id optional on GET /sessions/{id}/transcript/plan: omitted lists every ExitPlanMode call with recoverable plan content as a plans array - add a Plan lookup card to the kimi-inspect agent inspector via fetchTranscriptPlan - add TOOL_CALL_NOT_FOUND (40416) to the shared protocol error codes - update AGENTS.md and add changesets	2026-07-23 18:48:25 +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	430cd382a8	refactor(agent-core-v2): drop pass-through methods from AgentRPCService (#2042) ... - trim AgentRPCService/AgentAPI to the 10 methods with real logic (prompt, steer, cancel, undoHistory, setPermission, cancelCompaction, activateSkill, activatePluginCommand, getContext, getTools) - route the klient agent facade to the domain services directly (shellCommand, profile, usage, plan, task) with new wire contracts - keep the test harness ctx.rpc surface unchanged via passthrough adapters - rewire kap-server rpc tests and the kimi-inspect RPC panel	2026-07-22 13:42:01 +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	5ae60fa673	feat(transcript): add unified transcript layer, drop the /api/v2 RPC surface (#1888) ... * feat(transcript): add unified transcript layer and v1 surface - add packages/transcript: agent-granular L1 store, idempotent L2 ops, off/turn/block/delta L3 granularity, L4 view registry, and turn-cursor pagination; sole owner of all transcript wire types - kap-server: engine-event-driven TranscriptService with history backfill, GET /sessions/{id}/transcript, and transcript.ops WS deltas with per-connection granularity control - kimi-inspect: render ChatView from the transcript surface (REST pages + delta-only WS) instead of context memory - sync flake.nix workspace lists and document packages/transcript and packages/server-e2e in AGENTS.md * fix(transcript): project live prompts and anchor backfilled items - agent-core-v2: carry the extracted prompt text on turn.started so the transcript projector can render the user input at turn open (the context append with the same text is not a bus event and lands later) - kap-server: keep the prompt through turn.ended; anchor backfilled markers/taskrefs to their following snapshot turn so replaying history after live turns arrived keeps the historical order - transcript: add an optional beforeTurn placement anchor to marker.upsert / taskref.upsert; anchored inserts land before the first turn at or past the anchor instead of appending blindly Addresses review feedback on #1888. * fix(transcript): adopt backfilled stream frames and group goal turns - kap-server: on mid-stream attach, adopt the backfill-seeded stream frame (id + offset) instead of opening an empty one whose upsert clobbered the seeded text and whose offset-0 appends could not land - transcript: group a turn-opening system_trigger (goal continuation) into its own turn so cold rebuilds keep the turn boundary and stay ordinal-aligned with the engine's live turn numbering Addresses review feedback on #1888. * fix(transcript): drop stale live stores on close and heal after turns - drop a session's live transcript store when the session closes or archives (lifecycle events plus a re-check on the cached-entry path) so reads fall back to the cold rebuild instead of serving a stale store - re-read an ended turn from the persisted wire records (debounced per agent) and merge it back live-first: headers keep live state/timestamps while origin/prompt recover from disk, and truncated text/thinking frames from a mid-turn attach are restored only when the persisted text is longer — a fresh live frame or a lagging flush is never reverted Addresses review feedback on #1888. * fix(transcript): adopt seeded tool frames and route subagent questions - kap-server: adopt the backfill-seeded tool frame when a tool.result arrives for a call that started before the projector attached, so the output lands instead of being dropped (the producer-store lookups now ride one projector options object) - agent-core-v2: record the owning agent on question interactions (ISessionQuestionService.request gains an agentId option, passed by AskUserQuestionTool from its agent scope) so a subagent's questions route to its own transcript and WS events instead of 'main' Addresses review feedback on #1888. * fix(transcript): adopt parent frames, namespace live markers, redact resets - kap-server: fall back to store adoption when subagent.spawned links a parent tool call that started before the projector attached, so the agentRefs link is not lost on mid-bind attaches - kap-server: id live markers in their own namespace (live-mN) — the cold rebuild numbers its markers m1... too, and a colliding id made the store's upsert replace the historical marker instead of appending - transcript/kap-server: redact transcript.reset snapshots to the subscriber's grade (below 'block' the step/frame detail is stripped), so a 'turn'-grade subscription no longer receives full content on resets Addresses review feedback on #1888. * fix(transcript): fold blocked turns into failed, drop inline v2 comment - kap-server: map turn.ended reason 'blocked' to the 'failed' transcript state, matching the engine's TurnEndReason wire contract and the v1 mapTurnReason folding (it was presented as a user cancellation) - agent-core-v2: move the question agentId rationale into the ask-user file header — package rules keep comments in the top-of-file block only Addresses review feedback on #1888. * fix(transcript): keep roster descriptors and resolved-event agents - kap-server: keep the metadata-seeded roster descriptor (parentAgentId / label) when an on-demand history backfill lands its roster entry, instead of downgrading it to { agentId, type } - kap-server: remember each interaction's owning agent and stamp it on the resolved question/approval v1 events — they were hard-coded to 'main', so an agent-filtered subscriber saw a subagent's question open but never close Addresses review feedback on #1888. * fix(transcript): defer pending seeding, skip ghost roster entries - kap-server: announce interactions pending at bind time only after the initial backfill (new TranscriptBinding.seedPendingInteractions), and adopt the seeded tool frame on the request/resolve paths, so a pre-existing approval lands next to its backfilled tool call and keeps the approvalId back-link - kap-server: skip the roster entry when a probed agent id has neither a roster presence nor persisted content (agent_id=nope no longer conjures a ghost subagent) - agent-core-v2: fold the turnEvents import rationale into the loop file header (package rule: comments live in the top-of-file block only) Addresses review feedback on #1888. * fix(transcript): reject hostile agent ids, honor the agent allowlist - transcript/kap-server: validate agent ids as plain names (no separators, no dot segments) at the REST query layer and again before the id is joined into the wire-records path — an authenticated client could otherwise read a wire.jsonl outside the agents directory - kap-server: compose the legacy v1 agent allowlist with transcript grades on every fan-out path (initial resets, per-ops fan-out, roster-driven resets), so a filtered connection no longer receives other agents' transcript frames Addresses review feedback on #1888. * fix(transcript): settle foreground shell tasks on shell.completed - agent-core-v2: emit a transient shell.completed event when a foreground `!` command settles (detached runs keep reporting through the task lifecycle) — the generic task.terminated never fires for foreground tasks, so their transcript cards were stuck at 'running' - kap-server: map shell.completed to the terminal transcript task state (completed/failed) and classify the event as volatile on both v1 durability gates, like its shell.* siblings Addresses review feedback on #1888. * fix(transcript): replay early resolves, reset on a widened filter - kap-server: register bind-time pending interactions without frames so a resolve arriving before the post-backfill seed still routes, then replay it at seed time — request and resolve land together with the approvalId back-link, instead of the interaction vanishing entirely - kap-server: treat an agent newly admitted by a broadened legacy agent filter as owed a transcript.reset even when its grade transition is a no-op (delta → delta) — its ops were suppressed so far, so it has no baseline otherwise Addresses review feedback on #1888. * fix(transcript): keep materialized transcripts on agent disposal - kap-server: only the projector dies with the agent scope — the materialized transcript and roster entry now survive disposal (the roster mirrors session metadata, which keeps completed agents). Dropping them lost already-served history for good: the backfill cache dedupes per agent, so the next read rebuilt an empty shell instead of replaying the persisted records Addresses review feedback on #1888. * fix(transcript): anchor refreshes by oldest turn, group slash turns - kimi-inspect: re-cover the previously loaded window after a refresh by paging until the previous OLDEST turn is loaded again (extracted as recoverLoadedWindow) — a count-based stop silently dropped the window's head once new turns shifted the server window - transcript: group user-slash skill/plugin activations into their own turn (marker included), mirroring the engine's isRealUserPrompt — their assistant output no longer folds into the previous turn on cold rebuilds; other triggers stay marker-only Addresses review feedback on #1888. * fix(transcript): compare all tool fields, overlay in-flight backfills - transcript: include toolCallId/name/view/input in the tool frame equality check — an upsert correcting only those was dropped as a no-op, leaving stale tool metadata on clients - kap-server: overlay the loop's active turn as 'running' after a backfill (cold grouping marks every rebuilt turn completed, so a live turn showed as finished until it ended); snapshot data supplies origin/prompt, and a projector-owned running header is never downgraded Addresses review feedback on #1888. * fix(transcript): gate ops before the seed, re-assert running headers - kap-server: gate the transcript ops fan-out (and roster-driven resets) on a per-connection seeded flag set only after the baseline reset has landed — a subscriber joining mid-stream no longer receives deltas against an empty baseline - kap-server: always re-assert the loop's active turn as 'running' after the snapshot ops in a backfill (skipping the overlay when a live running header existed let the snapshot's cold 'completed' header downgrade it); live header fields win over the snapshot's Addresses review feedback on #1888. * docs(agent-core-v2): fold turnEvents notes into the file header Move the turn.started prompt rationale from field/function TSDoc into the module header — package rules keep comments in the top-of-file block only. Addresses review feedback on #1888. * fix(transcript): emit shell failure output, dispose per-agent listeners - agent-core-v2: emit the synthesized failure text as a final shell.output chunk before shell.completed (it was never streamed, so failed foreground commands showed empty output in transcript tasks until a full rebuild) - kap-server: track each agent's bus subscription per agent and dispose it in onDidDispose — the listener captures the projector, so a disposed agent no longer keeps projecting late events into the store Addresses review feedback on #1888. * fix(transcript): route shell events by task id, tidy question docs - agent-core-v2: keep the commandId → foreground-task-id mapping and carry taskId on shell.output / shell.completed, so consumers attaching mid-command (having missed shell.started) can still route output and the terminal state - kap-server: fall back to the event's taskId in the shell output/completed projectors and seed the shell task before the first chunk, so output is preserved and the terminal upsert cannot clobber it with an empty tail - agent-core-v2: fold the question agentId note into the question.ts file header (package rule: comments live in the top-of-file block only) Addresses review feedback on #1888. * fix(transcript): tighten agent id validation, match kinds in heals - transcript: constrain agent ids to a filename-safe shape ([A-Za-z0-9._-], <=128 chars) — NUL-containing or overlong ids made the wire-records read throw unhandled errors (500) instead of failing validation - kap-server: require the live frame's kind to match before the post-turn heal's length shortcut — a kind-mismatched frame (the projector guessed the stream kind wrong mid-turn) is now replaced by the persisted one instead of being skipped Addresses review feedback on #1888. * fix(transcript): heal missed tool results, seed pendings per agent - kap-server: re-emit tool frames in the post-turn heal when the live step lacks the frame or the live frame lacks the outcome the persisted one carries (a tool.result dropped in the attach race is otherwise unrecoverable); live-only extras (display / agentRefs / approvalId) are preserved, and frames with a live outcome stay untouched - kap-server: scope seedPendingInteractions by agent — the initial seed after backfillMain covers main-owned pendings, and each subagent's pendings seed after its own on-demand backfill, so placement and the approvalId back-link find the persisted tool frames Addresses review feedback on #1888. * fix(protocol): register shell.completed on the v1 event surface - packages/protocol: add ShellCompletedEvent (plus optional taskId on shell.output / shell.completed and prompt on turn.started) to the event interfaces, zod schemas, the agent event union, and the volatile list — schema-validating consumers previously rejected the forwarded shell.completed frames outright - kap-server: mirror the same fields in the v1 events-zod module Addresses review feedback on #1888. * test(node-sdk): cover shell.completed in the exhaustive event switch The SDK's session-event type test asserts exhaustiveness with assertNever; register the new event there (CI typecheck caught it). Addresses review feedback on #1888. * fix(transcript): source cold-session rosters from session metadata - kap-server: add TranscriptService.readColdRoster (persisted state.json → descriptors, mapped like the live seeding) and use it for the cold transcript path — the requested agent id is only appended when it has content (or is main), so an empty probe (agent_id=nope) no longer fabricates a ghost roster entry, matching the live path Addresses review feedback on #1888. * fix(transcript): emit taskrefs when seeding missed shell commands - kap-server: the mid-command-attach seeding in onShellOutput now emits the matching taskref.upsert (exactly like onShellStarted), and onShellCompleted emits one when the whole command was missed — the task no longer exists only in the global map with no timeline item to render Addresses review feedback on #1888. * fix(transcript): defer unseeded live pendings, keep cold tools running - kap-server: pendings created before their owning agent's seed has run now defer into the same unseeded queue as bind-time ones (tracked per agent) — announcing them during the backfill window misplaced them into a synthetic step with no later repair - transcript: cold grouping initializes tool frames as 'running' and lets the tool-message branch transition them to done/error — an approval- gated or still-executing tool no longer shows as completed on rebuilds Addresses review feedback on #1888. * fix(transcript): seed live-created agents, merge backfills live-first - kap-server: agents created after binding are marked seeded immediately — their projector covers every event from creation on, so their pendings announce without waiting for an explicit history read (which previously left live subagent approvals/questions stuck in the unseeded queue) - kap-server: the initial backfill merges turns live-first via healTurnOps (snapshotToOps gains a turn-mapper parameter) — live frame fields landed during the disk read (display/approvalId, longer text) are no longer replaced by the staler persisted version Addresses review feedback on #1888. * fix(transcript): count pages in turn segments, not head units - transcript: the leading non-turn unit no longer consumes a turn slot — pages are counted in turn segments and the head unit rides only with the page reaching the first turn. A timeline with a head marker and exactly pageSize turns used to drop the marker from the newest page and hallucinate an older marker-only page (has_more: true with no older turns) Addresses review feedback on #1888. * fix(transcript): send baseline resets after cursor replay - kap-server: broadcaster.subscribe gains deferTranscriptReset (recording prev grades/filter per target) plus flushTranscriptSeed; the v1 connection defers the transcript baseline on cursor-carrying (re)subscribes and flushes it after replay — a reconnecting client no longer sees the reset's current seq ahead of the replayed lower-seq backlog Addresses review feedback on #1888. * fix(transcript): gate the ops fan-out only when a reset is coming - kap-server: willSendTranscriptReset decides upfront whether any reset will be sent (grade upgrade or widened legacy filter); a same-grades resubscribe no longer un-seeds the target, so ops emitted mid-resubscribe keep flowing instead of being silently dropped by the fan-out gate Addresses review feedback on #1888. * fix(transcript): seed subscribers even when no reset is owed - kap-server: a no-reset subscription (e.g. a client subscribing to a fresh session with an empty roster) now still marks the target seeded after subscribeTranscript completes — roster resets and ops would otherwise stay gated forever once agents appear Addresses review feedback on #1888. * fix(transcript): guard mismatched appends, expose prompt via klient - transcript: appendAtOffset now treats an overlapping chunk whose head does not match the local tail as a gap (diverged stream) instead of silently rewriting from the offset and dropping local content - klient: add the optional prompt field to the turn.started event schema so SDK listeners receive it instead of zod stripping it Addresses review feedback on #1888. * fix(transcript): open turns for subagent run prompts in cold grouping - transcript: add the subagent system trigger to the turn-opening set — a subagent's run prompt (persisted as system_trigger/'subagent') always launches a new engine turn, so resumed subagent histories no longer fold the response into the previous turn or lose the prompt Addresses review feedback on #1888. * fix(transcript): guard bus subscriptions independently of projectors - kap-server: subscribeAgent now guards on a dedicated subscribedAgents set instead of projector existence — a projector seeded before its agent's handle exists (e.g. during an on-demand backfill) no longer blocks the bus subscription, so the agent's live events keep flowing Addresses review feedback on #1888. * fix(kimi-inspect): reconcile the transcript on every socket open - apps/kimi-inspect: TranscriptWs now reports onReconnected on the FIRST successful open too, not only on re-established ones — ops emitted between the REST page load and the subscription (a delayed or failed first connection) were previously lost onto a stale store; the consumer's refresh guard drops the no-op call while the initial load is in flight Addresses review feedback on #1888. * fix(transcript): derive the active step, dedupe tool error rendering - kap-server: the projector gains a stepOrdinal lookup backed by the engine's activity view (resolved lazily through the agent lifecycle), so deltas after a late attach at step >= 2 land in the real active step instead of a synthesized t<N>.1 - apps/kimi-inspect: render a tool frame's error only when it differs from its output — onToolResult sets both to the same string for failed tools, which drew the failure twice in red Addresses review feedback on #1888. * fix(kimi-inspect): reconcile the transcript on the subscribe ack - apps/kimi-inspect: TranscriptWs now fires onReconnected when the subscribe ack for its client_hello arrives instead of at socket open — the server attaches the transcript stream only after processing client_hello, so a refresh fired at open could finish before the subscription was active and still miss the ops in between Addresses review feedback on #1888. * fix(kimi-inspect): coalesce concurrent transcript refreshes instead of dropping A subscribe ack landing while the initial REST load was still in flight hit the `if (refreshing) return` guard, so ops emitted between the REST page snapshot and the WS subscribe were neither in the page nor delivered over the socket. Replace the drop guard with a coalesced runner: at most one refresh in flight, and triggers during a run are collapsed into exactly one follow-up run after it settles. * fix(kap-server): force the transcript baseline after cursor-based replay A cursor re-subscribe at unchanged grades deferred its baseline and then compared against the previous grades on flush, so no reset was sent — while volatile ops fanned out during the deferral had been dropped, leaving the client with a permanent gap. flushTranscriptSeed now always seeds a full baseline (previous grades no longer tracked in the deferred record), and a regression test covers the same-grade cursor resubscribe. Also drop the inline comments added to shellCommandService.ts — the agent-core-v2 convention keeps commentary in the top-of-file block; the context moved there. * fix(kap-server): harden transcript seeding against stale and wildcard subs Two subscribeTranscript gaps found in review: - Re-read the target's subscription after the history awaits: subscribe work runs asynchronously, so an overlapping downgrade/unsubscribe used to be answered with resets computed from the stale spec. The reset loop now uses the latest grades/filter from state.targets and bails when the target is gone or no longer graded. - Backfill roster agents admitted via the wildcard grade, not just explicitly named ones: a historical subagent seeded into the roster from session metadata had no materialized AgentTranscript, so wildcard subscribers silently never received its baseline reset. Adds regression tests for the wildcard backfill, the mid-seed downgrade, and the mid-seed unsubscribe (all three fail without the fix); makeCore now accepts persisted agent metadata for roster seeding. * fix(transcript): let meta.merge clear mode badges on mode exit `agent.status.updated` with `planMode: false` / `swarmMode: false` was dropped by the transcript projector because `meta.merge` could only set mode badges, never clear them — clients kept rendering an exited mode until the next full reset. The merge wire shape now accepts `null` per mode key (set = object, clear = null, absent = keep): the reducer deletes the key and normalizes an empty `modes` away, the zod schema validates the nullable form, and the projector emits the clearing op for exit events. * fix(agent-core-v2): keep system-turn steering text out of turn prompts `turn.started.prompt` was populated from the turn input for every origin, so system-triggered turns (goal continuation, subagent run, cron) exposed their internal steering text to live transcript consumers; the cold rebuild mirrored the same leak when grouping persisted history. The loop now populates the prompt only for displayable user origins (user input, or a user-slash skill/plugin activation) via the new isDisplayablePromptOrigin gate, and the cold grouping opens hidden-origin turns promptless. Turns still open normally — only the prompt text is withheld. * fix(kap-server): reattach the transcript fan-out after a session reload When the engine session closed or archived, TranscriptService dropped the live store together with its ops listener set, but the broadcaster's SessionState kept its transcriptStream — so ensureTranscriptStream returned early for a later subscribe on the resumed session, delivering a fresh reset but never the live transcript.ops. The stream is now pinned to its TranscriptStore instance and the fan-out re-registers whenever a rebuilt store shows up. Adds a regression test that drops the service entry mid-stream and asserts ops keep flowing after resubscribe (fails without the fix). * fix(transcript): map legacy background_task origins in cold rebuilds Legacy/v1 sessions persist background-task notifications with origin.kind === 'background_task' (the live mapper already handles that spelling), but the cold grouping only mapped 'task' — after a restart those turns fell through to { kind: 'other' } and lost their taskId, so the transcript could no longer associate the notification turn with its background task. Both spellings now share the task-origin branch. * fix(kap-server): project no-taskId shell failures into the transcript A foreground `!` command that failed before onForegroundTaskStart ran (Bash validation/spawn/registerTask errors) published shell.output / shell.completed with taskId undefined, and the projector's guard dropped them — the live transcript lost the stderr and the terminal state of a command that did run. Shell events now resolve their task as the id learned at shell.started, else the event's own taskId, else a synthetic per-command id (shell-<commandId>), so early failures land like any other shell task. * refactor: drop the /api/v2 RPC surface and the klient http transport - kap-server: remove the /api/v2 REST routes and /api/v2/ws socket (registerRpcRoutes renamed to serviceDispatcherRoutes; transport/ws/{eventMap,registerWs,wsClient,wsConnection,wsProtocol} deleted). /api/v1/debug/* is now the only RPC surface — a reflection dispatcher over the entire scoped DI registry with no whitelist — and /api/v1/ws the only WS endpoint - klient: drop the http transport (transports/http/*, transports/ws/wsSocket.ts) and the kap-server devDependency; transports reduce to the ipc|memory subpath entries, and the dual/v2 e2e suites go with them - kimi-inspect: target /api/v1/debug only with no fallback, replace the Service-event push channel (wsChannel/wsSocket) with on-demand fetch plus 15 s polling, and show a blocking "Debug surface unavailable" screen on connection failure - transcript: add global attachment/interaction/todo entities (model, ops, wire schema) and project them from engine events in kap-server's coreEventMap * fix(kimi-inspect): drop the unused TranscriptTodo import	2026-07-20 15:33:05 +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
Haozhe	9b496946dc	feat(kimi-inspect): add kap-server web inspector with dev-only /api/v1/debug RPC surface (#1806) ... * feat(kimi-inspect): add web inspector for kap-server /api/v2 surface - new apps/kimi-inspect app: connect screen (server URL + optional bearer token, persisted in localStorage, deep-linkable via ?url=/?token=), workspace/session browser sidebar, per-session chat view, and live Service panels with data and trigger buttons for Session/Agent scopes - built on @moonshot-ai/klient (HTTP for calls, /api/v2/ws for events); Vite dev server proxies /api to a running kap-server - register the workspace in AGENTS.md project map and flake.nix workspacePaths/workspaceNames * fix(kimi-inspect): align dependency versions with the workspace (sherif) * feat: dev /api/v1/debug RPC surface and kimi-inspect channel rework - kimi-inspect: replace @moonshot-ai/klient with an in-app old-klient-style channel layer (service-bound IChannel, HTTP ProxyChannel, shared /api/v2/ws socket with ref-counted event listens), typed by agent-core-v2 interfaces; /channels descriptors + serviceByName keep every wire protocol loaded 1:1 - kimi-inspect: local server auto-discovery (Vite middleware over the kap-server instance registry + home token), zero-config startup connect, and a header switcher for runtime server switching - kap-server: wire the dormant --debug-endpoints flag to a new whitelist-free /api/v1/debug dispatcher (every scoped service callable), gated to loopback binds; repo dev scripts pass the flag - kimi-inspect: probe the debug surface at connect, falling back to /api/v2 on servers without it - tests: channel + discovery unit tests in kimi-inspect; debug RPC and loopback-gating coverage in the kap-server rpc/debugNonloopback suites * chore(changesets): ignore @moonshot-ai/kimi-inspect The private dev app never ships, so it should never appear in a changeset. Add it to the changeset config ignore list (next to vis*) and note the rule in the gen-changesets skill.	2026-07-17 15:56:53 +08:00