Add files using upload-large-folder tool

apps/kimi-code/dist-web/assets/arc-Bh_RIraT.js

@@ -0,0 +1 @@
+import{Y as ln,$ as an,a0 as y,a1 as tn,a2 as F,a3 as q,a4 as _,a5 as un,a6 as rn,a7 as J,a8 as o,a9 as j,aa as sn,ab as on,ac as fn}from"./mermaidParser.worker-BFSlSHEW.js";function cn(l){return l.innerRadius}function yn(l){return l.outerRadius}function gn(l){return l.startAngle}function dn(l){return l.endAngle}function mn(l){return l&&l.padAngle}function pn(l,h,I,D,v,A,z,a){var O=I-l,i=D-h,n=z-v,d=a-A,u=d*O-n*i;if(!(u*u<y))return u=(n*(h-A)-d*(l-v))/u,[l+u*O,h+u*i]}function U(l,h,I,D,v,A,z){var a=l-I,O=h-D,i=(z?A:-A)/J(a*a+O*O),n=i*O,d=-i*a,u=l+n,s=h+d,f=I+n,c=D+d,B=(u+f)/2,t=(s+c)/2,m=f-u,g=c-s,R=m*m+g*g,T=v-A,P=u*c-f*s,S=(g<0?-1:1)*J(fn(0,T*T*R-P*P)),Y=(P*g-m*S)/R,$=(-P*m-g*S)/R,w=(P*g+m*S)/R,p=(-P*m+g*S)/R,x=Y-B,e=$-t,r=w-B,C=p-t;return x*x+e*e>r*r+C*C&&(Y=w,$=p),{cx:Y,cy:$,x01:-n,y01:-d,x11:Y*(v/T-1),y11:$*(v/T-1)}}function hn(){var l=cn,h=yn,I=j(0),D=null,v=gn,A=dn,z=mn,a=null,O=ln(i);function i(){var n,d,u=+l.apply(this,arguments),s=+h.apply(this,arguments),f=v.apply(this,arguments)-an,c=A.apply(this,arguments)-an,B=un(c-f),t=c>f;if(a||(a=n=O()),s<u&&(d=s,s=u,u=d),!(s>y))a.moveTo(0,0);else if(B>tn-y)a.moveTo(s*F(f),s*q(f)),a.arc(0,0,s,f,c,!t),u>y&&(a.moveTo(u*F(c),u*q(c)),a.arc(0,0,u,c,f,t));else{var m=f,g=c,R=f,T=c,P=B,S=B,Y=z.apply(this,arguments)/2,$=Y>y&&(D?+D.apply(this,arguments):J(u*u+s*s)),w=_(un(s-u)/2,+I.apply(this,arguments)),p=w,x=w,e,r;if($>y){var C=sn($/u*q(Y)),K=sn($/s*q(Y));(P-=C*2)>y?(C*=t?1:-1,R+=C,T-=C):(P=0,R=T=(f+c)/2),(S-=K*2)>y?(K*=t?1:-1,m+=K,g-=K):(S=0,m=g=(f+c)/2)}var G=s*F(m),H=s*q(m),L=u*F(T),M=u*q(T);if(w>y){var N=s*F(g),Q=s*q(g),V=u*F(R),W=u*q(R),E;if(B<rn)if(E=pn(G,H,V,W,N,Q,L,M)){var X=G-E[0],Z=H-E[1],b=N-E[0],k=Q-E[1],nn=1/q(on((X*b+Z*k)/(J(X*X+Z*Z)*J(b*b+k*k)))/2),en=J(E[0]*E[0]+E[1]*E[1]);p=_(w,(u-en)/(nn-1)),x=_(w,(s-en)/(nn+1))}else p=x=0}S>y?x>y?(e=U(V,W,G,H,s,x,t),r=U(N,Q,L,M,s,x,t),a.moveTo(e.cx+e.x01,e.cy+e.y01),x<w?a.arc(e.cx,e.cy,x,o(e.y01,e.x01),o(r.y01,r.x01),!t):(a.arc(e.cx,e.cy,x,o(e.y01,e.x01),o(e.y11,e.x11),!t),a.arc(0,0,s,o(e.cy+e.y11,e.cx+e.x11),o(r.cy+r.y11,r.cx+r.x11),!t),a.arc(r.cx,r.cy,x,o(r.y11,r.x11),o(r.y01,r.x01),!t))):(a.moveTo(G,H),a.arc(0,0,s,m,g,!t)):a.moveTo(G,H),!(u>y)||!(P>y)?a.lineTo(L,M):p>y?(e=U(L,M,N,Q,u,-p,t),r=U(G,H,V,W,u,-p,t),a.lineTo(e.cx+e.x01,e.cy+e.y01),p<w?a.arc(e.cx,e.cy,p,o(e.y01,e.x01),o(r.y01,r.x01),!t):(a.arc(e.cx,e.cy,p,o(e.y01,e.x01),o(e.y11,e.x11),!t),a.arc(0,0,u,o(e.cy+e.y11,e.cx+e.x11),o(r.cy+r.y11,r.cx+r.x11),t),a.arc(r.cx,r.cy,p,o(r.y11,r.x11),o(r.y01,r.x01),!t))):a.arc(0,0,u,T,R,t)}if(a.closePath(),n)return a=null,n+""||null}return i.centroid=function(){var n=(+l.apply(this,arguments)+ +h.apply(this,arguments))/2,d=(+v.apply(this,arguments)+ +A.apply(this,arguments))/2-rn/2;return[F(d)*n,q(d)*n]},i.innerRadius=function(n){return arguments.length?(l=typeof n=="function"?n:j(+n),i):l},i.outerRadius=function(n){return arguments.length?(h=typeof n=="function"?n:j(+n),i):h},i.cornerRadius=function(n){return arguments.length?(I=typeof n=="function"?n:j(+n),i):I},i.padRadius=function(n){return arguments.length?(D=n==null?null:typeof n=="function"?n:j(+n),i):D},i.startAngle=function(n){return arguments.length?(v=typeof n=="function"?n:j(+n),i):v},i.endAngle=function(n){return arguments.length?(A=typeof n=="function"?n:j(+n),i):A},i.padAngle=function(n){return arguments.length?(z=typeof n=="function"?n:j(+n),i):z},i.context=function(n){return arguments.length?(a=n??null,i):a},i}export{hn as d};

apps/kimi-code/dist-web/assets/chunk-32BRIVSS-Dvm33eUZ.js

@@ -0,0 +1 @@
+import{_ as i,d as l,S as d,j as o}from"./mermaidParser.worker-BFSlSHEW.js";var x=i((r,t)=>{const e=r.append("rect");if(e.attr("x",t.x),e.attr("y",t.y),e.attr("fill",t.fill),e.attr("stroke",t.stroke),e.attr("width",t.width),e.attr("height",t.height),t.name&&e.attr("name",t.name),t.rx&&e.attr("rx",t.rx),t.ry&&e.attr("ry",t.ry),t.attrs!==void 0)for(const s in t.attrs)e.attr(s,t.attrs[s]);return t.class&&e.attr("class",t.class),e},"drawRect"),p=i((r,t)=>{const e={x:t.startx,y:t.starty,width:t.stopx-t.startx,height:t.stopy-t.starty,fill:t.fill,stroke:t.stroke,class:"rect"};x(r,e).lower()},"drawBackgroundRect"),y=i((r,t)=>{const e=t.text.replace(d," "),s=r.append("text");s.attr("x",t.x),s.attr("y",t.y),s.attr("class","legend"),s.style("text-anchor",t.anchor),t.class&&s.attr("class",t.class);const a=s.append("tspan");return a.attr("x",t.x+t.textMargin*2),a.text(e),s},"drawText"),m=i((r,t,e,s)=>{const a=r.append("image");a.attr("x",t),a.attr("y",e);const n=o.sanitizeUrl(s);a.attr("xlink:href",n)},"drawImage"),g=i((r,t,e,s)=>{const a=r.append("use");a.attr("x",t),a.attr("y",e);const n=o.sanitizeUrl(s);a.attr("xlink:href",`#${n}`)},"drawEmbeddedImage"),h=i(()=>({x:0,y:0,width:100,height:100,fill:"#EDF2AE",stroke:"#666",anchor:"start",rx:0,ry:0}),"getNoteRect"),f=i(()=>({x:0,y:0,width:100,height:100,"text-anchor":"start",style:"#666",textMargin:0,rx:0,ry:0,tspan:!0}),"getTextObj"),w=i(()=>{let r=l(".mermaidTooltip");return r.empty()&&(r=l("body").append("div").attr("class","mermaidTooltip").style("opacity",0).style("position","absolute").style("text-align","center").style("max-width","200px").style("padding","2px").style("font-size","12px").style("background","#ffffde").style("border","1px solid #333").style("border-radius","2px").style("pointer-events","none").style("z-index","100")),r},"createTooltip");export{p as a,f as b,g as c,x as d,m as e,w as f,h as g,y as h};

apps/kimi-code/dist-web/assets/clojure-P80f7IUj.js

@@ -0,0 +1 @@
+const e=Object.freeze(JSON.parse(`{"displayName":"Clojure","name":"clojure","patterns":[{"include":"#comment"},{"include":"#shebang-comment"},{"include":"#quoted-sexp"},{"include":"#sexp"},{"include":"#keyfn"},{"include":"#string"},{"include":"#vector"},{"include":"#set"},{"include":"#map"},{"include":"#regexp"},{"include":"#var"},{"include":"#constants"},{"include":"#dynamic-variables"},{"include":"#metadata"},{"include":"#namespace-symbol"},{"include":"#symbol"}],"repository":{"comment":{"begin":"(?<!\\\\\\\\);","beginCaptures":{"0":{"name":"punctuation.definition.comment.clojure"}},"end":"$","name":"comment.line.semicolon.clojure"},"constants":{"patterns":[{"match":"(nil)(?=([])}\\\\s]))","name":"constant.language.nil.clojure"},{"match":"(true|false)","name":"constant.language.boolean.clojure"},{"match":"(##(?:Inf|-Inf|NaN))","name":"constant.numeric.symbol.clojure"},{"match":"([-+]?\\\\d+/\\\\d+)","name":"constant.numeric.ratio.clojure"},{"match":"([-+]?(?:3[0-6]|[12]\\\\d|[2-9])[Rr][0-9A-Za-z]+N?)","name":"constant.numeric.arbitrary-radix.clojure"},{"match":"([-+]?0[Xx]\\\\h+N?)","name":"constant.numeric.hexadecimal.clojure"},{"match":"([-+]?0[0-7]+N?)","name":"constant.numeric.octal.clojure"},{"match":"([-+]?[0-9]+(\\\\.|(?=[EMe]))[0-9]*([Ee][-+]?[0-9]+)?M?)","name":"constant.numeric.double.clojure"},{"match":"([-+]?\\\\d+N?)","name":"constant.numeric.long.clojure"},{"include":"#keyword"}]},"dynamic-variables":{"match":"\\\\*[-!+.:<-?_\\\\w\\\\d]+\\\\*","name":"meta.symbol.dynamic.clojure"},"keyfn":{"patterns":[{"match":"(?<=([(\\\\[{\\\\s]))(if(-[-?\\\\p{Ll}]*)?|when(-[-\\\\p{Ll}]*)?|for(-[-\\\\p{Ll}]*)?|cond|do|let(-[-?\\\\p{Ll}]*)?|binding|loop|recur|fn|throw[-\\\\p{Ll}]*|try|catch|finally|(\\\\p{Ll}*case))(?=([])}\\\\s]))","name":"storage.control.clojure"},{"match":"(?<=([(\\\\[{\\\\s]))(declare-?|(in-)?ns|import|use|require|load|compile|(def[-\\\\p{Ll}]*))(?=([])}\\\\s]))","name":"keyword.control.clojure"}]},"keyword":{"match":"(?<=([(\\\\[{\\\\s])):[-!#*+./:<-?_\\\\w]+(?=([]),}\\\\s]))","name":"constant.keyword.clojure"},"map":{"begin":"(\\\\{)","beginCaptures":{"1":{"name":"punctuation.section.map.begin.clojure"}},"end":"(}(?=[])}\\\\s]*(?:;|$)))|(})","endCaptures":{"1":{"name":"punctuation.section.map.end.trailing.clojure"},"2":{"name":"punctuation.section.map.end.clojure"}},"name":"meta.map.clojure","patterns":[{"include":"$self"}]},"metadata":{"patterns":[{"begin":"(\\\\^\\\\{)","beginCaptures":{"1":{"name":"punctuation.section.metadata.map.begin.clojure"}},"end":"(}(?=[])}\\\\s]*(?:;|$)))|(})","endCaptures":{"1":{"name":"punctuation.section.metadata.map.end.trailing.clojure"},"2":{"name":"punctuation.section.metadata.map.end.clojure"}},"name":"meta.metadata.map.clojure","patterns":[{"include":"$self"}]},{"begin":"(\\\\^)","end":"(\\\\s)","name":"meta.metadata.simple.clojure","patterns":[{"include":"#keyword"},{"include":"$self"}]}]},"namespace-symbol":{"patterns":[{"captures":{"1":{"name":"meta.symbol.namespace.clojure"}},"match":"([-!*+.<-?_\\\\p{L}][-!*+.:<-?_\\\\w\\\\d]*)/"}]},"quoted-sexp":{"begin":"(['\`]\\\\()","beginCaptures":{"1":{"name":"punctuation.section.expression.begin.clojure"}},"end":"(\\\\))$|(\\\\)(?=[])}\\\\s]*(?:;|$)))|(\\\\))","endCaptures":{"1":{"name":"punctuation.section.expression.end.trailing.clojure"},"2":{"name":"punctuation.section.expression.end.trailing.clojure"},"3":{"name":"punctuation.section.expression.end.clojure"}},"name":"meta.quoted-expression.clojure","patterns":[{"include":"$self"}]},"regexp":{"begin":"#\\"","beginCaptures":{"0":{"name":"punctuation.definition.regexp.begin.clojure"}},"end":"\\"","endCaptures":{"0":{"name":"punctuation.definition.regexp.end.clojure"}},"name":"string.regexp.clojure","patterns":[{"include":"#regexp_escaped_char"}]},"regexp_escaped_char":{"match":"\\\\\\\\.","name":"constant.character.escape.clojure"},"set":{"begin":"(#\\\\{)","beginCaptures":{"1":{"name":"punctuation.section.set.begin.clojure"}},"end":"(}(?=[])}\\\\s]*(?:;|$)))|(})","endCaptures":{"1":{"name":"punctuation.section.set.end.trailing.clojure"},"2":{"name":"punctuation.section.set.end.clojure"}},"name":"meta.set.clojure","patterns":[{"include":"$self"}]},"sexp":{"begin":"(\\\\()","beginCaptures":{"1":{"name":"punctuation.section.expression.begin.clojure"}},"end":"(\\\\))$|(\\\\)(?=[])}\\\\s]*(?:;|$)))|(\\\\))","endCaptures":{"1":{"name":"punctuation.section.expression.end.trailing.clojure"},"2":{"name":"punctuation.section.expression.end.trailing.clojure"},"3":{"name":"punctuation.section.expression.end.clojure"}},"name":"meta.expression.clojure","patterns":[{"begin":"(?<=\\\\()(ns|declare|def[-!*+.:<-?_\\\\w\\\\d]*|[-!*+.:<-?_\\\\w][-!*+.:<-?_\\\\w\\\\d]*/def[-!*+.:<-?_\\\\w\\\\d]*)\\\\s+","beginCaptures":{"1":{"name":"keyword.control.clojure"}},"end":"(?=\\\\))","name":"meta.definition.global.clojure","patterns":[{"include":"#metadata"},{"include":"#dynamic-variables"},{"match":"([-!*+.<-?_\\\\p{L}][-!*+.:<-?_\\\\w\\\\d]*)","name":"entity.global.clojure"},{"include":"$self"}]},{"include":"#keyfn"},{"include":"#constants"},{"include":"#vector"},{"include":"#map"},{"include":"#set"},{"include":"#sexp"},{"captures":{"1":{"name":"entity.name.function.clojure"}},"match":"(?<=\\\\()(.+?)(?=[)\\\\s])","patterns":[{"include":"$self"}]},{"include":"$self"}]},"shebang-comment":{"begin":"^(#!)","beginCaptures":{"1":{"name":"punctuation.definition.comment.shebang.clojure"}},"end":"$","name":"comment.line.shebang.clojure"},"string":{"begin":"(?<!\\\\\\\\)(\\")","beginCaptures":{"1":{"name":"punctuation.definition.string.begin.clojure"}},"end":"(\\")","endCaptures":{"1":{"name":"punctuation.definition.string.end.clojure"}},"name":"string.quoted.double.clojure","patterns":[{"match":"\\\\\\\\.","name":"constant.character.escape.clojure"}]},"symbol":{"patterns":[{"match":"([-!*+.<-?_\\\\p{L}][-!*+.:<-?_\\\\w\\\\d]*)","name":"meta.symbol.clojure"}]},"var":{"match":"(?<=([(\\\\[{\\\\s])#)'[-!*+./:<-?_\\\\w]+(?=([])}\\\\s]))","name":"meta.var.clojure"},"vector":{"begin":"(\\\\[)","beginCaptures":{"1":{"name":"punctuation.section.vector.begin.clojure"}},"end":"(](?=[])}\\\\s]*(?:;|$)))|(])","endCaptures":{"1":{"name":"punctuation.section.vector.end.trailing.clojure"},"2":{"name":"punctuation.section.vector.end.clojure"}},"name":"meta.vector.clojure","patterns":[{"include":"$self"}]}},"scopeName":"source.clojure","aliases":["clj"]}`)),n=[e];export{n as default};

apps/kimi-code/dist-web/assets/dagre-VKFMJZFB-DkhizOKY.js

@@ -0,0 +1,4 @@
+import{c as O,w as I,a as J,f as P,b as E,s as A}from"./chunk-RYQCIY6F-BQRhK4dT.js";import{_ as w,am as v,an as D,ao as H,ap as Y,l,c as _,aq as W,ar as $,ae as j,as as q,af as R,ad as F,at as z,au as K,av as G}from"./mermaidParser.worker-BFSlSHEW.js";import{G as Q}from"./graph-CAUpWmoK.js";import{l as U}from"./layout-CvP6o9AK.js";import"./map-CWKZqZjr.js";var C=w((s,t,g)=>Math.max(t,Math.min(g,s)),"clamp"),B=w((s="TB")=>{switch(s){case"BT":return"bottom";case"LR":return"right";case"RL":return"left";case"TB":default:return"top"}},"getDefaultSelfLoopSide"),V=w(s=>s==="flowchart"||s==="flowchart-v2"||s==="stateDiagram","shouldMergeSelfLoopSegments"),Z=w((s,t,g,y,c)=>{const o=[],r=new Set;if(g.forEach(({start:i,end:n})=>{i!==y&&r.add(i),n!==y&&r.add(n)}),r.forEach(i=>{const n=s.node(i);typeof n?.x=="number"&&typeof n?.y=="number"&&o.push(n)}),o.length===0&&g.forEach(({edge:i})=>{(i.points??[]).forEach(n=>{typeof n?.x=="number"&&typeof n?.y=="number"&&o.push(n)})}),o.length===0)return B(c);const f=o.reduce((i,n)=>({x:i.x+n.x/o.length,y:i.y+n.y/o.length}),{x:0,y:0}),h=f.x-t.x,a=f.y-t.y;return Math.abs(h)>Math.abs(a)?h>0?"right":"left":Math.abs(a)>0?a>0?"bottom":"top":B(c)},"getSelfLoopSide"),ee=w((s,t="top",g=0,y=0)=>{const c=s.x,o=s.y-g,r=s.width/2,f=s.height/2,h=Math.max(36,Math.min(100,s.width*.8)),a=C(Math.max(y,s.width*.35),36,h),i=C(Math.min(s.width,s.height)*.45,24,48);switch(t){case"bottom":{const n=o+f;return[{x:c-a/2,y:n},{x:c-a/2,y:n+i},{x:c+a/2,y:n+i},{x:c+a/2,y:n}]}case"right":{const n=c+r;return[{x:n,y:o-a/2},{x:n+i,y:o-a/2},{x:n+i,y:o+a/2},{x:n,y:o+a/2}]}case"left":{const n=c-r;return[{x:n,y:o-a/2},{x:n-i,y:o-a/2},{x:n-i,y:o+a/2},{x:n,y:o+a/2}]}case"top":default:{const n=o-f;return[{x:c-a/2,y:n},{x:c-a/2,y:n-i},{x:c+a/2,y:n-i},{x:c+a/2,y:n}]}}},"getSelfLoopPoints"),te=w((s,t,g="top",y=0,c={})=>{const r=s.x,f=s.y-y,h=c.width??0,a=c.height??0;switch(g){case"bottom":return{x:r,y:Math.max(...t.map(i=>i.y))+a/2+4};case"right":return{x:Math.max(...t.map(i=>i.x))+h/2+4,y:f};case"left":return{x:Math.min(...t.map(i=>i.x))-h/2-4,y:f};case"top":default:return{x:r,y:Math.min(...t.map(i=>i.y))-a/2-4}}},"getSelfLoopLabelPosition"),ne=w((s,t=0,{mergeSelfLoops:g=!0}={})=>{const y=new Map,c=[],o=s.graph()?.rankdir;return s.edges().forEach(r=>{const f=s.edge(r);if(g&&f.selfLoop){const h=f.selfLoop.id;y.has(h)||y.set(h,[]),y.get(h).push({edge:f,start:r.v,end:r.w})}else c.push({edge:f,start:r.v,end:r.w})}),y.forEach(r=>{if(r.length!==3){r.forEach(L=>c.push(L));return}r.sort((L,d)=>L.edge.selfLoop.order-d.edge.selfLoop.order);const[f,h,a]=r,i=f.edge.originalEdge??h.edge.originalEdge??a.edge.originalEdge??h.edge,n=s.node(i.start);if(!n){r.forEach(L=>c.push(L));return}const p={width:h.edge.width,height:h.edge.height},m=Z(s,n,r,i.start,o),X=ee(n,m,t,p.width??0),S=te(n,X,m,t,p),b={...h.edge,...i,id:i.id,points:X,start:i.start,end:i.end,x:S.x,y:S.y,width:p.width,height:p.height,labelStyle:h.edge.labelStyle,fromCluster:f.edge.fromCluster??h.edge.fromCluster??a.edge.fromCluster,toCluster:f.edge.toCluster??h.edge.toCluster??a.edge.toCluster};delete b.selfLoop,delete b.originalEdge,c.push({edge:b,start:b.start,end:b.end})}),c},"getEdgesToRender"),T=w(async(s,t,g,y,c,o)=>{l.warn("Graph in recursive render:XAX",I(t),c);const r=t.graph().rankdir;l.trace("Dir in recursive render - dir:",r);const f=s.insert("g").attr("class","root");t.nodes()?l.info("Recursive render XXX",t.nodes()):l.info("No nodes found for",t),t.edges().length>0&&l.info("Recursive edges",t.edge(t.edges()[0]));const h=f.insert("g").attr("class","clusters"),a=f.insert("g").attr("class","edgePaths"),i=f.insert("g").attr("class","edgeLabels"),n=f.insert("g").attr("class","nodes"),p=V(g);await Promise.all(t.nodes().map(async function(d){const e=t.node(d);if(c!==void 0){const u=JSON.parse(JSON.stringify(c.clusterData));l.trace(`Setting data for parent cluster XXX
+ Node.id = `,d,`
+ data=`,u.height,`
+Parent cluster`,c.height),t.setNode(c.id,u),t.parent(d)||(l.trace("Setting parent",d,c.id),t.setParent(d,c.id,u))}if(l.info("(Insert) Node XXX"+d+": "+JSON.stringify(t.node(d))),e?.clusterNode){l.info("Cluster identified XBX",d,e.width,t.node(d));const{ranksep:u,nodesep:x}=t.graph();e.graph.setGraph({...e.graph.graph(),ranksep:u+25,nodesep:x});const N=await T(n,e.graph,g,y,t.node(d),o),M=N.elem;W(e,M),e.diff=N.diff||0,l.info("New compound node after recursive render XAX",d,"width",e.width,"height",e.height),$(M,e)}else t.children(d).length>0?(l.trace("Cluster - the non recursive path XBX",d,e.id,e,e.width,"Graph:",t),l.trace(P(e.id,t)),E.set(e.id,{id:P(e.id,t),node:e})):(l.trace("Node - the non recursive path XAX",d,n,t.node(d),r),await j(n,t.node(d),{config:o,dir:r}))})),await w(async()=>{const d=t.edges().map(async function(e){const u=t.edge(e.v,e.w,e.name);if(l.info("Edge "+e.v+" -> "+e.w+": "+JSON.stringify(e)),l.info("Edge "+e.v+" -> "+e.w+": ",e," ",JSON.stringify(t.edge(e))),l.info("Fix",E,"ids:",e.v,e.w,"Translating: ",E.get(e.v),E.get(e.w)),p&&u.selfLoop){if(u.selfLoop.order!==1)return;const x=u.id;u.id=u.selfLoop.id,await G(i,u),u.id=x;return}await G(i,u)});await Promise.all(d)},"processEdges")(),l.info("Graph before layout:",JSON.stringify(I(t))),l.info("############################################# XXX"),l.info("###                Layout                 ### XXX"),l.info("############################################# XXX"),U(t),l.info("Graph after layout:",JSON.stringify(I(t)));let X=0,{subGraphTitleTotalMargin:S}=q(o);await Promise.all(A(t).map(async function(d){const e=t.node(d);if(l.info("Position XBX => "+d+": ("+e.x,","+e.y,") width: ",e.width," height: ",e.height),e?.clusterNode)e.y+=S,l.info("A tainted cluster node XBX1",d,e.id,e.width,e.height,e.x,e.y,t.parent(d)),E.get(e.id).node=e,R(e);else if(t.children(d).length>0){l.info("A pure cluster node XBX1",d,e.id,e.x,e.y,e.width,e.height,t.parent(d)),e.height+=S,t.node(e.parentId);const u=e?.padding/2||0,x=e?.labelBBox?.height||0,N=x-u||0;l.debug("OffsetY",N,"labelHeight",x,"halfPadding",u),await F(h,e),E.get(e.id).node=e}else{const u=t.node(e.parentId);e.y+=S/2,l.info("A regular node XBX1 - using the padding",e.id,"parent",e.parentId,e.width,e.height,e.x,e.y,"offsetY",e.offsetY,"parent",u,u?.offsetY,e),R(e)}}));const b=S/2;return ne(t,b,{mergeSelfLoops:p}).forEach(function({edge:d,start:e,end:u}){l.info("Edge "+e+" -> "+u+": "+JSON.stringify(d),d),d.points.forEach(k=>k.y+=b);const x=t.node(e),N=t.node(u),M=z(a,d,E,g,x,N,y);K(d,M)}),t.nodes().forEach(function(d){const e=t.node(d);l.info(d,e.type,e.diff),e.isGroup&&(X=e.diff)}),l.warn("Returning from recursive render XAX",f,X),{elem:f,diff:X}},"recursiveRender"),ae=w(async(s,t)=>{const g=new Q({multigraph:!0,compound:!0}).setGraph({rankdir:s.direction,nodesep:s.config?.nodeSpacing||s.config?.flowchart?.nodeSpacing||s.nodeSpacing,ranksep:s.config?.rankSpacing||s.config?.flowchart?.rankSpacing||s.rankSpacing,marginx:8,marginy:8}).setDefaultEdgeLabel(function(){return{}}),y=t.select("g");v(y,s.markers,s.type,s.diagramId),D(),H(),Y(),O(),s.nodes.forEach(o=>{g.setNode(o.id,{...o}),o.parentId&&g.setParent(o.id,o.parentId)}),l.debug("Edges:",s.edges),s.edges.forEach(o=>{if(o.start===o.end){const r=o.start,f=r+"---"+r+"---1",h=r+"---"+r+"---2",a=g.node(r);g.setNode(f,{domId:f,id:f,parentId:a.parentId,labelStyle:"",label:"",padding:0,shape:"labelRect",style:"",width:10,height:10}),g.setParent(f,a.parentId),g.setNode(h,{domId:h,id:h,parentId:a.parentId,labelStyle:"",padding:0,shape:"labelRect",label:"",style:"",width:10,height:10}),g.setParent(h,a.parentId);const i=structuredClone(o),n=structuredClone(o),p=structuredClone(o),m=structuredClone(o);n.originalEdge=i,n.selfLoop={id:i.id,order:0},p.originalEdge=i,p.selfLoop={id:i.id,order:1},m.originalEdge=i,m.selfLoop={id:i.id,order:2},n.label="",n.arrowTypeEnd="none",n.endLabelLeft="",n.endLabelRight="",n.startLabelLeft="",n.id=r+"-cyclic-special-1",p.startLabelRight="",p.startLabelLeft="",p.endLabelLeft="",p.endLabelRight="",p.arrowTypeStart="none",p.arrowTypeEnd="none",p.id=r+"-cyclic-special-mid",m.label="",m.startLabelRight="",m.startLabelLeft="",m.arrowTypeStart="none",a.isGroup&&(n.fromCluster=r,m.toCluster=r),m.id=r+"-cyclic-special-2",m.arrowTypeStart="none",g.setEdge(r,f,n,r+"-cyclic-special-0"),g.setEdge(f,h,p,r+"-cyclic-special-1"),g.setEdge(h,r,m,r+"-cyclic-special-2")}else g.setEdge(o.start,o.end,{...o},o.id)}),l.warn("Graph at first:",JSON.stringify(I(g))),J(g),l.warn("Graph after XAX:",JSON.stringify(I(g)));const c=_();await T(y,g,s.type,s.diagramId,void 0,c)},"render");export{ne as getEdgesToRender,ae as render};

apps/kimi-code/dist-web/assets/mindmap-definition-LN4V7U3C-BYqiMfi6.js

@@ -0,0 +1,96 @@
+import{g as oe}from"./chunk-XXDRQBXY-4Gs_c1bc.js";import{s as ae}from"./chunk-VR4S4FIN-DAoPzKmc.js";import{_ as l,l as C,u as ce,v as le,y as he,B as G,c as B,i as F,b6 as de,aa as ge,ab as ue,ac as pe}from"./mermaid.core-CCxZmhet.js";import"./index-Baap3_X9.js";import"./_commonjsHelpers-CqkleIqs.js";const E=[];for(let e=0;e<256;++e)E.push((e+256).toString(16).slice(1));function fe(e,n=0){return(E[e[n+0]]+E[e[n+1]]+E[e[n+2]]+E[e[n+3]]+"-"+E[e[n+4]]+E[e[n+5]]+"-"+E[e[n+6]]+E[e[n+7]]+"-"+E[e[n+8]]+E[e[n+9]]+"-"+E[e[n+10]]+E[e[n+11]]+E[e[n+12]]+E[e[n+13]]+E[e[n+14]]+E[e[n+15]]).toLowerCase()}const me=new Uint8Array(16);function ye(){return crypto.getRandomValues(me)}function Ee(e,n,g){return crypto.randomUUID?crypto.randomUUID():_e(e)}function _e(e,n,g){e=e||{};const a=e.random??e.rng?.()??ye();if(a.length<16)throw new Error("Random bytes length must be >= 16");return a[6]=a[6]&15|64,a[8]=a[8]&63|128,fe(a)}var Y=(function(){var e=l(function(D,s,i,o){for(i=i||{},o=D.length;o--;i[D[o]]=s);return i},"o"),n=[1,4],g=[1,13],a=[1,12],t=[1,15],h=[1,16],f=[1,20],m=[1,19],_=[6,7,8],T=[1,26],I=[1,24],w=[1,25],d=[6,7,11],R=[1,6,13,15,16,19,22],q=[1,33],J=[1,34],A=[1,6,7,11,13,15,16,19,22],j={trace:l(function(){},"trace"),yy:{},symbols_:{error:2,start:3,mindMap:4,spaceLines:5,SPACELINE:6,NL:7,MINDMAP:8,document:9,stop:10,EOF:11,statement:12,SPACELIST:13,node:14,ICON:15,CLASS:16,nodeWithId:17,nodeWithoutId:18,NODE_DSTART:19,NODE_DESCR:20,NODE_DEND:21,NODE_ID:22,$accept:0,$end:1},terminals_:{2:"error",6:"SPACELINE",7:"NL",8:"MINDMAP",11:"EOF",13:"SPACELIST",15:"ICON",16:"CLASS",19:"NODE_DSTART",20:"NODE_DESCR",21:"NODE_DEND",22:"NODE_ID"},productions_:[0,[3,1],[3,2],[5,1],[5,2],[5,2],[4,2],[4,3],[10,1],[10,1],[10,1],[10,2],[10,2],[9,3],[9,2],[12,2],[12,2],[12,2],[12,1],[12,1],[12,1],[12,1],[12,1],[14,1],[14,1],[18,3],[17,1],[17,4]],performAction:l(function(s,i,o,c,p,r,$){var u=r.length-1;switch(p){case 6:case 7:return c;case 8:c.getLogger().trace("Stop NL ");break;case 9:c.getLogger().trace("Stop EOF ");break;case 11:c.getLogger().trace("Stop NL2 ");break;case 12:c.getLogger().trace("Stop EOF2 ");break;case 15:c.getLogger().info("Node: ",r[u].id),c.addNode(r[u-1].length,r[u].id,r[u].descr,r[u].type);break;case 16:c.getLogger().trace("Icon: ",r[u]),c.decorateNode({icon:r[u]});break;case 17:case 21:c.decorateNode({class:r[u]});break;case 18:c.getLogger().trace("SPACELIST");break;case 19:c.getLogger().trace("Node: ",r[u].id),c.addNode(0,r[u].id,r[u].descr,r[u].type);break;case 20:c.decorateNode({icon:r[u]});break;case 25:c.getLogger().trace("node found ..",r[u-2]),this.$={id:r[u-1],descr:r[u-1],type:c.getType(r[u-2],r[u])};break;case 26:this.$={id:r[u],descr:r[u],type:c.nodeType.DEFAULT};break;case 27:c.getLogger().trace("node found ..",r[u-3]),this.$={id:r[u-3],descr:r[u-1],type:c.getType(r[u-2],r[u])};break}},"anonymous"),table:[{3:1,4:2,5:3,6:[1,5],8:n},{1:[3]},{1:[2,1]},{4:6,6:[1,7],7:[1,8],8:n},{6:g,7:[1,10],9:9,12:11,13:a,14:14,15:t,16:h,17:17,18:18,19:f,22:m},e(_,[2,3]),{1:[2,2]},e(_,[2,4]),e(_,[2,5]),{1:[2,6],6:g,12:21,13:a,14:14,15:t,16:h,17:17,18:18,19:f,22:m},{6:g,9:22,12:11,13:a,14:14,15:t,16:h,17:17,18:18,19:f,22:m},{6:T,7:I,10:23,11:w},e(d,[2,22],{17:17,18:18,14:27,15:[1,28],16:[1,29],19:f,22:m}),e(d,[2,18]),e(d,[2,19]),e(d,[2,20]),e(d,[2,21]),e(d,[2,23]),e(d,[2,24]),e(d,[2,26],{19:[1,30]}),{20:[1,31]},{6:T,7:I,10:32,11:w},{1:[2,7],6:g,12:21,13:a,14:14,15:t,16:h,17:17,18:18,19:f,22:m},e(R,[2,14],{7:q,11:J}),e(A,[2,8]),e(A,[2,9]),e(A,[2,10]),e(d,[2,15]),e(d,[2,16]),e(d,[2,17]),{20:[1,35]},{21:[1,36]},e(R,[2,13],{7:q,11:J}),e(A,[2,11]),e(A,[2,12]),{21:[1,37]},e(d,[2,25]),e(d,[2,27])],defaultActions:{2:[2,1],6:[2,2]},parseError:l(function(s,i){if(i.recoverable)this.trace(s);else{var o=new Error(s);throw o.hash=i,o}},"parseError"),parse:l(function(s){var i=this,o=[0],c=[],p=[null],r=[],$=this.table,u="",M=0,K=0,ne=2,Q=1,ie=r.slice.call(arguments,1),y=Object.create(this.lexer),L={yy:{}};for(var H in this.yy)Object.prototype.hasOwnProperty.call(this.yy,H)&&(L.yy[H]=this.yy[H]);y.setInput(s,L.yy),L.yy.lexer=y,L.yy.parser=this,typeof y.yylloc>"u"&&(y.yylloc={});var W=y.yylloc;r.push(W);var se=y.options&&y.options.ranges;typeof L.yy.parseError=="function"?this.parseError=L.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function re(k){o.length=o.length-2*k,p.length=p.length-k,r.length=r.length-k}l(re,"popStack");function Z(){var k;return k=c.pop()||y.lex()||Q,typeof k!="number"&&(k instanceof Array&&(c=k,k=c.pop()),k=i.symbols_[k]||k),k}l(Z,"lex");for(var b,v,S,z,O={},U,x,ee,V;;){if(v=o[o.length-1],this.defaultActions[v]?S=this.defaultActions[v]:((b===null||typeof b>"u")&&(b=Z()),S=$[v]&&$[v][b]),typeof S>"u"||!S.length||!S[0]){var X="";V=[];for(U in $[v])this.terminals_[U]&&U>ne&&V.push("'"+this.terminals_[U]+"'");y.showPosition?X="Parse error on line "+(M+1)+`:
+`+y.showPosition()+`
+Expecting `+V.join(", ")+", got '"+(this.terminals_[b]||b)+"'":X="Parse error on line "+(M+1)+": Unexpected "+(b==Q?"end of input":"'"+(this.terminals_[b]||b)+"'"),this.parseError(X,{text:y.match,token:this.terminals_[b]||b,line:y.yylineno,loc:W,expected:V})}if(S[0]instanceof Array&&S.length>1)throw new Error("Parse Error: multiple actions possible at state: "+v+", token: "+b);switch(S[0]){case 1:o.push(b),p.push(y.yytext),r.push(y.yylloc),o.push(S[1]),b=null,K=y.yyleng,u=y.yytext,M=y.yylineno,W=y.yylloc;break;case 2:if(x=this.productions_[S[1]][1],O.$=p[p.length-x],O._$={first_line:r[r.length-(x||1)].first_line,last_line:r[r.length-1].last_line,first_column:r[r.length-(x||1)].first_column,last_column:r[r.length-1].last_column},se&&(O._$.range=[r[r.length-(x||1)].range[0],r[r.length-1].range[1]]),z=this.performAction.apply(O,[u,K,M,L.yy,S[1],p,r].concat(ie)),typeof z<"u")return z;x&&(o=o.slice(0,-1*x*2),p=p.slice(0,-1*x),r=r.slice(0,-1*x)),o.push(this.productions_[S[1]][0]),p.push(O.$),r.push(O._$),ee=$[o[o.length-2]][o[o.length-1]],o.push(ee);break;case 3:return!0}}return!0},"parse")},te=(function(){var D={EOF:1,parseError:l(function(i,o){if(this.yy.parser)this.yy.parser.parseError(i,o);else throw new Error(i)},"parseError"),setInput:l(function(s,i){return this.yy=i||this.yy||{},this._input=s,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:l(function(){var s=this._input[0];this.yytext+=s,this.yyleng++,this.offset++,this.match+=s,this.matched+=s;var i=s.match(/(?:\r\n?|\n).*/g);return i?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),s},"input"),unput:l(function(s){var i=s.length,o=s.split(/(?:\r\n?|\n)/g);this._input=s+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-i),this.offset-=i;var c=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),o.length-1&&(this.yylineno-=o.length-1);var p=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:o?(o.length===c.length?this.yylloc.first_column:0)+c[c.length-o.length].length-o[0].length:this.yylloc.first_column-i},this.options.ranges&&(this.yylloc.range=[p[0],p[0]+this.yyleng-i]),this.yyleng=this.yytext.length,this},"unput"),more:l(function(){return this._more=!0,this},"more"),reject:l(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:l(function(s){this.unput(this.match.slice(s))},"less"),pastInput:l(function(){var s=this.matched.substr(0,this.matched.length-this.match.length);return(s.length>20?"...":"")+s.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:l(function(){var s=this.match;return s.length<20&&(s+=this._input.substr(0,20-s.length)),(s.substr(0,20)+(s.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:l(function(){var s=this.pastInput(),i=new Array(s.length+1).join("-");return s+this.upcomingInput()+`
+`+i+"^"},"showPosition"),test_match:l(function(s,i){var o,c,p;if(this.options.backtrack_lexer&&(p={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(p.yylloc.range=this.yylloc.range.slice(0))),c=s[0].match(/(?:\r\n?|\n).*/g),c&&(this.yylineno+=c.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:c?c[c.length-1].length-c[c.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+s[0].length},this.yytext+=s[0],this.match+=s[0],this.matches=s,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(s[0].length),this.matched+=s[0],o=this.performAction.call(this,this.yy,this,i,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),o)return o;if(this._backtrack){for(var r in p)this[r]=p[r];return!1}return!1},"test_match"),next:l(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var s,i,o,c;this._more||(this.yytext="",this.match="");for(var p=this._currentRules(),r=0;r<p.length;r++)if(o=this._input.match(this.rules[p[r]]),o&&(!i||o[0].length>i[0].length)){if(i=o,c=r,this.options.backtrack_lexer){if(s=this.test_match(o,p[r]),s!==!1)return s;if(this._backtrack){i=!1;continue}else return!1}else if(!this.options.flex)break}return i?(s=this.test_match(i,p[c]),s!==!1?s:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text.
+`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:l(function(){var i=this.next();return i||this.lex()},"lex"),begin:l(function(i){this.conditionStack.push(i)},"begin"),popState:l(function(){var i=this.conditionStack.length-1;return i>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:l(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:l(function(i){return i=this.conditionStack.length-1-Math.abs(i||0),i>=0?this.conditionStack[i]:"INITIAL"},"topState"),pushState:l(function(i){this.begin(i)},"pushState"),stateStackSize:l(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:l(function(i,o,c,p){switch(c){case 0:return i.getLogger().trace("Found comment",o.yytext),6;case 1:return 8;case 2:this.begin("CLASS");break;case 3:return this.popState(),16;case 4:this.popState();break;case 5:i.getLogger().trace("Begin icon"),this.begin("ICON");break;case 6:return i.getLogger().trace("SPACELINE"),6;case 7:return 7;case 8:return 15;case 9:i.getLogger().trace("end icon"),this.popState();break;case 10:return i.getLogger().trace("Exploding node"),this.begin("NODE"),19;case 11:return i.getLogger().trace("Cloud"),this.begin("NODE"),19;case 12:return i.getLogger().trace("Explosion Bang"),this.begin("NODE"),19;case 13:return i.getLogger().trace("Cloud Bang"),this.begin("NODE"),19;case 14:return this.begin("NODE"),19;case 15:return this.begin("NODE"),19;case 16:return this.begin("NODE"),19;case 17:return this.begin("NODE"),19;case 18:return 13;case 19:return 22;case 20:return 11;case 21:this.begin("NSTR2");break;case 22:return"NODE_DESCR";case 23:this.popState();break;case 24:i.getLogger().trace("Starting NSTR"),this.begin("NSTR");break;case 25:return i.getLogger().trace("description:",o.yytext),"NODE_DESCR";case 26:this.popState();break;case 27:return this.popState(),i.getLogger().trace("node end ))"),"NODE_DEND";case 28:return this.popState(),i.getLogger().trace("node end )"),"NODE_DEND";case 29:return this.popState(),i.getLogger().trace("node end ...",o.yytext),"NODE_DEND";case 30:return this.popState(),i.getLogger().trace("node end (("),"NODE_DEND";case 31:return this.popState(),i.getLogger().trace("node end (-"),"NODE_DEND";case 32:return this.popState(),i.getLogger().trace("node end (-"),"NODE_DEND";case 33:return this.popState(),i.getLogger().trace("node end (("),"NODE_DEND";case 34:return this.popState(),i.getLogger().trace("node end (("),"NODE_DEND";case 35:return i.getLogger().trace("Long description:",o.yytext),20;case 36:return i.getLogger().trace("Long description:",o.yytext),20}},"anonymous"),rules:[/^(?:\s*%%.*)/i,/^(?:mindmap\b)/i,/^(?::::)/i,/^(?:.+)/i,/^(?:\n)/i,/^(?:::icon\()/i,/^(?:[\s]+[\n])/i,/^(?:[\n]+)/i,/^(?:[^\)]+)/i,/^(?:\))/i,/^(?:-\))/i,/^(?:\(-)/i,/^(?:\)\))/i,/^(?:\))/i,/^(?:\(\()/i,/^(?:\{\{)/i,/^(?:\()/i,/^(?:\[)/i,/^(?:[\s]+)/i,/^(?:[^\(\[\n\)\{\}]+)/i,/^(?:$)/i,/^(?:["][`])/i,/^(?:[^`"]+)/i,/^(?:[`]["])/i,/^(?:["])/i,/^(?:[^"]+)/i,/^(?:["])/i,/^(?:[\)]\))/i,/^(?:[\)])/i,/^(?:[\]])/i,/^(?:\}\})/i,/^(?:\(-)/i,/^(?:-\))/i,/^(?:\(\()/i,/^(?:\()/i,/^(?:[^\)\]\(\}]+)/i,/^(?:.+(?!\(\())/i],conditions:{CLASS:{rules:[3,4],inclusive:!1},ICON:{rules:[8,9],inclusive:!1},NSTR2:{rules:[22,23],inclusive:!1},NSTR:{rules:[25,26],inclusive:!1},NODE:{rules:[21,24,27,28,29,30,31,32,33,34,35,36],inclusive:!1},INITIAL:{rules:[0,1,2,5,6,7,10,11,12,13,14,15,16,17,18,19,20],inclusive:!0}}};return D})();j.lexer=te;function P(){this.yy={}}return l(P,"Parser"),P.prototype=j,j.Parser=P,new P})();Y.parser=Y;var be=Y,ke=12,N={DEFAULT:0,NO_BORDER:0,ROUNDED_RECT:1,RECT:2,CIRCLE:3,CLOUD:4,BANG:5,HEXAGON:6},Se=class{constructor(){this.nodes=[],this.count=0,this.elements={},this.getLogger=this.getLogger.bind(this),this.nodeType=N,this.clear(),this.getType=this.getType.bind(this),this.getElementById=this.getElementById.bind(this),this.getParent=this.getParent.bind(this),this.getMindmap=this.getMindmap.bind(this),this.addNode=this.addNode.bind(this),this.decorateNode=this.decorateNode.bind(this)}static{l(this,"MindmapDB")}clear(){this.nodes=[],this.count=0,this.elements={},this.baseLevel=void 0}getParent(e){for(let n=this.nodes.length-1;n>=0;n--)if(this.nodes[n].level<e)return this.nodes[n];return null}getMindmap(){return this.nodes.length>0?this.nodes[0]:null}addNode(e,n,g,a){C.info("addNode",e,n,g,a);let t=!1;this.nodes.length===0?(this.baseLevel=e,e=0,t=!0):this.baseLevel!==void 0&&(e=e-this.baseLevel,t=!1);const h=B();let f=h.mindmap?.padding??G.mindmap.padding;switch(a){case this.nodeType.ROUNDED_RECT:case this.nodeType.RECT:case this.nodeType.HEXAGON:f*=2;break}const m={id:this.count++,nodeId:F(n,h),level:e,descr:F(g,h),type:a,children:[],width:h.mindmap?.maxNodeWidth??G.mindmap.maxNodeWidth,padding:f,isRoot:t},_=this.getParent(e);if(_)_.children.push(m),this.nodes.push(m);else if(t)this.nodes.push(m);else throw new Error(`There can be only one root. No parent could be found for ("${m.descr}")`)}getType(e,n){switch(C.debug("In get type",e,n),e){case"[":return this.nodeType.RECT;case"(":return n===")"?this.nodeType.ROUNDED_RECT:this.nodeType.CLOUD;case"((":return this.nodeType.CIRCLE;case")":return this.nodeType.CLOUD;case"))":return this.nodeType.BANG;case"{{":return this.nodeType.HEXAGON;default:return this.nodeType.DEFAULT}}setElementForId(e,n){this.elements[e]=n}getElementById(e){return this.elements[e]}decorateNode(e){if(!e)return;const n=B(),g=this.nodes[this.nodes.length-1];e.icon&&(g.icon=F(e.icon,n)),e.class&&(g.class=F(e.class,n))}type2Str(e){switch(e){case this.nodeType.DEFAULT:return"no-border";case this.nodeType.RECT:return"rect";case this.nodeType.ROUNDED_RECT:return"rounded-rect";case this.nodeType.CIRCLE:return"circle";case this.nodeType.CLOUD:return"cloud";case this.nodeType.BANG:return"bang";case this.nodeType.HEXAGON:return"hexgon";default:return"no-border"}}assignSections(e,n){if(e.level===0?e.section=void 0:e.section=n,e.children)for(const[g,a]of e.children.entries()){const t=e.level===0?g%(ke-1):n;this.assignSections(a,t)}}flattenNodes(e,n){const g=B(),a=["mindmap-node"];e.isRoot===!0?a.push("section-root","section--1"):e.section!==void 0&&a.push(`section-${e.section}`),e.class&&a.push(e.class);const t=a.join(" "),h=l(m=>{const T=(g.theme?.toLowerCase()??"").includes("redux");switch(m){case N.CIRCLE:return"mindmapCircle";case N.RECT:return"rect";case N.ROUNDED_RECT:return"rounded";case N.CLOUD:return"cloud";case N.BANG:return"bang";case N.HEXAGON:return"hexagon";case N.DEFAULT:return T?"rounded":"defaultMindmapNode";case N.NO_BORDER:default:return"rect"}},"getShapeFromType"),f={id:e.id.toString(),domId:"node_"+e.id.toString(),label:e.descr,labelType:"markdown",isGroup:!1,shape:h(e.type),width:e.width,height:e.height??0,padding:e.padding,cssClasses:t,cssStyles:[],look:g.look,icon:e.icon,x:e.x,y:e.y,level:e.level,nodeId:e.nodeId,type:e.type,section:e.section};if(n.push(f),e.children)for(const m of e.children)this.flattenNodes(m,n)}generateEdges(e,n){if(!e.children)return;const g=B();for(const a of e.children){let t="edge";a.section!==void 0&&(t+=` section-edge-${a.section}`);const h=e.level+1;t+=` edge-depth-${h}`;const f={id:`edge_${e.id}_${a.id}`,start:e.id.toString(),end:a.id.toString(),type:"normal",curve:"basis",thickness:"normal",look:g.look,classes:t,depth:e.level,section:a.section};n.push(f),this.generateEdges(a,n)}}getData(){const e=this.getMindmap(),n=B(),a=de().layout!==void 0,t=n;if(a||(t.layout="cose-bilkent"),!e)return{nodes:[],edges:[],config:t};C.debug("getData: mindmapRoot",e,n),this.assignSections(e);const h=[],f=[];this.flattenNodes(e,h),this.generateEdges(e,f),C.debug(`getData: processed ${h.length} nodes and ${f.length} edges`);const m=new Map;for(const _ of h)m.set(_.id,{shape:_.shape,width:_.width,height:_.height,padding:_.padding});return{nodes:h,edges:f,config:t,rootNode:e,markers:["point"],direction:"TB",nodeSpacing:50,rankSpacing:50,shapes:Object.fromEntries(m),type:"mindmap",diagramId:"mindmap-"+Ee()}}getLogger(){return C}},xe=l(async(e,n,g,a)=>{C.debug(`Rendering mindmap diagram
+`+e);const t=a.db,h=t.getData(),f=oe(n,h.config.securityLevel);if(h.type=a.type,h.layoutAlgorithm=ce(h.config.layout,{fallback:"cose-bilkent"}),h.diagramId=n,!t.getMindmap())return;h.nodes.forEach(d=>{d.shape==="rounded"?(d.radius=15,d.taper=15,d.stroke="none",d.width=0,d.padding=15):d.shape==="circle"?d.padding=10:d.shape==="rect"?(d.width=0,d.padding=10):d.shape==="hexagon"&&(d.width=0,d.height=0)}),await le(h,f);const{themeVariables:_}=he(),{useGradient:T,gradientStart:I,gradientStop:w}=_;if(T&&I&&w){const d=f.attr("id"),R=f.append("defs").append("linearGradient").attr("id",`${d}-gradient`).attr("gradientUnits","objectBoundingBox").attr("x1","0%").attr("y1","0%").attr("x2","100%").attr("y2","0%");R.append("stop").attr("offset","0%").attr("stop-color",I).attr("stop-opacity",1),R.append("stop").attr("offset","100%").attr("stop-color",w).attr("stop-opacity",1)}ae(f,h.config.mindmap?.padding??G.mindmap.padding,"mindmapDiagram",h.config.mindmap?.useMaxWidth??G.mindmap.useMaxWidth)},"draw"),Ne={draw:xe},De=l(e=>{const{theme:n,look:g}=e;let a="";for(let t=0;t<e.THEME_COLOR_LIMIT;t++)e["lineColor"+t]=e["lineColor"+t]||e["cScaleInv"+t],ge(e["lineColor"+t])?e["lineColor"+t]=ue(e["lineColor"+t],20):e["lineColor"+t]=pe(e["lineColor"+t],20);for(let t=0;t<e.THEME_COLOR_LIMIT;t++){const h=""+(g==="neo"?Math.max(10-(t-1)*2,2):17-3*t);a+=`
+    .section-${t-1} rect, .section-${t-1} path, .section-${t-1} circle, .section-${t-1} polygon, .section-${t-1} path  {
+      fill: ${e["cScale"+t]};
+    }
+    .section-${t-1} text {
+     fill: ${e["cScaleLabel"+t]};
+    }
+     .section-${t-1} span {
+     color: ${e["cScaleLabel"+t]};
+    }
+    .node-icon-${t-1} {
+      font-size: 40px;
+      color: ${e["cScaleLabel"+t]};
+    }
+    .section-edge-${t-1}{
+      stroke: ${e["cScale"+t]};
+    }
+    .edge-depth-${t-1}{
+      stroke-width: ${h};
+    }
+    .section-${t-1} line {
+      stroke: ${e["cScaleInv"+t]} ;
+      stroke-width: 3;
+    }
+
+    .disabled, .disabled circle, .disabled text {
+      fill: lightgray;
+    }
+    .disabled text {
+      fill: #efefef;
+    }
+    [data-look="neo"].mindmap-node.section-${t-1} rect, [data-look="neo"].mindmap-node.section-${t-1} path, [data-look="neo"].mindmap-node.section-${t-1} circle, [data-look="neo"].mindmap-node.section-${t-1} polygon {
+      fill: ${n==="redux"||n==="redux-dark"||n==="neutral"?e.mainBkg:e["cScale"+t]};
+      stroke: ${n==="redux"||n==="redux-dark"?e.nodeBorder:e["cScale"+t]};
+      stroke-width: ${e.strokeWidth??2}px;
+    }
+    [data-look="neo"].section-edge-${t-1}{
+      stroke: ${n?.includes("redux")||n==="neo-dark"?e.nodeBorder:e["cScale"+t]};
+    }
+    [data-look="neo"].mindmap-node.section-${t-1} text {
+     fill: ${n==="redux"||n==="redux-dark"?e.nodeBorder:e["cScaleLabel"+(n==="neutral"?1:t)]};
+    }
+    `}return a},"genSections"),Le=l((e,n,g)=>{let a="";for(let t=0;t<e;t++)a+=`
+    [data-look="neo"].mindmap-node.section-${t-1} rect, [data-look="neo"].mindmap-node.section-${t-1} path, [data-look="neo"].mindmap-node.section-${t-1} circle, [data-look="neo"].mindmap-node.section-${t-1} polygon {
+      stroke: url(${n}-gradient);
+      fill: ${g};
+    }
+    .section-${t-1} line {
+      stroke-width: 0;
+    }`;return a},"genGradient"),ve=l(e=>{const{theme:n}=e,g=e.svgId,a=e.dropShadow?e.dropShadow.replace("url(#drop-shadow)",`url(${g}-drop-shadow)`):"none";return`
+  .edge {
+    stroke-width: 3;
+  }
+  ${De(e)}
+  .section-root rect, .section-root path, .section-root circle, .section-root polygon  {
+    fill: ${e.git0};
+  }
+  .section-root text {
+    fill: ${e.gitBranchLabel0};
+  }
+  .section-root span {
+    color: ${n?.includes("redux")?e.nodeBorder:e.gitBranchLabel0};
+  }
+  .icon-container {
+    height:100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+  .edge {
+    fill: none;
+  }
+  .mindmap-node-label {
+    dy: 1em;
+    alignment-baseline: middle;
+    text-anchor: middle;
+    dominant-baseline: middle;
+    text-align: center;
+  }
+  [data-look="neo"].mindmap-node  {
+    filter: ${a};
+  }
+  [data-look="neo"].mindmap-node.section-root rect, [data-look="neo"].mindmap-node.section-root path, [data-look="neo"].mindmap-node.section-root circle, [data-look="neo"].mindmap-node.section-root polygon  {
+    fill: ${n?.includes("redux")?e.mainBkg:e.git0};
+  }
+  [data-look="neo"].mindmap-node.section-root .text-inner-tspan {
+    fill:  ${n?.includes("redux")?e.nodeBorder:e["cScaleLabel"+(n==="neutral"?1:0)]};
+  }
+  ${e.useGradient&&g&&e.mainBkg?Le(e.THEME_COLOR_LIMIT,g,e.mainBkg):""}
+`},"getStyles"),Te=ve,Ae={get db(){return new Se},renderer:Ne,parser:be,styles:Te};export{Ae as diagram};

apps/kimi-code/dist-web/assets/pkl-u5AG7uiY.js

@@ -0,0 +1 @@
+const e=Object.freeze(JSON.parse('{"displayName":"Pkl","fileTypes":["pkl","pcf"],"foldingStartMarker":"\\\\{","foldingStopMarker":"}","name":"pkl","patterns":[{"captures":{"1":{"name":"variable.language.pkl"},"2":{"name":"variable.other.module.pkl"}},"match":"\\\\b(module)\\\\s+([$_\\\\p{L}][$0-9_\\\\p{L}]*(?:\\\\.[$_\\\\p{L}][$0-9_\\\\p{L}]*)*)"},{"captures":{"1":{"name":"keyword.class.pkl"},"2":{"name":"entity.name.type.pkl"},"3":{"name":"punctuation.pkl"},"4":{"name":"entity.name.type.pkl"}},"match":"(typealias)\\\\s+([$_\\\\p{L}][$0-9_\\\\p{L}]*)\\\\s*(=)\\\\s*([$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??\\\\s*(\\\\|\\\\s*[$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??)*)"},{"captures":{"1":{"name":"keyword.class.pkl"}},"match":"\\\\b(class)\\\\s+[$_\\\\p{L}][$0-9_\\\\p{L}]*","name":"entity.name.type.pkl"},{"captures":{"1":{"name":"keyword.control.pkl"},"2":{"name":"variable.other.property.pkl"},"3":{"name":"variable.other.property.pkl"},"4":{"name":"storage.modifier.pkl"}},"match":"\\\\b(for)\\\\s*\\\\(([$_\\\\p{L}][$0-9_\\\\p{L}]*)(?:\\\\s*,\\\\s*([$_\\\\p{L}][$0-9_\\\\p{L}]*))*\\\\s+(in)"},{"captures":{"1":{"name":"keyword.control.pkl"},"2":{"name":"entity.name.type.pkl"}},"match":"\\\\b(new)\\\\s+([$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??\\\\s*(\\\\|\\\\s*[$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??)*)"},{"captures":{"1":{"name":"keyword.pkl"},"2":{"name":"variable.other.property.pkl"}},"match":"\\\\b(function)\\\\s+([$_\\\\p{L}][$0-9_\\\\p{L}]*)"},{"captures":{"1":{"name":"keyword.pkl"},"2":{"name":"entity.name.type.pkl"}},"match":"\\\\b(as)\\\\s+([$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??\\\\s*(\\\\|\\\\s*[$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??)*)"},{"match":"\\\\b(true|false|null)\\\\b","name":"constant.character.language.pkl"},{"match":"//.*","name":"comment.line.pkl"},{"begin":"/\\\\*","end":"\\\\*/","name":"comment.block.pkl"},{"begin":"((?:\\\\b|\\\\s*)[$_\\\\p{L}][$0-9_\\\\p{L}]*|`[^`]+`)\\\\s*(:)\\\\s*([$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??\\\\s*(\\\\|\\\\s*[$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??)*)","captures":{"1":{"name":"variable.other.property.pkl"},"2":{"name":"punctuation.pkl"},"3":{"name":"entity.name.type.pkl"}},"end":"\\\\s*=|[),]|^[\\\\t ]*$"},{"captures":{"1":{"name":"variable.other.property.pkl"},"2":{"name":"punctuation.pkl"}},"match":"(\\\\b[$_\\\\p{L}][$0-9_\\\\p{L}]*|`[^`]+`)\\\\s*(=)(?!=)"},{"captures":{"1":{"name":"punctuation.pkl"},"2":{"name":"entity.name.type.pkl"}},"match":"(:)\\\\s*([$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??\\\\s*(\\\\|\\\\s*[$_\\\\p{L}][$0-9_\\\\p{L}]*\\\\s*(?:<[^>]*>)?\\\\s*(?:\\\\([^)]*\\\\))?\\\\s*\\\\??)*)"},{"captures":{"1":{"name":"variable.other.property.pkl"}},"match":"^\\\\s*([$_\\\\p{L}][$0-9_\\\\p{L}]*)\\\\s*\\\\{"},{"match":"\\\\b(hidden|local|abstract|external|open|in|out|amends|extends|fixed|const)\\\\b","name":"storage.modifier.pkl"},{"match":"\\\\b(amends|as|extends|function|is|let|read\\\\???|import|throw|trace)\\\\b","name":"keyword.pkl"},{"match":"\\\\b(if|else|when|for|import|new)\\\\b","name":"keyword.control.pkl"},{"match":"\\\\b0x(?:[A-Fa-f\\\\d][A-F_a-f\\\\d]*[A-Fa-f\\\\d]|[A-F_a-f\\\\d])\\\\b","name":"constant.numeric.hex.pkl"},{"match":"\\\\b0b(?:[01][01_]*[01]|[01])\\\\b","name":"constant.numeric.binary.pkl"},{"match":"\\\\b0o(?:[0-7][0-7_]*[0-7]|[0-7])\\\\b","name":"constant.numeric.octal.pkl"},{"match":"\\\\b\\\\d(?:[0-9_]*\\\\d|)\\\\b","name":"constant.numeric.decimal.pkl"},{"match":"\\\\b(?:(?:\\\\d(?:[0-9_]*\\\\d|))?\\\\.\\\\d(?:[0-9_]*\\\\d|)(?:[Ee][-+]?\\\\d(?:[0-9_]*\\\\d|))?|\\\\d(?:[0-9_]*\\\\d|)[Ee][-+]?\\\\d(?:[0-9_]*\\\\d|))\\\\b","name":"constant.numeric.pkl"},{"match":"[-*+/]|~/|%|\\\\*\\\\*|>=??|<=??|==|!=?|&&|\\\\|\\\\||\\\\|>|\\\\?\\\\?|!!|=|->|\\\\|","name":"keyword.operator.pkl"},{"match":"\\\\b(this|module|outer|super)\\\\b","name":"variable.language.pkl"},{"match":"\\\\b(unknown|never)\\\\b","name":"support.type.pkl"},{"match":"[]()\\\\[{}]","name":"meta.brace.pkl"},{"match":"\\\\b(class|typealias)\\\\b","name":"keyword.class.pkl"},{"match":"\\\\.\\\\?|[.:;]","name":"punctuation.pkl"},{"match":"@[$_\\\\p{L}][$0-9_\\\\p{L}]*","name":"entity.name.type.pkl"},{"begin":"(\\"\\"\\")","captures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"\\"\\")","name":"string.quoted.triple.0.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\.)","name":"constant.character.escape.0.pkl"}]},{"begin":"(\\")","beginCaptures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\")|(.?)$","endCaptures":{"1":{"name":"punctuation.delimimter.pkl"},"2":{"name":"invalid.illegal.newline.pkl"}},"name":"string.quoted.double.0.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\.)","name":"constant.character.escape.0.pkl"}]},{"begin":"(#\\"\\"\\")","captures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"\\"\\"#)","name":"string.quoted.triple.1.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\#(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\#.)","name":"constant.character.escape.1.pkl"}]},{"begin":"(#\\")","beginCaptures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"#)|(.?)$","endCaptures":{"1":{"name":"punctuation.delimimter.pkl"},"2":{"name":"invalid.illegal.newline.pkl"}},"name":"string.quoted.double.1.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\#(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\#.)","name":"constant.character.escape.1.pkl"}]},{"begin":"(##\\"\\"\\")","captures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"\\"\\"##)","name":"string.quoted.triple.2.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\##(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\##.)","name":"constant.character.escape.2.pkl"}]},{"begin":"(##\\")","beginCaptures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"##)|(.?)$","endCaptures":{"1":{"name":"punctuation.delimimter.pkl"},"2":{"name":"invalid.illegal.newline.pkl"}},"name":"string.quoted.double.2.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\##(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\##.)","name":"constant.character.escape.2.pkl"}]},{"begin":"(###\\"\\"\\")","captures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"\\"\\"###)","name":"string.quoted.triple.3.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\###(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\###.)","name":"constant.character.escape.3.pkl"}]},{"begin":"(###\\")","beginCaptures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"###)|(.?)$","endCaptures":{"1":{"name":"punctuation.delimimter.pkl"},"2":{"name":"invalid.illegal.newline.pkl"}},"name":"string.quoted.double.3.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\###(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\###.)","name":"constant.character.escape.3.pkl"}]},{"begin":"(####\\"\\"\\")","captures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"\\"\\"####)","name":"string.quoted.triple.4.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\####(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\####.)","name":"constant.character.escape.4.pkl"}]},{"begin":"(####\\")","beginCaptures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"####)|(.?)$","endCaptures":{"1":{"name":"punctuation.delimimter.pkl"},"2":{"name":"invalid.illegal.newline.pkl"}},"name":"string.quoted.double.4.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\####(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\####.)","name":"constant.character.escape.4.pkl"}]},{"begin":"(#####\\"\\"\\")","captures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"\\"\\"#####)","name":"string.quoted.triple.5.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\#####(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\#####.)","name":"constant.character.escape.5.pkl"}]},{"begin":"(#####\\")","beginCaptures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"#####)|(.?)$","endCaptures":{"1":{"name":"punctuation.delimimter.pkl"},"2":{"name":"invalid.illegal.newline.pkl"}},"name":"string.quoted.double.5.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\#####(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\#####.)","name":"constant.character.escape.5.pkl"}]},{"begin":"(######\\"\\"\\")","captures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"\\"\\"######)","name":"string.quoted.triple.6.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\######(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\######.)","name":"constant.character.escape.6.pkl"}]},{"begin":"(######\\")","beginCaptures":{"1":{"name":"punctuation.delimiter.pkl"}},"end":"(\\"######)|(.?)$","endCaptures":{"1":{"name":"punctuation.delimimter.pkl"},"2":{"name":"invalid.illegal.newline.pkl"}},"name":"string.quoted.double.6.pkl","patterns":[{"captures":{"1":{"name":"invalid.illegal.unrecognized-string-escape.pkl"}},"match":"\\\\\\\\######(?:[\\"\\\\\\\\nrt]|u\\\\{[A-Fa-f\\\\d]+}|\\\\(.+?\\\\))|(\\\\\\\\######.)","name":"constant.character.escape.6.pkl"}]}],"scopeName":"source.pkl"}')),a=[e];export{a as default};

apps/kimi-code/dist-web/assets/timeline-definition-FHXFAJF6-CHrctaTh.js

@@ -0,0 +1,120 @@
+import{_ as o,y as pt,T as Rt,U as Ct,V as Wt,c as gt,l as E,D as Pt,K as Bt,W as ft,d as X,t as Vt,X as Ft,p as zt}from"./mermaidParser.worker-BFSlSHEW.js";import{d as ot}from"./arc-Bh_RIraT.js";var tt=(function(){var e=o(function(k,s,d,l){for(d=d||{},l=k.length;l--;d[k[l]]=s);return d},"o"),t=[6,11,13,14,15,17,19,20,23,24],n=[1,12],i=[1,13],r=[1,14],h=[1,15],c=[1,16],a=[1,19],f=[1,20],g={trace:o(function(){},"trace"),yy:{},symbols_:{error:2,start:3,timeline_header:4,document:5,EOF:6,timeline:7,timeline_lr:8,timeline_td:9,line:10,SPACE:11,statement:12,NEWLINE:13,title:14,acc_title:15,acc_title_value:16,acc_descr:17,acc_descr_value:18,acc_descr_multiline_value:19,section:20,period_statement:21,event_statement:22,period:23,event:24,$accept:0,$end:1},terminals_:{2:"error",6:"EOF",7:"timeline",8:"timeline_lr",9:"timeline_td",11:"SPACE",13:"NEWLINE",14:"title",15:"acc_title",16:"acc_title_value",17:"acc_descr",18:"acc_descr_value",19:"acc_descr_multiline_value",20:"section",23:"period",24:"event"},productions_:[0,[3,3],[4,1],[4,1],[4,1],[5,0],[5,2],[10,2],[10,1],[10,1],[10,1],[12,1],[12,2],[12,2],[12,1],[12,1],[12,1],[12,1],[21,1],[22,1]],performAction:o(function(s,d,l,p,x,u,S){var v=u.length-1;switch(x){case 1:return u[v-1];case 3:p.setDirection("LR");break;case 4:p.setDirection("TD");break;case 5:this.$=[];break;case 6:u[v-1].push(u[v]),this.$=u[v-1];break;case 7:case 8:this.$=u[v];break;case 9:case 10:this.$=[];break;case 11:p.getCommonDb().setDiagramTitle(u[v].substr(6)),this.$=u[v].substr(6);break;case 12:this.$=u[v].trim(),p.getCommonDb().setAccTitle(this.$);break;case 13:case 14:this.$=u[v].trim(),p.getCommonDb().setAccDescription(this.$);break;case 15:p.addSection(u[v].substr(8)),this.$=u[v].substr(8);break;case 18:p.addTask(u[v],0,""),this.$=u[v];break;case 19:p.addEvent(u[v].substr(2)),this.$=u[v];break}},"anonymous"),table:[{3:1,4:2,7:[1,3],8:[1,4],9:[1,5]},{1:[3]},e(t,[2,5],{5:6}),e(t,[2,2]),e(t,[2,3]),e(t,[2,4]),{6:[1,7],10:8,11:[1,9],12:10,13:[1,11],14:n,15:i,17:r,19:h,20:c,21:17,22:18,23:a,24:f},e(t,[2,10],{1:[2,1]}),e(t,[2,6]),{12:21,14:n,15:i,17:r,19:h,20:c,21:17,22:18,23:a,24:f},e(t,[2,8]),e(t,[2,9]),e(t,[2,11]),{16:[1,22]},{18:[1,23]},e(t,[2,14]),e(t,[2,15]),e(t,[2,16]),e(t,[2,17]),e(t,[2,18]),e(t,[2,19]),e(t,[2,7]),e(t,[2,12]),e(t,[2,13])],defaultActions:{},parseError:o(function(s,d){if(d.recoverable)this.trace(s);else{var l=new Error(s);throw l.hash=d,l}},"parseError"),parse:o(function(s){var d=this,l=[0],p=[],x=[null],u=[],S=this.table,v="",I=0,R=0,W=2,O=1,L=u.slice.call(arguments,1),w=Object.create(this.lexer),H={yy:{}};for(var V in this.yy)Object.prototype.hasOwnProperty.call(this.yy,V)&&(H.yy[V]=this.yy[V]);w.setInput(s,H.yy),H.yy.lexer=w,H.yy.parser=this,typeof w.yylloc>"u"&&(w.yylloc={});var F=w.yylloc;u.push(F);var U=w.options&&w.options.ranges;typeof H.yy.parseError=="function"?this.parseError=H.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function N(A){l.length=l.length-2*A,x.length=x.length-A,u.length=u.length-A}o(N,"popStack");function b(){var A;return A=p.pop()||w.lex()||O,typeof A!="number"&&(A instanceof Array&&(p=A,A=p.pop()),A=d.symbols_[A]||A),A}o(b,"lex");for(var _,$,T,P,C={},G,B,Z,j;;){if($=l[l.length-1],this.defaultActions[$]?T=this.defaultActions[$]:((_===null||typeof _>"u")&&(_=b()),T=S[$]&&S[$][_]),typeof T>"u"||!T.length||!T[0]){var Y="";j=[];for(G in S[$])this.terminals_[G]&&G>W&&j.push("'"+this.terminals_[G]+"'");w.showPosition?Y="Parse error on line "+(I+1)+`:
+`+w.showPosition()+`
+Expecting `+j.join(", ")+", got '"+(this.terminals_[_]||_)+"'":Y="Parse error on line "+(I+1)+": Unexpected "+(_==O?"end of input":"'"+(this.terminals_[_]||_)+"'"),this.parseError(Y,{text:w.match,token:this.terminals_[_]||_,line:w.yylineno,loc:F,expected:j})}if(T[0]instanceof Array&&T.length>1)throw new Error("Parse Error: multiple actions possible at state: "+$+", token: "+_);switch(T[0]){case 1:l.push(_),x.push(w.yytext),u.push(w.yylloc),l.push(T[1]),_=null,R=w.yyleng,v=w.yytext,I=w.yylineno,F=w.yylloc;break;case 2:if(B=this.productions_[T[1]][1],C.$=x[x.length-B],C._$={first_line:u[u.length-(B||1)].first_line,last_line:u[u.length-1].last_line,first_column:u[u.length-(B||1)].first_column,last_column:u[u.length-1].last_column},U&&(C._$.range=[u[u.length-(B||1)].range[0],u[u.length-1].range[1]]),P=this.performAction.apply(C,[v,R,I,H.yy,T[1],x,u].concat(L)),typeof P<"u")return P;B&&(l=l.slice(0,-1*B*2),x=x.slice(0,-1*B),u=u.slice(0,-1*B)),l.push(this.productions_[T[1]][0]),x.push(C.$),u.push(C._$),Z=S[l[l.length-2]][l[l.length-1]],l.push(Z);break;case 3:return!0}}return!0},"parse")},m=(function(){var k={EOF:1,parseError:o(function(d,l){if(this.yy.parser)this.yy.parser.parseError(d,l);else throw new Error(d)},"parseError"),setInput:o(function(s,d){return this.yy=d||this.yy||{},this._input=s,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},"setInput"),input:o(function(){var s=this._input[0];this.yytext+=s,this.yyleng++,this.offset++,this.match+=s,this.matched+=s;var d=s.match(/(?:\r\n?|\n).*/g);return d?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),s},"input"),unput:o(function(s){var d=s.length,l=s.split(/(?:\r\n?|\n)/g);this._input=s+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-d),this.offset-=d;var p=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),l.length-1&&(this.yylineno-=l.length-1);var x=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:l?(l.length===p.length?this.yylloc.first_column:0)+p[p.length-l.length].length-l[0].length:this.yylloc.first_column-d},this.options.ranges&&(this.yylloc.range=[x[0],x[0]+this.yyleng-d]),this.yyleng=this.yytext.length,this},"unput"),more:o(function(){return this._more=!0,this},"more"),reject:o(function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},"reject"),less:o(function(s){this.unput(this.match.slice(s))},"less"),pastInput:o(function(){var s=this.matched.substr(0,this.matched.length-this.match.length);return(s.length>20?"...":"")+s.substr(-20).replace(/\n/g,"")},"pastInput"),upcomingInput:o(function(){var s=this.match;return s.length<20&&(s+=this._input.substr(0,20-s.length)),(s.substr(0,20)+(s.length>20?"...":"")).replace(/\n/g,"")},"upcomingInput"),showPosition:o(function(){var s=this.pastInput(),d=new Array(s.length+1).join("-");return s+this.upcomingInput()+`
+`+d+"^"},"showPosition"),test_match:o(function(s,d){var l,p,x;if(this.options.backtrack_lexer&&(x={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(x.yylloc.range=this.yylloc.range.slice(0))),p=s[0].match(/(?:\r\n?|\n).*/g),p&&(this.yylineno+=p.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:p?p[p.length-1].length-p[p.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+s[0].length},this.yytext+=s[0],this.match+=s[0],this.matches=s,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(s[0].length),this.matched+=s[0],l=this.performAction.call(this,this.yy,this,d,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),l)return l;if(this._backtrack){for(var u in x)this[u]=x[u];return!1}return!1},"test_match"),next:o(function(){if(this.done)return this.EOF;this._input||(this.done=!0);var s,d,l,p;this._more||(this.yytext="",this.match="");for(var x=this._currentRules(),u=0;u<x.length;u++)if(l=this._input.match(this.rules[x[u]]),l&&(!d||l[0].length>d[0].length)){if(d=l,p=u,this.options.backtrack_lexer){if(s=this.test_match(l,x[u]),s!==!1)return s;if(this._backtrack){d=!1;continue}else return!1}else if(!this.options.flex)break}return d?(s=this.test_match(d,x[p]),s!==!1?s:!1):this._input===""?this.EOF:this.parseError("Lexical error on line "+(this.yylineno+1)+`. Unrecognized text.
+`+this.showPosition(),{text:"",token:null,line:this.yylineno})},"next"),lex:o(function(){var d=this.next();return d||this.lex()},"lex"),begin:o(function(d){this.conditionStack.push(d)},"begin"),popState:o(function(){var d=this.conditionStack.length-1;return d>0?this.conditionStack.pop():this.conditionStack[0]},"popState"),_currentRules:o(function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},"_currentRules"),topState:o(function(d){return d=this.conditionStack.length-1-Math.abs(d||0),d>=0?this.conditionStack[d]:"INITIAL"},"topState"),pushState:o(function(d){this.begin(d)},"pushState"),stateStackSize:o(function(){return this.conditionStack.length},"stateStackSize"),options:{"case-insensitive":!0},performAction:o(function(d,l,p,x){switch(p){case 0:break;case 1:break;case 2:return 13;case 3:break;case 4:break;case 5:return 8;case 6:return 9;case 7:return 7;case 8:return 14;case 9:return this.begin("acc_title"),15;case 10:return this.popState(),"acc_title_value";case 11:return this.begin("acc_descr"),17;case 12:return this.popState(),"acc_descr_value";case 13:this.begin("acc_descr_multiline");break;case 14:this.popState();break;case 15:return"acc_descr_multiline_value";case 16:return 20;case 17:return 24;case 18:return 23;case 19:return 6;case 20:return"INVALID"}},"anonymous"),rules:[/^(?:%(?!\{)[^\n]*)/i,/^(?:[^\}]%%[^\n]*)/i,/^(?:[\n]+)/i,/^(?:\s+)/i,/^(?:#[^\n]*)/i,/^(?:timeline[ \t]+LR\b)/i,/^(?:timeline[ \t]+TD\b)/i,/^(?:timeline\b)/i,/^(?:title\s[^\n]+)/i,/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:section\s[^:\n]+)/i,/^(?::\s(?:[^:\n]|:(?!\s))+)/i,/^(?:[^#:\n]+)/i,/^(?:$)/i,/^(?:.)/i],conditions:{acc_descr_multiline:{rules:[14,15],inclusive:!1},acc_descr:{rules:[12],inclusive:!1},acc_title:{rules:[10],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,7,8,9,11,13,16,17,18,19,20],inclusive:!0}}};return k})();g.lexer=m;function y(){this.yy={}}return o(y,"Parser"),y.prototype=g,g.Parser=y,new y})();tt.parser=tt;var Ot=tt,yt={};Vt(yt,{addEvent:()=>Tt,addSection:()=>_t,addTask:()=>Et,addTaskOrg:()=>$t,clear:()=>kt,default:()=>Gt,getCommonDb:()=>xt,getDirection:()=>bt,getSections:()=>wt,getTasks:()=>St,setDirection:()=>vt});var D="",mt=0,nt="LR",rt=[],q=[],K=[],xt=o(()=>Ft,"getCommonDb"),kt=o(function(){rt.length=0,q.length=0,D="",K.length=0,nt="LR",zt()},"clear"),vt=o(function(e){nt=e},"setDirection"),bt=o(function(){return nt},"getDirection"),_t=o(function(e){D=e,rt.push(e)},"addSection"),wt=o(function(){return rt},"getSections"),St=o(function(){let e=ct();const t=100;let n=0;for(;!e&&n<t;)e=ct(),n++;return q.push(...K),q},"getTasks"),Et=o(function(e,t,n){const i={id:mt++,section:D,type:D,task:e,score:t||0,events:n?[n]:[]};K.push(i)},"addTask"),Tt=o(function(e){K.find(n=>n.id===mt-1).events.push(e)},"addEvent"),$t=o(function(e){const t={section:D,type:D,description:e,task:e,classes:[]};q.push(t)},"addTaskOrg"),ct=o(function(){const e=o(function(n){return K[n].processed},"compileTask");let t=!0;for(const[n,i]of K.entries())e(n),t=t&&i.processed;return t},"compileTasks"),Gt={clear:kt,getCommonDb:xt,getDirection:bt,setDirection:vt,addSection:_t,getSections:wt,getTasks:St,addTask:Et,addTaskOrg:$t,addEvent:Tt},Nt=0,J=o(function(e,t){const n=e.append("rect");return n.attr("x",t.x),n.attr("y",t.y),n.attr("fill",t.fill),n.attr("stroke",t.stroke),n.attr("width",t.width),n.attr("height",t.height),n.attr("rx",t.rx),n.attr("ry",t.ry),t.class!==void 0&&n.attr("class",t.class),n},"drawRect"),Dt=o(function(e,t){const i=e.append("circle").attr("cx",t.cx).attr("cy",t.cy).attr("class","face").attr("r",15).attr("stroke-width",2).attr("overflow","visible"),r=e.append("g");r.append("circle").attr("cx",t.cx-15/3).attr("cy",t.cy-15/3).attr("r",1.5).attr("stroke-width",2).attr("fill","#666").attr("stroke","#666"),r.append("circle").attr("cx",t.cx+15/3).attr("cy",t.cy-15/3).attr("r",1.5).attr("stroke-width",2).attr("fill","#666").attr("stroke","#666");function h(f){const g=ot().startAngle(Math.PI/2).endAngle(3*(Math.PI/2)).innerRadius(7.5).outerRadius(6.8181818181818175);f.append("path").attr("class","mouth").attr("d",g).attr("transform","translate("+t.cx+","+(t.cy+2)+")")}o(h,"smile");function c(f){const g=ot().startAngle(3*Math.PI/2).endAngle(5*(Math.PI/2)).innerRadius(7.5).outerRadius(6.8181818181818175);f.append("path").attr("class","mouth").attr("d",g).attr("transform","translate("+t.cx+","+(t.cy+7)+")")}o(c,"sad");function a(f){f.append("line").attr("class","mouth").attr("stroke",2).attr("x1",t.cx-5).attr("y1",t.cy+7).attr("x2",t.cx+5).attr("y2",t.cy+7).attr("class","mouth").attr("stroke-width","1px").attr("stroke","#666")}return o(a,"ambivalent"),t.score>3?h(r):t.score<3?c(r):a(r),i},"drawFace"),Kt=o(function(e,t){const n=e.append("circle");return n.attr("cx",t.cx),n.attr("cy",t.cy),n.attr("class","actor-"+t.pos),n.attr("fill",t.fill),n.attr("stroke",t.stroke),n.attr("r",t.r),n.class!==void 0&&n.attr("class",n.class),t.title!==void 0&&n.append("title").text(t.title),n},"drawCircle"),It=o(function(e,t){const n=t.text.replace(/<br\s*\/?>/gi," "),i=e.append("text");i.attr("x",t.x),i.attr("y",t.y),i.attr("class","legend"),i.style("text-anchor",t.anchor),t.class!==void 0&&i.attr("class",t.class);const r=i.append("tspan");return r.attr("x",t.x+t.textMargin*2),r.text(n),i},"drawText"),Ut=o(function(e,t){function n(r,h,c,a,f){return r+","+h+" "+(r+c)+","+h+" "+(r+c)+","+(h+a-f)+" "+(r+c-f*1.2)+","+(h+a)+" "+r+","+(h+a)}o(n,"genPoints");const i=e.append("polygon");i.attr("points",n(t.x,t.y,50,20,7)),i.attr("class","labelBox"),t.y=t.y+t.labelMargin,t.x=t.x+.5*t.labelMargin,It(e,t)},"drawLabel"),Xt=o(function(e,t,n){const i=e.append("g"),r=st();r.x=t.x,r.y=t.y,r.fill=t.fill,r.width=n.width,r.height=n.height,r.class="journey-section section-type-"+t.num,r.rx=3,r.ry=3,J(i,r),Ht(n)(t.text,i,r.x,r.y,r.width,r.height,{class:"journey-section section-type-"+t.num},n,t.colour)},"drawSection"),et=-1,Zt=o(function(e,t,n,i){const r=t.x+n.width/2,h=e.append("g");et++,h.append("line").attr("id",i+"-task"+et).attr("x1",r).attr("y1",t.y).attr("x2",r).attr("y2",450).attr("class","task-line").attr("stroke-width","1px").attr("stroke-dasharray","4 2").attr("stroke","#666"),Dt(h,{cx:r,cy:300+(5-t.score)*30,score:t.score});const a=st();a.x=t.x,a.y=t.y,a.fill=t.fill,a.width=n.width,a.height=n.height,a.class="task task-type-"+t.num,a.rx=3,a.ry=3,J(h,a),Ht(n)(t.task,h,a.x,a.y,a.width,a.height,{class:"task"},n,t.colour)},"drawTask"),jt=o(function(e,t){J(e,{x:t.startx,y:t.starty,width:t.stopx-t.startx,height:t.stopy-t.starty,fill:t.fill,class:"rect"}).lower()},"drawBackgroundRect"),qt=o(function(){return{x:0,y:0,fill:void 0,"text-anchor":"start",width:100,height:100,textMargin:0,rx:0,ry:0}},"getTextObj"),st=o(function(){return{x:0,y:0,width:100,anchor:"start",height:100,rx:0,ry:0}},"getNoteRect"),Ht=(function(){function e(r,h,c,a,f,g,m,y){const k=h.append("text").attr("x",c+f/2).attr("y",a+g/2+5).style("font-color",y).style("text-anchor","middle").text(r);i(k,m)}o(e,"byText");function t(r,h,c,a,f,g,m,y,k){const{taskFontSize:s,taskFontFamily:d}=y,l=r.split(/<br\s*\/?>/gi);for(let p=0;p<l.length;p++){const x=p*s-s*(l.length-1)/2,u=h.append("text").attr("x",c+f/2).attr("y",a).attr("fill",k).style("text-anchor","middle").style("font-size",s).style("font-family",d);u.append("tspan").attr("x",c+f/2).attr("dy",x).text(l[p]),u.attr("y",a+g/2).attr("dominant-baseline","central").attr("alignment-baseline","central"),i(u,m)}}o(t,"byTspan");function n(r,h,c,a,f,g,m,y){const k=h.append("switch"),d=k.append("foreignObject").attr("x",c).attr("y",a).attr("width",f).attr("height",g).attr("position","fixed").append("xhtml:div").style("display","table").style("height","100%").style("width","100%");d.append("div").attr("class","label").style("display","table-cell").style("text-align","center").style("vertical-align","middle").text(r),t(r,k,c,a,f,g,m,y),i(d,m)}o(n,"byFo");function i(r,h){for(const c in h)c in h&&r.attr(c,h[c])}return o(i,"_setTextAttrs"),function(r){return r.textPlacement==="fo"?n:r.textPlacement==="old"?e:t}})(),Jt=o(function(e,t){Nt=0,et=-1,e.append("defs").append("marker").attr("id",t+"-arrowhead").attr("refX",5).attr("refY",2).attr("markerWidth",6).attr("markerHeight",4).attr("orient","auto").append("path").attr("d","M 0,0 V 4 L6,2 Z")},"initGraphics");function it(e,t){e.each(function(){var n=X(this),i=n.text().split(/(\s+|<br>)/).reverse(),r,h=[],c=1.1,a=n.attr("y"),f=parseFloat(n.attr("dy")),g=n.text(null).append("tspan").attr("x",0).attr("y",a).attr("dy",f+"em");for(let m=0;m<i.length;m++)r=i[i.length-1-m],h.push(r),g.text(h.join(" ").trim()),(g.node().getComputedTextLength()>t||r==="<br>")&&(h.pop(),g.text(h.join(" ").trim()),r==="<br>"?h=[""]:h=[r],g=n.append("tspan").attr("x",0).attr("y",a).attr("dy",c+"em").text(r))})}o(it,"wrap");var Qt=o(function(e,t,n,i,r,h=!1){const{theme:c,look:a}=i,f=c?.includes("redux"),g=i?.themeVariables?.THEME_COLOR_LIMIT??12,m=n%g-1,y=e.append("g");t.section=m,y.attr("class",(t.class?t.class+" ":"")+"timeline-node "+("section-"+m));const k=y.append("g"),s=y.append("g"),l=s.append("text").text(t.descr).attr("dy","1em").attr("alignment-baseline","middle").attr("dominant-baseline","middle").attr("text-anchor","middle").call(it,t.width).node().getBBox(),p=i.fontSize?.replace?i.fontSize.replace("px",""):i.fontSize;if(t.height=l.height+p*1.1*.5+t.padding,t.height=Math.max(t.height,t.maxHeight),t.width=t.width+2*t.padding,s.attr("transform","translate("+t.width/2+", "+t.padding/2+")"),f&&s.attr("transform",`translate(${t.width/2}, ${h?t.padding/2+3:t.padding})`),te(k,t,m,r,i),a==="neo"&&(y.attr("data-look","neo"),f)){const x=c.includes("dark"),u=e.node()?.ownerSVGElement??e.node(),S=X(u),v=S.attr("id")??"",I=v?`${v}-drop-shadow`:"drop-shadow";if(S.select(`#${I}`).empty()){const R=S.select("defs");(R.empty()?S.append("defs"):R).append("filter").attr("id",I).attr("height","130%").attr("width","130%").append("feDropShadow").attr("dx","4").attr("dy","4").attr("stdDeviation",0).attr("flood-opacity",x?"0.2":"0.06").attr("flood-color",x?"#FFFFFF":"#000000")}}return t},"drawNode"),Yt=o(function(e,t,n){const i=e.append("g"),h=i.append("text").text(t.descr).attr("dy","1em").attr("alignment-baseline","middle").attr("dominant-baseline","middle").attr("text-anchor","middle").call(it,t.width).node().getBBox(),c=n.fontSize?.replace?n.fontSize.replace("px",""):n.fontSize;return i.remove(),h.height+c*1.1*.5+t.padding},"getVirtualNodeHeight"),te=o(function(e,t,n,i,r){const{theme:h}=r,c=h?.includes("redux")?0:5,a=5,f=c>0?`M0 ${t.height-a} v${-t.height+2*a} q0,-${c},${c},-${c} h${t.width-2*a} q${c},0,${c},${c} v${t.height-a} H0 Z`:`M0 ${t.height-a} v${-(t.height-a)} h${t.width} v${t.height} H0 Z`;e.append("path").attr("id",i+"-node-"+Nt++).attr("class","node-bkg node-"+t.type).attr("d",f),h?.includes("redux")||e.append("line").attr("class","node-line-"+n).attr("x1",0).attr("y1",t.height).attr("x2",t.width).attr("y2",t.height)},"defaultBkg"),M={drawRect:J,drawCircle:Kt,drawSection:Xt,drawText:It,drawLabel:Ut,drawTask:Zt,drawBackgroundRect:jt,getTextObj:qt,getNoteRect:st,initGraphics:Jt,drawNode:Qt,getVirtualNodeHeight:Yt},ee=o(function(e,t,n,i){const r=gt(),{look:h,theme:c,themeVariables:a}=r,{useGradient:f,gradientStart:g,gradientStop:m}=a,y=r.timeline?.leftMargin??50;E.debug("timeline",i.db);const k=r.securityLevel;let s;k==="sandbox"&&(s=X("#i"+t));const l=(k==="sandbox"?X(s.nodes()[0].contentDocument.body):X("body")).select("#"+t);l.append("g");const p=i.db.getTasks(),x=i.db.getCommonDb().getDiagramTitle();E.debug("task",p),M.initGraphics(l,t);const u=i.db.getSections();E.debug("sections",u);let S=0,v=0,I=0,R=0,W=50+y,O=50;R=50;let L=0,w=!0;u.forEach(function(N){const b={number:L,descr:N,section:L,width:150,padding:20,maxHeight:S},_=M.getVirtualNodeHeight(l,b,r);E.debug("sectionHeight before draw",_),S=Math.max(S,_+20)});let H=0,V=0;E.debug("tasks.length",p.length);for(const[N,b]of p.entries()){const _={number:N,descr:b,section:b.section,width:150,padding:20,maxHeight:v},$=M.getVirtualNodeHeight(l,_,r);E.debug("taskHeight before draw",$),v=Math.max(v,$+20),H=Math.max(H,b.events.length);let T=0;for(const P of b.events){const C={descr:P,section:b.section,number:b.section,width:150,padding:20,maxHeight:50};T+=M.getVirtualNodeHeight(l,C,r)}b.events.length>0&&(T+=(b.events.length-1)*10),V=Math.max(V,T)}E.debug("maxSectionHeight before draw",S),E.debug("maxTaskHeight before draw",v),u&&u.length>0?u.forEach(N=>{const b=p.filter(P=>P.section===N),_={number:L,descr:N,section:L,width:200*Math.max(b.length,1)-50,padding:20,maxHeight:S};E.debug("sectionNode",_);const $=l.append("g"),T=M.drawNode($,_,L,r,t);E.debug("sectionNode output",T),$.attr("transform",`translate(${W}, ${R})`),O+=S+50,b.length>0&&lt(l,b,L,W,O,v,r,H,V,S,!1,t),W+=200*Math.max(b.length,1),O=R,L++}):(w=!1,lt(l,p,L,W,O,v,r,H,V,S,!0,t));const F=l.node().getBBox();if(E.debug("bounds",F),x&&l.append("text").text(x).attr("x",h==="neo"?F.x*2+y:F.width/2-y).attr("font-size","4ex").attr("font-weight","bold").attr("y",20),I=w?S+v+150:v+100,l.append("g").attr("class","lineWrapper").append("line").attr("x1",y).attr("y1",I).attr("x2",F.width+3*y).attr("y2",I).attr("stroke-width",4).attr("stroke","black").attr("marker-end",`url(#${t}-arrowhead)`),h==="neo"&&f&&c!=="neutral"){const N=l.select("defs"),_=(N.empty()?l.append("defs"):N).append("linearGradient").attr("id",l.attr("id")+"-gradient").attr("gradientUnits","objectBoundingBox").attr("x1","0%").attr("y1","0%").attr("x2","100%").attr("y2","0%");_.append("stop").attr("offset","0%").attr("stop-color",g).attr("stop-opacity",1),_.append("stop").attr("offset","100%").attr("stop-color",m).attr("stop-opacity",1)}ft(void 0,l,r.timeline?.padding??50,r.timeline?.useMaxWidth??!1)},"draw"),lt=o(function(e,t,n,i,r,h,c,a,f,g,m,y){for(const k of t){const s={descr:k.task,section:n,number:n,width:150,padding:20,maxHeight:h};E.debug("taskNode",s);const d=e.append("g").attr("class","taskWrapper"),p=M.drawNode(d,s,n,c,y).height;if(E.debug("taskHeight after draw",p),d.attr("transform",`translate(${i}, ${r})`),h=Math.max(h,p),k.events){const x=e.append("g").attr("class","lineWrapper");let u=h;r+=100,u=u+ne(e,k.events,n,i,r,c,y),r-=100,x.append("line").attr("x1",i+190/2).attr("y1",r+h).attr("x2",i+190/2).attr("y2",r+h+100+f+100).attr("stroke-width",2).attr("stroke","black").attr("marker-end",`url(#${y}-arrowhead)`).attr("stroke-dasharray","5,5")}i=i+200,m&&!c.timeline?.disableMulticolor&&n++}r=r-10},"drawTasks"),ne=o(function(e,t,n,i,r,h,c){let a=0;const f=r;r=r+100;for(const g of t){const m={descr:g,section:n,number:n,width:150,padding:20,maxHeight:50};E.debug("eventNode",m);const y=e.append("g").attr("class","eventWrapper"),s=M.drawNode(y,m,n,h,c,!0).height;a=a+s,y.attr("transform",`translate(${i}, ${r})`),r=r+10+s}return r=f,a},"drawEvents"),re={setConf:o(()=>{},"setConf"),draw:ee},Q=200,z=5,se=Q+z*2,at=Q+100,ie=at+z*2,Lt=10,ae=0,ht=20,Mt=20,dt=30,At=50,oe=o(function(e,t,n,i){const r=gt(),h=r.timeline?.leftMargin??50;E.debug("timeline",i.db);const c=Pt(t);c.append("g");const a=i.db.getTasks(),f=i.db.getCommonDb().getDiagramTitle();E.debug("task",a),M.initGraphics(c);const g=i.db.getSections();E.debug("sections",g);let m=0,y=0;const k=50+h;let s=50;const d=s,l=k,p=se+Mt,x=ie+At,u=l+p;let S=0;const v=g&&g.length>0,I=v?u:k+p,R=Math.max(50,p+x-z*2);g.forEach(function(N){const b={number:S,descr:N,section:S,width:R,padding:z,maxHeight:m},_=M.getVirtualNodeHeight(c,b,r);E.debug("sectionHeight before draw",_),m=Math.max(m,_)});let W=0;E.debug("tasks.length",a.length);for(const[N,b]of a.entries()){const _={number:N,descr:b,section:b.section,width:Q,padding:z,maxHeight:y},$=M.getVirtualNodeHeight(c,_,r);E.debug("taskHeight before draw",$),y=Math.max(y,$);let T=0;for(const P of b.events){const C={descr:P,section:b.section,number:b.section,width:at,padding:z,maxHeight:50};T+=M.getVirtualNodeHeight(c,C,r)}b.events.length>0&&(T+=(b.events.length-1)*Lt),W=Math.max(W,T)+ae}E.debug("maxSectionHeight before draw",m),E.debug("maxTaskHeight before draw",y);const L=Math.max(y,W)+dt;v?g.forEach(N=>{const b=a.filter(Z=>Z.section===N),_={number:S,descr:N,section:S,width:R,padding:z,maxHeight:m};E.debug("sectionNode",_);const $=c.append("g"),T=M.drawNode($,_,S,r);E.debug("sectionNode output",T);const P=I-p;$.attr("transform",`translate(${P}, ${s})`);const C=s+T.height+ht;b.length>0&&ut(c,b,S,I,C,y,r,L,!1);const G=b.length,B=T.height+ht+L*Math.max(G,1)-(G>0?dt*2:0);s+=B,S++}):ut(c,a,S,I,s,y,r,L,!0);let w=c.node()?.getBBox();if(!w)throw new Error("bbox not found");if(E.debug("bounds",w),f){if(c.append("text").text(f).attr("x",w.width/2-h).attr("font-size","4ex").attr("font-weight","bold").attr("y",20),w=c.node()?.getBBox(),!w)throw new Error("bbox not found");E.debug("bounds after title",w)}const[H]=Bt(r.fontSize),V=(H??16)*2,F=(H??16)*.5+20,U=c.append("g").attr("class","lineWrapper");U.append("line").attr("x1",I).attr("y1",d-V).attr("x2",I).attr("y2",w.y+w.height+F).attr("stroke-width",4).attr("stroke","black").attr("marker-end","url(#arrowhead)"),U.lower(),ft(void 0,c,r.timeline?.padding??50,r.timeline?.useMaxWidth??!1)},"draw"),ut=o(function(e,t,n,i,r,h,c,a,f){for(const g of t){const m={descr:g.task,section:n,number:n,width:Q,padding:z,maxHeight:h};E.debug("taskNode",m);const y=e.append("g").attr("class","taskWrapper"),k=M.drawNode(y,m,n,c),s=k.height;E.debug("taskHeight after draw",s);const d=i-Mt-k.width;if(y.attr("transform",`translate(${d}, ${r})`),h=Math.max(h,s),g.events&&g.events.length>0){const l=r,p=i+At;ce(e,g.events,n,i,p,l,c)}r=r+a,f&&!c.timeline?.disableMulticolor&&n++}},"drawTasks"),ce=o(function(e,t,n,i,r,h,c){let a=h;for(const f of t){const g={descr:f,section:n,number:n,width:at,padding:z,maxHeight:0};E.debug("eventNode",g);const m=e.append("g").attr("class","eventWrapper"),k=M.drawNode(m,g,n,c).height;m.attr("transform",`translate(${r}, ${a})`);const s=e.append("g").attr("class","lineWrapper"),d=a+k/2;s.append("line").attr("x1",i).attr("y1",d).attr("x2",r).attr("y2",d).attr("stroke-width",2).attr("stroke","black").attr("marker-end","url(#arrowhead)").attr("stroke-dasharray","5,5"),a=a+k+Lt}return a-h},"drawEvents"),le={setConf:o(()=>{},"setConf"),draw:oe},he=o(e=>{const{theme:t}=pt(),n=t?.includes("dark"),i=t?.includes("color"),r=e.svgId?.replace(/^#/,"")??"",h=r?`url(#${r}-drop-shadow)`:e.dropShadow??"none";let c="";for(let a=0;a<e.THEME_COLOR_LIMIT;a++){const f=`${17-3*a}`,g=i?e.borderColorArray[a]:e.mainBkg,m=i?e.borderColorArray[a]:e.nodeBorder;c+=`
+    .section-${a-1} rect,
+    .section-${a-1} path,
+    .section-${a-1} circle {
+      fill: ${n&&i?e.mainBkg:g};
+      stroke: ${m};
+      stroke-width: ${e.strokeWidth};
+      filter: ${h};
+    }
+
+    .section-${a-1} text {
+      fill: ${e.nodeBorder};
+      font-weight: ${e.fontWeight}
+    }
+
+    .node-icon-${a-1} {
+      font-size: 40px;
+      color: ${e["cScaleLabel"+a]};
+    }
+
+    .section-edge-${a-1} {
+      stroke: ${e["cScale"+a]};
+    }
+
+    .edge-depth-${a-1} {
+      stroke-width: ${f};
+    }
+
+    .section-${a-1} line {
+      stroke: ${e["cScaleInv"+a]};
+      stroke-width: 3;
+    }
+
+    .lineWrapper line {
+      stroke: ${e.nodeBorder};
+      stroke-width:${e.strokeWidth}
+    }
+
+    .disabled,
+    .disabled circle,
+    .disabled text {
+      fill: ${e.tertiaryColor??"lightgray"};
+    }
+
+    .disabled text {
+      fill: ${e.clusterBorder??"#efefef"};
+    }
+    `}return c},"genReduxSections"),de=o(e=>{let t="";for(let n=0;n<e.THEME_COLOR_LIMIT;n++)e["lineColor"+n]=e["lineColor"+n]||e["cScaleInv"+n],Rt(e["lineColor"+n])?e["lineColor"+n]=Ct(e["lineColor"+n],20):e["lineColor"+n]=Wt(e["lineColor"+n],20);for(let n=0;n<e.THEME_COLOR_LIMIT;n++){const i=""+(17-3*n);t+=`
+    .section-${n-1} rect, .section-${n-1} path, .section-${n-1} circle, .section-${n-1} path  {
+      fill: ${e["cScale"+n]};
+    }
+    .section-${n-1} text {
+     fill: ${e["cScaleLabel"+n]};
+    }
+    .node-icon-${n-1} {
+      font-size: 40px;
+      color: ${e["cScaleLabel"+n]};
+    }
+    .section-edge-${n-1}{
+      stroke: ${e["cScale"+n]};
+    }
+    .edge-depth-${n-1}{
+      stroke-width: ${i};
+    }
+    .section-${n-1} line {
+      stroke: ${e["cScaleInv"+n]} ;
+      stroke-width: 3;
+    }
+
+    .lineWrapper line{
+      stroke: ${e["cScaleLabel"+n]} ;
+    }
+
+    .disabled, .disabled circle, .disabled text {
+      fill: ${e.tertiaryColor??"lightgray"};
+    }
+    .disabled text {
+      fill: ${e.clusterBorder??"#efefef"};
+    }
+    `}return t},"genSections"),ue=o(e=>{const{theme:t}=pt(),n=t?.includes("redux"),i=t==="neutral",r=e.svgId?.replace(/^#/,"")??"";let h="";if(e.useGradient&&r&&e.THEME_COLOR_LIMIT&&!i)for(let c=0;c<e.THEME_COLOR_LIMIT;c++)h+=`
+      .section-${c-1}[data-look="neo"] rect,
+      .section-${c-1}[data-look="neo"] path,
+      .section-${c-1}[data-look="neo"] circle {
+        fill: ${e.mainBkg};
+        stroke: url(#${r}-gradient);
+        stroke-width: 2;
+      }
+      .section-${c-1}[data-look="neo"] line {
+        stroke: url(#${r}-gradient);
+        stroke-width: 2;
+      }`;return`
+  .edge {
+    stroke-width: 3;
+  }
+  ${n?he(e):de(e)}
+  ${h}
+  .section-root rect, .section-root path, .section-root circle  {
+    fill: ${e.git0};
+  }
+  .section-root text {
+    fill: ${e.gitBranchLabel0};
+  }
+  .icon-container {
+    height:100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+  .edge {
+    fill: none;
+  }
+  .eventWrapper  {
+   filter: brightness(120%);
+  }
+`},"getStyles"),pe=ue,ge={setConf:o(()=>{},"setConf"),draw:o((e,t,n,i)=>(i?.db?.getDirection?.()??"LR")==="TD"?le.draw(e,t,n,i):re.draw(e,t,n,i),"draw")},me={db:yt,renderer:ge,parser:Ot,styles:pe};export{me as diagram};

apps/kimi-code/src/cli/sub/fork.ts

@@ -0,0 +1,197 @@
+import { createInterface } from 'node:readline/promises';
+
+import {
+  setTelemetryContext,
+  shutdownTelemetry,
+  track,
+  withTelemetryContext,
+} from '@moonshot-ai/kimi-telemetry';
+import {
+  createKimiHarness,
+  type KimiHarness,
+  type SessionSummary,
+  type TelemetryClient,
+} from '@moonshot-ai/kimi-code-sdk';
+import type { Command } from 'commander';
+
+import { CLI_SHUTDOWN_TIMEOUT_MS, CLI_UI_MODE } from '#/constant/app';
+import { createCliTelemetryBootstrap, initializeCliTelemetry } from '#/cli/telemetry';
+import { createKimiCodeHostIdentity } from '#/cli/version';
+
+interface WritableLike {
+  write(chunk: string): boolean;
+}
+
+export interface ForkedSessionResult {
+  readonly id: string;
+  readonly title?: string | undefined;
+}
+
+export interface ForkDeps {
+  readonly listSessions: (workDir: string) => Promise<readonly SessionSummary[]>;
+  readonly forkSession: (sessionId: string) => Promise<ForkedSessionResult>;
+  readonly confirmPreviousSession: (summary: SessionSummary) => Promise<boolean>;
+  readonly cwd: () => string;
+  readonly stdout: WritableLike;
+  readonly stderr: WritableLike;
+  readonly exit: (code: number) => never;
+}
+
+export interface ForkOptions {
+  readonly yes: boolean;
+  readonly cwd?: string | undefined;
+}
+
+export async function handleFork(
+  deps: ForkDeps,
+  sessionId: string | undefined,
+  opts: ForkOptions,
+): Promise<void> {
+  let resolvedId = normalizeOptionalSessionId(sessionId);
+  if (resolvedId === undefined) {
+    const sessions = await deps.listSessions(opts.cwd ?? deps.cwd());
+    const latest = sessions[0];
+    if (latest === undefined) {
+      deps.stderr.write('No previous session found to fork.\n');
+      deps.exit(1);
+    }
+    if (!opts.yes) {
+      const confirmed = await deps.confirmPreviousSession(latest);
+      if (!confirmed) {
+        deps.stdout.write('Fork cancelled.\n');
+        return;
+      }
+    }
+    resolvedId = latest.id;
+  }
+
+  const startedAt = Date.now();
+  try {
+    const forked = await deps.forkSession(resolvedId);
+    const elapsedMs = Date.now() - startedAt;
+    const title = forked.title === undefined ? '' : ` ("${forked.title}")`;
+    deps.stdout.write(`Forked to ${forked.id}${title} in ${elapsedMs}ms\n`);
+  } catch (error) {
+    deps.stderr.write(`${errorMessage(error)}\n`);
+    deps.exit(1);
+  }
+}
+
+export function registerForkCommand(parent: Command, deps?: Partial<ForkDeps>): void {
+  parent
+    .command('fork')
+    .description('Fork a session into a new session.')
+    .option(
+      '--cwd <path>',
+      'Working directory used to find the most recent session to fork. Defaults to the current directory.',
+    )
+    .option('-y, --yes', 'Skip previous-session confirmation.')
+    .argument('[sessionId]', 'Session id to fork. Defaults to the most recent session.')
+    .action(async (sessionId: string | undefined, options: { cwd?: string; yes?: boolean }) => {
+      const resolved = createDefaultForkDeps(deps);
+      try {
+        await handleFork(resolved, sessionId, {
+          yes: options.yes === true,
+          cwd: options.cwd,
+        });
+      } finally {
+        await resolved.close();
+      }
+    });
+}
+
+function createDefaultForkDeps(overrides: Partial<ForkDeps> = {}): ForkDeps & {
+  readonly close: () => Promise<void>;
+} {
+  let harness: KimiHarness | undefined;
+  let telemetryBootstrap: ReturnType<typeof createCliTelemetryBootstrap> | undefined;
+  let telemetryInitialized = false;
+  let telemetryShutdown = false;
+  const identity = createKimiCodeHostIdentity();
+  const telemetryClient: TelemetryClient = {
+    track,
+    withContext: withTelemetryContext,
+    setContext: setTelemetryContext,
+  };
+  const getTelemetryBootstrap = (): ReturnType<typeof createCliTelemetryBootstrap> => {
+    telemetryBootstrap ??= createCliTelemetryBootstrap();
+    return telemetryBootstrap;
+  };
+  const getHarness = (): KimiHarness => {
+    const currentTelemetryBootstrap = getTelemetryBootstrap();
+    harness ??= createKimiHarness({
+      homeDir: currentTelemetryBootstrap.homeDir,
+      identity,
+      telemetry: telemetryClient,
+    });
+    return harness;
+  };
+  const initializeDefaultTelemetry = async (): Promise<void> => {
+    if (telemetryInitialized) return;
+    const currentTelemetryBootstrap = getTelemetryBootstrap();
+    const currentHarness = getHarness();
+    await currentHarness.ensureConfigFile();
+    const config = await currentHarness.getConfig();
+    initializeCliTelemetry({
+      harness: currentHarness,
+      bootstrap: currentTelemetryBootstrap,
+      config,
+      version: identity.version,
+      uiMode: CLI_UI_MODE,
+    });
+    telemetryInitialized = true;
+  };
+  const shutdownDefaultTelemetry = async (): Promise<void> => {
+    if (!telemetryInitialized || telemetryShutdown) return;
+    telemetryShutdown = true;
+    await shutdownTelemetry({ timeoutMs: CLI_SHUTDOWN_TIMEOUT_MS });
+  };
+  return {
+    listSessions:
+      overrides.listSessions ??
+      ((workDir: string) =>
+        getHarness().listSessions({
+          workDir,
+        })),
+    forkSession:
+      overrides.forkSession ??
+      (async (sessionId: string) => {
+        await initializeDefaultTelemetry();
+        try {
+          const forked = await getHarness().forkSession({ id: sessionId });
+          return { id: forked.id, title: forked.summary?.title };
+        } finally {
+          await shutdownDefaultTelemetry();
+        }
+      }),
+    confirmPreviousSession: overrides.confirmPreviousSession ?? confirmPreviousSession,
+    cwd: overrides.cwd ?? (() => process.cwd()),
+    stdout: overrides.stdout ?? process.stdout,
+    stderr: overrides.stderr ?? process.stderr,
+    exit: overrides.exit ?? ((code: number) => process.exit(code)),
+    close: async () => {
+      await harness?.close();
+    },
+  };
+}
+
+function normalizeOptionalSessionId(sessionId: string | undefined): string | undefined {
+  const trimmed = sessionId?.trim();
+  return trimmed === undefined || trimmed === '' ? undefined : trimmed;
+}
+
+async function confirmPreviousSession(summary: SessionSummary): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const title = summary.title === undefined ? summary.id : `${summary.title} (${summary.id})`;
+    const answer = await rl.question(`Fork previous session "${title}"? [Y/n] `);
+    const trimmed = answer.trim().toLowerCase();
+    return trimmed === '' || trimmed === 'y' || trimmed === 'yes';
+  } finally {
+    rl.close();
+  }
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

apps/kimi-code/src/cli/sub/login-flow.ts

@@ -0,0 +1,83 @@
+/**
+ * Shared device-code login flow used by both `kimi login` (top-level
+ * subcommand) and `kimi acp --login` (the first-class ACP terminal-auth
+ * entry point). Exiting the process is part of the contract — callers
+ * MUST treat the returned promise as `Promise<never>`.
+ */
+
+import { createKimiHarness } from '@moonshot-ai/kimi-code-sdk';
+import { OAuthAccessDeniedError, type KimiRegion } from '@moonshot-ai/kimi-code-oauth';
+
+import { createKimiCodeHostIdentity } from '#/cli/version';
+import { openUrl } from '#/utils/open-url';
+import { persistedKimiOAuthRef, regionForBareLogin } from '#/utils/region';
+
+/** Parse a `--region` CLI flag; exits with an actionable message on bad input. */
+export function parseRegionFlag(value: string): KimiRegion {
+  if (value !== 'mainland-cn' && value !== 'global') {
+    process.stderr.write(`Invalid --region "${value}" (expected "mainland-cn" or "global").\n`);
+    process.exit(1);
+  }
+  return value;
+}
+
+export async function runLoginFlow(options: { region?: KimiRegion } = {}): Promise<never> {
+  // No flag: a fresh install follows the resolved region (env/marker/
+  // default); an existing login keeps its own environment (see
+  // regionForBareLogin — the default slot re-pins mainland-cn, a scoped slot
+  // keeps its configured hosts).
+  const region = options.region ?? regionForBareLogin(persistedKimiOAuthRef());
+  const identity = createKimiCodeHostIdentity();
+  const harness = createKimiHarness({
+    identity,
+    uiMode: 'cli',
+  });
+  const controller = new AbortController();
+  process.once('SIGINT', () => {
+    controller.abort();
+  });
+  try {
+    const result = await harness.auth.login(undefined, {
+      signal: controller.signal,
+      region,
+      onDeviceCode: (data) => {
+        const url = data.verificationUriComplete || data.verificationUri;
+        // Print the manual fallback before attempting to open the user's
+        // browser so headless/browser-opener failures never hide the URL
+        // and code needed to complete login.
+        process.stderr.write(
+          [
+            '',
+            `Opening browser for Kimi device login: ${url}`,
+            `If the browser did not open, paste the URL above and enter code: ${data.userCode}`,
+            data.expiresIn !== null && data.expiresIn !== undefined
+              ? `Code expires in ${data.expiresIn}s.`
+              : undefined,
+            'Waiting for authorization to complete…',
+            '',
+          ]
+            .filter((line): line is string => line !== undefined)
+            .join('\n'),
+        );
+        try {
+          openUrl(url);
+        } catch {
+          // Best effort only: the manual fallback has already been printed.
+        }
+      },
+    });
+    process.stderr.write(`Logged in to ${result.providerName}.\n`);
+    process.exit(0);
+  } catch (error) {
+    if (controller.signal.aborted) {
+      process.stderr.write('Login cancelled.\n');
+    } else if (error instanceof OAuthAccessDeniedError) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`Login cancelled: ${message}\n`);
+    } else {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`Login failed: ${message}\n`);
+    }
+    process.exit(1);
+  }
+}

apps/kimi-code/src/cli/sub/provider.ts

@@ -0,0 +1,602 @@
+/**
+ * `kimi provider` sub-command — non-interactive provider management.
+ *
+ * Mirrors the TUI `/provider` flow (apps/kimi-code/src/tui/commands/provider.ts)
+ * for the custom-registry path so users can import an api.json document, drop
+ * a provider, or inspect what is configured without launching the TUI.
+ *
+ * `add` writes the same `source = { kind: 'apiJson', url, apiKey }` blob the
+ * TUI does; the next launch's `refreshAllProviderModels`
+ * (apps/kimi-code/src/tui/utils/refresh-providers.ts) groups by URL, retries
+ * available API-key candidates, and re-fetches the model list, so periodic
+ * refresh is automatic.
+ */
+
+import {
+  applyCustomRegistryProvider,
+  CustomRegistryApiError,
+  fetchCustomRegistry,
+  type CustomRegistrySource,
+  type ManagedKimiConfigShape,
+} from '@moonshot-ai/kimi-code-oauth';
+import {
+  applyCatalogProvider,
+  catalogProviderModels,
+  CatalogFetchError,
+  createKimiHarness,
+  DEFAULT_CATALOG_URL,
+  resolveCatalogImport,
+  type Catalog,
+  type CatalogProviderEntry,
+  type KimiConfig,
+  type KimiHarness,
+} from '@moonshot-ai/kimi-code-sdk';
+import type { Command } from 'commander';
+
+import { createKimiCodeHostIdentity, createKimiCodeUserAgent } from '#/cli/version';
+import { fetchCatalogOrBuiltIn } from '#/utils/catalog-fetch';
+
+interface WritableLike {
+  write(chunk: string): boolean;
+}
+
+export interface ProviderDeps {
+  readonly getHarness: () => KimiHarness;
+  readonly stdout: WritableLike;
+  readonly stderr: WritableLike;
+  readonly env: NodeJS.ProcessEnv;
+  readonly exit: (code: number) => never;
+}
+
+interface AddOptions {
+  readonly apiKey?: string;
+}
+
+interface ListOptions {
+  readonly json: boolean;
+}
+
+interface CatalogListOptions {
+  readonly json: boolean;
+  readonly filter?: string;
+  readonly url?: string;
+}
+
+interface CatalogAddOptions {
+  readonly apiKey?: string;
+  readonly defaultModel?: string;
+  readonly url?: string;
+  readonly baseUrl?: string;
+}
+
+export async function handleProviderAdd(
+  deps: ProviderDeps,
+  url: string,
+  opts: AddOptions,
+): Promise<void> {
+  const apiKey = resolveApiKey(opts.apiKey, deps.env);
+  if (apiKey === undefined) {
+    deps.stderr.write(
+      'Missing API key. Pass --api-key <key> or set KIMI_REGISTRY_API_KEY.\n',
+    );
+    deps.exit(1);
+  }
+
+  const trimmedUrl = url.trim();
+  if (trimmedUrl.length === 0) {
+    deps.stderr.write('Registry URL is required.\n');
+    deps.exit(1);
+  }
+
+  const source: CustomRegistrySource = {
+    kind: 'apiJson',
+    url: trimmedUrl,
+    apiKey,
+  };
+
+  const harness = deps.getHarness();
+  await harness.ensureConfigFile();
+
+  let entries: Awaited<ReturnType<typeof fetchCustomRegistry>>;
+  try {
+    entries = await fetchCustomRegistry(source, { userAgent: createKimiCodeUserAgent() });
+  } catch (error) {
+    const suffix = error instanceof CustomRegistryApiError ? ` (HTTP ${String(error.status)})` : '';
+    deps.stderr.write(`Failed to fetch registry${suffix}: ${errorMessage(error)}\n`);
+    deps.exit(1);
+  }
+
+  const entryList = Object.values(entries);
+  if (entryList.length === 0) {
+    deps.stderr.write(`Registry at ${trimmedUrl} contained no usable providers.\n`);
+    deps.exit(1);
+  }
+
+  // `harness.removeProvider` reloads the config from disk on each call (see
+  // `core-impl.ts removeKimiProvider`), so calling it inside the apply loop
+  // would discard providers we already applied in memory but have not yet
+  // persisted. Drop every stale id up front in a single batch instead, then
+  // apply against the resulting fresh config.
+  let config = await harness.getConfig();
+  const staleIds = entryList
+    .filter((entry) => config.providers[entry.id] !== undefined)
+    .map((entry) => entry.id);
+  for (const id of staleIds) {
+    config = await harness.removeProvider(id);
+  }
+
+  const addedProviderIds: string[] = [];
+  let modelCount = 0;
+  for (const entry of entryList) {
+    applyCustomRegistryProvider(asManaged(config), entry, source);
+    addedProviderIds.push(entry.id);
+    modelCount += Object.keys(entry.models).length;
+  }
+
+  await harness.setConfig({
+    providers: config.providers,
+    models: config.models,
+  });
+
+  deps.stdout.write(
+    `Imported ${String(addedProviderIds.length)} provider${addedProviderIds.length === 1 ? '' : 's'} ` +
+      `(${String(modelCount)} model${modelCount === 1 ? '' : 's'}) from ${trimmedUrl}:\n`,
+  );
+  for (const id of addedProviderIds) {
+    deps.stdout.write(`  - ${id}\n`);
+  }
+}
+
+export async function handleProviderRemove(
+  deps: ProviderDeps,
+  providerId: string,
+): Promise<void> {
+  const harness = deps.getHarness();
+  await harness.ensureConfigFile();
+  const config = await harness.getConfig();
+  if (config.providers[providerId] === undefined) {
+    deps.stderr.write(`Provider "${providerId}" not found.\n`);
+    deps.exit(1);
+  }
+  await harness.removeProvider(providerId);
+  deps.stdout.write(`Removed provider "${providerId}".\n`);
+}
+
+export async function handleProviderList(
+  deps: ProviderDeps,
+  opts: ListOptions,
+): Promise<void> {
+  const harness = deps.getHarness();
+  await harness.ensureConfigFile();
+  const config = await harness.getConfig();
+
+  if (opts.json) {
+    deps.stdout.write(
+      `${JSON.stringify({ providers: config.providers, models: config.models ?? {} }, null, 2)}\n`,
+    );
+    return;
+  }
+
+  const modelsByProvider = new Map<string, string[]>();
+  for (const [alias, model] of Object.entries(config.models ?? {})) {
+    const list = modelsByProvider.get(model.provider) ?? [];
+    list.push(alias);
+    modelsByProvider.set(model.provider, list);
+  }
+
+  const providerIds = Object.keys(config.providers).toSorted();
+  if (providerIds.length === 0) {
+    deps.stdout.write('No providers configured.\n');
+    return;
+  }
+
+  for (const id of providerIds) {
+    const provider = config.providers[id]!;
+    const aliases = modelsByProvider.get(id) ?? [];
+    const sourceLabel = providerSourceLabel(provider);
+    deps.stdout.write(
+      `${id}  type=${provider.type}  models=${String(aliases.length)}  source=${sourceLabel}\n`,
+    );
+  }
+  if (config.defaultModel !== undefined) {
+    deps.stdout.write(`\nDefault model: ${config.defaultModel}\n`);
+  }
+}
+
+/**
+ * Fetches the models.dev-style public catalog and lists providers, or — when
+ * `providerId` is given — drills into one provider and lists its models. This
+ * mirrors the discovery half of the TUI "Known third-party provider" flow.
+ */
+export async function handleCatalogList(
+  deps: ProviderDeps,
+  providerId: string | undefined,
+  opts: CatalogListOptions,
+): Promise<void> {
+  const url = opts.url ?? DEFAULT_CATALOG_URL;
+  const catalog = await loadCatalogOrExit(deps, url);
+
+  if (providerId !== undefined) {
+    const entry = catalog[providerId];
+    if (entry === undefined) {
+      deps.stderr.write(`Provider "${providerId}" not found in catalog at ${url}.\n`);
+      deps.exit(1);
+    }
+    const models = catalogProviderModels(entry);
+    if (opts.json) {
+      deps.stdout.write(
+        `${JSON.stringify({ providerId, name: entry.name ?? providerId, models }, null, 2)}\n`,
+      );
+      return;
+    }
+    if (models.length === 0) {
+      deps.stdout.write(`Provider "${providerId}" lists no usable models in this catalog.\n`);
+      return;
+    }
+    deps.stdout.write(`${entry.name ?? providerId} (${providerId})\n`);
+    for (const model of models) {
+      const cap: string[] = [];
+      if (model.capability.tool_use) cap.push('tool_use');
+      if (model.capability.thinking) cap.push('thinking');
+      if (model.capability.image_in) cap.push('image_in');
+      const ctx =
+        typeof model.capability.max_context_tokens === 'number'
+          ? String(model.capability.max_context_tokens)
+          : '?';
+      const capLabel = cap.length > 0 ? ` [${cap.join(',')}]` : '';
+      deps.stdout.write(`  ${model.id}  ctx=${ctx}${capLabel}\n`);
+    }
+    return;
+  }
+
+  const filter = opts.filter?.toLowerCase();
+  const entries = Object.entries(catalog)
+    .filter(([id, entry]) => {
+      if (filter === undefined) return true;
+      const haystack = `${id} ${entry.name ?? ''}`.toLowerCase();
+      return haystack.includes(filter);
+    })
+    .toSorted(([a], [b]) => a.localeCompare(b));
+
+  if (opts.json) {
+    const out: Record<string, CatalogProviderEntry> = {};
+    for (const [id, entry] of entries) out[id] = entry;
+    deps.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
+    return;
+  }
+
+  if (entries.length === 0) {
+    if (filter !== undefined) {
+      deps.stdout.write(`No providers in catalog match "${filter}".\n`);
+    } else {
+      deps.stdout.write('Catalog is empty.\n');
+    }
+    return;
+  }
+
+  for (const [id, entry] of entries) {
+    const modelCount = entry.models === undefined ? 0 : Object.keys(entry.models).length;
+    const resolution = resolveCatalogImport(entry);
+    const wireLabel =
+      resolution.kind === 'invalid'
+        ? '?'
+        : resolution.guessed
+          ? `${resolution.wire} (guessed)`
+          : resolution.wire;
+    deps.stdout.write(
+      `${id}  wire=${wireLabel}  models=${String(modelCount)}  ${entry.name ?? ''}\n`,
+    );
+  }
+}
+
+/**
+ * Imports a known provider from the models.dev catalog by id. Unlike
+ * `provider add` (which expects a custom api.json), this command relies on
+ * the catalog's normalized metadata to fill in context limits and capabilities.
+ */
+export async function handleCatalogAdd(
+  deps: ProviderDeps,
+  providerId: string,
+  opts: CatalogAddOptions,
+): Promise<void> {
+  const apiKey = resolveApiKey(opts.apiKey, deps.env);
+  if (apiKey === undefined) {
+    deps.stderr.write(
+      'Missing API key. Pass --api-key <key> or set KIMI_REGISTRY_API_KEY.\n',
+    );
+    deps.exit(1);
+  }
+
+  const url = opts.url ?? DEFAULT_CATALOG_URL;
+  const catalog = await loadCatalogOrExit(deps, url);
+
+  const entry = catalog[providerId];
+  if (entry === undefined) {
+    deps.stderr.write(`Provider "${providerId}" not found in catalog at ${url}.\n`);
+    deps.exit(1);
+  }
+
+  const resolution = resolveCatalogImport(entry, opts.baseUrl);
+  if (resolution.kind === 'invalid') {
+    switch (resolution.reason) {
+      case 'unknown-explicit-type':
+        deps.stderr.write(
+          `Provider "${providerId}" declares protocol "${entry.type}" in the catalog, which this client version does not support.\n`,
+        );
+        break;
+      case 'proprietary-sdk':
+        deps.stderr.write(
+          `Provider "${providerId}" uses a proprietary SDK this client cannot speak (e.g. Amazon Bedrock or Cohere); it cannot be imported from the catalog.\n`,
+        );
+        break;
+      case 'empty-base-url':
+        deps.stderr.write('--base-url cannot be empty.\n');
+        break;
+      case 'placeholder-base-url':
+        deps.stderr.write(
+          `Base URL "${opts.baseUrl}" contains an env placeholder. Pass --base-url with the resolved value.\n`,
+        );
+        break;
+    }
+    deps.exit(1);
+  }
+  if (resolution.kind === 'needs-base-url') {
+    deps.stderr.write(
+      `The catalog does not declare an endpoint for "${providerId}". Pass --base-url <url> (e.g. the vendor's OpenAI-compatible base URL).\n`,
+    );
+    deps.exit(1);
+  }
+  const { wire, baseUrl } = resolution;
+
+  const models = catalogProviderModels(entry);
+  if (models.length === 0) {
+    deps.stderr.write(`Provider "${providerId}" lists no usable models in this catalog.\n`);
+    deps.exit(1);
+  }
+
+  if (opts.defaultModel !== undefined && !models.some((m) => m.id === opts.defaultModel)) {
+    deps.stderr.write(
+      `Model "${opts.defaultModel}" is not in provider "${providerId}". Run "kimi provider catalog list ${providerId}" to see available ids.\n`,
+    );
+    deps.exit(1);
+  }
+
+  const harness = deps.getHarness();
+  await harness.ensureConfigFile();
+
+  let config = await harness.getConfig();
+
+  // Capture defaults BEFORE `removeProvider`, because that call clears
+  // `defaultModel` when it points at one of this provider's aliases (see
+  // `core-impl.ts removeKimiProvider`). Without this, re-importing an
+  // already-configured provider would lose the user's previously-set default
+  // even when `--default-model` is not supplied.
+  const previousDefaultModel = config.defaultModel;
+  const previousThinking = config.thinking;
+
+  if (config.providers[providerId] !== undefined) {
+    config = await harness.removeProvider(providerId);
+  }
+
+  // `applyCatalogProvider` always overwrites both `defaultModel` and
+  // `[thinking]`. The values we pass here are temporary; we restore
+  // a consistent state in the post-apply block below.
+  applyCatalogProvider(config, {
+    providerId,
+    wire,
+    ...(baseUrl === undefined ? {} : { baseUrl }),
+    apiKey,
+    models,
+    selectedModelId: opts.defaultModel ?? '',
+    thinking: false,
+  });
+
+  // Resolve the final `defaultModel`:
+  //   - If the caller asked for one, `applyCatalogProvider` already set it.
+  //   - Else, restore the previous default ONLY when its alias still resolves
+  //     after the catalog refresh; the catalog may have dropped the old
+  //     model, in which case restoring would point default_model at a
+  //     non-existent alias and break the next session.
+  if (opts.defaultModel === undefined) {
+    const stillResolves =
+      previousDefaultModel !== undefined &&
+      config.models?.[previousDefaultModel] !== undefined;
+    config.defaultModel = stillResolves ? previousDefaultModel : undefined;
+  }
+
+  // Always restore `[thinking]` from what was there before — including
+  // `undefined`. Persisting `enabled: false` when the user never set it would
+  // make `resolveThinkingEffort` (agent-core-v2/src/kosong/model/thinking.ts) treat
+  // it as an explicit "off" request and silently disable thinking, even for
+  // thinking-capable models.
+  config.thinking = previousThinking;
+
+  await harness.setConfig({
+    providers: config.providers,
+    models: config.models,
+    defaultModel: config.defaultModel,
+    thinking: config.thinking,
+  });
+
+  const displayName = entry.name ?? providerId;
+  deps.stdout.write(
+    `Imported ${displayName} (${providerId}) with ${String(models.length)} model${models.length === 1 ? '' : 's'} from ${url}.\n`,
+  );
+  if (resolution.guessed) {
+    deps.stdout.write(
+      `Note: the catalog does not declare a protocol for "${providerId}"; guessed "openai". Edit "type" in config.toml if requests fail.\n`,
+    );
+  }
+  if (opts.defaultModel !== undefined) {
+    deps.stdout.write(`Default model set to ${providerId}/${opts.defaultModel}.\n`);
+  }
+}
+
+async function loadCatalogOrExit(deps: ProviderDeps, url: string): Promise<Catalog> {
+  try {
+    const loaded = await fetchCatalogOrBuiltIn(url, { userAgent: createKimiCodeUserAgent() });
+    if (loaded.fromBuiltIn) {
+      deps.stderr.write(
+        `Warning: failed to reach ${url}; using the built-in models.dev catalog snapshot.\n`,
+      );
+    }
+    return loaded.catalog;
+  } catch (error) {
+    const suffix = error instanceof CatalogFetchError ? ` (HTTP ${String(error.status)})` : '';
+    deps.stderr.write(`Failed to fetch catalog from ${url}${suffix}: ${errorMessage(error)}\n`);
+    deps.exit(1);
+  }
+}
+
+export function registerProviderCommand(parent: Command, deps?: Partial<ProviderDeps>): void {
+  const provider = parent
+    .command('provider')
+    .description('Manage LLM providers non-interactively.');
+
+  // Last-resort boundary: handlers report expected failures themselves, but
+  // anything that escapes (e.g. a config write rejected because config.toml
+  // is invalid) must end as a one-line error + exit 1, not an unhandled
+  // rejection dumping a stack trace.
+  const runAction = async (
+    resolved: ResolvedProviderDeps,
+    run: () => Promise<void>,
+  ): Promise<void> => {
+    try {
+      await run();
+    } catch (error) {
+      resolved.stderr.write(`${errorMessage(error)}\n`);
+      resolved.exit(1);
+    } finally {
+      await resolved.close();
+    }
+  };
+
+  provider
+    .command('add <url>')
+    .description('Import every provider listed in a custom registry (api.json).')
+    .option('--api-key <key>', 'Registry API key. Falls back to KIMI_REGISTRY_API_KEY.')
+    .action(async (url: string, options: { apiKey?: string }) => {
+      const resolved = resolveDeps(deps);
+      await runAction(resolved, () => handleProviderAdd(resolved, url, { apiKey: options.apiKey }));
+    });
+
+  provider
+    .command('remove <providerId>')
+    .description('Remove a provider and every model alias that referenced it.')
+    .action(async (providerId: string) => {
+      const resolved = resolveDeps(deps);
+      await runAction(resolved, () => handleProviderRemove(resolved, providerId));
+    });
+
+  provider
+    .command('list')
+    .description('Show configured providers and their model counts.')
+    .option('--json', 'Emit the raw providers/models config as JSON.', false)
+    .action(async (options: { json?: boolean }) => {
+      const resolved = resolveDeps(deps);
+      await runAction(resolved, () => handleProviderList(resolved, { json: options.json === true }));
+    });
+
+  const catalog = provider
+    .command('catalog')
+    .description('Discover and import providers from the public models.dev catalog.');
+
+  catalog
+    .command('list [providerId]')
+    .description('List providers in the catalog, or models when a providerId is given.')
+    .option('--filter <substring>', 'Case-insensitive id/name substring filter.')
+    .option('--url <url>', `Override catalog URL. Defaults to ${DEFAULT_CATALOG_URL}.`)
+    .option('--json', 'Emit the matching catalog slice as JSON.', false)
+    .action(
+      async (
+        providerId: string | undefined,
+        options: { filter?: string; url?: string; json?: boolean },
+      ) => {
+        const resolved = resolveDeps(deps);
+        await runAction(resolved, () =>
+          handleCatalogList(resolved, providerId, {
+            json: options.json === true,
+            ...(options.filter === undefined ? {} : { filter: options.filter }),
+            ...(options.url === undefined ? {} : { url: options.url }),
+          }),
+        );
+      },
+    );
+
+  catalog
+    .command('add <providerId>')
+    .description('Import a known provider from the catalog by id.')
+    .option('--api-key <key>', 'API key for the provider. Falls back to KIMI_REGISTRY_API_KEY.')
+    .option('--default-model <modelId>', 'Mark the imported model as default_model after import.')
+    .option(
+      '--base-url <url>',
+      'Override the catalog endpoint. Required when the catalog declares none (or an env placeholder).',
+    )
+    .option('--url <url>', `Override catalog URL. Defaults to ${DEFAULT_CATALOG_URL}.`)
+    .action(
+      async (
+        providerId: string,
+        options: { apiKey?: string; defaultModel?: string; url?: string; baseUrl?: string },
+      ) => {
+        const resolved = resolveDeps(deps);
+        await runAction(resolved, () =>
+          handleCatalogAdd(resolved, providerId, {
+            ...(options.apiKey === undefined ? {} : { apiKey: options.apiKey }),
+            ...(options.defaultModel === undefined ? {} : { defaultModel: options.defaultModel }),
+            ...(options.url === undefined ? {} : { url: options.url }),
+            ...(options.baseUrl === undefined ? {} : { baseUrl: options.baseUrl }),
+          }),
+        );
+      },
+    );
+}
+
+type ResolvedProviderDeps = ProviderDeps & { readonly close: () => Promise<void> };
+
+function resolveDeps(overrides: Partial<ProviderDeps> = {}): ResolvedProviderDeps {
+  let harness: KimiHarness | undefined;
+  const identity = createKimiCodeHostIdentity();
+  return {
+    getHarness:
+      overrides.getHarness ??
+      (() => {
+        harness ??= createKimiHarness({ identity });
+        return harness;
+      }),
+    stdout: overrides.stdout ?? process.stdout,
+    stderr: overrides.stderr ?? process.stderr,
+    env: overrides.env ?? process.env,
+    exit: overrides.exit ?? ((code: number) => process.exit(code)),
+    // The v2 harness boots an engine whose watchers hold the event loop open;
+    // close it so a one-shot command can exit. No-op for injected harnesses.
+    close: async () => {
+      await harness?.close();
+    },
+  };
+}
+
+function resolveApiKey(flag: string | undefined, env: NodeJS.ProcessEnv): string | undefined {
+  if (typeof flag === 'string' && flag.length > 0) return flag;
+  const fromEnv = env['KIMI_REGISTRY_API_KEY'];
+  if (typeof fromEnv === 'string' && fromEnv.length > 0) return fromEnv;
+  return undefined;
+}
+
+function asManaged(config: KimiConfig): ManagedKimiConfigShape {
+  return config as unknown as ManagedKimiConfigShape;
+}
+
+function providerSourceLabel(provider: KimiConfig['providers'][string]): string {
+  const source = provider.source;
+  if (source !== undefined) {
+    if (source['kind'] === 'apiJson' && typeof source['url'] === 'string') {
+      return `apiJson(${source['url']})`;
+    }
+  }
+  if (provider.oauth !== undefined) return 'oauth';
+  return 'inline';
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

apps/kimi-code/src/cli/sub/session.ts

@@ -0,0 +1,154 @@
+/**
+ * `kimi session` sub-command group.
+ *
+ * CLI glue only: listing semantics (workspace scoping, recency order,
+ * archived filtering) are owned by the SDK/engine; this file parses options
+ * and formats rows.
+ */
+
+import { setTelemetryContext, track, withTelemetryContext } from '@moonshot-ai/kimi-telemetry';
+import {
+  createKimiHarness,
+  type KimiHarness,
+  type ListSessionsOptions,
+  type SessionSummary,
+  type TelemetryClient,
+} from '@moonshot-ai/kimi-code-sdk';
+import type { Command } from 'commander';
+
+import { createCliTelemetryBootstrap } from '#/cli/telemetry';
+import { createKimiCodeHostIdentity } from '#/cli/version';
+
+interface WritableLike {
+  write(chunk: string): boolean;
+}
+
+export interface SessionListDeps {
+  readonly listSessions: (options: ListSessionsOptions) => Promise<readonly SessionSummary[]>;
+  readonly cwd: () => string;
+  readonly stdout: WritableLike;
+  readonly stderr: WritableLike;
+  readonly exit: (code: number) => never;
+}
+
+export interface SessionListOptions {
+  readonly all: boolean;
+  readonly archived: boolean;
+  readonly cwd?: string;
+  readonly limit?: number;
+  readonly json: boolean;
+}
+
+export async function handleSessionList(
+  deps: SessionListDeps,
+  opts: SessionListOptions,
+): Promise<void> {
+  const workDir = opts.all ? undefined : (opts.cwd ?? deps.cwd());
+  const sessions = await deps.listSessions({
+    workDir,
+    includeArchived: opts.archived ? true : undefined,
+  });
+  const limited = opts.limit === undefined ? sessions : sessions.slice(0, opts.limit);
+  if (opts.json) {
+    deps.stdout.write(`${JSON.stringify(limited, null, 2)}\n`);
+    return;
+  }
+  if (limited.length === 0) {
+    deps.stdout.write('No sessions found.\n');
+    return;
+  }
+  for (const summary of limited) {
+    deps.stdout.write(`${formatRow(summary, opts.all)}\n`);
+  }
+}
+
+export function registerSessionCommand(parent: Command, deps?: Partial<SessionListDeps>): void {
+  const session = parent.command('session').description('Manage sessions non-interactively.');
+
+  session
+    .command('list')
+    .description('List sessions, most recently updated first.')
+    .option('--cwd <path>', 'List sessions of this working directory. Defaults to the current directory.')
+    .option('--all', 'List sessions across every workspace.', false)
+    .option('--archived', 'Include archived sessions.', false)
+    .option('--limit <n>', 'Print at most n sessions.', parseLimitOption)
+    .option('--json', 'Emit the session summaries as JSON.', false)
+    .action(async (options: { cwd?: string; all?: boolean; archived?: boolean; limit?: number; json?: boolean }) => {
+      const resolved = createDefaultSessionListDeps(deps);
+      try {
+        await handleSessionList(resolved, {
+          all: options.all === true,
+          archived: options.archived === true,
+          cwd: options.cwd,
+          limit: options.limit,
+          json: options.json === true,
+        });
+      } catch (error) {
+        resolved.stderr.write(`${errorMessage(error)}\n`);
+        resolved.exit(1);
+      } finally {
+        await resolved.close();
+      }
+    });
+}
+
+function createDefaultSessionListDeps(
+  overrides: Partial<SessionListDeps> = {},
+): SessionListDeps & { readonly close: () => Promise<void> } {
+  let harness: KimiHarness | undefined;
+  const identity = createKimiCodeHostIdentity();
+  const telemetryClient: TelemetryClient = {
+    track,
+    withContext: withTelemetryContext,
+    setContext: setTelemetryContext,
+  };
+  const getHarness = (): KimiHarness => {
+    harness ??= createKimiHarness({
+      homeDir: createCliTelemetryBootstrap().homeDir,
+      identity,
+      telemetry: telemetryClient,
+    });
+    return harness;
+  };
+  return {
+    listSessions:
+      overrides.listSessions ??
+      ((options: ListSessionsOptions) => getHarness().listSessions(options)),
+    cwd: overrides.cwd ?? (() => process.cwd()),
+    stdout: overrides.stdout ?? process.stdout,
+    stderr: overrides.stderr ?? process.stderr,
+    exit: overrides.exit ?? ((code: number) => process.exit(code)),
+    close: async () => {
+      await harness?.close();
+    },
+  };
+}
+
+function formatRow(summary: SessionSummary, showWorkDir: boolean): string {
+  const archived = summary.archived === true ? ' [archived]' : '';
+  const title = sanitizeField(summary.title ?? summary.lastPrompt ?? '');
+  const base = `${formatTimestamp(summary.updatedAt)}  ${summary.id}  ${title}${archived}`;
+  return showWorkDir ? `${base}  ${sanitizeField(summary.workDir)}` : base;
+}
+
+function sanitizeField(value: string): string {
+  return value.replaceAll(/[\x00-\x1f\x7f]+/g, ' ').trim();
+}
+
+function formatTimestamp(epochMs: number): string {
+  const date = new Date(epochMs);
+  const pad = (value: number): string => String(value).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+function parseLimitOption(value: string): number {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`--limit must be a positive integer, got "${value}"`);
+  }
+  return parsed;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

apps/kimi-code/src/cli/sub/upgrade.ts

@@ -0,0 +1,232 @@
+import { log, type Logger } from '@moonshot-ai/kimi-code-sdk';
+import { track as trackTelemetry, type TelemetryProperties } from '@moonshot-ai/kimi-telemetry';
+
+import { INTERACTIVE_UPDATE_CHECK_TIMEOUT_MS } from '#/constant/app';
+
+import { refreshUpdateCache } from '#/cli/update/refresh';
+import { selectUpdateTarget } from '#/cli/update/select';
+import { detectInstallSource } from '#/cli/update/source';
+import {
+  canAutoInstall,
+  installCommandFor,
+  installUpdate as installUpdateForeground,
+  renderInstallSuccessMessage,
+  renderManualUpdateMessage,
+} from '#/cli/update/preflight';
+import {
+  promptForInstallChoice,
+  type InstallPromptChoiceValue,
+  type InstallPromptOptions,
+} from '#/cli/update/prompt';
+import {
+  NPM_PACKAGE_NAME,
+  type InstallSource,
+  type UpdateCache,
+} from '#/cli/update/types';
+
+interface WritableLike {
+  write(chunk: string): boolean;
+}
+
+type UpgradeTrack = (event: string, properties?: TelemetryProperties) => void;
+type UpgradeLogger = Pick<Logger, 'info' | 'warn'>;
+
+export interface UpgradeDeps {
+  readonly refreshUpdateCache: () => Promise<UpdateCache>;
+  readonly detectInstallSource: () => Promise<InstallSource>;
+  readonly installUpdate: (
+    source: InstallSource,
+    version: string,
+    platform: NodeJS.Platform,
+  ) => Promise<void>;
+  readonly promptForInstallChoice: (
+    options: InstallPromptOptions,
+  ) => Promise<InstallPromptChoiceValue>;
+  readonly platform: NodeJS.Platform;
+  readonly stdout: WritableLike;
+  readonly stderr: WritableLike;
+  readonly isInteractive: boolean;
+  readonly yes: boolean;
+  readonly track: UpgradeTrack;
+  readonly logger: UpgradeLogger;
+}
+
+export async function handleUpgrade(
+  currentVersion: string,
+  overrides: Partial<UpgradeDeps> = {},
+): Promise<number> {
+  const deps = createDefaultUpgradeDeps(overrides);
+
+  let cache: UpdateCache;
+  try {
+    cache = await deps.refreshUpdateCache();
+  } catch (error) {
+    const reason = formatErrorMessage(error);
+    trackUpgradeEvent(deps.track, 'upgrade_command_failed', {
+      current_version: currentVersion,
+      stage: 'refresh',
+      reason,
+    });
+    logUpgradeWarn(deps.logger, 'manual upgrade check failed', {
+      currentVersion,
+      error,
+    });
+    deps.stderr.write(`error: failed to check for updates: ${reason}\n`);
+    return 1;
+  }
+
+  const target = selectUpdateTarget(currentVersion, cache.latest);
+  if (target === null) {
+    trackUpgradeEvent(deps.track, 'upgrade_command_no_update', {
+      current_version: currentVersion,
+    });
+    logUpgradeInfo(deps.logger, 'manual upgrade no update', {
+      currentVersion,
+    });
+    deps.stdout.write(`Kimi Code is already up to date (${formatDisplayVersion(currentVersion)}).\n`);
+    return 0;
+  }
+
+  const source = await deps.detectInstallSource().catch(() => 'unsupported' as const);
+  const installCommand = installCommandFor(source, target.version, deps.platform);
+  if (!canAutoInstall(source, deps.platform) || (!deps.yes && !deps.isInteractive)) {
+    trackUpgradeEvent(deps.track, 'upgrade_command_manual_command', {
+      current_version: currentVersion,
+      target_version: target.version,
+      source,
+    });
+    logUpgradeInfo(deps.logger, 'manual upgrade command shown', {
+      currentVersion,
+      targetVersion: target.version,
+      source,
+    });
+    deps.stdout.write(renderManualUpdateMessage(currentVersion, target, source, installCommand));
+    return 0;
+  }
+
+  if (!deps.yes) {
+    trackUpgradeEvent(deps.track, 'upgrade_command_prompted', {
+      current_version: currentVersion,
+      target_version: target.version,
+      source,
+    });
+    logUpgradeInfo(deps.logger, 'manual upgrade prompted', {
+      currentVersion,
+      targetVersion: target.version,
+      source,
+    });
+    const choice = await deps.promptForInstallChoice({
+      currentVersion,
+      target,
+      installCommand,
+      installSource: source,
+    });
+    if (choice === 'skip') {
+      trackUpgradeEvent(deps.track, 'upgrade_command_skipped', {
+        current_version: currentVersion,
+        target_version: target.version,
+        source,
+      });
+      logUpgradeInfo(deps.logger, 'manual upgrade skipped', {
+        currentVersion,
+        targetVersion: target.version,
+        source,
+      });
+      return 0;
+    }
+  }
+
+  try {
+    trackUpgradeEvent(deps.track, 'upgrade_command_install_selected', {
+      current_version: currentVersion,
+      target_version: target.version,
+      source,
+    });
+    await deps.installUpdate(source, target.version, deps.platform);
+    trackUpgradeEvent(deps.track, 'upgrade_command_succeeded', {
+      current_version: currentVersion,
+      target_version: target.version,
+      source,
+    });
+    logUpgradeInfo(deps.logger, 'manual upgrade install succeeded', {
+      currentVersion,
+      targetVersion: target.version,
+      source,
+    });
+    deps.stdout.write(renderInstallSuccessMessage(target));
+    return 0;
+  } catch (error) {
+    trackUpgradeEvent(deps.track, 'upgrade_command_failed', {
+      current_version: currentVersion,
+      target_version: target.version,
+      source,
+      stage: 'install',
+      reason: formatErrorMessage(error),
+    });
+    logUpgradeWarn(deps.logger, 'manual upgrade install failed', {
+      currentVersion,
+      targetVersion: target.version,
+      source,
+      error,
+    });
+    deps.stderr.write(
+      `warning: failed to install ${NPM_PACKAGE_NAME}@${target.version}: ` +
+        `${formatErrorMessage(error)}\n`,
+    );
+    return 1;
+  }
+}
+
+function createDefaultUpgradeDeps(overrides: Partial<UpgradeDeps>): UpgradeDeps {
+  return {
+    refreshUpdateCache:
+      overrides.refreshUpdateCache ??
+      (() => refreshUpdateCache({ timeoutMs: INTERACTIVE_UPDATE_CHECK_TIMEOUT_MS })),
+    detectInstallSource: overrides.detectInstallSource ?? (() => detectInstallSource()),
+    installUpdate: overrides.installUpdate ?? installUpdateForeground,
+    promptForInstallChoice: overrides.promptForInstallChoice ?? promptForInstallChoice,
+    platform: overrides.platform ?? process.platform,
+    stdout: overrides.stdout ?? process.stdout,
+    stderr: overrides.stderr ?? process.stderr,
+    isInteractive: overrides.isInteractive ?? (process.stdin.isTTY && process.stdout.isTTY),
+    yes: overrides.yes ?? false,
+    track: overrides.track ?? trackTelemetry,
+    logger: overrides.logger ?? log,
+  };
+}
+
+function formatDisplayVersion(version: string): string {
+  return version.startsWith('v') ? version : `v${version}`;
+}
+
+function formatErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function trackUpgradeEvent(
+  track: UpgradeTrack,
+  event: string,
+  properties: TelemetryProperties,
+): void {
+  try {
+    track(event, properties);
+  } catch {
+    // Telemetry must never affect upgrade flow.
+  }
+}
+
+function logUpgradeInfo(logger: UpgradeLogger, message: string, payload: Record<string, unknown>): void {
+  try {
+    logger.info(message, payload);
+  } catch {
+    // Diagnostic logging must never affect upgrade flow.
+  }
+}
+
+function logUpgradeWarn(logger: UpgradeLogger, message: string, payload: Record<string, unknown>): void {
+  try {
+    logger.warn(message, payload);
+  } catch {
+    // Diagnostic logging must never affect upgrade flow.
+  }
+}

apps/kimi-code/src/cli/sub/web/access-urls.ts

@@ -0,0 +1,97 @@
+/**
+ * Build the clickable/copyable access URLs for the running server.
+ *
+ * Shared by the `kimi web` ready banner and `kimi web rotate-token` so both
+ * show the same Local/Network links. When a token is known it rides in the
+ * `#token=` fragment (never sent to the server, so never logged), letting a
+ * user open the link on another device and be authenticated automatically.
+ */
+
+import { formatHostForUrl, listNetworkAddresses, type NetworkAddress } from './networks';
+
+/**
+ * Build a directly-openable server URL. When the token is known it is appended
+ * as `#token=<token>`; otherwise the bare origin (with a trailing slash) is
+ * returned.
+ */
+export function buildOpenableUrl(bareOrigin: string, token: string | undefined): string {
+  const base = bareOrigin.endsWith('/') ? bareOrigin.slice(0, -1) : bareOrigin;
+  return token === undefined ? `${base}/` : `${base}/#token=${token}`;
+}
+
+/**
+ * Split a full URL into the part before `#token=` and the `#token=…` fragment
+ * itself, so callers can render the fragment in a de-emphasized color. Returns
+ * `[fullUrl, '']` when there is no token fragment.
+ */
+export function splitTokenFragment(fullUrl: string): [string, string] {
+  const marker = '#token=';
+  const idx = fullUrl.indexOf(marker);
+  return idx < 0 ? [fullUrl, ''] : [fullUrl.slice(0, idx), fullUrl.slice(idx)];
+}
+
+export interface AccessUrlLine {
+  /** Fixed-width label including trailing padding, e.g. `"Local:    "`. */
+  label: string;
+  /** Full URL, carrying `#token=` when a token is known. */
+  url: string;
+}
+
+function isWildcard(host: string): boolean {
+  return host === '' || host === '0.0.0.0' || host === '::';
+}
+
+/**
+ * Rewrite a bound origin for browser auto-open. A wildcard bind host
+ * (`0.0.0.0` / `::` / empty) is not navigable, so open localhost on the same
+ * port instead — the same address the ready banner's `Local:` line shows.
+ */
+export function browserOpenOrigin(origin: string): string {
+  const separator = origin.lastIndexOf(':');
+  const host = origin.slice(origin.indexOf('://') + 3, separator);
+  if (!isWildcard(host)) return origin;
+  return `http://localhost${origin.slice(separator)}`;
+}
+
+/** True when `host` is a loopback address (this host only). */
+export function isLoopbackHost(host: string): boolean {
+  return host === 'localhost' || host === '127.0.0.1' || host === '::1';
+}
+
+function hostOrigin(host: string, port: number): string {
+  const family = host.includes(':') ? 'IPv6' : 'IPv4';
+  return `http://${formatHostForUrl(host, family)}:${port}`;
+}
+
+/**
+ * Compute the access-URL lines for a bind host/port.
+ *
+ * - wildcard (`0.0.0.0` / `::` / empty): a `Local:` line (localhost) plus one
+ *   `Network:` line per non-loopback interface.
+ * - loopback: a single `Local:` line.
+ * - specific host: a single `URL:` line.
+ */
+export function accessUrlLines(
+  host: string,
+  port: number,
+  token: string | undefined,
+  networkAddresses?: NetworkAddress[],
+): AccessUrlLine[] {
+  if (isWildcard(host)) {
+    const lines: AccessUrlLine[] = [
+      { label: 'Local:    ', url: buildOpenableUrl(`http://localhost:${port}`, token) },
+    ];
+    const addrs = networkAddresses ?? listNetworkAddresses();
+    for (const addr of addrs) {
+      lines.push({
+        label: 'Network:  ',
+        url: buildOpenableUrl(`http://${formatHostForUrl(addr.address, addr.family)}:${port}`, token),
+      });
+    }
+    return lines;
+  }
+  if (isLoopbackHost(host)) {
+    return [{ label: 'Local:    ', url: buildOpenableUrl(hostOrigin(host, port), token) }];
+  }
+  return [{ label: 'URL:      ', url: buildOpenableUrl(hostOrigin(host, port), token) }];
+}

apps/kimi-code/src/cli/sub/web/deprecated-server.ts

@@ -0,0 +1,38 @@
+/**
+ * Deprecated `kimi server` shim.
+ *
+ * The `kimi server` command tree was replaced by `kimi web` (a foreground
+ * server opened in the browser). Any `kimi server …` invocation — bare or
+ * with any legacy subcommand/flags — lands here, prints the deprecation
+ * notice, and exits 1. The shim itself is scheduled for removal in the next
+ * major version of Kimi Code.
+ *
+ * One subcommand stays functional: `kimi server kill`, the cleanup path for
+ * background servers started by pre-0.28.0 builds (recorded in the legacy
+ * single-instance lock, which the instance registry never sees).
+ */
+
+import type { Command } from 'commander';
+
+import { registerLegacyKillCommand } from './legacy-kill';
+
+export const DEPRECATED_SERVER_NOTICE =
+  '`kimi server` has been deprecated and no longer works.\n' +
+  'Use `kimi web` instead — it runs the local server in the foreground and opens the web UI (`--no-open` to skip).\n' +
+  'To stop a server started by a version before 0.28.0, use `kimi server kill`.\n' +
+  'This notice will be removed in the next major version of Kimi Code.\n';
+
+export function registerDeprecatedServerCommand(program: Command): void {
+  const server = program
+    .command('server')
+    .description('Deprecated — use `kimi web` instead.')
+    // Swallow every legacy subcommand/flag (`run`, `kill`, `--port`, …) so
+    // they all land in the same notice instead of a commander parse error.
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .action(() => {
+      process.stderr.write(DEPRECATED_SERVER_NOTICE);
+      process.exit(1);
+    });
+  registerLegacyKillCommand(server);
+}

apps/kimi-code/src/cli/sub/web/index.ts

@@ -0,0 +1,34 @@
+/**
+ * `kimi web` — run the local Kimi server (REST + WebSocket + web UI) in the
+ * foreground and open the web UI in the default browser.
+ *
+ * The command itself is the runner (`kimi web` = start the server + open the
+ * browser; `--no-open` to skip). The server stays attached to the terminal
+ * and stops with Ctrl+C, so there is no kill/ps subcommand; the only
+ * management subcommand is `web rotate-token` (rotate the home-wide bearer
+ * token). Servers left behind by pre-0.28.0 builds are cleaned up with
+ * `kimi server kill`.
+ */
+
+import type { Command } from 'commander';
+
+import { registerDeprecatedServerCommand } from './deprecated-server';
+import { registerRotateTokenCommand } from './rotate-token';
+import { buildWebCommand } from './run';
+
+export function registerWebCommand(program: Command): void {
+  const web = buildWebCommand(
+    program
+      .command('web')
+      .description('Run the local Kimi server and open the web UI.'),
+  );
+  registerRotateTokenCommand(web);
+  registerDeprecatedServerCommand(program);
+  buildWebCommand(
+    program
+      .command('rc')
+      .alias('remote')
+      .description('Run the local Kimi server and open the web UI through Remote Control.'),
+    { forceRemoteControl: true },
+  );
+}

apps/kimi-code/src/cli/sub/web/legacy-kill.ts

@@ -0,0 +1,263 @@
+/**
+ * `kimi server kill` — deprecated; only stops a server started by an old
+ * (pre-`kimi web`, i.e. before 0.28.0) build.
+ *
+ * Servers started by current builds run in the foreground attached to a
+ * terminal (Ctrl+C stops them), so they need no kill command. Builds before
+ * the `kimi web` command tree could leave a background daemon behind; those
+ * recorded themselves in the legacy single-instance lock at
+ * `<KIMI_CODE_HOME>/server/lock`, which the instance registry never sees.
+ * This command is the cleanup path for exactly those servers.
+ *
+ * The kill combines two independent mechanisms so the server dies even if one
+ * path fails:
+ *
+ *   1. API path  — `POST /api/v1/shutdown` for a graceful, in-process shutdown
+ *                  (best-effort; old builds may not have the route, or may not
+ *                  answer at all).
+ *   2. PID path  — signal the pid recorded in the lock (SIGTERM → wait →
+ *                  SIGKILL). SIGKILL is the hard guarantee: it cannot be
+ *                  caught or ignored.
+ *
+ * The lock file is removed once the recorded pid is confirmed dead (or was
+ * dead already), so the cleanup is complete after one run.
+ */
+
+import { readFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import type { Command } from 'commander';
+
+import { getDataDir } from '#/utils/paths';
+
+import { authHeaders, serverOrigin, tryResolveServerToken } from './shared';
+
+/** How long to wait for the graceful API shutdown request. */
+const API_TIMEOUT_MS = 2000;
+/** Grace period after SIGTERM before escalating to SIGKILL. */
+const TERM_GRACE_MS = 3000;
+/** Grace period after SIGKILL before giving up. */
+const KILL_GRACE_MS = 2000;
+/** Poll cadence while waiting for the pid to exit. */
+const POLL_INTERVAL_MS = 100;
+
+/**
+ * The first release whose servers run in the foreground (`kimi web`) and
+ * register under `server/instances/`. Servers from older builds are the only
+ * ones this command can — and should — kill.
+ */
+export const LEGACY_SERVER_MAX_VERSION = '0.28.0';
+
+/** Deprecation notice printed on every `kimi server kill` run. */
+export const DEPRECATED_KILL_NOTICE =
+  '`kimi server kill` is deprecated: it only stops servers started by a version before 0.28.0. Servers started by `kimi web` run in the foreground — stop them with Ctrl+C.\n';
+
+/**
+ * The fields of the legacy `<home>/server/lock` this command needs. The full
+ * on-disk shape also carried `started_at` / `host_version` / `entry`, which
+ * are irrelevant to killing the process.
+ */
+export interface LegacyServerLock {
+  pid: number;
+  host?: string;
+  port?: number;
+}
+
+export interface LegacyKillDeps {
+  /** Read and parse the legacy lock; undefined when missing or unparseable. */
+  readLock(): Promise<LegacyServerLock | undefined>;
+  /** Delete the lock file. Best-effort semantics live with the caller. */
+  removeLock(): Promise<void>;
+  requestShutdown(origin: string, token: string | undefined): Promise<void>;
+  /** Best-effort read of the persistent bearer token; undefined on miss. */
+  resolveToken(): string | undefined;
+  signalPid(pid: number, signal: NodeJS.Signals): boolean;
+  pidAlive(pid: number): boolean;
+  sleep(ms: number): Promise<void>;
+  stdout: Pick<NodeJS.WriteStream, 'write'>;
+  stderr: Pick<NodeJS.WriteStream, 'write'>;
+  now(): number;
+}
+
+export function registerLegacyKillCommand(server: Command): void {
+  server
+    .command('kill')
+    .description(
+      'Deprecated — stop a server started by a version before 0.28.0 (recorded in the legacy server lock). Servers started by `kimi web` run in the foreground — stop them with Ctrl+C.',
+    )
+    // Swallow legacy argument shapes (`kimi server kill <serverId>`, flags):
+    // the legacy lock records a single server, so they carry no meaning here.
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .action(async () => {
+      try {
+        await handleLegacyKillCommand(DEFAULT_LEGACY_KILL_DEPS);
+      } catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+      }
+    });
+}
+
+export async function handleLegacyKillCommand(deps: LegacyKillDeps): Promise<void> {
+  deps.stderr.write(DEPRECATED_KILL_NOTICE);
+
+  const lock = await deps.readLock();
+  if (lock === undefined) {
+    deps.stdout.write('No running legacy Kimi server.\n');
+    return;
+  }
+
+  if (!deps.pidAlive(lock.pid)) {
+    // Stale lock from a server that died without releasing it; sweep it so the
+    // cleanup is done in one run.
+    await deps.removeLock().catch(() => {});
+    deps.stdout.write('No running legacy Kimi server.\n');
+    return;
+  }
+
+  const outcome = await killLegacyServer(lock, deps);
+  await deps.removeLock().catch(() => {});
+  deps.stdout.write(`Legacy Kimi server (pid ${String(lock.pid)}) ${outcome}.\n`);
+}
+
+/**
+ * Kill the locked server via the API path (best-effort graceful shutdown)
+ * followed by the PID path (SIGTERM �� wait → SIGKILL). Resolves with how the
+ * process went down; throws when the pid survives SIGKILL.
+ */
+async function killLegacyServer(
+  lock: LegacyServerLock,
+  deps: LegacyKillDeps,
+): Promise<'stopped' | 'killed'> {
+  const { pid } = lock;
+
+  // 1. API path — best-effort graceful shutdown. Ignore every outcome: an old
+  //    build may not have the route, may be wedged, or may drop the connection
+  //    as it exits. The bearer token is best-effort too: if it can't be read
+  //    the API call 401s and the PID path below still guarantees the kill.
+  if (lock.port !== undefined) {
+    const origin = serverOrigin(lock.host ?? '127.0.0.1', lock.port);
+    await deps.requestShutdown(origin, deps.resolveToken()).catch(() => {});
+  }
+
+  // 2. PID path — SIGTERM, wait, then SIGKILL.
+  deps.signalPid(pid, 'SIGTERM');
+
+  if (await waitForExit(pid, TERM_GRACE_MS, deps)) {
+    return 'stopped';
+  }
+
+  deps.signalPid(pid, 'SIGKILL');
+
+  if (await waitForExit(pid, KILL_GRACE_MS, deps)) {
+    return 'killed';
+  }
+
+  throw new Error(
+    `Failed to stop legacy Kimi server (pid ${String(pid)}); insufficient permissions?`,
+  );
+}
+
+async function waitForExit(
+  pid: number,
+  timeoutMs: number,
+  deps: Pick<LegacyKillDeps, 'pidAlive' | 'sleep' | 'now'>,
+): Promise<boolean> {
+  const deadline = deps.now() + timeoutMs;
+  do {
+    if (!deps.pidAlive(pid)) return true;
+    await deps.sleep(POLL_INTERVAL_MS);
+  } while (deps.now() < deadline);
+  return !deps.pidAlive(pid);
+}
+
+/** `process.kill(pid, 0)` probe — true if the pid exists, false on ESRCH. */
+export function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ESRCH') return false;
+    // EPERM = process exists but we can't signal it. Treat as alive.
+    return true;
+  }
+}
+
+/** Send `signal` to `pid`. Returns false if the signal could not be sent. */
+export function signalPid(pid: number, signal: NodeJS.Signals): boolean {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** POST the shutdown endpoint; resolves once the request completes or times out. */
+export async function requestShutdownViaApi(
+  origin: string,
+  token: string | undefined,
+): Promise<void> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort();
+  }, API_TIMEOUT_MS);
+  try {
+    await fetch(`${origin}/api/v1/shutdown`, {
+      method: 'POST',
+      headers: token !== undefined ? authHeaders(token) : undefined,
+      signal: controller.signal,
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/** Path of the legacy single-instance lock under the CLI's data dir. */
+export function legacyLockPath(homeDir: string): string {
+  return join(homeDir, 'server', 'lock');
+}
+
+/** Read + decode the legacy lock; undefined on missing/unparseable input. */
+export async function readLegacyLock(lockPath: string): Promise<LegacyServerLock | undefined> {
+  let raw: string;
+  try {
+    raw = await readFile(lockPath, 'utf8');
+  } catch {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(raw) as Partial<{ pid: unknown; host: unknown; port: unknown }>;
+    // Only accept a positive safe-integer pid: on POSIX, 0 and negative pids
+    // have process-GROUP semantics, so signaling a corrupt lock's pid could
+    // hit this CLI's own group or an unrelated one.
+    if (typeof parsed.pid !== 'number' || !Number.isSafeInteger(parsed.pid) || parsed.pid <= 0) {
+      return undefined;
+    }
+    return {
+      pid: parsed.pid,
+      host: typeof parsed.host === 'string' ? parsed.host : undefined,
+      port: typeof parsed.port === 'number' ? parsed.port : undefined,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+const DEFAULT_LEGACY_KILL_DEPS: LegacyKillDeps = {
+  readLock: () => readLegacyLock(legacyLockPath(getDataDir())),
+  removeLock: () => unlink(legacyLockPath(getDataDir())),
+  requestShutdown: requestShutdownViaApi,
+  resolveToken: () => tryResolveServerToken(getDataDir()),
+  signalPid,
+  pidAlive,
+  sleep: (ms) =>
+    new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    }),
+  stdout: process.stdout,
+  stderr: process.stderr,
+  now: () => Date.now(),
+};

apps/kimi-code/src/cli/sub/web/networks.ts

@@ -0,0 +1,84 @@
+/**
+ * Enumerate this machine's non-loopback network interface addresses, used to
+ * print `Network: http://<addr>:<port>/` hints (à la Vite) when the server
+ * binds a wildcard host (`0.0.0.0` / `::`).
+ */
+
+import { networkInterfaces } from 'node:os';
+
+export interface NetworkAddress {
+  /** Raw IP address (IPv4 or IPv6); IPv6 is NOT bracket-wrapped here. */
+  address: string;
+  family: 'IPv4' | 'IPv6';
+}
+
+/**
+ * List non-internal interface addresses, IPv4 first then IPv6, preserving
+ * interface order within each family.
+ *
+ * Like Vite, this lists the machine's own interface addresses — LAN
+ * (192.168/10/172.16) plus any directly-assigned public address. It does not
+ * (and cannot, without an external service) discover a NAT-translated WAN IP,
+ * and we deliberately avoid any network call for a startup hint.
+ */
+export function listNetworkAddresses(): NetworkAddress[] {
+  const raw: NetworkAddress[] = [];
+  for (const entries of Object.values(networkInterfaces())) {
+    for (const info of entries ?? []) {
+      if (info.internal) {
+        continue;
+      }
+      if (info.family === 'IPv4') {
+        raw.push({ address: info.address, family: 'IPv4' });
+      } else if (info.family === 'IPv6') {
+        raw.push({ address: info.address, family: 'IPv6' });
+      }
+    }
+  }
+  return filterDisplayAddresses(raw);
+}
+
+/**
+ * Drop addresses that are not useful as a connect target and de-duplicate.
+ *
+ * IPv6 link-local (`fe80::/10`) is filtered out: it is only reachable with a
+ * zone id (e.g. `fe80::1%en0`), which our bare URL cannot carry, so showing it
+ * is pure noise — and it is the bulk of what `os.networkInterfaces()` reports
+ * on a typical machine. Duplicates (the same address reported on more than one
+ * interface) are collapsed. The result is IPv4 first, then IPv6, preserving
+ * order within each family.
+ */
+export function filterDisplayAddresses(
+  addrs: readonly NetworkAddress[],
+): NetworkAddress[] {
+  const seen = new Set<string>();
+  const kept: NetworkAddress[] = [];
+  for (const addr of addrs) {
+    if (addr.family === 'IPv6' && isLinkLocalV6(addr.address)) {
+      continue;
+    }
+    if (seen.has(addr.address)) {
+      continue;
+    }
+    seen.add(addr.address);
+    kept.push(addr);
+  }
+  return [
+    ...kept.filter((a) => a.family === 'IPv4'),
+    ...kept.filter((a) => a.family === 'IPv6'),
+  ];
+}
+
+/** True for IPv6 link-local addresses (`fe80::/10`, i.e. `fe80::`–`febf::`). */
+function isLinkLocalV6(address: string): boolean {
+  const first = Number.parseInt(address.split(':')[0] ?? '', 16);
+  return first >= 0xfe80 && first <= 0xfebf;
+}
+
+/**
+ * Format an address for use as a URL host: bracket-wrap IPv6 per RFC 3986,
+ * return IPv4 as-is.
+ */
+export function formatHostForUrl(address: string, family: NetworkAddress['family']): string {
+  return family === 'IPv6' ? `[${address}]` : address;
+}

apps/kimi-code/src/cli/sub/web/remote-control.ts

@@ -0,0 +1,92 @@
+import chalk from 'chalk';
+
+import { getVersion } from '../../version';
+import { darkColors } from '../../../tui/theme/colors';
+import { supportsHyperlinks, toTerminalHyperlink } from '../../../utils/terminal-hyperlink';
+import type { RemoteControlStatus } from '@moonshot-ai/remote-control';
+import { buildOpenableUrl, splitTokenFragment } from './access-urls';
+
+export {
+  acquireRemoteControlLock,
+  buildRemoteControlUrl,
+  filterForwardRequestHeaders,
+  formatRemoteControlAlreadyRunning,
+  inspectRemoteControlLock,
+  parseRawHttpRequest,
+  remoteControlLockPath,
+  RemoteControlAlreadyRunningError,
+  REMOTE_CONTROL_RELAY_ORIGIN,
+  REMOTE_CONTROL_RELAY_URL_ENV,
+  resolveRemoteControlRelayOrigin,
+  rewriteRemoteControlResponse,
+  startRemoteControl,
+} from '@moonshot-ai/remote-control';
+export type {
+  ParsedRawHttpRequest,
+  RemoteControlHandle,
+  RemoteControlLock,
+  RemoteControlLockInfo,
+  RemoteControlOptions,
+  RemoteControlStatus,
+} from '@moonshot-ai/remote-control';
+
+export interface RemoteControlOutputOptions {
+  readonly url: string;
+  readonly localOrigin: string;
+  readonly localServerToken: string;
+  readonly deviceName: string;
+  readonly qrCode: string;
+  readonly pngPath: string;
+}
+
+export function formatRemoteControlOutput(options: RemoteControlOutputOptions): string {
+  const title = (text: string): string => chalk.bold.hex(darkColors.primary)(text);
+  const label = (text: string): string => chalk.bold.hex(darkColors.textDim)(text);
+  const accent = (text: string): string => chalk.hex(darkColors.accent)(text);
+  const dim = (text: string): string => chalk.hex(darkColors.textDim)(text);
+  const muted = (text: string): string => chalk.hex(darkColors.textMuted)(text);
+  const status = (text: string): string => chalk.hex(darkColors.success)(text);
+  const link = (url: string): string =>
+    supportsHyperlinks() ? toTerminalHyperlink(accent(url), url) : accent(url);
+  const docs = toTerminalHyperlink('docs', 'https://kimi.com/code/docs/remote-control');
+  const feedback = toTerminalHyperlink('feedback', 'https://kimi.com/code/feedback');
+  const [localBase, localFrag] = splitTokenFragment(
+    buildOpenableUrl(options.localOrigin, options.localServerToken),
+  );
+  return [
+    '',
+    `  ${title('Kimi Remote Control ready')}  ${muted(getVersion())}`,
+    `  ${muted('Use Kimi Code on this machine from your phone or another computer.')}`,
+    '',
+    `  ${label('1.')} Scan the QR code, or open ${link(options.url)}`,
+    `  ${label('2.')} Log in with your Kimi account`,
+    `  ${label('3.')} Start chatting — sessions run on this machine`,
+    '',
+    `  ${status('✓')} ${muted(`Connected to ${new URL(options.url).host}, waiting for remote devices…`)}`,
+    `  ${label('This device: ')}${muted(options.deviceName)}`,
+    `  ${status('⚠')} ${muted('This link grants control of this machine. Do not share it.')}`,
+    '',
+    options.qrCode.trimEnd().replaceAll(/^/gm, '    '),
+    `  ${label('QR code PNG: ')}${options.pngPath} ${muted('(open this if the QR above does not scan)')}`,
+    `  ${label('Local UI: ')}${accent(localBase)}${dim(localFrag)} ${muted('(LAN: --host)')}`,
+    '',
+    `  ${docs} ${muted('·')} ${feedback}`,
+    `  ${label('Logs: ')}${muted('off (--log-level info)')} ${muted('·')} ${label('Stop: ')}${muted('Ctrl+C')}`,
+    '',
+  ].join('\n');
+}
+
+export function formatRemoteControlStatus(status: RemoteControlStatus): string {
+  const label = (text: string): string => chalk.bold.hex(darkColors.textDim)(text);
+  const value = (text: string): string => chalk.hex(darkColors.success)(text);
+  switch (status) {
+    case 'relay_connected':
+      return `  ${value('✓')} ${label('Connected to relay, waiting for remote devices…')}\n`;
+    case 'relay_disconnected':
+      return `  ${value('!')} ${label('Relay disconnected; reconnecting…')}\n`;
+    case 'device_connected':
+      return `  ${value('✓')} ${label('Remote device connected (1 active session)')}\n`;
+    case 'device_disconnected':
+      return `  ${value('→')} ${label('Remote device disconnected')}\n`;
+  }
+}

apps/kimi-code/src/cli/sub/web/rotate-token.ts

@@ -0,0 +1,56 @@
+/**
+ * `kimi web rotate-token` — generate a new persistent server token.
+ *
+ * Rewrites `<KIMI_CODE_HOME>/server.token` (0600, atomic). The previous token
+ * stops working immediately: a running server re-reads the file on its next
+ * auth check, so rotation takes effect without a restart.
+ */
+
+import { getLiveServerInstance, rotateServerToken } from '@moonshot-ai/kap-server';
+import chalk from 'chalk';
+import type { Command } from 'commander';
+
+import { darkColors } from '#/tui/theme/colors';
+import { getDataDir } from '#/utils/paths';
+
+import { accessUrlLines, splitTokenFragment } from './access-urls';
+
+export function registerRotateTokenCommand(server: Command): void {
+  server
+    .command('rotate-token')
+    .description(
+      'Generate a new persistent server token; the previous token stops working immediately.',
+    )
+    .action(async () => {
+      try {
+        const token = await rotateServerToken(getDataDir());
+        process.stdout.write(
+          'The previous token is now invalid. A running server picks up the new token automatically.\n',
+        );
+
+        // Token in the middle: indented and set off by blank lines (no color
+        // highlight), so it is easy to spot without dominating the output.
+        process.stdout.write(`\n  ${chalk.bold('New server token:')} ${token}\n\n`);
+
+        // Re-print the access links with the new token so the user can
+        // reconnect immediately. When a server is running its bind host/port
+        // come from the instance registry; otherwise there is nothing to
+        // connect to yet.
+        const instance = await getLiveServerInstance();
+        if (instance !== undefined) {
+          for (const { label, url: href } of accessUrlLines(instance.host, instance.port, token)) {
+            // De-emphasize the `#token=…` fragment so the host/port stands out.
+            const [base, frag] = splitTokenFragment(href);
+            const rendered =
+              frag === ''
+                ? chalk.hex(darkColors.accent)(base)
+                : chalk.hex(darkColors.accent)(base) + chalk.hex(darkColors.textDim)(frag);
+            process.stdout.write(`  ${chalk.dim(label)}${rendered}\n`);
+          }
+        }
+      } catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+      }
+    });
+}

apps/kimi-code/src/cli/sub/web/run.ts

@@ -0,0 +1,528 @@
+/**
+ * `kimi web` — run the local server in the foreground and open the web UI.
+ *
+ * The server always runs in the current process, attached to the terminal,
+ * and shuts down cleanly on SIGINT/SIGTERM. `--no-open` skips the browser.
+ * Multiple instances can share the home directory: each registers itself in
+ * the instance registry and takes the next free port (see kap-server's
+ * `startServer`).
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { createServerLogger, startServer, type ServerLogger } from '@moonshot-ai/kap-server';
+import { shutdownTelemetry, track } from '@moonshot-ai/kimi-telemetry';
+import chalk from 'chalk';
+import { type Command, Option } from 'commander';
+
+import { CLI_SHUTDOWN_TIMEOUT_MS, WEB_USER_AGENT_SUFFIX } from '#/constant/app';
+import { getNativeWebAssetsDir } from '#/native/web-assets';
+import { darkColors } from '#/tui/theme/colors';
+import { openUrl as defaultOpenUrl } from '#/utils/open-url';
+import { getDataDir } from '#/utils/paths';
+import { generateRemoteControlQr } from '#/utils/remote-control-qr';
+
+import { initializeServerTelemetry } from '../../telemetry';
+import {
+  createKimiCodeHostIdentity,
+  getHostPackageRoot,
+  getVersion,
+} from '../../version';
+import {
+  accessUrlLines,
+  browserOpenOrigin,
+  buildOpenableUrl,
+  isLoopbackHost,
+  splitTokenFragment,
+} from './access-urls';
+import { type NetworkAddress } from './networks';
+import {
+  formatRemoteControlOutput,
+  formatRemoteControlStatus,
+  startRemoteControl,
+  type RemoteControlHandle,
+  type RemoteControlOptions,
+  type RemoteControlStatus,
+} from './remote-control';
+import {
+  DEFAULT_FOREGROUND_LOG_LEVEL,
+  DEFAULT_LAN_HOST,
+  DEFAULT_SERVER_HOST,
+  DEFAULT_SERVER_PORT,
+  parseServerOptions,
+  tryResolveServerToken,
+  VALID_LOG_LEVELS,
+  type ParsedServerOptions,
+  type ServerCliOptions,
+} from './shared';
+
+const WEB_ASSETS_DIR = 'dist-web';
+
+/**
+ * Minimal surface `runServerInProcess` needs from the server. kap-server's
+ * `RunningServer` is adapted to it (it returns `{ host, port, close }`
+ * instead of `{ address, logger, close }`).
+ */
+interface RoutedServer {
+  readonly address: string;
+  readonly logger: ServerLogger;
+  close(): Promise<void>;
+}
+
+export interface WebCliOptions extends ServerCliOptions {
+  open?: boolean;
+  remoteControl?: boolean;
+}
+
+export interface StartForegroundHooks {
+  /** Fires once the server is listening, before the foreground runner blocks. */
+  onReady?: (origin: string) => void | Promise<void>;
+  onShutdown?: (reason: string) => void | Promise<void>;
+}
+
+export interface WebCommandDeps {
+  /** Foreground runner; defaults to the real in-process runner when omitted. */
+  startServerForeground?: (
+    options: ParsedServerOptions,
+    hooks?: StartForegroundHooks,
+  ) => Promise<never>;
+  startRemoteControl?: (options: RemoteControlOptions) => Promise<RemoteControlHandle>;
+  openUrl(url: string): void;
+  /**
+   * Best-effort read of the server's persistent bearer token. When it returns
+   * a token, the ready banner prints it and the opened Web UI URL carries it in
+   * the `#token=` fragment (M5.5). Optional so callers/tests that don't supply
+   * it simply print/open the plain origin.
+   */
+  resolveToken?: () => string | undefined;
+  /**
+   * Non-loopback interface addresses to display for a wildcard bind. Defaults
+   * to the machine's own interfaces (`listNetworkAddresses()`); inject a fixed
+   * list in tests for deterministic output.
+   */
+  networkAddresses?: NetworkAddress[];
+  stdout: Pick<NodeJS.WriteStream, 'write'>;
+  stderr: Pick<NodeJS.WriteStream, 'write'>;
+}
+
+/**
+ * Build the Web UI URL, carrying the bearer token in the URL fragment.
+ *
+ * The token rides in `#token=<token>` — a client-side fragment that is never
+ * sent to the server (so it never appears in server access logs) and is not
+ * logged by proxies. The Web UI reads it from `location.hash` after load.
+ */
+export function buildWebUrl(origin: string, token: string): string {
+  return buildOpenableUrl(origin, token);
+}
+
+/** Build the `web` command, mounting the runner action on `cmd` itself. */
+export function buildWebCommand(
+  cmd: Command,
+  opts: { forceRemoteControl?: boolean } = {},
+): Command {
+  const forceRemoteControl = opts.forceRemoteControl === true;
+  const withServerOptions = cmd
+    .option(
+      '--port <port>',
+      `Bind port (default ${DEFAULT_SERVER_PORT})`,
+      String(DEFAULT_SERVER_PORT),
+    )
+    .option(
+      '--host [host]',
+      `Bind host. Omit to bind ${DEFAULT_SERVER_HOST} (this machine only); pass --host to bind ${DEFAULT_LAN_HOST} (all interfaces), or --host <host> for a specific host. The bearer token is printed at startup.`,
+    )
+    .option(
+      '--allowed-host <host...>',
+      'Extra Host header value to allow through the DNS-rebinding check. Repeat or comma-separate; a leading dot matches a domain suffix (e.g. .example.com).',
+    )
+    .option(
+      '--insecure-no-tls',
+      'Allow a non-loopback bind without a TLS-terminating reverse proxy. Defaults to true; only relevant for non-loopback binds.',
+      true,
+    )
+    .option(
+      '--allow-remote-shutdown',
+      'On a non-loopback bind, keep POST /api/v1/shutdown enabled (default: route is disabled → 404).',
+      false,
+    )
+    .option(
+      '--dangerous-bypass-auth',
+      'Disable bearer-token auth on every REST and WebSocket route, and advertise it via /api/v1/meta so the web UI connects without a token. Only use on a trusted network or behind your own authenticating proxy.',
+      false,
+    )
+    .option(
+      '--log-level <level>',
+      `Server log level: ${VALID_LOG_LEVELS.join('|')}. Omit to keep logs off.`,
+    )
+    .option(
+      '--debug-endpoints',
+      'Mount /api/v1/debug/* routes for test introspection. OFF by default; production callers leave this unset.',
+      false,
+    )
+    .option(
+      '--web-title <title>',
+      'Set a custom browser tab title for this web UI instance (default: "<workspace dir> | Kimi Code").',
+    );
+  if (!forceRemoteControl) {
+    withServerOptions.addOption(
+      new Option(
+        '--rc, --remote-control',
+        'Expose the web UI through Kimi Remote Control.',
+      ).default(false),
+    );
+  }
+  return withServerOptions
+    .option('--no-open', 'Do not open the web UI in the default browser.', true)
+    .action(async (opts: WebCliOptions) => {
+      try {
+        await handleWebCommand(
+          forceRemoteControl ? { ...opts, remoteControl: true } : opts,
+        );
+      } catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+      }
+    });
+}
+
+export async function handleWebCommand(
+  opts: WebCliOptions,
+  deps: WebCommandDeps = DEFAULT_WEB_COMMAND_DEPS,
+): Promise<void> {
+  const parsed = parseServerOptions(opts);
+  if (opts.remoteControl === true && parsed.dangerousBypassAuth) {
+    throw new Error('--remote-control cannot be combined with --dangerous-bypass-auth.');
+  }
+  if (opts.remoteControl === true && !isLoopbackHost(parsed.host)) {
+    throw new Error('--remote-control requires a loopback host.');
+  }
+  const run = deps.startServerForeground ?? startServerForeground;
+  let remoteControl: RemoteControlHandle | undefined;
+  await run(parsed, {
+    onReady: async (origin) => {
+      // Resolve the persistent token only once the server is up: a fresh
+      // server writes `server.token` on first boot, so reading it beforehand
+      // would miss first-time starts and the browser would hit the auth gate.
+      // It is printed in the ready banner and rides in the opened Web UI
+      // URL's `#token=` fragment (M5.5); falls back to the plain origin / no
+      // token line when unavailable. When auth is bypassed, the token is
+      // meaningless and is intentionally NOT shown or carried in the URL.
+      const token = parsed.dangerousBypassAuth ? undefined : deps.resolveToken?.();
+      if (opts.remoteControl === true) {
+        if (token === undefined) throw new Error('Unable to read the local server token.');
+        const dataDir = getDataDir();
+        let outputReady = false;
+        const pendingStatuses: string[] = [];
+        const onStatus = (status: RemoteControlStatus): void => {
+          const line = formatRemoteControlStatus(status);
+          if (outputReady) deps.stdout.write(line);
+          else pendingStatuses.push(line);
+        };
+        remoteControl = await (deps.startRemoteControl ?? startRemoteControl)({
+          homeDir: dataDir,
+          localOrigin: origin,
+          localServerToken: token,
+          clientVersion: `kimi-code/${getVersion()}`,
+          stderr: deps.stderr,
+          onStatus,
+        });
+        const qrCode = await generateRemoteControlQr(remoteControl.url, dataDir);
+        deps.stdout.write(
+          formatRemoteControlOutput({
+            url: remoteControl.url,
+            localOrigin: origin,
+            localServerToken: token,
+            deviceName: remoteControl.deviceName,
+            qrCode: qrCode.terminal,
+            pngPath: qrCode.pngPath,
+          }),
+        );
+        outputReady = true;
+        for (const line of pendingStatuses) deps.stdout.write(line);
+        if (opts.open === true) deps.openUrl(remoteControl.url);
+        return;
+      }
+      deps.stdout.write(
+        parsed.logLevel === DEFAULT_FOREGROUND_LOG_LEVEL
+          ? formatReadyBanner(origin, parsed.host, {
+              token,
+              networkAddresses: deps.networkAddresses,
+              dangerousBypassAuth: parsed.dangerousBypassAuth,
+            })
+          : formatReadyLine(origin, token, parsed.dangerousBypassAuth),
+      );
+      if (opts.open === true) {
+        const openOrigin = browserOpenOrigin(origin);
+        deps.openUrl(token !== undefined ? buildWebUrl(openOrigin, token) : openOrigin);
+      }
+    },
+    onShutdown: async () => {
+      await remoteControl?.close();
+    },
+  });
+}
+
+function formatReadyLine(
+  origin: string,
+  token: string | undefined,
+  dangerousBypassAuth = false,
+): string {
+  const notice = dangerousBypassAuth
+    ? `${formatDangerNoticeLines().join('\n')}\n`
+    : '';
+  return `${notice}Kimi server: ${buildOpenableUrl(origin, token)}\n`;
+}
+
+/**
+ * Red, impossible-to-miss notice emitted when `--dangerous-bypass-auth`
+ * disables the bearer-token gate. Shared by the full ready banner and the
+ * compact one-line output so the warning always shows regardless of log level.
+ */
+function formatDangerNoticeLines(): string[] {
+  const danger = (text: string): string => chalk.hex(darkColors.error)(text);
+  const dangerBold = (text: string): string => chalk.bold.hex(darkColors.error)(text);
+  return [
+    `  ${dangerBold('⚠ DANGER: authentication is DISABLED (--dangerous-bypass-auth).')}`,
+    `  ${danger('Anyone who can reach this port gets full access. Only continue if you understand the risk.')}`,
+    `  ${danger('If you are unsure, stop this process now with ')}${dangerBold('Ctrl+C')}${danger('.')}`,
+  ];
+}
+
+/**
+ * `kimi web` — runs the local server in-process, attached to the current
+ * terminal. Resolves only via `process.exit` (SIGINT/SIGTERM).
+ */
+export async function startServerForeground(
+  options: ParsedServerOptions,
+  hooks: StartForegroundHooks = {},
+): Promise<never> {
+  return runServerInProcess(options, hooks);
+}
+
+/**
+ * Start the server in the current process and block until shutdown.
+ * `onReady` fires once the server is listening.
+ */
+async function runServerInProcess(
+  options: ParsedServerOptions,
+  hooks: StartForegroundHooks,
+): Promise<never> {
+  const version = getVersion();
+  // Registers the telemetry provider for `track` / `shutdownTelemetry`; the
+  // client itself is not passed into kap-server.
+  initializeServerTelemetry({ version });
+
+  let running: RoutedServer | undefined;
+  let stopping = false;
+
+  async function shutdown(reason: string): Promise<void> {
+    if (stopping) return;
+    stopping = true;
+    running?.logger.info({ reason }, 'server shutting down');
+    try {
+      await hooks.onShutdown?.(reason);
+    } catch (error) {
+      running?.logger.error(
+        { err: error instanceof Error ? error : new Error(String(error)) },
+        'foreground shutdown hook error',
+      );
+    }
+    try {
+      await running?.close();
+      await shutdownTelemetry({ timeoutMs: CLI_SHUTDOWN_TIMEOUT_MS });
+    } catch (error) {
+      running?.logger.error(
+        { err: error instanceof Error ? error : new Error(String(error)) },
+        'server shutdown error',
+      );
+    }
+    process.exit(0);
+  }
+
+  // kap-server (the DI × Scope engine server) is the only server flavor. Its
+  // `startServer` returns `{ host, port, close }` rather than `{ address,
+  // logger, close }`, so adapt it to the `RoutedServer` surface the rest of
+  // this runner consumes.
+  const logger = createServerLogger({ level: options.logLevel });
+  const webAssetsDir = serverWebAssetsDir();
+  if (webAssetsDir === undefined) {
+    logger.info(
+      'dev mode: web assets not built; starting the API server without the web UI',
+    );
+  }
+  const v2 = await startServer({
+    host: options.host,
+    port: options.port,
+    // Report the CLI's product version as `server_version` (/meta, web UI)
+    // rather than kap-server's private package version.
+    serverVersion: version,
+    // The CLI's host identity: feeds the engine's bootstrap client identity
+    // and the derived outbound headers (User-Agent + X-Msh-*), so web-UI
+    // OAuth flows and model / WebSearch requests carry the CLI identity. The
+    // `web` User-Agent suffix distinguishes web-UI traffic from direct CLI
+    // runs upstream (same product token, same platform).
+    hostIdentity: {
+      ...createKimiCodeHostIdentity(version),
+      userAgentSuffix: WEB_USER_AGENT_SUFFIX,
+    },
+    logLevel: options.logLevel,
+    logger,
+    debugEndpoints: options.debugEndpoints,
+    insecureNoTls: options.insecureNoTls,
+    allowRemoteShutdown: options.allowRemoteShutdown,
+    allowedHosts: options.allowedHosts,
+    disableAuth: options.dangerousBypassAuth,
+    webTitle: options.webTitle,
+    // Attach the engine's cloud telemetry appender (still gated by the config
+    // `telemetry` toggle). Complements the v1 client registered above, which
+    // only covers host-level events.
+    telemetry: true,
+    webAssetsDir,
+  });
+  logger.info('serving the REST/WS API and the bundled web UI');
+  running = {
+    address: `http://${v2.host}:${v2.port}`,
+    logger,
+    close: () => v2.close(),
+  };
+
+  track('server_started', { daemon: false });
+
+  process.once('SIGINT', () => {
+    void shutdown('SIGINT');
+  });
+  process.once('SIGTERM', () => {
+    void shutdown('SIGTERM');
+  });
+
+  running.logger.info({ address: running.address }, 'server ready');
+
+  try {
+    await hooks.onReady?.(running.address);
+  } catch (error) {
+    try {
+      await hooks.onShutdown?.('startup_failed');
+    } finally {
+      await running.close();
+      await shutdownTelemetry({ timeoutMs: CLI_SHUTDOWN_TIMEOUT_MS });
+    }
+    throw error;
+  }
+
+  return new Promise<never>(() => {
+    // Keeps the event loop alive; the process ends via shutdown()/process.exit.
+  });
+}
+
+/**
+ * Resolve the web assets directory passed to kap-server. In dev mode
+ * (`KIMI_CODE_DEV_SERVER=1`, set by the repo's `dev:server` / `dev:kap-server*`
+ * scripts) a missing `dist-web` build is tolerated: the server starts API-only
+ * and the web UI is expected to come from a Vite dev server (the web UI source lives in the code-app repo).
+ * Outside dev mode the directory is always returned and kap-server keeps
+ * failing fast when the assets are missing.
+ */
+export function serverWebAssetsDir(
+  env: NodeJS.ProcessEnv = process.env,
+  nativeWebAssetsDir: string | null = getNativeWebAssetsDir(),
+): string | undefined {
+  const dir = resolveServerWebAssetsDir(nativeWebAssetsDir);
+  if (env['KIMI_CODE_DEV_SERVER'] === '1' && !existsSync(join(dir, 'index.html'))) {
+    return undefined;
+  }
+  return dir;
+}
+
+export function resolveServerWebAssetsDir(
+  nativeWebAssetsDir: string | null = getNativeWebAssetsDir(),
+): string {
+  return nativeWebAssetsDir ?? join(getHostPackageRoot(), WEB_ASSETS_DIR);
+}
+
+interface FormatReadyBannerOptions {
+  /** Persistent bearer token to print; omitted when unresolvable. */
+  token?: string;
+  /** Non-loopback interface addresses to list for a wildcard bind. */
+  networkAddresses?: NetworkAddress[];
+  /** When true, render a red danger notice (auth is disabled). */
+  dangerousBypassAuth?: boolean;
+}
+
+export function formatReadyBanner(
+  origin: string,
+  host: string,
+  opts: FormatReadyBannerOptions = {},
+): string {
+  const primary = (text: string): string => chalk.hex(darkColors.primary)(text);
+  const title = (text: string): string => chalk.bold.hex(darkColors.primary)(text);
+  const dim = (text: string): string => chalk.hex(darkColors.textDim)(text);
+  const muted = (text: string): string => chalk.hex(darkColors.textMuted)(text);
+  const label = (text: string): string => chalk.bold.hex(darkColors.textDim)(text);
+  const url = (text: string): string => chalk.hex(darkColors.accent)(text);
+  // Render the `#token=…` fragment in a de-emphasized gray so the host/port
+  // stands out while the full URL stays selectable for copying.
+  const urlWithDimToken = (href: string): string => {
+    const [base, frag] = splitTokenFragment(href);
+    return frag === '' ? url(base) : url(base) + dim(frag);
+  };
+
+  const port = Number(origin.slice(origin.lastIndexOf(':') + 1));
+  // Borderless header: the Kimi sprite (the little mascot with eyes) sits next
+  // to the title, keeping the brand without the enclosing box.
+  const logo = ['▐█▛█▛█▌', '▐█████▌'] as const;
+  const lines: string[] = [
+    '',
+    `  ${primary(logo[0])}  ${title('Kimi server ready')}  ${dim(getVersion())}`,
+    `  ${primary(logo[1])}  ${dim('Local web UI is available from this machine.')}`,
+    '',
+  ];
+
+  if (opts.dangerousBypassAuth === true) {
+    // Red, impossible-to-miss notice: the bearer-token gate is off, so anyone
+    // who can reach this port gets full session / filesystem / shell access.
+    lines.push(...formatDangerNoticeLines(), '');
+  }
+
+  // Access links.
+  for (const { label: text, url: href } of accessUrlLines(
+    host,
+    port,
+    opts.token,
+    opts.networkAddresses,
+  )) {
+    lines.push(`  ${label(text)}${urlWithDimToken(href)}`);
+  }
+  // On a loopback bind there is no network URL; show how to enable one.
+  if (isLoopbackHost(host)) {
+    lines.push(`  ${label('Network:  ')}${muted('off')}${dim('  use --host to enable')}`);
+  }
+  if (opts.token !== undefined) {
+    // Set the token off with surrounding whitespace rather than color, so it is
+    // easy to spot without being highlighted.
+    lines.push('');
+    lines.push(`  ${label('Token:    ')}${opts.token}`);
+    lines.push('');
+  }
+
+  // Auxiliary controls last.
+  lines.push(`  ${label('Logs:     ')}${muted('off')}${dim('  use --log-level info to enable')}`);
+  // The server always runs in the foreground attached to this terminal.
+  lines.push(`  ${label('Stop:     ')}${muted('Ctrl+C')}`);
+  lines.push('');
+  return lines.join('\n');
+}
+
+const DEFAULT_WEB_COMMAND_DEPS: WebCommandDeps = {
+  startServerForeground,
+  openUrl: defaultOpenUrl,
+  resolveToken: () => {
+    // Read the persistent `<homeDir>/server.token` written on first boot
+    // (M5.1). Best-effort: a missing/older server yields undefined and the
+    // caller opens the plain origin.
+    return tryResolveServerToken(getDataDir());
+  },
+  stdout: process.stdout,
+  stderr: process.stderr,
+};

apps/kimi-code/src/cli/sub/web/shared.ts

@@ -0,0 +1,164 @@
+/**
+ * Shared helpers for `kimi web` and its subcommands.
+ *
+ * Owns the default host/port, option parsers, and health/readiness probes.
+ */
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import type { ServerLogLevel } from '@moonshot-ai/kap-server';
+
+export const LOCAL_SERVER_HOST = '127.0.0.1';
+export const DEFAULT_LAN_HOST = '0.0.0.0';
+export const DEFAULT_SERVER_HOST = LOCAL_SERVER_HOST;
+export const DEFAULT_SERVER_PORT = 58627;
+export const DEFAULT_SERVER_ORIGIN = serverOrigin(DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT);
+
+/** Filename (under KIMI_CODE_HOME) of the persistent server bearer token. */
+export const SERVER_TOKEN_FILE = 'server.token';
+
+export const DEFAULT_LOG_LEVEL: ServerLogLevel = 'info';
+export const DEFAULT_FOREGROUND_LOG_LEVEL: ServerLogLevel = 'silent';
+
+export const VALID_LOG_LEVELS: readonly ServerLogLevel[] = [
+  'fatal',
+  'error',
+  'warn',
+  'info',
+  'debug',
+  'trace',
+  'silent',
+];
+
+export interface ParsedServerOptions {
+  host: string;
+  port: number;
+  logLevel: ServerLogLevel;
+  debugEndpoints: boolean;
+  /** Allow a non-loopback bind without a TLS-terminating reverse proxy. */
+  insecureNoTls: boolean;
+  /** Allow `POST /api/v1/shutdown` on a non-loopback bind. */
+  allowRemoteShutdown: boolean;
+  /** Disable bearer-token auth on every route (`--dangerous-bypass-auth`). */
+  dangerousBypassAuth: boolean;
+  /** Extra `Host` header values to allow through the DNS-rebinding check. */
+  allowedHosts: readonly string[];
+  /** Custom browser tab title for this web UI instance (`--web-title`). */
+  webTitle?: string;
+}
+
+export interface ServerCliOptions {
+  host?: string | boolean;
+  port?: string;
+  logLevel?: string;
+  debugEndpoints?: boolean;
+  /** Allow a non-loopback bind without TLS (`--insecure-no-tls`). */
+  insecureNoTls?: boolean;
+  /** Allow remote shutdown on a non-loopback bind (`--allow-remote-shutdown`). */
+  allowRemoteShutdown?: boolean;
+  /** Disable bearer-token auth on every route (`--dangerous-bypass-auth`). */
+  dangerousBypassAuth?: boolean;
+  /** Extra `Host` header values to allow (`--allowed-host`). */
+  allowedHost?: string[];
+  /** Custom browser tab title for this web UI instance (`--web-title`). */
+  webTitle?: string;
+}
+
+export function parseServerOptions(opts: ServerCliOptions): ParsedServerOptions {
+  return {
+    host: parseHost(opts.host),
+    port: parsePort(opts.port, '--port', DEFAULT_SERVER_PORT),
+    logLevel: parseLogLevel(opts.logLevel ?? DEFAULT_FOREGROUND_LOG_LEVEL),
+    debugEndpoints: opts.debugEndpoints === true,
+    insecureNoTls: opts.insecureNoTls !== false,
+    allowRemoteShutdown: opts.allowRemoteShutdown === true,
+    dangerousBypassAuth: opts.dangerousBypassAuth === true,
+    allowedHosts: parseAllowedHostArgs(opts.allowedHost),
+    webTitle: opts.webTitle,
+  };
+}
+
+export function parseAllowedHostArgs(raw: readonly string[] | undefined): string[] {
+  if (raw === undefined) return [];
+  return raw
+    .flatMap((entry) => entry.split(','))
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+}
+
+function parseHost(raw: string | boolean | undefined): string {
+  if (raw === undefined || raw === false) return DEFAULT_SERVER_HOST;
+  if (raw === true || raw === '') return DEFAULT_LAN_HOST;
+  return raw;
+}
+
+export function parsePort(raw: string | undefined, label: string, fallback: number): number {
+  if (raw === undefined) return fallback;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 0 || n > 65535) {
+    throw new Error(`error: invalid ${label} value: ${raw}`);
+  }
+  return n;
+}
+
+export function parseLogLevel(raw: string | undefined): ServerLogLevel {
+  if (raw === undefined) return DEFAULT_LOG_LEVEL;
+  if ((VALID_LOG_LEVELS as readonly string[]).includes(raw)) {
+    return raw as ServerLogLevel;
+  }
+  throw new Error(
+    `error: invalid --log-level value: ${raw} (allowed: ${VALID_LOG_LEVELS.join(', ')})`,
+  );
+}
+
+export function serverOrigin(host: string, port: number): string {
+  return `http://${host}:${port}`;
+}
+
+/** Strip `/api/v1` and trailing slashes so user-supplied origins are uniform. */
+export function normalizeServerOrigin(value: string): string {
+  const url = new URL(value);
+  url.pathname = url.pathname.replace(/\/api\/v1\/?$/, '').replace(/\/$/, '');
+  url.search = '';
+  url.hash = '';
+  return url.toString().replace(/\/$/, '');
+}
+
+/**
+ * Read the persistent bearer token for the server.
+ *
+ * The server writes `<homeDir>/server.token` (0600) on first boot and reuses
+ * it across restarts (ROADMAP M5.1); CLI commands that hit a gated REST route
+ * read it back here and send it as `Authorization: Bearer <token>`. `homeDir`
+ * is the CLI's own KIMI_CODE_HOME resolution (`getDataDir()`).
+ *
+ * Throws a clear error when the file is missing/unreadable — the usual cause
+ * is a server that has never been started (no token file yet), or an older
+ * build that predates token auth.
+ */
+export function resolveServerToken(homeDir: string): string {
+  const tokenPath = join(homeDir, SERVER_TOKEN_FILE);
+  try {
+    return readFileSync(tokenPath, 'utf8').trim();
+  } catch (error) {
+    throw new Error(
+      `unable to read server token at ${tokenPath}; has the server been started at least once?`,
+      { cause: error },
+    );
+  }
+}
+
+/** Best-effort token read: returns `undefined` instead of throwing. */
+export function tryResolveServerToken(homeDir: string): string | undefined {
+  try {
+    return resolveServerToken(homeDir);
+  } catch {
+    return undefined;
+  }
+}
+
+/** An `Authorization: Bearer <token>` header bag for `fetch`. */
+export function authHeaders(token: string): { Authorization: string } {
+  return { Authorization: `Bearer ${token}` };
+}

apps/kimi-code/src/tui/banner/banner-config.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+import { fetchClientConfig, type ClientConfigFetchOptions } from '#/utils/client-configs';
+
+/** The tips/banner payload is one named config on the client-configs endpoint. */
+const CONFIG_NAME = 'client_banner';
+
+/** The payload keeps the legacy tips.json shape, which banner-provider parses
+    defensively; the schema only guarantees an object. */
+const bannerConfigSchema = z.looseObject({});
+
+export type BannerConfig = z.infer<typeof bannerConfigSchema>;
+export type BannerConfigFetchOptions = ClientConfigFetchOptions;
+
+/**
+ * Fetches the banner config straight from the endpoint — banners are
+ * time-sensitive announcements, so no caching layer is used. Any failure
+ * resolves to `undefined` — callers treat that as "no banner".
+ */
+export async function getBannerConfig(
+  options: BannerConfigFetchOptions = {},
+): Promise<BannerConfig | undefined> {
+  return fetchClientConfig(CONFIG_NAME, bannerConfigSchema, options);
+}

apps/kimi-code/src/tui/banner/banner-provider.ts

@@ -0,0 +1,356 @@
+import { createHash } from 'node:crypto';
+
+import { eq, gte, lt, valid } from 'semver';
+
+import type { BannerDisplay, BannerState } from '#/tui/types';
+
+import { getBannerConfig } from './banner-config';
+import type { BannerDisplayState } from './state';
+
+interface BannerVersionFields {
+  banner_min_version?: string | null;
+  banner_max_version?: string | null;
+  banner_version?: string | null;
+}
+
+interface TipsBannerFallbackItem extends BannerVersionFields {
+  banner_id?: string | null;
+  enabled?: boolean;
+  banner_title?: string | null;
+  banner_maintext?: string;
+  banner_subtext?: string | null;
+  banner_start_time?: string | null;
+  banner_end_time?: string | null;
+  banner_display?: unknown;
+  banner_display_ttl_hours?: unknown;
+  banner_platform?: string | null;
+}
+
+interface TipsBannerJson extends BannerVersionFields {
+  banner_id?: string | null;
+  banner_enabled?: boolean;
+  banner_title?: string | null;
+  banner_maintext?: string;
+  banner_subtext?: string | null;
+  banner_start_time?: string | null;
+  banner_end_time?: string | null;
+  banner_display?: unknown;
+  banner_display_ttl_hours?: unknown;
+  banner_fallback_enabled?: boolean;
+  banner_fallback_list?: unknown[];
+  banner_platform?: string | null;
+}
+
+interface BannerHashInput {
+  tag: string | null;
+  mainText: string;
+  subText: string | null;
+  startTime: string | null;
+  endTime: string | null;
+  display: BannerDisplay;
+  ttlHours?: number;
+}
+
+interface BannerCandidateInput {
+  id: unknown;
+  tag: unknown;
+  mainText: string;
+  subText: unknown;
+  display: BannerDisplay;
+  ttlHours?: number;
+  startTime?: unknown;
+  endTime?: unknown;
+}
+
+export interface SelectDisplayableBannerArgs {
+  json: unknown;
+  clientVersion: string;
+  now: Date;
+  random: () => number;
+  state: BannerDisplayState;
+}
+
+interface BannerProviderLoadOptions {
+  state?: BannerDisplayState;
+  now?: Date;
+  random?: () => number;
+}
+
+const HOUR_MS = 60 * 60 * 1000;
+export const DEFAULT_COOLDOWN_TTL_HOURS = 24;
+
+function normalizeTag(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function normalizeText(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function normalizeUtcDate(value: string): string {
+  if (value.endsWith('Z')) return value;
+  if (/[+-]\d{2}:\d{2}$/.test(value)) return value;
+  return `${value}Z`;
+}
+
+function parseDate(value: unknown): Date | null {
+  if (typeof value !== 'string' || value.length === 0) return null;
+  const normalized = normalizeUtcDate(value);
+  const date = new Date(normalized);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function isWithinWindow(start: Date | null, end: Date | null, now: Date): boolean {
+  if (start !== null && now < start) return false;
+  if (end !== null && now > end) return false;
+  return true;
+}
+
+type VersionConstraintCompare = (current: string, target: string) => boolean;
+
+function meetsVersionConstraint(
+  constraint: unknown,
+  clientVersion: string,
+  compare: VersionConstraintCompare,
+): boolean {
+  if (constraint === undefined || constraint === null) return true;
+  if (typeof constraint !== 'string' || constraint.length === 0) return true;
+  const target = valid(constraint);
+  const current = valid(clientVersion);
+  if (target === null || current === null) return false;
+  return compare(current, target);
+}
+
+function meetsVersion(banner: BannerVersionFields, clientVersion: string): boolean {
+  return (
+    meetsVersionConstraint(banner.banner_min_version, clientVersion, gte) &&
+    meetsVersionConstraint(banner.banner_max_version, clientVersion, lt) &&
+    meetsVersionConstraint(banner.banner_version, clientVersion, eq)
+  );
+}
+
+/** The CLI shows banners targeting every platform (missing / empty / 'all')
+    or the CLI itself; any other platform value ('desktop', 'web', …) hides
+    the banner here. */
+function meetsPlatform(value: unknown): boolean {
+  if (typeof value !== 'string') return true;
+  const platform = value.trim().toLowerCase();
+  return platform === '' || platform === 'all' || platform === 'cli';
+}
+
+function parseBannerDisplay(value: unknown): BannerDisplay {
+  if (value === 'once') return 'once';
+  if (value === 'cooldown') return 'cooldown';
+  return 'always';
+}
+
+function parseBannerDisplayTtlHours(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0
+    ? value
+    : DEFAULT_COOLDOWN_TTL_HOURS;
+}
+
+function normalizeBannerId(value: unknown): string | null {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function hashBannerIdentity(input: BannerHashInput): string {
+  const raw = JSON.stringify([
+    input.tag ?? '',
+    input.mainText,
+    input.subText ?? '',
+    input.startTime ?? '',
+    input.endTime ?? '',
+    input.display,
+    input.ttlHours ?? '',
+  ]);
+  return createHash('sha256').update(raw).digest('hex').slice(0, 32);
+}
+
+function getBannerKey(rawBannerId: unknown, input: BannerHashInput): string {
+  return normalizeBannerId(rawBannerId) ?? hashBannerIdentity(input);
+}
+
+function toBannerState(input: BannerCandidateInput): BannerState {
+  const tag = normalizeTag(input.tag);
+  const subText = normalizeText(input.subText);
+  const display = input.display;
+  const ttlHours = display === 'cooldown' ? parseBannerDisplayTtlHours(input.ttlHours) : undefined;
+  const startTime = normalizeText(input.startTime);
+  const endTime = normalizeText(input.endTime);
+  const key = getBannerKey(input.id, {
+    tag,
+    mainText: input.mainText,
+    subText,
+    startTime,
+    endTime,
+    display,
+    ttlHours,
+  });
+
+  return {
+    key,
+    tag,
+    mainText: input.mainText,
+    subText,
+    display,
+    ttlHours,
+  };
+}
+
+function pickActiveBanner(
+  json: TipsBannerJson,
+  clientVersion: string,
+  now: Date,
+): BannerState | null {
+  if (json.banner_enabled !== true) return null;
+  if (!meetsVersion(json, clientVersion)) return null;
+  if (!meetsPlatform(json.banner_platform)) return null;
+  const start = parseDate(json.banner_start_time);
+  const end = parseDate(json.banner_end_time);
+  if (!isWithinWindow(start, end, now)) return null;
+  const mainText = normalizeText(json.banner_maintext);
+  if (mainText === null) return null;
+  const display = parseBannerDisplay(json.banner_display);
+  return toBannerState({
+    id: json.banner_id,
+    tag: json.banner_title,
+    mainText,
+    subText: json.banner_subtext,
+    display,
+    ttlHours: display === 'cooldown' ? parseBannerDisplayTtlHours(json.banner_display_ttl_hours) : undefined,
+    startTime: json.banner_start_time,
+    endTime: json.banner_end_time,
+  });
+}
+
+function pickFallbackCandidates(
+  json: TipsBannerJson,
+  clientVersion: string,
+  now: Date,
+): BannerState[] {
+  if (json.banner_fallback_enabled !== true) return [];
+  const list = Array.isArray(json.banner_fallback_list) ? json.banner_fallback_list : [];
+  const candidates: BannerState[] = [];
+  for (const raw of list) {
+    if (typeof raw !== 'object' || raw === null) continue;
+    const item = raw as TipsBannerFallbackItem;
+    if (item.enabled !== true) continue;
+    if (!meetsVersion(item, clientVersion)) continue;
+    if (!meetsPlatform(item.banner_platform)) continue;
+    const start = parseDate(item.banner_start_time);
+    const end = parseDate(item.banner_end_time);
+    if (!isWithinWindow(start, end, now)) continue;
+    const mainText = normalizeText(item.banner_maintext);
+    if (mainText === null) continue;
+    const display = parseBannerDisplay(item.banner_display);
+    candidates.push(
+      toBannerState({
+        id: item.banner_id,
+        tag: item.banner_title,
+        mainText,
+        subText: item.banner_subtext,
+        display,
+        ttlHours: display === 'cooldown' ? parseBannerDisplayTtlHours(item.banner_display_ttl_hours) : undefined,
+        startTime: item.banner_start_time,
+        endTime: item.banner_end_time,
+      }),
+    );
+  }
+  return candidates;
+}
+
+function pickRandomCandidate(candidates: BannerState[], random: () => number): BannerState | null {
+  if (candidates.length === 0) return null;
+  const index = Math.floor(random() * candidates.length);
+  return candidates[index]!;
+}
+
+function pickFallbackBanner(
+  json: TipsBannerJson,
+  clientVersion: string,
+  now: Date,
+  random: () => number,
+): BannerState | null {
+  return pickRandomCandidate(pickFallbackCandidates(json, clientVersion, now), random);
+}
+
+function parseShownAt(value: string | undefined): Date | null {
+  if (value === undefined) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function getCooldownTtlHours(banner: BannerState): number {
+  return typeof banner.ttlHours === 'number' && Number.isFinite(banner.ttlHours) && banner.ttlHours > 0
+    ? banner.ttlHours
+    : DEFAULT_COOLDOWN_TTL_HOURS;
+}
+
+export function shouldDisplayBanner(
+  banner: BannerState,
+  state: BannerDisplayState,
+  now: Date,
+): boolean {
+  if (banner.display === 'always') return true;
+  const lastShownAt = parseShownAt(state.shown[banner.key]?.lastShownAt);
+  if (lastShownAt === null) return true;
+  if (banner.display === 'once') return false;
+  return now.getTime() - lastShownAt.getTime() >= getCooldownTtlHours(banner) * HOUR_MS;
+}
+
+export function selectBannerState(
+  json: unknown,
+  clientVersion: string,
+  now: Date,
+  random: () => number,
+): BannerState | null {
+  const typed = typeof json === 'object' && json !== null ? (json as TipsBannerJson) : {};
+  return (
+    pickActiveBanner(typed, clientVersion, now) ??
+    pickFallbackBanner(typed, clientVersion, now, random)
+  );
+}
+
+export function selectDisplayableBanner({
+  json,
+  clientVersion,
+  now,
+  random,
+  state,
+}: SelectDisplayableBannerArgs): BannerState | null {
+  const typed = typeof json === 'object' && json !== null ? (json as TipsBannerJson) : {};
+  const active = pickActiveBanner(typed, clientVersion, now);
+  if (active !== null && shouldDisplayBanner(active, state, now)) return active;
+  const candidates = pickFallbackCandidates(typed, clientVersion, now).filter((candidate) =>
+    shouldDisplayBanner(candidate, state, now),
+  );
+  return pickRandomCandidate(candidates, random);
+}
+
+export class BannerProvider {
+  constructor(private readonly clientVersion: string) {}
+
+  async load(options: BannerProviderLoadOptions = {}): Promise<BannerState | null> {
+    // getBannerConfig never throws; undefined means "config unavailable".
+    const json = await getBannerConfig();
+    if (json === undefined) return null;
+    const now = options.now ?? new Date();
+    const random = options.random ?? Math.random;
+    return options.state === undefined
+      ? selectBannerState(json, this.clientVersion, now, random)
+      : selectDisplayableBanner({
+          json,
+          clientVersion: this.clientVersion,
+          now,
+          random,
+          state: options.state,
+        });
+  }
+}

apps/kimi-code/src/tui/banner/state.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+
+import { getBannerStateFile } from '#/utils/paths';
+import { readJsonFile, writeJsonFile } from '#/utils/persistence';
+
+export type BannerDisplayRecord = {
+  lastShownAt: string;
+};
+
+export type BannerDisplayState = {
+  version: 1;
+  shown: Record<string, BannerDisplayRecord>;
+};
+
+const BannerDisplayRecordSchema = z
+  .object({
+    lastShownAt: z.string().min(1),
+  })
+  .strict();
+
+const BannerDisplayStateSchema = z.preprocess(
+  (value) => {
+    if (typeof value !== 'object' || value === null) return value;
+    const shown = (value as { shown?: unknown }).shown;
+    if (typeof shown !== 'object' || shown === null) {
+      return { ...(value as Record<string, unknown>), shown: {} };
+    }
+
+    const normalizedShown: Record<string, BannerDisplayRecord> = {};
+    for (const [key, record] of Object.entries(shown)) {
+      if (key.length === 0 || typeof record !== 'object' || record === null) continue;
+      const lastShownAt = (record as { lastShownAt?: unknown }).lastShownAt;
+      if (typeof lastShownAt !== 'string' || Number.isNaN(Date.parse(lastShownAt))) continue;
+      normalizedShown[key] = { lastShownAt };
+    }
+
+    return { ...(value as Record<string, unknown>), shown: normalizedShown };
+  },
+  z
+    .object({
+      version: z.literal(1),
+      shown: z.record(z.string().min(1), BannerDisplayRecordSchema),
+    })
+    .strict(),
+);
+
+export function emptyBannerDisplayState(): BannerDisplayState {
+  return {
+    version: 1,
+    shown: {},
+  };
+}
+
+export async function readBannerDisplayState(
+  filePath: string = getBannerStateFile(),
+): Promise<BannerDisplayState> {
+  try {
+    return await readJsonFile(filePath, BannerDisplayStateSchema, emptyBannerDisplayState());
+  } catch {
+    return emptyBannerDisplayState();
+  }
+}
+
+export async function writeBannerDisplayState(
+  value: BannerDisplayState,
+  filePath: string = getBannerStateFile(),
+): Promise<void> {
+  await writeJsonFile(filePath, BannerDisplayStateSchema, value);
+}

apps/kimi-code/src/tui/commands/add-dir.ts

@@ -0,0 +1,107 @@
+import { NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
+import { ChoicePickerComponent } from '../components/dialogs/choice-picker';
+import type { SlashCommandHost } from './dispatch';
+import { slashBusyMessage, slashCommandBusyReason } from './resolve';
+
+type AddDirChoice = 'session' | 'remember' | 'cancel';
+
+export async function handleAddDirCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const input = args.trim();
+  let session = host.session;
+
+  if (input.length === 0 || input.toLowerCase() === 'list') {
+    // With no session yet (v2 session-less startup) the pending startup
+    // directories live in appState and will be passed to the lazy-created
+    // session; reflect them instead of reporting an empty list.
+    const additionalDirs = session?.summary?.additionalDirs ?? host.state.appState.additionalDirs;
+    if (additionalDirs.length === 0) {
+      host.showStatus('No additional directories configured.');
+      return;
+    }
+    host.showStatus(formatAdditionalDirsStatus(additionalDirs));
+    return;
+  }
+
+  if (session === undefined) {
+    // The path-adding form needs a live session; lazy-create it on first use
+    // (the read-only `list`/bare forms above tolerate a missing session).
+    session = await host.ensureSession();
+    if (session === undefined) return;
+    // A first prompt may have started a turn during the await; /add-dir is
+    // idle-only, so re-check the busy gate resolved before it.
+    const busyReason = slashCommandBusyReason({
+      isStreaming: host.state.appState.streamingPhase !== 'idle',
+      isCompacting: host.state.appState.isCompacting,
+    });
+    if (busyReason !== undefined) {
+      host.showError(slashBusyMessage('add-dir', busyReason));
+      return;
+    }
+  }
+
+  host.mountEditorReplacement(
+    new ChoicePickerComponent({
+      title: `Add directory to workspace: ${input}`,
+      hint: '↑↓ navigate · Enter confirm · Esc cancel',
+      options: [
+        {
+          value: 'session',
+          label: 'Yes, for this session',
+        },
+        {
+          value: 'remember',
+          label: 'Yes, and remember this directory',
+        },
+        {
+          value: 'cancel',
+          label: 'No',
+        },
+      ],
+      onSelect: (value) => {
+        void handleAddDirChoice(host, session.id, input, value as AddDirChoice);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+        host.showStatus(`Did not add ${input} as a working directory.`);
+      },
+    }),
+  );
+}
+
+function formatAdditionalDirsStatus(additionalDirs: readonly string[]): string {
+  return ['Additional directories:', ...additionalDirs.map((dir) => `  ${dir}`)].join('\n');
+}
+
+async function handleAddDirChoice(
+  host: SlashCommandHost,
+  sessionId: string,
+  path: string,
+  choice: AddDirChoice,
+): Promise<void> {
+  host.restoreEditor();
+
+  if (choice === 'cancel') {
+    host.showStatus(`Did not add ${path} as a working directory.`);
+    return;
+  }
+
+  const session = host.session;
+  if (session === undefined || session.id !== sessionId) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  try {
+    const result = await session.addAdditionalDir(path, { persist: choice === 'remember' });
+    host.setAppState({ additionalDirs: result.additionalDirs });
+    host.refreshSlashCommandAutocomplete();
+    host.showStatus(
+      choice === 'remember'
+        ? `Added workspace directory:\n  ${path}\n  Saved to:\n  ${result.configPath}`
+        : `Added workspace directory:\n  ${path}\n  For this session only`,
+      'success',
+    );
+  } catch (error) {
+    host.showError(error instanceof Error ? error.message : String(error));
+  }
+}

apps/kimi-code/src/tui/commands/auth.ts

@@ -0,0 +1,262 @@
+import {
+  applyOpenPlatformConfig,
+  fetchOpenPlatformModels,
+  filterModelsByPrefix,
+  getOpenPlatformById,
+  OAuthAccessDeniedError,
+  OpenPlatformApiError,
+  type KimiRegion,
+  type ManagedKimiCodeModelInfo,
+  type ManagedKimiConfigShape,
+  type OpenPlatformDefinition,
+} from '@moonshot-ai/kimi-code-oauth';
+import { log } from '@moonshot-ai/kimi-code-sdk';
+
+import type { ChoiceOption } from '../components/dialogs/choice-picker';
+import { DEFAULT_OAUTH_PROVIDER_NAME, PRODUCT_NAME } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import {
+  KIMI_CODE_GLOBAL_PLATFORM_VALUE,
+  refreshKimiRegion,
+} from '#/utils/region';
+import type { LoginProgressSpinnerHandle } from '../types';
+import {
+  promptApiKey,
+  promptLogoutProviderSelection,
+  promptModelSelectionForOpenPlatform,
+  promptPlatformSelection,
+} from './prompts';
+import type { SlashCommandHost } from './dispatch';
+
+// ---------------------------------------------------------------------------
+// Auth: login / logout
+// ---------------------------------------------------------------------------
+
+export async function handleLoginCommand(host: SlashCommandHost): Promise<void> {
+  const platformId = await promptPlatformSelection(host);
+  if (platformId === undefined) return;
+
+  if (platformId === 'kimi-code' || platformId === KIMI_CODE_GLOBAL_PLATFORM_VALUE) {
+    const region: KimiRegion = platformId === KIMI_CODE_GLOBAL_PLATFORM_VALUE ? 'global' : 'mainland-cn';
+    await handleKimiCodeOAuthLogin(host, region);
+    return;
+  }
+
+  const platform = getOpenPlatformById(platformId);
+  if (platform === undefined) return;
+  await handleOpenPlatformLogin(host, platform);
+}
+
+async function handleKimiCodeOAuthLogin(
+  host: SlashCommandHost,
+  region: KimiRegion,
+): Promise<void> {
+  const status = await host.harness.auth.status(DEFAULT_OAUTH_PROVIDER_NAME);
+  const alreadyLoggedIn = status.providers.some(
+    (provider) => provider.providerName === DEFAULT_OAUTH_PROVIDER_NAME && provider.hasToken,
+  );
+
+  let spinner: LoginProgressSpinnerHandle | undefined;
+  const controller = new AbortController();
+  const cancelLogin = (): void => {
+    controller.abort();
+  };
+  host.cancelInFlight = cancelLogin;
+  try {
+    // The facade maps region → profile hosts (env overrides keep priority);
+    // 'mainland-cn' is passed explicitly too so switching back overrides a
+    // persisted global login.
+    await host.harness.auth.login(DEFAULT_OAUTH_PROVIDER_NAME, {
+      signal: controller.signal,
+      region,
+      onDeviceCode: (data) => {
+        spinner = host.showLoginAuthorizationPrompt(data);
+      },
+    });
+    refreshKimiRegion();
+    spinner?.stop({ ok: true, label: 'Logged in.' });
+    spinner = undefined;
+    try {
+      await host.authFlow.refreshConfigAfterLogin();
+    } catch (refreshError) {
+      const message = formatErrorMessage(refreshError);
+      host.showError(`Authentication successful, but failed to refresh config: ${message}`);
+      return;
+    }
+    host.track('login', {
+      provider: DEFAULT_OAUTH_PROVIDER_NAME,
+      method: 'oauth',
+      already_logged_in: alreadyLoggedIn,
+    });
+    if (alreadyLoggedIn) {
+      host.showStatus('Already logged in. Model configuration refreshed.', 'success');
+    }
+  } catch (error) {
+    const cancelled = controller.signal.aborted;
+    const denied = error instanceof OAuthAccessDeniedError;
+    spinner?.stop({
+      ok: false,
+      label: cancelled || denied ? 'Login cancelled.' : 'Login failed.',
+    });
+    spinner = undefined;
+    if (cancelled) return;
+    const message = formatErrorMessage(error);
+    if (denied) {
+      host.showError(`Login cancelled: ${message}`);
+      return;
+    }
+    log.warn('login failed', {
+      providerName: DEFAULT_OAUTH_PROVIDER_NAME,
+      alreadyLoggedIn,
+      sessionId: host.session?.id,
+      error,
+    });
+    host.showError(`Login failed: ${message}`);
+  } finally {
+    if (host.cancelInFlight === cancelLogin) {
+      host.cancelInFlight = undefined;
+    }
+  }
+}
+
+async function handleOpenPlatformLogin(
+  host: SlashCommandHost,
+  platform: OpenPlatformDefinition,
+): Promise<void> {
+  const consoleHost = platform.consoleUrl?.replace(/^https?:\/\//, '') ?? '';
+  const platformName = consoleHost.length > 0 ? `Kimi Platform (${consoleHost})` : 'Kimi Platform';
+  const subtitleLines = [
+    `${'base_url'.padEnd(12)}${platform.baseUrl}`,
+    `${'saved to'.padEnd(12)}~/.kimi-code/config.toml`,
+  ];
+  const apiKey = await promptApiKey(host, platformName, subtitleLines);
+  if (apiKey === undefined) return;
+
+  const controller = new AbortController();
+  const cancelLogin = (): void => {
+    controller.abort();
+  };
+  host.cancelInFlight = cancelLogin;
+
+  let models: ManagedKimiCodeModelInfo[];
+  try {
+    models = await fetchOpenPlatformModels(platform, apiKey, fetch, controller.signal);
+    models = filterModelsByPrefix(models, platform);
+  } catch (error) {
+    if (controller.signal.aborted) return;
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to verify API key: ${msg}`);
+    if (
+      error instanceof OpenPlatformApiError &&
+      error.status === 401
+    ) {
+      host.showStatus(
+        'Hint: If your API key was obtained from Kimi Code, please select "Kimi Code" instead.',
+      );
+    }
+    return;
+  } finally {
+    if (host.cancelInFlight === cancelLogin) {
+      host.cancelInFlight = undefined;
+    }
+  }
+
+  if (models.length === 0) {
+    host.showError('No models available for this platform.');
+    return;
+  }
+
+  const selection = await promptModelSelectionForOpenPlatform(host, models, platform);
+  if (selection === undefined) return;
+
+  const existingConfig = await host.harness.getConfig();
+  if (existingConfig.providers[platform.id] !== undefined) {
+    await host.harness.removeProvider(platform.id);
+  }
+
+  const config = await host.harness.getConfig();
+  applyOpenPlatformConfig(config as ManagedKimiConfigShape, {
+    platform,
+    models,
+    selectedModel: selection.model,
+    thinking: selection.thinking !== 'off',
+    effort:
+      selection.thinking !== 'off' && selection.thinking !== 'on'
+        ? selection.thinking
+        : undefined,
+    apiKey,
+  });
+
+  await host.harness.setConfig({
+    providers: config.providers,
+    models: config.models,
+    defaultModel: config.defaultModel,
+    thinking: config.thinking,
+  });
+
+  await host.authFlow.refreshConfigAfterLogin();
+  host.track('login', { provider: platform.id, method: 'api_key' });
+  host.showStatus(`Setup complete: ${platform.name} · ${selection.model.id}`);
+}
+
+export async function handleLogoutCommand(host: SlashCommandHost): Promise<void> {
+  const oauthStatus = await host.harness.auth.status(DEFAULT_OAUTH_PROVIDER_NAME);
+  const hasOAuthToken = oauthStatus.providers.some(
+    (p) => p.providerName === DEFAULT_OAUTH_PROVIDER_NAME && p.hasToken,
+  );
+  const config = await host.harness.getConfig();
+  const hasManagedRemnant =
+    hasOAuthToken || config.providers[DEFAULT_OAUTH_PROVIDER_NAME] !== undefined;
+  const apiKeyProviderIds = Object.keys(config.providers ?? {})
+    .filter((id) => id !== DEFAULT_OAUTH_PROVIDER_NAME)
+    .toSorted();
+
+  const options: ChoiceOption[] = [];
+  if (hasManagedRemnant) {
+    options.push({
+      value: DEFAULT_OAUTH_PROVIDER_NAME,
+      label: PRODUCT_NAME,
+      description: 'OAuth login',
+    });
+  }
+  for (const id of apiKeyProviderIds) {
+    const baseUrl = config.providers[id]?.baseUrl;
+    options.push({
+      value: id,
+      label: id,
+      description: typeof baseUrl === 'string' && baseUrl.length > 0 ? baseUrl : undefined,
+    });
+  }
+
+  if (options.length === 0) {
+    host.showStatus('Nothing to logout.');
+    return;
+  }
+
+  const currentModel = host.state.appState.model.trim();
+  const currentProvider = host.state.appState.availableModels[currentModel]?.provider;
+
+  const target = await promptLogoutProviderSelection(host, options, currentProvider);
+  if (target === undefined) return;
+
+  if (target === DEFAULT_OAUTH_PROVIDER_NAME) {
+    await host.harness.auth.logout(DEFAULT_OAUTH_PROVIDER_NAME);
+  } else {
+    await host.harness.removeProvider(target);
+  }
+
+  if (target === currentProvider) {
+    await host.authFlow.refreshConfigAfterLogout();
+  } else {
+    const updated = await host.harness.getConfig({ reload: true });
+    host.setAppState({
+      availableModels: updated.models ?? {},
+      availableProviders: updated.providers ?? {},
+    });
+  }
+  refreshKimiRegion();
+
+  host.track('logout', { provider: target });
+  const label = target === DEFAULT_OAUTH_PROVIDER_NAME ? PRODUCT_NAME : target;
+  host.showStatus(`Logged out from ${label}.`);
+}

apps/kimi-code/src/tui/commands/btw.ts

@@ -0,0 +1,28 @@
+import { LLM_NOT_SET_MESSAGE } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import { extractInlineSkillActivations } from '../utils/inline-skill-tokens';
+import type { SlashCommandHost } from './dispatch';
+
+export async function handleBtwCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const prompt = args.trim();
+  const session = host.session;
+  if (host.state.appState.model.trim().length === 0 || session === undefined) {
+    host.showError(LLM_NOT_SET_MESSAGE);
+    return;
+  }
+  host.btwPanelController.closeOrCancel();
+
+  try {
+    const agentId = await session.startBtw();
+    const activations = extractInlineSkillActivations(prompt, host.skillCommandMap, {
+      includeLeading: true,
+    });
+    host.btwPanelController.open(
+      agentId,
+      prompt,
+      activations.length > 0 ? activations : undefined,
+    );
+  } catch (error) {
+    host.showError(`Failed to start /btw: ${formatErrorMessage(error)}`);
+  }
+}

apps/kimi-code/src/tui/commands/complete-args.ts

@@ -0,0 +1,41 @@
+import type { AutocompleteItem } from '@moonshot-ai/pi-tui';
+
+/**
+ * A completable token (subcommand or flag) for a slash command's argument
+ * position. Generic across commands — any `KimiSlashCommand` can build a
+ * `getArgumentCompletions` from a list of these via {@link completeLeadingArg}.
+ */
+export interface ArgCompletionSpec {
+  /** The token inserted on completion, e.g. `pause` or `resume`. */
+  readonly value: string;
+  /** Short description shown in the autocomplete menu. */
+  readonly description: string;
+}
+
+/**
+ * Generic leading-token completer for slash-command arguments.
+ *
+ * pi-tui passes `argumentPrefix` = everything typed after `/<command> `. We only
+ * complete the *first* token: once the user has typed a space after it (moved on
+ * to an objective, a flag value, etc.) we return `null` so completion never
+ * clobbers free text. Matching is case-insensitive prefix match on `value`.
+ */
+export function completeLeadingArg(
+  specs: readonly ArgCompletionSpec[],
+  argumentPrefix: string,
+): AutocompleteItem[] | null {
+  if (argumentPrefix.includes(' ')) return null;
+  const lower = argumentPrefix.toLowerCase();
+  const items = specs
+    .filter((spec) => spec.value.toLowerCase().startsWith(lower))
+    .map((spec) => ({ value: spec.value, label: spec.value, description: spec.description }));
+  // Nothing left to complete: the user has finished typing a token that is the
+  // sole remaining match (e.g. `status`). Keeping the menu open here would make
+  // Enter confirm the no-op completion instead of submitting the command, so we
+  // suppress it. (A space after the token already returns null above.)
+  const [only] = items;
+  if (items.length === 1 && only !== undefined && only.value.toLowerCase() === lower) {
+    return null;
+  }
+  return items.length > 0 ? items : null;
+}

apps/kimi-code/src/tui/commands/config.ts

@@ -0,0 +1,912 @@
+import {
+  effectiveModelAlias,
+  PRIMARY_SUBAGENT_MODEL_CHOICE,
+  SECONDARY_DERIVED_MODEL_ALIAS,
+  type ExperimentalFeatureState,
+  type ModelAlias,
+  type PermissionMode,
+  type Session,
+  type ThinkingEffort,
+} from '@moonshot-ai/kimi-code-sdk';
+
+import { EditorSelectorComponent } from '../components/dialogs/editor-selector';
+import { EffortSelectorComponent } from '../components/dialogs/effort-selector';
+import {
+  ExperimentsSelectorComponent,
+  type ExperimentalFeatureDraftChange,
+} from '../components/dialogs/experiments-selector';
+import { modelDisplayName, segmentsFor } from '../components/dialogs/model-selector';
+import { TabbedModelSelectorComponent } from '../components/dialogs/tabbed-model-selector';
+import { PermissionSelectorComponent } from '../components/dialogs/permission-selector';
+import { SettingsSelectorComponent, type SettingsSelection } from '../components/dialogs/settings-selector';
+import { SurveyPreferenceSelectorComponent } from '../components/dialogs/survey-preference-selector';
+import { ThemeSelectorComponent } from '../components/dialogs/theme-selector';
+import { UpdatePreferenceSelectorComponent } from '../components/dialogs/update-preference-selector';
+import { DEFAULT_TUI_CONFIG, saveTuiConfig, type TuiConfig } from '../config';
+import type { ThemeName } from '#/tui/theme';
+import { currentTheme, isBuiltInTheme, lightColors, loadCustomThemeMerged } from '#/tui/theme';
+import { NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import { PERMISSION_MODE_DESCRIPTIONS, PERMISSION_MODE_DISPLAY_NAMES } from '../utils/permission-mode';
+import { thinkingEffortToConfig } from '../utils/thinking-config';
+import { showUsage } from './info';
+import { setExperimentalFeatures } from './experimental-flags';
+import type { SlashCommandHost } from './dispatch';
+
+// ---------------------------------------------------------------------------
+// Plan / Config commands
+// ---------------------------------------------------------------------------
+
+const MODEL_PICKER_REFRESH_TIMEOUT_MS = 2_000;
+
+const MODEL_SWITCH_CACHE_WARNING =
+  'Note: Switching models invalidates the existing prompt cache. Use /new to avoid extra token costs.';
+const EFFORT_SWITCH_CACHE_WARNING =
+  'Note: Switching effort invalidates the existing prompt cache. Use /new to avoid extra token costs.';
+
+/** True once the conversation has at least one user message: a switch from
+ * then on resends the accumulated context, losing the cache. Shell-command
+ * echoes are also 'user' transcript entries but carry an empty `bullet`, so
+ * they're excluded. */
+function hasConversationHistory(host: SlashCommandHost): boolean {
+  return host.state.transcriptEntries.some(
+    (entry) => entry.kind === 'user' && entry.bullet !== '',
+  );
+}
+
+export function currentTuiConfig(host: Pick<SlashCommandHost, 'state'>): TuiConfig {
+  return {
+    theme: host.state.appState.theme,
+    editorCommand: host.state.appState.editorCommand,
+    disablePasteBurst: host.state.appState.disablePasteBurst ?? DEFAULT_TUI_CONFIG.disablePasteBurst,
+    renderLatex: host.state.appState.renderLatex ?? DEFAULT_TUI_CONFIG.renderLatex ?? true,
+    cacheExpiryHint: host.state.appState.cacheExpiryHint ?? DEFAULT_TUI_CONFIG.cacheExpiryHint,
+    disableFeedbackSurvey:
+      host.state.appState.disableFeedbackSurvey ?? DEFAULT_TUI_CONFIG.disableFeedbackSurvey,
+    notifications: host.state.appState.notifications,
+    upgrade: host.state.appState.upgrade,
+    statusLine: host.state.appState.statusLine ?? DEFAULT_TUI_CONFIG.statusLine,
+  };
+}
+
+export function effectiveModelForHost(host: SlashCommandHost, model: ModelAlias): ModelAlias {
+  const providerType = host.state.appState.availableProviders[model.provider]?.type;
+  // Flat models (no named provider, e.g. inline base_url served by a v2
+  // backend) have no provider entry to look up; their own protocol declaration
+  // plays the provider-identity role, mirroring the resolver.
+  return effectiveModelAlias(model, providerType ?? model.protocol);
+}
+
+export async function handlePlanCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const session = host.session;
+  if (session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  const subcmd = args.trim().toLowerCase();
+  if (subcmd === 'clear') {
+    await session.clearPlan();
+    host.showNotice('Plan cleared');
+    return;
+  }
+
+  let enabled: boolean;
+  if (subcmd.length === 0) enabled = !host.state.appState.planMode;
+  else if (subcmd === 'on') enabled = true;
+  else if (subcmd === 'off') enabled = false;
+  else {
+    host.showError(`Unknown plan subcommand: ${subcmd}`);
+    return;
+  }
+
+  // The session may already be in the requested mode (e.g. it was created
+  // with config.defaultPlanMode applied), and re-entering plan mode throws.
+  if (host.state.appState.planMode === enabled) {
+    host.showNotice(`Plan mode is already ${enabled ? 'on' : 'off'}`);
+    return;
+  }
+
+  await applyPlanMode(host, session, enabled);
+}
+
+async function applyPlanMode(host: SlashCommandHost, session: Session, enabled: boolean): Promise<void> {
+  try {
+    await session.setPlanMode(enabled);
+    host.setAppState({ planMode: enabled });
+    if (enabled) {
+      const plan = await session.getPlan().catch(() => null);
+      host.showNotice(
+        'Plan mode: ON',
+        plan?.path !== undefined ? `Plan will be created here: ${plan.path}` : undefined,
+      );
+      return;
+    }
+    host.showNotice('Plan mode: OFF');
+  } catch (error) {
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to set plan mode: ${msg}`);
+  }
+}
+
+export async function handleCompactCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const session = host.session;
+  if (session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+  const customInstruction = args.trim() || undefined;
+  await session.compact({ instruction: customInstruction });
+}
+
+export async function handleEditorCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const command = args.trim();
+  if (command.length === 0) {
+    showEditorPicker(host);
+    return;
+  }
+  await applyEditorChoice(host, command);
+}
+
+export async function handleThemeCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const theme = args.trim();
+  if (theme.length === 0) {
+    showThemePicker(host);
+    return;
+  }
+  if (!isBuiltInTheme(theme)) {
+    const custom = await loadCustomThemeMerged(theme);
+    if (custom === null) {
+      host.showError(`Unknown theme: ${theme}`);
+      return;
+    }
+  }
+  await applyThemeChoice(host, theme);
+}
+
+export async function handleModelCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const alias = args.trim();
+  await refreshModelsForPicker(host);
+  if (alias.length === 0) {
+    showModelPicker(host);
+    return;
+  }
+  if (host.state.appState.availableModels[alias] === undefined) {
+    host.showError(`Unknown model alias: ${alias}`);
+    return;
+  }
+  showModelPicker(host, alias);
+}
+
+export async function handleSecondaryModelCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const alias = args.trim();
+  await refreshModelsForPicker(host);
+  const models = pickerModelsForHost(host);
+  // The pool reserves `primary` as the symbolic "caller's own model" choice —
+  // a user alias with that name can never be the subagent default.
+  delete models[PRIMARY_SUBAGENT_MODEL_CHOICE];
+  if (alias === PRIMARY_SUBAGENT_MODEL_CHOICE) {
+    host.showError(
+      `"${PRIMARY_SUBAGENT_MODEL_CHOICE}" is reserved by the subagent model pool (it always binds the caller's own model) — rename the [models] alias to use it here.`,
+    );
+    return;
+  }
+  if (Object.keys(models).length === 0) {
+    host.showNotice(
+      'No models configured',
+      'Run /login to sign in to Kimi, or /provider to add another provider from a model catalog.',
+    );
+    return;
+  }
+  if (alias.length > 0 && models[alias] === undefined) {
+    host.showError(`Unknown model alias: ${alias}`);
+    return;
+  }
+  const secondary = (await host.harness.getConfig()).secondaryModel;
+  // The v2 engine honors a lone legacy `model` key as the fallback pool
+  // default — reflect it as the picker's current value.
+  const current = secondary?.defaultModel ?? secondary?.model ?? '';
+  showSecondaryModelPicker(host, models, current, alias.length > 0 ? alias : undefined);
+}
+
+export async function handleEffortCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const alias = host.state.appState.model;
+  const model = host.state.appState.availableModels[alias];
+  if (model === undefined) {
+    host.showError('No model selected. Run /model to select one first.');
+    return;
+  }
+  const effective = effectiveModelForHost(host, model);
+  const segments = segmentsFor(effective);
+  const arg = args.trim().toLowerCase();
+  if (arg.length === 0) {
+    showEffortPicker(host, effective, segments);
+    return;
+  }
+  if (!segments.includes(arg)) {
+    const providerType = host.state.appState.availableProviders[effective.provider]?.type;
+    const protocol = effective.protocol ?? providerType;
+    if (protocol !== 'anthropic') {
+      host.showError(
+        `Unsupported thinking effort "${arg}" for ${alias}. Available: ${segments.join(', ')}`,
+      );
+      return;
+    }
+    const knownEfforts = effective.supportEfforts?.join(', ') ?? 'none declared';
+    host.showStatus(
+      `Thinking effort "${arg}" is not listed for ${alias} (known: ${knownEfforts}). Sending "${arg}" unchanged; the configured provider will validate it.`,
+      'warning',
+    );
+  }
+  await performModelSwitch(host, alias, arg, true);
+}
+
+function showEffortPicker(
+  host: SlashCommandHost,
+  model: ModelAlias,
+  segments: readonly string[],
+): void {
+  const liveEffort = host.state.appState.thinkingEffort;
+  const currentValue = segments.includes(liveEffort) ? liveEffort : (segments[0] ?? 'off');
+  const alias = host.state.appState.model;
+  host.mountEditorReplacement(
+    new EffortSelectorComponent({
+      efforts: segments,
+      currentValue,
+      warning: hasConversationHistory(host) ? EFFORT_SWITCH_CACHE_WARNING : undefined,
+      onSelect: (effort) => {
+        host.restoreEditor();
+        void performModelSwitch(host, alias, effort, true);
+      },
+      onSessionOnlySelect: (effort) => {
+        host.restoreEditor();
+        void performModelSwitch(host, alias, effort, false);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Pickers & config apply
+// ---------------------------------------------------------------------------
+
+function showEditorPicker(host: SlashCommandHost): void {
+  const currentValue = host.state.appState.editorCommand ?? '';
+  host.mountEditorReplacement(
+    new EditorSelectorComponent({
+      currentValue,
+      onSelect: (value) => {
+        host.restoreEditor();
+        void applyEditorChoice(host, value);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+async function refreshModelsForPicker(host: SlashCommandHost): Promise<void> {
+  try {
+    const result = await withTimeout(
+      host.authFlow.refreshOAuthProviderModels(),
+      MODEL_PICKER_REFRESH_TIMEOUT_MS,
+    );
+    if (result === undefined) return;
+    for (const f of result.failed) {
+      host.showStatus(`Skipped refreshing ${f.provider}: ${f.reason}`, 'warning');
+    }
+  } catch (error) {
+    host.showStatus(`Skipped refreshing models: ${formatErrorMessage(error)}`, 'warning');
+  }
+}
+
+async function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | undefined> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<undefined>((resolve) => {
+        timeout = setTimeout(() => {
+          resolve(undefined);
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeout !== undefined) clearTimeout(timeout);
+  }
+}
+
+async function applyEditorChoice(host: SlashCommandHost, value: string): Promise<void> {
+  const previous = host.state.appState.editorCommand ?? '';
+  if (value === previous && value.length > 0) {
+    host.showStatus(`Editor unchanged: ${value.length > 0 ? value : 'auto-detect'}`);
+    return;
+  }
+
+  const editorCommand = value.length > 0 ? value : null;
+  try {
+    await saveTuiConfig({
+      ...currentTuiConfig(host),
+      editorCommand,
+    });
+  } catch (error) {
+    host.showStatus(
+      `Failed to save editor: ${formatErrorMessage(error)}`,
+      'error',
+    );
+    return;
+  }
+
+  host.setAppState({ editorCommand });
+  host.showStatus(
+    value.length > 0
+      ? `Editor set to "${value}".`
+      : 'Editor set to auto-detect ($VISUAL / $EDITOR).',
+  );
+}
+
+/**
+ * The models a picker may offer: the user's configured aliases with
+ * host-effective provider resolution applied, minus the synthesized
+ * `__secondary__` derived entry — a runtime artifact of the v1 engine's
+ * `[secondary_model]` recipe that must never be selectable as a model.
+ */
+function pickerModelsForHost(host: SlashCommandHost): Record<string, ModelAlias> {
+  return Object.fromEntries(
+    Object.entries(host.state.appState.availableModels)
+      .filter(([alias]) => alias !== SECONDARY_DERIVED_MODEL_ALIAS)
+      .map(([alias, model]) => [alias, effectiveModelForHost(host, model)]),
+  );
+}
+
+export function showModelPicker(host: SlashCommandHost, selectedValue: string = host.state.appState.model): void {
+  const models = pickerModelsForHost(host);
+  const entries = Object.entries(models);
+  if (entries.length === 0) {
+    host.showNotice(
+      'No models configured',
+      'Run /login to sign in to Kimi, or /provider to add another provider from a model catalog.',
+    );
+    return;
+  }
+  host.mountEditorReplacement(
+    new TabbedModelSelectorComponent({
+      models,
+      currentValue: host.state.appState.model,
+      selectedValue,
+      currentThinkingEffort: host.state.appState.thinkingEffort,
+      warning: hasConversationHistory(host) ? MODEL_SWITCH_CACHE_WARNING : undefined,
+      onSelect: ({ alias, thinking }) => {
+        host.restoreEditor();
+        void performModelSwitch(host, alias, thinking, true);
+      },
+      onSessionOnlySelect: ({ alias, thinking }) => {
+        host.restoreEditor();
+        void performModelSwitch(host, alias, thinking, false);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+async function performModelSwitch(
+  host: SlashCommandHost,
+  alias: string,
+  effort: ThinkingEffort,
+  persist: boolean,
+): Promise<void> {
+  let session = host.session;
+  if (session === undefined) {
+    // A first prompt may still be inside lazy creation: wait it out so the
+    // switch lands on the new session instead of being overwritten by its
+    // assembly.
+    await host.waitForLazyCreation();
+    session = host.session;
+  }
+  if (host.state.appState.streamingPhase !== 'idle') {
+    host.showError('Cannot switch models while streaming — press Esc or Ctrl-C first.');
+    return;
+  }
+
+  const prevModel = host.state.appState.model;
+  const prevEffort = host.state.appState.thinkingEffort;
+  const modelChanged = alias !== prevModel;
+  const effortChanged = effort !== prevEffort;
+  const runtimeChanged = modelChanged || effortChanged;
+  let effectiveAlias = alias;
+  let effectiveEffort = effort;
+
+  try {
+    if (session === undefined && runtimeChanged) {
+      await host.authFlow.activateModelAfterLogin(alias, effort);
+    } else if (session !== undefined) {
+      if (alias !== prevModel) {
+        await session.setModel(alias);
+      }
+      if (effort !== prevEffort) {
+        await session.setThinking(effort);
+      }
+      const status = await session.getStatus();
+      effectiveAlias = status.model ?? alias;
+      effectiveEffort = status.thinkingEffort;
+    }
+  } catch (error) {
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to switch model: ${msg}`);
+    return;
+  }
+
+  if (session === undefined) {
+    effectiveAlias = host.state.appState.model;
+    effectiveEffort = host.state.appState.thinkingEffort;
+  }
+  const effectiveModelChanged = effectiveAlias !== prevModel;
+  const effectiveEffortChanged = effectiveEffort !== prevEffort;
+  const displayName = modelDisplayName(
+    effectiveAlias,
+    host.state.appState.availableModels[effectiveAlias],
+  );
+  host.setAppState({ model: effectiveAlias, thinkingEffort: effectiveEffort });
+  if (session === undefined && runtimeChanged) {
+    if (effectiveModelChanged) {
+      host.track('model_switch', { model: effectiveAlias });
+    }
+    if (effectiveEffortChanged) {
+      host.track('thinking_toggle', {
+        enabled: effectiveEffort !== 'off',
+        effort: effectiveEffort,
+        from: prevEffort,
+      });
+    }
+  }
+
+  let persisted = false;
+  if (persist) {
+    try {
+      persisted = await persistModelSelection(
+        host,
+        effectiveAlias,
+        effectiveEffort,
+        effectiveEffortChanged,
+      );
+    } catch (error) {
+      const msg = formatErrorMessage(error);
+      host.showError(`Switched to ${displayName}, but failed to save default: ${msg}`);
+      return;
+    }
+  }
+
+  let status: string;
+  if (effectiveModelChanged) {
+    status = persist
+      ? `Switched to ${displayName} with thinking ${effectiveEffort}.`
+      : `Switched to ${displayName} with thinking ${effectiveEffort} for this session only.`;
+  } else if (effectiveEffortChanged) {
+    status = persist
+      ? `Thinking set to ${effectiveEffort}.`
+      : `Thinking set to ${effectiveEffort} for this session only.`;
+  } else if (persist && persisted) {
+    status = `Saved ${displayName} with thinking ${effectiveEffort} as default.`;
+  } else {
+    status = `Already using ${displayName} with thinking ${effectiveEffort}.`;
+  }
+  host.showStatus(status, 'success');
+}
+
+async function persistModelSelection(
+  host: SlashCommandHost,
+  alias: string,
+  effort: ThinkingEffort,
+  effortChanged: boolean,
+): Promise<boolean> {
+  const config = await host.harness.getConfig({ reload: true });
+  const model = host.state.appState.availableModels[alias];
+  const full = thinkingEffortToConfig(
+    effort,
+    model === undefined ? undefined : effectiveModelForHost(host, model),
+  );
+  // Re-confirming the effort shown when the picker opened is not an explicit
+  // choice — persist the model but leave the stored effort preference alone.
+  const patch = effortChanged ? full : { enabled: full.enabled };
+  if (
+    config.defaultModel === alias &&
+    config.thinking?.enabled === patch.enabled &&
+    (!effortChanged || config.thinking?.effort === patch.effort)
+  ) {
+    return false;
+  }
+  await host.harness.setConfig({
+    defaultModel: alias,
+    thinking: patch,
+  });
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Secondary model (`/secondary-model`) — persists `[secondary_model] default_model`
+// ---------------------------------------------------------------------------
+
+function showSecondaryModelPicker(
+  host: SlashCommandHost,
+  models: Record<string, ModelAlias>,
+  currentValue: string,
+  selectedValue?: string,
+): void {
+  host.mountEditorReplacement(
+    new TabbedModelSelectorComponent({
+      models,
+      currentValue,
+      selectedValue,
+      currentThinkingEffort: 'off',
+      // Subagent pool bindings carry no explicit thinking level, so the picker
+      // hides the Thinking footer instead of offering a no-op choice.
+      thinkingControl: false,
+      title: ' Select a secondary model (subagents)',
+      onSelect: ({ alias }) => {
+        host.restoreEditor();
+        void performSecondaryModelSave(host, alias);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+/**
+ * Persists `[secondary_model] default_model`. When a
+ * `[secondary_model.models]` pool exists and does not list the alias yet, the
+ * alias is added with an empty description — the engine requires the default
+ * to be a pool key. Without a pool the default alone forms an implicit
+ * single-entry pool, so nothing else is written. No live-apply step: the
+ * engine resolves the pool per spawn, so the next subagent dispatch picks the
+ * new value up on its own.
+ */
+async function performSecondaryModelSave(host: SlashCommandHost, alias: string): Promise<void> {
+  const displayName = modelDisplayName(alias, host.state.appState.availableModels[alias]);
+  try {
+    const config = await host.harness.getConfig({ reload: true });
+    const existing = config.secondaryModel?.models;
+    const patch: { defaultModel: string; models?: Record<string, string> } = {
+      defaultModel: alias,
+    };
+    if (existing !== undefined) {
+      patch.models = { ...existing, [alias]: existing[alias] ?? '' };
+    }
+    await host.harness.setConfig({ secondaryModel: patch });
+  } catch (error) {
+    host.showError(`Failed to save secondary model: ${formatErrorMessage(error)}`);
+    return;
+  }
+  host.showStatus(
+    `Secondary model set to ${displayName}. Newly spawned subagents will use it by default.`,
+    'success',
+  );
+}
+
+function showThemePicker(host: SlashCommandHost): void {
+  host.mountEditorReplacement(
+    new ThemeSelectorComponent({
+      currentValue: host.state.appState.theme,
+      onSelect: (value) => {
+        host.restoreEditor();
+        void applyThemeChoice(host, value);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+async function applyThemeChoice(host: SlashCommandHost, theme: ThemeName): Promise<void> {
+  if (theme === host.state.appState.theme) {
+    if (theme === 'auto') host.refreshTerminalThemeTracking();
+    host.showStatus(`Theme unchanged: "${theme}".`);
+    return;
+  }
+
+  // Validate custom themes up front so a missing / malformed file reports an
+  // error instead of silently persisting a name that resolves to the dark
+  // fallback.
+  if (!isBuiltInTheme(theme)) {
+    const palette = await loadCustomThemeMerged(theme);
+    if (palette === null) {
+      host.showStatus(`Theme "${theme}" could not be loaded.`, 'error');
+      return;
+    }
+  }
+
+  try {
+    await saveTuiConfig({
+      ...currentTuiConfig(host),
+      theme,
+    });
+  } catch (error) {
+    host.showStatus(
+      `Failed to save theme: ${formatErrorMessage(error)}`,
+      'error',
+    );
+    return;
+  }
+
+  const resolved = theme === 'auto'
+    ? (currentTheme.palette === lightColors ? 'light' : 'dark')
+    : undefined;
+  await host.applyTheme(theme, resolved);
+  host.refreshTerminalThemeTracking();
+  host.track('theme_switch', { theme });
+  const detail = theme === 'auto' ? ` (tracking terminal; current: ${resolved})` : '';
+  host.showStatus(`Theme set to "${theme}"${detail}.`);
+}
+
+export function showPermissionPicker(host: SlashCommandHost, initialMode?: PermissionMode): void {
+  host.mountEditorReplacement(
+    new PermissionSelectorComponent({
+      currentValue: host.state.appState.permissionMode,
+      initialValue: initialMode,
+      onSelect: (value) => {
+        host.restoreEditor();
+        void applyPermissionChoice(host, value);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+export function showUpdatePreferencePicker(host: SlashCommandHost): void {
+  host.mountEditorReplacement(
+    new UpdatePreferenceSelectorComponent({
+      currentValue: host.state.appState.upgrade.autoInstall,
+      onSelect: (value) => {
+        host.restoreEditor();
+        void applyUpdatePreferenceChoice(host, value);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+export async function showExperimentsPanel(host: SlashCommandHost): Promise<void> {
+  let features: readonly ExperimentalFeatureState[];
+  try {
+    features = await host.harness.getExperimentalFeatures();
+  } catch (error) {
+    host.showError(`Failed to load experimental features: ${formatErrorMessage(error)}`);
+    return;
+  }
+  mountExperimentsPanel(host, features);
+}
+
+export async function applyExperimentalFeatureChanges(
+  host: SlashCommandHost,
+  changes: readonly ExperimentalFeatureDraftChange[],
+): Promise<void> {
+  if (changes.length === 0) {
+    host.showStatus(
+      'No experimental feature changes to apply.',
+      'textMuted',
+    );
+    return;
+  }
+
+  const experimental: Record<string, boolean> = {};
+  for (const change of changes) {
+    experimental[change.id] = change.enabled;
+  }
+
+  try {
+    await host.harness.setConfig({ experimental });
+    const features = await host.harness.getExperimentalFeatures();
+    setExperimentalFeatures(features);
+    host.refreshSlashCommandAutocomplete();
+    host.restoreEditor();
+    if (host.session !== undefined && changes.some((change) => change.id !== 'notify_user')) {
+      const reloadedSession = await host.harness.reloadSession({ id: host.session.id });
+      await host.reloadCurrentSessionView(
+        reloadedSession,
+        'Experimental features updated. Session reloaded.',
+      );
+    } else {
+      host.showStatus('Experimental features updated.', 'success');
+    }
+    if (
+      host.session !== undefined &&
+      changes.some((change) => change.id === 'notify_user' && change.enabled)
+    ) {
+      host.showNotice(
+        'Start a new session to use Updates if this session was created with the feature disabled.',
+      );
+    }
+    if (changes.some((change) => change.id === 'tower')) {
+      // TowerFeature assembles its tool/profile contributions once at App
+      // scope construction, so a live flag flip cannot install or retract
+      // them; only the mode machinery (enter/injection/guards) reacts live.
+      host.showNotice('Tower mode takes effect after restarting Kimi Code.');
+    }
+    host.track('experimental_features_apply', {
+      changed: changes.length,
+      flags: features
+        .filter((feature) => feature.enabled)
+        .map((feature) => feature.id)
+        .toSorted()
+        .join(','),
+    });
+  } catch (error) {
+    host.showError(`Failed to update experimental features: ${formatErrorMessage(error)}`);
+  }
+}
+
+function mountExperimentsPanel(
+  host: SlashCommandHost,
+  features: readonly ExperimentalFeatureState[],
+): void {
+  host.mountEditorReplacement(
+    new ExperimentsSelectorComponent({
+      features,
+      onApply: (changes) => {
+        void applyExperimentalFeatureChanges(host, changes);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+type UpdatePreferenceHost = {
+  readonly state: {
+    readonly appState: Pick<
+      SlashCommandHost['state']['appState'],
+      'theme' | 'editorCommand' | 'notifications' | 'upgrade'
+    >;
+  };
+  setAppState(patch: Pick<SlashCommandHost['state']['appState'], 'upgrade'>): void;
+  showStatus(msg: string, color?: string): void;
+  track: SlashCommandHost['track'];
+};
+
+export async function applyUpdatePreferenceChoice(
+  host: UpdatePreferenceHost,
+  autoInstall: boolean,
+): Promise<void> {
+  if (autoInstall === host.state.appState.upgrade.autoInstall) {
+    host.showStatus(`Automatic updates already ${autoInstall ? 'enabled' : 'disabled'}.`);
+    return;
+  }
+
+  const upgrade = { autoInstall };
+  try {
+    await saveTuiConfig({
+      ...currentTuiConfig(host as unknown as SlashCommandHost),
+      upgrade,
+    });
+  } catch (error) {
+    host.showStatus(
+      `Failed to save automatic update setting: ${formatErrorMessage(error)}`,
+      'error',
+    );
+    return;
+  }
+
+  host.setAppState({ upgrade });
+  host.track('upgrade_preference_changed', { auto_install: autoInstall });
+  host.showStatus(`Automatic updates ${autoInstall ? 'enabled' : 'disabled'}.`);
+}
+
+async function applyPermissionChoice(host: SlashCommandHost, mode: PermissionMode): Promise<void> {
+  if (mode === host.state.appState.permissionMode) {
+    host.showStatus(`Permission mode unchanged: ${PERMISSION_MODE_DISPLAY_NAMES[mode]}.`);
+    return;
+  }
+
+  try {
+    if (host.session !== undefined) {
+      await host.session.setPermission(mode);
+    }
+    // v2 session-less: the chosen mode is recorded in appState and passed to
+    // the lazy-created session.
+  } catch (error) {
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to set permission mode: ${msg}`);
+    return;
+  }
+
+  host.setAppState({ permissionMode: mode });
+  host.showNotice(`Permission mode: ${PERMISSION_MODE_DISPLAY_NAMES[mode]}`);
+  if (mode !== 'manual') {
+    host.showStatus(PERMISSION_MODE_DESCRIPTIONS[mode], 'warning');
+  }
+}
+
+export function showSurveyPreferencePicker(host: SlashCommandHost): void {
+  host.mountEditorReplacement(
+    new SurveyPreferenceSelectorComponent({
+      currentValue: host.state.appState.disableFeedbackSurvey !== true,
+      onSelect: (value) => {
+        host.restoreEditor();
+        void applySurveyPreferenceChoice(host, value);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+type SurveyPreferenceHost = {
+  readonly state: {
+    readonly appState: Pick<
+      SlashCommandHost['state']['appState'],
+      'theme' | 'editorCommand' | 'notifications' | 'upgrade' | 'disableFeedbackSurvey'
+    >;
+  };
+  setAppState(
+    patch: Pick<SlashCommandHost['state']['appState'], 'disableFeedbackSurvey'>,
+  ): void;
+  showStatus(msg: string, color?: string): void;
+};
+
+export async function applySurveyPreferenceChoice(
+  host: SurveyPreferenceHost,
+  enabled: boolean,
+): Promise<void> {
+  const disableFeedbackSurvey = !enabled;
+  if (disableFeedbackSurvey === (host.state.appState.disableFeedbackSurvey === true)) {
+    host.showStatus(`Feedback survey already ${enabled ? 'enabled' : 'disabled'}.`);
+    return;
+  }
+
+  try {
+    await saveTuiConfig({
+      ...currentTuiConfig(host as unknown as SlashCommandHost),
+      disableFeedbackSurvey,
+    });
+  } catch (error) {
+    host.showStatus(
+      `Failed to save session rating setting: ${formatErrorMessage(error)}`,
+      'error',
+    );
+    return;
+  }
+
+  host.setAppState({ disableFeedbackSurvey });
+  host.showStatus(`Feedback survey ${enabled ? 'enabled' : 'disabled'}.`);
+}
+
+export function showSettingsSelector(host: SlashCommandHost): void {
+  host.mountEditorReplacement(
+    new SettingsSelectorComponent({
+      onSelect: (value) => {
+        handleSettingsSelection(host, value);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+function handleSettingsSelection(host: SlashCommandHost, value: SettingsSelection): void {
+  host.restoreEditor();
+  switch (value) {
+    case 'model': showModelPicker(host); return;
+    case 'permission': showPermissionPicker(host); return;
+    case 'theme': showThemePicker(host); return;
+    case 'editor': showEditorPicker(host); return;
+    case 'survey': showSurveyPreferencePicker(host); return;
+    case 'experiments': void showExperimentsPanel(host); return;
+    case 'upgrade': showUpdatePreferencePicker(host); return;
+    case 'usage': void showUsage(host); return;
+  }
+}

apps/kimi-code/src/tui/commands/copy.ts

@@ -0,0 +1,41 @@
+import { copyTextToClipboard } from '#/utils/clipboard/clipboard-text';
+import type { TranscriptEntry } from '../types';
+import { formatErrorMessage } from '../utils/event-payload';
+import type { SlashCommandHost } from './dispatch';
+
+/**
+ * Visible text of the last assistant transcript entry, newest first; empty
+ * string when none. Sourced from the rendered transcript rather than the
+ * model context so it survives compaction and session resume: after
+ * `/compact` the context keeps user messages plus a user-role summary only,
+ * while the last reply is still on screen. Only entries tagged `modelText`
+ * count — hook-result and goal-completion cards share kind 'assistant' but
+ * are not replies.
+ */
+export function findLastAssistantText(entries: readonly TranscriptEntry[]): string {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry === undefined || entry.kind !== 'assistant' || entry.modelText !== true) continue;
+    if (entry.content.trim().length > 0) return entry.content;
+  }
+  return '';
+}
+
+export async function handleCopyCommand(host: SlashCommandHost): Promise<void> {
+  const text = findLastAssistantText(host.state.transcriptEntries);
+  if (text.length === 0) {
+    host.showStatus('No assistant message to copy.', 'warning');
+    return;
+  }
+
+  try {
+    const method = await copyTextToClipboard(text);
+    host.showStatus(
+      method === 'native'
+        ? `Copied to clipboard (${String(text.length)} characters).`
+        : `Copied via terminal escape sequence (unverified, ${String(text.length)} characters).`,
+    );
+  } catch (error) {
+    host.showError(`Failed to copy to clipboard: ${formatErrorMessage(error)}`);
+  }
+}

apps/kimi-code/src/tui/commands/dispatch.ts

@@ -0,0 +1,607 @@
+import type { Component, Focusable } from '@moonshot-ai/pi-tui';
+import type { DeviceAuthorization } from '@moonshot-ai/kimi-code-oauth';
+import type { KimiHarness, Session } from '@moonshot-ai/kimi-code-sdk';
+
+import type { ColorToken, ThemeName } from '#/tui/theme';
+
+import { LLM_NOT_SET_MESSAGE } from '../constant/kimi-tui';
+import type { AuthFlowController } from '../controllers/auth-flow';
+import type { BtwPanelController } from '../controllers/btw-panel';
+import type { StreamingUIController } from '../controllers/streaming-ui';
+import type { TasksBrowserController } from '../controllers/tasks-browser';
+import { tryHandleDanceCommand } from '../easter-eggs/dance';
+import type { ResolvedTheme } from '../theme/colors';
+import type { TUIState } from '../tui-state';
+import type {
+  AppState,
+  InlineSkillActivation,
+  LoginProgressSpinnerHandle,
+  QueuedMessage,
+  TranscriptEntry,
+} from '../types';
+import { formatErrorMessage } from '../utils/event-payload';
+import {
+  extractInlineSkillActivations,
+  findInlineSkillTokens,
+} from '../utils/inline-skill-tokens';
+import { handleLoginCommand, handleLogoutCommand } from './auth';
+import { handleBtwCommand } from './btw';
+import { handleCopyCommand } from './copy';
+import {
+  handleCompactCommand,
+  handleEditorCommand,
+  handleEffortCommand,
+  handleModelCommand,
+  handlePlanCommand,
+  handleSecondaryModelCommand,
+  handleThemeCommand,
+  showExperimentsPanel,
+  showModelPicker,
+  showPermissionPicker,
+  showSettingsSelector,
+} from './config';
+import { handleGoalCommand } from './goal';
+import { handleFeedbackCommand, showMcpServers, showStatusReport, showUsage } from './info';
+import { handleAddDirCommand } from './add-dir';
+import { parseSlashInput } from './parse';
+import { handlePluginsCommand } from './plugins';
+import { handleProviderCommand } from './provider';
+import {
+  findBuiltInSlashCommand,
+  resolveSlashCommandAvailability,
+  type BuiltinSlashCommandName,
+} from './registry';
+import { handleReloadCommand, handleReloadTuiCommand } from './reload';
+import type { SkillListSession } from './skills';
+import {
+  canRestoreSubmittedInput,
+  resolveSlashCommandInput,
+  slashBusyMessage,
+  slashCommandBusyReason,
+} from './resolve';
+import {
+  handleExportDebugZipCommand,
+  handleExportMdCommand,
+  handleForkCommand,
+  handleInitCommand,
+  handleTitleCommand,
+} from './session';
+import { handleSwarmCommand } from './swarm';
+import { handleTowerCommand } from './tower';
+import { handleUndoCommand } from './undo';
+import { handleRemoteControlCommand, handleWebCommand } from './web';
+
+// ---------------------------------------------------------------------------
+// Re-exports — keep existing consumers working
+// ---------------------------------------------------------------------------
+
+export { handleLoginCommand, handleLogoutCommand } from './auth';
+export { handleBtwCommand } from './btw';
+export { handleCopyCommand } from './copy';
+export { handleAddDirCommand } from './add-dir';
+export {
+  handleCompactCommand,
+  handleEditorCommand,
+  handleEffortCommand,
+  handleModelCommand,
+  handlePlanCommand,
+  handleSecondaryModelCommand,
+  handleThemeCommand,
+  showModelPicker,
+  showExperimentsPanel,
+  showPermissionPicker,
+  showSettingsSelector,
+} from './config';
+export { handleSwarmCommand } from './swarm';
+export { handleTowerCommand } from './tower';
+export { handleFeedbackCommand, showMcpServers, showStatusReport, showUsage } from './info';
+export { handlePluginsCommand } from './plugins';
+export { handleReloadCommand, handleReloadTuiCommand } from './reload';
+export { handleGoalCommand } from './goal';
+export {
+  handleExportDebugZipCommand,
+  handleExportMdCommand,
+  handleForkCommand,
+  handleInitCommand,
+  handleTitleCommand,
+} from './session';
+export { handleUndoCommand } from './undo';
+export { handleRemoteControlCommand, handleWebCommand } from './web';
+
+// ---------------------------------------------------------------------------
+// Host interface
+// ---------------------------------------------------------------------------
+
+export interface SlashCommandHost {
+  state: TUIState;
+  session: Session | undefined;
+  readonly harness: KimiHarness;
+  cancelInFlight: (() => void) | undefined;
+  deferUserMessages: boolean;
+
+  setAppState(patch: Partial<AppState>): void;
+  resetLivePane(): void;
+  showError(msg: string): void;
+  showStatus(msg: string, color?: ColorToken): void;
+  showNotice(title: string, detail?: string): void;
+  appendTranscriptEntry(entry: TranscriptEntry): void;
+  track(event: string, props?: Record<string, unknown>): void;
+  mountEditorReplacement(panel: Component & Focusable): void;
+  restoreEditor(): void;
+  restoreInputText(text: string): void;
+  refreshSlashCommandAutocomplete(): void;
+  /**
+   * Rebuild the plugin slash-command list. With no session (v2 session-less
+   * startup) this reads the app-global plugin commands instead, so `/plugins`
+   * mutations apply before the first session exists.
+   */
+  refreshPluginCommands(session?: Session): Promise<void>;
+  /**
+   * Rebuild the skill slash-command list. With no session (v2 session-less
+   * startup) this reads the workspace skills instead.
+   */
+  refreshSkillCommands(session?: SkillListSession): Promise<void>;
+  /**
+   * Seed appState with the config defaults the v2 engine would apply at
+   * createSession time (model, permission, plan mode, thinking effort,
+   * context cap). No-op semantics on a live session path: only /reload calls
+   * it while still session-less.
+   */
+  hydrateLazyConfigDefaults(): Promise<void>;
+
+  // Session
+  requireSession(): Session;
+  /**
+   * Lazy-create the session on first use (v2 engine). Returns the existing
+   * session, or undefined (with the error already surfaced) when creation
+   * fails.
+   */
+  ensureSession(): Promise<Session | undefined>;
+  /** Await the in-flight lazy session creation, if any (v2); no-op otherwise. */
+  waitForLazyCreation(): Promise<void>;
+  switchToSession(session: Session, message: string): Promise<void>;
+  reloadCurrentSessionView(session: Session, message: string): Promise<void>;
+  beginSessionRequest(): void;
+  failSessionRequest(message: string): void;
+  sendQueuedMessage(session: Session, item: QueuedMessage): void;
+  requestQueuedGoalPromotion?(): void;
+  /** Reset the client-side cache-break baseline after the context was cut
+   *  (/undo): the next step's cache-read drop is expected, not a break. */
+  noteContextCut?(): void;
+
+  // UI
+  showLoginProgressSpinner(label: string): LoginProgressSpinnerHandle;
+  showLoginAuthorizationPrompt(auth: DeviceAuthorization): LoginProgressSpinnerHandle;
+  showProgressSpinner(label: string): LoginProgressSpinnerHandle;
+
+  // Theme
+  applyTheme(theme: ThemeName, resolved?: ResolvedTheme): Promise<void>;
+  refreshTerminalThemeTracking(): void;
+
+  // Dispatch
+  stop(exitCode?: number): Promise<void>;
+  setExitOpenUrl(url: string): void;
+  /**
+   * Register a task that takes over the process after the TUI has shut down
+   * (instead of exiting): the runner awaits it and only exits when it returns.
+   * Used by `/web` to keep a freshly started server attached to this terminal
+   * until Ctrl+C.
+   */
+  setExitForegroundTask(task: (exitCode: number) => Promise<void>): void;
+  showHelpPanel(): void;
+  createNewSession(): Promise<void>;
+  showSessionPicker(): Promise<void>;
+  sendNormalUserInput(text: string): void;
+  /**
+   * Submit a prompt that explicitly activates one or more skills inline
+   * (v2 engine only): all activations ride the same submission as the prompt
+   * and launch as a single turn.
+   */
+  sendInlineSkillUserInput(text: string, activations: readonly InlineSkillActivation[]): Promise<void>;
+  sendSkillActivation(session: Session, skillName: string, skillArgs: string): void;
+  activatePluginCommand(
+    session: Session,
+    pluginId: string,
+    commandName: string,
+    args: string,
+  ): void;
+  readonly skillCommandMap: Map<string, string>;
+  readonly pluginCommandMap: Map<string, string>;
+
+  // Controller refs
+  readonly streamingUI: StreamingUIController;
+  readonly btwPanelController: BtwPanelController;
+  readonly tasksBrowserController: TasksBrowserController;
+  readonly authFlow: AuthFlowController;
+}
+
+// ---------------------------------------------------------------------------
+// Dispatch — entry point from handleUserInput
+// ---------------------------------------------------------------------------
+
+export function dispatchInput(host: SlashCommandHost, text: string): void {
+  if (parseSlashInput(text) !== null) {
+    // A leading skill command combined with further inline skill tokens
+    // (`/skill:a args /skill:b`) is one grouped submission on the v2 engine.
+    if (dispatchInlineSkillCombo(host, text)) {
+      return;
+    }
+    void executeSlashCommand(host, text);
+    return;
+  }
+  // Inline skill tokens anywhere in a plain prompt activate the skills.
+  const activations = extractInlineSkillActivations(text, host.skillCommandMap);
+  if (activations.length > 0) {
+    void host.sendInlineSkillUserInput(text, activations);
+    return;
+  }
+  host.sendNormalUserInput(text);
+}
+
+/**
+ * Handle a leading-slash input that may be a bundled submission. Returns true
+ * when the input was claimed, false when it should fall through to the
+ * regular single-skill slash path.
+ *
+ * Bundle rule: two or more known skill tokens with the first one leading the
+ * input make the whole input one bundled prompt in which every token
+ * activates with NO args — the mention is the whole interface, and args stay
+ * a standalone-activation concept (`/skill:a some args` with no other tokens
+ * keeps its single-skill path). Tokenization is whitespace-generic, so
+ * space- and newline-separated bundles behave identically. A recognized
+ * builtin or plugin command always keeps its own path, no matter how many
+ * skill tokens its arguments mention.
+ */
+function dispatchInlineSkillCombo(host: SlashCommandHost, text: string): boolean {
+  // The intent is parsed without the busy flags on purpose: submissions
+  // through sendInlineSkillUserInput queue while busy — only genuine
+  // single-skill commands reject.
+  const intent = resolveSlashCommandInput({
+    input: text,
+    skillCommandMap: host.skillCommandMap,
+    pluginCommandMap: host.pluginCommandMap,
+    isStreaming: false,
+    isCompacting: false,
+  });
+  if (intent.kind !== 'skill' && intent.kind !== 'message') return false;
+
+  const tokens = findInlineSkillTokens(text, {
+    isKnownSkill: (commandName) =>
+      host.skillCommandMap.has(commandName) || host.skillCommandMap.has(`skill:${commandName}`),
+    includeLeading: true,
+  });
+  // The 'message' kind joins the bundle rule because parseSlashInput only
+  // splits on a literal space: a newline after a leading skill resolves to
+  // 'message' instead of 'skill', and must not silently drop the leading
+  // activation.
+  if (tokens.length >= 2 && tokens[0]!.start === 0) {
+    const activations = extractInlineSkillActivations(text, host.skillCommandMap, {
+      includeLeading: true,
+    });
+    void host.sendInlineSkillUserInput(text, activations);
+    return true;
+  }
+
+  // An unrecognized leading slash token makes the whole input a plain
+  // message; scan it for inline skills like any other plain prompt.
+  if (intent.kind !== 'message') return false;
+  const activations = extractInlineSkillActivations(text, host.skillCommandMap);
+  if (activations.length === 0) return false;
+  void host.sendInlineSkillUserInput(text, activations);
+  return true;
+}
+
+async function executeSlashCommand(host: SlashCommandHost, input: string): Promise<void> {
+  const parsedCommand = parseSlashInput(input);
+  const intent = resolveSlashCommandInput({
+    input,
+    skillCommandMap: host.skillCommandMap,
+    pluginCommandMap: host.pluginCommandMap,
+    isStreaming: host.state.appState.streamingPhase !== 'idle',
+    isCompacting: host.state.appState.isCompacting,
+  });
+
+  switch (intent.kind) {
+    case 'not-command':
+      return;
+    case 'blocked':
+      host.track('input_command_invalid', { reason: 'blocked', command: intent.commandName });
+      host.showError(slashBusyMessage(intent.commandName, intent.reason));
+      // The editor buffer was already cleared on submit; give the rejected
+      // command line back so hand-typed input is not lost.
+      host.restoreInputText(input);
+      return;
+    case 'invalid':
+      host.track('input_command_invalid', {
+        reason: intent.reason,
+        command: intent.commandName,
+      });
+      host.showError(`Invalid slash command: /${intent.commandName}`);
+      return;
+    case 'skill': {
+      if (host.state.appState.model.trim().length === 0) {
+        host.showError(LLM_NOT_SET_MESSAGE);
+        return;
+      }
+      let session = host.session;
+      if (session === undefined) {
+        session = await ensureSessionForCommand(host);
+        if (session === undefined) return;
+        // A first prompt may have started a turn while the session was being
+        // created; skill commands are always busy-gated, so re-check the gate
+        // resolved before the await.
+        const busyReason = slashCommandBusyReason({
+          isStreaming: host.state.appState.streamingPhase !== 'idle',
+          isCompacting: host.state.appState.isCompacting,
+        });
+        if (busyReason !== undefined) {
+          host.showError(slashBusyMessage(intent.commandName, busyReason));
+          return;
+        }
+      }
+      host.track('input_command', {
+        command: intent.commandName,
+        skill_name: intent.skillName,
+      });
+      host.sendSkillActivation(session, intent.skillName, intent.args);
+      return;
+    }
+    case 'plugin-command': {
+      if (host.state.appState.model.trim().length === 0) {
+        host.showError(LLM_NOT_SET_MESSAGE);
+        return;
+      }
+      let session = host.session;
+      if (session === undefined) {
+        session = await ensureSessionForCommand(host);
+        if (session === undefined) return;
+        // Same busy re-check as the skill path: plugin commands are always
+        // busy-gated too.
+        const busyReason = slashCommandBusyReason({
+          isStreaming: host.state.appState.streamingPhase !== 'idle',
+          isCompacting: host.state.appState.isCompacting,
+        });
+        if (busyReason !== undefined) {
+          host.showError(slashBusyMessage(intent.commandName, busyReason));
+          return;
+        }
+      }
+      host.track('input_command', { command: `${intent.pluginId}:${intent.commandName}` });
+      host.activatePluginCommand(session, intent.pluginId, intent.commandName, intent.args);
+      return;
+    }
+    case 'message':
+      // Unknown slash command: let /dance claim it before it falls through to
+      // the model as a normal message. This runs *after* builtin and skill
+      // resolution, so a real command or a same-named skill always wins.
+      if (parsedCommand !== null && tryHandleDanceCommand(host, parsedCommand)) {
+        return;
+      }
+      host.sendNormalUserInput(intent.input);
+      return;
+    case 'builtin':
+      host.track('input_command', { command: intent.name });
+      if (intent.name === 'new' && parsedCommand?.name === 'clear') {
+        host.track('clear');
+      }
+      try {
+        await handleBuiltInSlashCommand(host, intent.name, intent.args, input);
+      } catch (error) {
+        host.showError(formatErrorMessage(error));
+      }
+      return;
+  }
+}
+
+/**
+ * Lazy-create the session for a slash command that needs one (v2 engine). A
+ * missing session means the TUI started session-less, so commands create it
+ * on first use. Returns undefined (error already shown) when creation fails.
+ */
+async function ensureSessionForCommand(host: SlashCommandHost): Promise<Session | undefined> {
+  return host.ensureSession();
+}
+
+/** Builtin commands that need an active session; lazy-created on the v2 engine. */
+const SESSION_REQUIRING_COMMANDS: ReadonlySet<BuiltinSlashCommandName> = new Set([
+  'btw',
+  'compact',
+  'export-debug-zip',
+  'export-md',
+  'fork',
+  'goal',
+  'init',
+  'plan',
+  'swarm',
+  'undo',
+  'web',
+]);
+
+async function handleBuiltInSlashCommand(
+  host: SlashCommandHost,
+  name: BuiltinSlashCommandName,
+  args: string,
+  input: string,
+): Promise<void> {
+  if (host.session === undefined && SESSION_REQUIRING_COMMANDS.has(name)) {
+    const session = await ensureSessionForCommand(host);
+    if (session === undefined) {
+      // Creation failed after submit cleared the buffer; give the input
+      // back unless the user moved on — a newer draft or an opened panel.
+      if (canRestoreSubmittedInput(host)) host.restoreInputText(input);
+      return;
+    }
+    // A first prompt may have started a turn while the session was being
+    // created; re-check the availability gate that was resolved before the
+    // await (idle-only commands are blocked while a turn is active).
+    const command = findBuiltInSlashCommand(name);
+    const busyReason = slashCommandBusyReason({
+      isStreaming: host.state.appState.streamingPhase !== 'idle',
+      isCompacting: host.state.appState.isCompacting,
+    });
+    if (
+      busyReason !== undefined &&
+      command !== undefined &&
+      resolveSlashCommandAvailability(command, args) === 'idle-only'
+    ) {
+      host.showError(slashBusyMessage(name, busyReason));
+      // Same as the dispatch blocked branch: give the cleared input back,
+      // guarded the same way — session creation awaited above.
+      if (canRestoreSubmittedInput(host)) host.restoreInputText(input);
+      return;
+    }
+  }
+  switch (name) {
+    case 'exit':
+      void host.stop();
+      return;
+    case 'help':
+      host.showHelpPanel();
+      return;
+    case 'version':
+      host.showStatus(`Kimi Code v${host.state.appState.version}`);
+      return;
+    case 'new': {
+      // A first-use lazy creation may still be in flight: wait it out so /new
+      // never races a second createSession against the pending prompt.
+      await host.waitForLazyCreation();
+      // The waited-out prompt may have started a turn meanwhile; /new is
+      // idle-only, so re-run the busy gate resolved before the await.
+      const busyReason = slashCommandBusyReason({
+        isStreaming: host.state.appState.streamingPhase !== 'idle',
+        isCompacting: host.state.appState.isCompacting,
+      });
+      if (busyReason !== undefined) {
+        host.showError(slashBusyMessage(name, busyReason));
+        return;
+      }
+      await host.createNewSession();
+      host.state.ui.requestRender();
+      return;
+    }
+    case 'sessions':
+      void host.showSessionPicker();
+      return;
+    case 'tasks':
+      void host.tasksBrowserController.show();
+      return;
+    case 'mcp':
+      void showMcpServers(host);
+      return;
+    case 'plugins':
+      // `handlePluginsCommand` throws when no session is active (its own
+      // requireSession), so catch here instead of letting the `void` call
+      // reject unhandled.
+      try {
+        await handlePluginsCommand(host, args);
+      } catch (error) {
+        host.showError(formatErrorMessage(error));
+      }
+      return;
+    case 'add-dir':
+      await handleAddDirCommand(host, args);
+      return;
+    case 'experiments':
+      await showExperimentsPanel(host);
+      return;
+    case 'reload':
+      await handleReloadCommand(host);
+      return;
+    case 'reload-tui':
+      await handleReloadTuiCommand(host);
+      return;
+    case 'editor':
+      await handleEditorCommand(host, args);
+      return;
+    case 'theme':
+      await handleThemeCommand(host, args);
+      return;
+    case 'model':
+      await handleModelCommand(host, args);
+      return;
+    case 'secondary-model':
+      await handleSecondaryModelCommand(host, args);
+      return;
+    case 'effort':
+      await handleEffortCommand(host, args);
+      return;
+    case 'provider':
+      await handleProviderCommand(host);
+      return;
+    case 'permission':
+      showPermissionPicker(host);
+      return;
+    case 'settings':
+      showSettingsSelector(host);
+      return;
+    case 'usage':
+      void showUsage(host);
+      return;
+    case 'status':
+      void showStatusReport(host);
+      return;
+    case 'feedback':
+      await handleFeedbackCommand(host);
+      return;
+    case 'btw':
+      await handleBtwCommand(host, args);
+      return;
+    case 'title':
+      await handleTitleCommand(host, args);
+      return;
+    case 'yolo':
+      showPermissionPicker(host, 'yolo');
+      return;
+    case 'auto':
+      showPermissionPicker(host, 'auto');
+      return;
+    case 'plan':
+      await handlePlanCommand(host, args);
+      return;
+    case 'swarm':
+      await handleSwarmCommand(host, args);
+      return;
+    case 'tower':
+      await handleTowerCommand(host, args);
+      return;
+    case 'compact':
+      await handleCompactCommand(host, args);
+      return;
+    case 'goal':
+      await handleGoalCommand(host, args);
+      return;
+    case 'init':
+      await handleInitCommand(host);
+      return;
+    case 'fork':
+      await handleForkCommand(host, args);
+      return;
+    case 'export-md':
+      await handleExportMdCommand(host, args);
+      return;
+    case 'export-debug-zip':
+      await handleExportDebugZipCommand(host);
+      return;
+    case 'copy':
+      await handleCopyCommand(host);
+      return;
+    case 'login':
+      await handleLoginCommand(host);
+      return;
+    case 'logout':
+      await handleLogoutCommand(host);
+      return;
+    case 'undo':
+      await handleUndoCommand(host, args);
+      return;
+    case 'web':
+      await handleWebCommand(host);
+      return;
+    case 'remote-control':
+      await handleRemoteControlCommand(host);
+      return;
+    default:
+      host.showError(`Unknown slash command: /${String(name)}`);
+      return;
+  }
+}

apps/kimi-code/src/tui/commands/experimental-flags.ts

@@ -0,0 +1,19 @@
+import type { ExperimentalFeatureState, ExperimentalFlagMap } from '@moonshot-ai/kimi-code-sdk';
+
+import { experimentalFeatureMap } from '#/utils/experimental-features';
+
+// Resolved experimental features, fetched once from the core over RPC at startup and then read
+// synchronously by the command palette and dispatch. App-local cache, not a source of truth.
+let snapshot: ExperimentalFlagMap = {};
+
+/** Replace the cached flag snapshot. Call after fetching via `harness.getExperimentalFeatures()`. */
+export function setExperimentalFeatures(
+  features: readonly Pick<ExperimentalFeatureState, 'id' | 'enabled'>[],
+): void {
+  snapshot = experimentalFeatureMap(features);
+}
+
+/** An `undefined` flag means "not gated" → always enabled, so callers can pass an optional flag id. */
+export function isExperimentalFlagEnabled(flag: string | undefined): boolean {
+  return flag === undefined || snapshot[flag] === true;
+}

apps/kimi-code/src/tui/commands/goal.ts

@@ -0,0 +1,576 @@
+import { ErrorCodes, isKimiError, type PermissionMode } from '@moonshot-ai/kimi-code-sdk';
+
+import {
+  GoalStartPermissionPromptComponent,
+  type GoalStartPermissionChoice,
+} from '../components/dialogs/goal-start-permission-prompt';
+import {
+  GoalQueueEditDialogComponent,
+  GoalQueueManagerComponent,
+  type GoalQueueEditResult,
+  type GoalQueueManagerAction,
+} from '../components/dialogs/goal-queue-manager';
+import {
+  GoalSetMessageComponent,
+  GoalStatusMessageComponent,
+  UpcomingGoalAddedMessageComponent,
+} from '../components/messages/goal-panel';
+import { LLM_NOT_SET_MESSAGE } from '../constant/kimi-tui';
+import {
+  appendGoalQueueItem,
+  moveGoalQueueItem,
+  readGoalQueue,
+  removeGoalQueueItem,
+  updateGoalQueueItem,
+  type GoalQueueSnapshot,
+} from '../goal-queue-store';
+import { formatErrorMessage } from '../utils/event-payload';
+import { PERMISSION_MODE_DESCRIPTIONS, PERMISSION_MODE_DISPLAY_NAMES } from '../utils/permission-mode';
+import { canRestoreSubmittedInput } from './resolve';
+import type { SlashCommandHost } from './dispatch';
+
+const MAX_GOAL_OBJECTIVE_LENGTH = 4000;
+const RESUME_GOAL_INPUT = 'Resume the active goal.';
+const START_NEXT_GOAL_NOW_MESSAGE = 'No active goal. Starting this goal now.';
+
+type GoalCommandHost = Pick<
+  SlashCommandHost,
+  | 'state'
+  | 'session'
+  | 'requireSession'
+  | 'setAppState'
+  | 'showError'
+  | 'showNotice'
+  | 'showStatus'
+  | 'track'
+  | 'mountEditorReplacement'
+  | 'restoreEditor'
+  | 'restoreInputText'
+  | 'sendNormalUserInput'
+>;
+
+export interface GoalStartOptions {
+  readonly beforeSend?: () => boolean | Promise<boolean>;
+  readonly sendInput?: (objective: string) => void;
+}
+
+export type ParsedGoalCommand =
+  | { readonly kind: 'status' }
+  | { readonly kind: 'pause' }
+  | { readonly kind: 'resume' }
+  | { readonly kind: 'cancel' }
+  | {
+      readonly kind: 'create';
+      readonly objective: string;
+      readonly replace: boolean;
+    }
+  | { readonly kind: 'next-add'; readonly objective: string }
+  | { readonly kind: 'next-manage' }
+  | {
+      readonly kind: 'error';
+      readonly message: string;
+      readonly severity?: 'error' | 'hint';
+      /** Restore the typed `/goal ...` line into the editor so the input is not lost. */
+      readonly restoreInput?: boolean;
+    };
+
+const CONTROL_SUBCOMMANDS = new Set(['pause', 'resume', 'cancel']);
+
+/**
+ * Parses the deterministic `/goal` command grammar. Reserved subcommands
+ * (`pause`/`resume`/`cancel`/`status`/`replace`) are only honored as the first
+ * token; use `/goal -- <objective>` to start a goal whose text begins with one
+ * of those words. (`cancel` is the single discard action — it removes the
+ * current goal.) Stop conditions are expressed in the objective in natural
+ * language (e.g. "…or stop after 20 turns"); the model honors them when it
+ * self-audits each turn and reports `complete`/`blocked` via UpdateGoal.
+ */
+export function parseGoalCommand(rawArgs: string): ParsedGoalCommand {
+  const args = rawArgs.trim();
+  if (args.length === 0 || args === 'status') return { kind: 'status' };
+
+  const tokens = args.split(/\s+/);
+  const first = tokens[0];
+  if (first === 'next') {
+    return parseNextGoalCommand(tokens);
+  }
+  if (first !== undefined && CONTROL_SUBCOMMANDS.has(first) && tokens.length === 1) {
+    return { kind: first as 'pause' | 'resume' | 'cancel' };
+  }
+
+  let index = 0;
+  let replace = false;
+  if (tokens[index] === 'replace') {
+    replace = true;
+    index += 1;
+  }
+  // `--` ends subcommand parsing so an objective can begin with a reserved word
+  // (e.g. `/goal -- pause the rollout`).
+  if (tokens[index] === '--') {
+    index += 1;
+  }
+
+  const objective = tokens.slice(index).join(' ').trim();
+  if (objective.length === 0) {
+    // A usage hint, not a failure — shown in the same calm style as the other
+    // "nothing to act on" messages (no goal to pause/resume/cancel).
+    return {
+      kind: 'error',
+      severity: 'hint',
+      message: 'Provide a goal objective, e.g. `/goal Ship feature X`.',
+    };
+  }
+  if (objective.length > MAX_GOAL_OBJECTIVE_LENGTH) {
+    return {
+      kind: 'error',
+      restoreInput: true,
+      message: `Goal objective is too long (max ${MAX_GOAL_OBJECTIVE_LENGTH} characters). Put long content in a file and reference the file path.`,
+    };
+  }
+  return { kind: 'create', objective, replace };
+}
+
+export async function handleGoalCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const parsed = parseGoalCommand(args);
+  switch (parsed.kind) {
+    case 'error':
+      if (parsed.severity === 'hint') host.showStatus(parsed.message);
+      else host.showError(parsed.message);
+      // Give rejected input back so a long hand-typed objective is not
+      // lost — unless the user already moved on (a newer draft or an
+      // opened panel), which is possible after the async lazy-session
+      // creation on the v2 engine.
+      if (parsed.restoreInput === true && canRestoreSubmittedInput(host))
+        host.restoreInputText(`/goal ${args}`);
+      return;
+    case 'status':
+      await showGoalStatus(host);
+      return;
+    case 'pause':
+      await pauseGoal(host);
+      return;
+    case 'resume':
+      await resumeGoal(host);
+      return;
+    case 'cancel':
+      await cancelGoal(host);
+      return;
+    case 'next-add':
+      await queueNextGoal(host, parsed);
+      return;
+    case 'next-manage':
+      await showGoalQueueManager(host);
+      return;
+    case 'create':
+      await createGoal(host, parsed, args);
+      return;
+  }
+}
+
+function parseNextGoalCommand(tokens: readonly string[]): ParsedGoalCommand {
+  if (tokens.length === 2 && tokens[1] === 'manage') return { kind: 'next-manage' };
+  let index = 1;
+  if (tokens[index] === '--') index += 1;
+  const objective = tokens.slice(index).join(' ').trim();
+  if (objective.length === 0) {
+    return {
+      kind: 'error',
+      severity: 'hint',
+      message:
+        'Provide an upcoming goal objective, e.g. `/goal next Ship feature X`, or use `/goal next manage`.',
+    };
+  }
+  if (objective.length > MAX_GOAL_OBJECTIVE_LENGTH) {
+    return {
+      kind: 'error',
+      restoreInput: true,
+      message: `Goal objective is too long (max ${MAX_GOAL_OBJECTIVE_LENGTH} characters). Put long content in a file and reference the file path.`,
+    };
+  }
+  return { kind: 'next-add', objective };
+}
+
+/**
+ * Live pre-send check for the main editor: when the typed text is a `/goal`
+ * create/next command whose objective already exceeds the length limit,
+ * returns a warning to show while typing — before anything is submitted or
+ * sent to the server. Returns undefined for non-goal input and for control
+ * forms (`status`/`pause`/`resume`/`cancel`/`next manage`).
+ */
+export function goalObjectiveLengthWarning(text: string): string | undefined {
+  // Submitted text is trimmed before dispatch, so match leading whitespace.
+  const trimmed = text.trimStart();
+  if (!trimmed.startsWith('/goal')) return undefined;
+  const args = trimmed.slice('/goal'.length);
+  // parseSlashInput splits the command name at a literal space only, so a
+  // newline/tab boundary (`/goal⏎…`, `/goalfoo`) is not the goal command.
+  if (args.length > 0 && args.charAt(0) !== ' ') return undefined;
+  const objective = extractGoalObjective(args);
+  if (objective === undefined || objective.length <= MAX_GOAL_OBJECTIVE_LENGTH) return undefined;
+  return `Goal objective is too long (${objective.length}/${MAX_GOAL_OBJECTIVE_LENGTH} characters); put long content in a file and reference the file path.`;
+}
+
+/**
+ * Mirrors the parse grammar above: strips `next` / `replace` / `--` and
+ * returns the objective text, or undefined when the args form a control
+ * command that carries no objective.
+ */
+function extractGoalObjective(rawArgs: string): string | undefined {
+  const args = rawArgs.trim();
+  if (args.length === 0 || args === 'status') return undefined;
+  const tokens = args.split(/\s+/);
+  const first = tokens[0];
+  let index = 0;
+  if (first === 'next') {
+    if (tokens.length === 2 && tokens[1] === 'manage') return undefined;
+    index = 1;
+  } else {
+    if (first !== undefined && CONTROL_SUBCOMMANDS.has(first) && tokens.length === 1) {
+      return undefined;
+    }
+    if (tokens[index] === 'replace') index += 1;
+  }
+  if (tokens[index] === '--') index += 1;
+  return tokens.slice(index).join(' ').trim();
+}
+
+async function queueNextGoal(
+  host: SlashCommandHost,
+  parsed: Extract<ParsedGoalCommand, { kind: 'next-add' }>,
+): Promise<void> {
+  const session = host.requireSession();
+  let hasCurrentGoal: boolean;
+  try {
+    const { goal } = await session.getGoal();
+    hasCurrentGoal = goal !== null;
+  } catch (error) {
+    host.showError(`Failed to inspect current goal: ${formatErrorMessage(error)}`);
+    return;
+  }
+
+  if (!hasCurrentGoal && !isBusy(host)) {
+    host.showStatus(START_NEXT_GOAL_NOW_MESSAGE);
+    await createGoal(
+      host,
+      { kind: 'create', objective: parsed.objective, replace: false },
+      `next ${parsed.objective}`,
+    );
+    return;
+  }
+
+  try {
+    await appendGoalQueueItem(session, { objective: parsed.objective });
+  } catch (error) {
+    host.showError(formatErrorMessage(error));
+    return;
+  }
+  host.track('goal_queue_append');
+  if (!hasCurrentGoal) host.requestQueuedGoalPromotion?.();
+  host.state.transcriptContainer.addChild(
+    new UpcomingGoalAddedMessageComponent(),
+  );
+  host.state.ui.requestRender();
+}
+
+async function showGoalQueueManager(
+  host: SlashCommandHost,
+  selectedGoalId?: string,
+): Promise<void> {
+  let snapshot: GoalQueueSnapshot;
+  try {
+    snapshot = await readGoalQueue(host.requireSession());
+  } catch (error) {
+    host.showError(`Failed to load upcoming goals: ${formatErrorMessage(error)}`);
+    return;
+  }
+
+  host.track('goal_queue_manage');
+  host.mountEditorReplacement(
+    new GoalQueueManagerComponent({
+      goals: snapshot.goals,
+      selectedGoalId,
+      onAction: async (action) => {
+        try {
+          return await handleGoalQueueManagerAction(host, action);
+        } catch (error) {
+          host.showError(`Failed to update upcoming goals: ${formatErrorMessage(error)}`);
+          return undefined;
+        }
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+async function handleGoalQueueManagerAction(
+  host: SlashCommandHost,
+  action: GoalQueueManagerAction,
+): Promise<GoalQueueSnapshot | void> {
+  const session = host.requireSession();
+  switch (action.kind) {
+    case 'move': {
+      const snapshot = await moveGoalQueueItem(session, {
+        goalId: action.goalId,
+        direction: action.direction,
+      });
+      host.track('goal_queue_move', { direction: action.direction });
+      return snapshot;
+    }
+    case 'delete': {
+      const snapshot = await removeGoalQueueItem(session, { goalId: action.goalId });
+      host.track('goal_queue_remove');
+      return snapshot;
+    }
+    case 'edit':
+      await showGoalQueueEditDialog(host, action.goalId);
+      return;
+  }
+}
+
+async function showGoalQueueEditDialog(
+  host: SlashCommandHost,
+  goalId: string,
+): Promise<void> {
+  let snapshot: GoalQueueSnapshot;
+  try {
+    snapshot = await readGoalQueue(host.requireSession());
+  } catch (error) {
+    host.showError(`Failed to load upcoming goals: ${formatErrorMessage(error)}`);
+    return;
+  }
+
+  const goal = snapshot.goals.find((item) => item.id === goalId);
+  if (goal === undefined) {
+    host.showStatus('Queued goal no longer exists.');
+    await showGoalQueueManager(host);
+    return;
+  }
+
+  host.mountEditorReplacement(
+    new GoalQueueEditDialogComponent({
+      goal,
+      onDone: (result) => {
+        void handleGoalQueueEditResult(host, result).catch((error: unknown) => {
+          host.showError(`Failed to update upcoming goal: ${formatErrorMessage(error)}`);
+        });
+      },
+    }),
+  );
+}
+
+async function handleGoalQueueEditResult(
+  host: SlashCommandHost,
+  result: GoalQueueEditResult,
+): Promise<void> {
+  if (result.kind === 'cancel') {
+    await showGoalQueueManager(host, result.goalId);
+    return;
+  }
+
+  await updateGoalQueueItem(host.requireSession(), {
+    goalId: result.goalId,
+    objective: result.objective,
+  });
+  host.track('goal_queue_update');
+  await showGoalQueueManager(host, result.goalId);
+}
+
+export async function createGoal(
+  host: GoalCommandHost,
+  parsed: Extract<ParsedGoalCommand, { kind: 'create' }>,
+  rawArgs?: string,
+  options: GoalStartOptions = {},
+): Promise<boolean> {
+  // A goal must be able to start a model turn; refuse to create one otherwise.
+  if (host.state.appState.model.trim().length === 0 || host.session === undefined) {
+    host.showError(LLM_NOT_SET_MESSAGE);
+    return false;
+  }
+
+  if (
+    host.state.appState.permissionMode === 'manual' ||
+    host.state.appState.permissionMode === 'yolo'
+  ) {
+    showGoalStartPermissionPrompt(host, parsed, rawArgs ?? parsed.objective, options);
+    return false;
+  }
+
+  return startGoal(host, parsed, options);
+}
+
+function showGoalStartPermissionPrompt(
+  host: GoalCommandHost,
+  parsed: Extract<ParsedGoalCommand, { kind: 'create' }>,
+  rawArgs: string,
+  options: GoalStartOptions,
+): void {
+  const commandText = `/goal ${rawArgs.trim()}`;
+  const cancelStart = (): void => {
+    host.restoreInputText(commandText);
+    host.showStatus('Goal not started.');
+  };
+  host.mountEditorReplacement(
+    new GoalStartPermissionPromptComponent({
+      mode: host.state.appState.permissionMode === 'yolo' ? 'yolo' : 'manual',
+      onSelect: (choice) => {
+        if (choice === 'cancel') {
+          cancelStart();
+          return;
+        }
+        host.restoreEditor();
+        void startGoalWithPermission(host, parsed, choice, options);
+      },
+      onCancel: cancelStart,
+    }),
+  );
+}
+
+async function startGoalWithPermission(
+  host: GoalCommandHost,
+  parsed: Extract<ParsedGoalCommand, { kind: 'create' }>,
+  choice: GoalStartPermissionChoice,
+  options: GoalStartOptions,
+): Promise<void> {
+  const previousMode = host.state.appState.permissionMode;
+  const switched =
+    choice !== previousMode && (choice === 'auto' || choice === 'yolo');
+  if (switched) {
+    if (!(await setPermissionForGoal(host, choice))) return;
+  }
+  const started = await startGoal(host, parsed, options);
+  // The permission switch only exists to run this goal. If creation fails
+  // (e.g. a goal already exists and `replace` was not given), restore the
+  // previous mode so the session is not left more permissive than before.
+  if (!started && switched) {
+    await setPermissionForGoal(host, previousMode);
+    return;
+  }
+  // Announce the switch only once the goal actually starts: shown earlier, a
+  // failed creation would leave a stale permissive-mode notice in the
+  // transcript even though the rollback above restored the previous mode.
+  if (switched) {
+    host.showNotice(`Permission mode: ${PERMISSION_MODE_DISPLAY_NAMES[choice]}`);
+    host.showStatus(PERMISSION_MODE_DESCRIPTIONS[choice], 'warning');
+  }
+}
+
+async function setPermissionForGoal(host: GoalCommandHost, mode: PermissionMode): Promise<boolean> {
+  try {
+    await host.requireSession().setPermission(mode);
+  } catch (error) {
+    host.showError(`Failed to set permission mode: ${formatErrorMessage(error)}`);
+    return false;
+  }
+  host.setAppState({ permissionMode: mode });
+  return true;
+}
+
+async function startGoal(
+  host: GoalCommandHost,
+  parsed: Extract<ParsedGoalCommand, { kind: 'create' }>,
+  options: GoalStartOptions,
+): Promise<boolean> {
+  try {
+    await host.requireSession().createGoal({
+      objective: parsed.objective,
+      replace: parsed.replace,
+    });
+  } catch (error) {
+    if (isKimiError(error) && error.code === ErrorCodes.GOAL_ALREADY_EXISTS) {
+      host.showError(
+        'A goal is already active. Use `/goal replace <objective>` to replace it, or `/goal status` to inspect it.',
+      );
+      return false;
+    }
+    host.showError(formatErrorMessage(error));
+    return false;
+  }
+  if (options.beforeSend !== undefined && !(await options.beforeSend())) {
+    return false;
+  }
+  host.state.transcriptContainer.addChild(new GoalSetMessageComponent());
+  host.state.ui.requestRender();
+  if (options.sendInput !== undefined) {
+    options.sendInput(parsed.objective);
+  } else {
+    host.sendNormalUserInput(parsed.objective);
+  }
+  return true;
+}
+
+async function pauseGoal(host: SlashCommandHost): Promise<void> {
+  const session = host.requireSession();
+  try {
+    await session.pauseGoal();
+    if (isStreaming(host)) await session.cancel();
+  } catch (error) {
+    if (isKimiError(error) && error.code === ErrorCodes.GOAL_NOT_FOUND) {
+      host.showStatus('No goal to pause.');
+      return;
+    }
+    host.showError(formatErrorMessage(error));
+    return;
+  }
+  host.track('goal_pause');
+  host.showStatus('Goal paused. Use `/goal resume` to continue.');
+}
+
+async function resumeGoal(host: SlashCommandHost): Promise<void> {
+  if (host.state.appState.model.trim().length === 0 || host.session === undefined) {
+    host.showError(LLM_NOT_SET_MESSAGE);
+    return;
+  }
+
+  try {
+    await host.requireSession().resumeGoal();
+  } catch (error) {
+    if (isKimiError(error) && error.code === ErrorCodes.GOAL_NOT_FOUND) {
+      host.showStatus('No goal to resume.');
+      return;
+    }
+    host.showError(formatErrorMessage(error));
+    return;
+  }
+  host.track('goal_resume');
+  host.sendNormalUserInput(RESUME_GOAL_INPUT);
+}
+
+async function cancelGoal(host: SlashCommandHost): Promise<void> {
+  const session = host.requireSession();
+  try {
+    await session.cancelGoal();
+    if (isStreaming(host)) await session.cancel();
+  } catch (error) {
+    if (isKimiError(error) && error.code === ErrorCodes.GOAL_NOT_FOUND) {
+      host.showStatus('No goal to cancel.');
+      return;
+    }
+    host.showError(formatErrorMessage(error));
+    return;
+  }
+  host.track('goal_cancel');
+  host.showNotice('Goal cancelled.');
+}
+
+async function showGoalStatus(host: SlashCommandHost): Promise<void> {
+  const { goal } = await host.requireSession().getGoal();
+  host.track('goal_status', { status: goal?.status ?? 'none' });
+  if (goal === null) {
+    host.showStatus('No goal set. Start one with `/goal <objective>`.');
+    return;
+  }
+  host.state.transcriptContainer.addChild(
+    new GoalStatusMessageComponent(goal),
+  );
+  host.state.ui.requestRender();
+}
+
+function isStreaming(host: SlashCommandHost): boolean {
+  return host.state.appState.streamingPhase !== 'idle';
+}
+
+function isBusy(host: SlashCommandHost): boolean {
+  return isStreaming(host) || host.state.appState.isCompacting;
+}

apps/kimi-code/src/tui/commands/index.ts

@@ -0,0 +1,43 @@
+export * from './experimental-flags';
+export * from './parse';
+export * from './registry';
+export * from './resolve';
+export * from './skills';
+export * from './plugin-commands';
+export * from './types';
+
+export { dispatchInput, type SlashCommandHost } from './dispatch';
+export { handleLoginCommand, handleLogoutCommand } from './auth';
+export { handleBtwCommand } from './btw';
+export { handleCopyCommand } from './copy';
+export {
+  handleCompactCommand,
+  handleEditorCommand,
+  handleModelCommand,
+  handlePlanCommand,
+  handleThemeCommand,
+  showExperimentsPanel,
+  showModelPicker,
+  showPermissionPicker,
+  showSettingsSelector,
+} from './config';
+export { handleSwarmCommand } from './swarm';
+export { handleTowerCommand } from './tower';
+export { handleFeedbackCommand, showMcpServers, showStatusReport, showUsage } from './info';
+export { handlePluginsCommand } from './plugins';
+export { handleReloadCommand, handleReloadTuiCommand } from './reload';
+export { handleGoalCommand, parseGoalCommand, goalObjectiveLengthWarning } from './goal';
+export { goalArgumentCompletions } from './registry';
+export { handleForkCommand, handleInitCommand, handleTitleCommand } from './session';
+export { handleUndoCommand } from './undo';
+export { handleRemoteControlCommand, handleWebCommand } from './web';
+export {
+  promptApiKey,
+  promptCatalogProviderSelection,
+  promptFeedbackInput,
+  promptLogoutProviderSelection,
+  promptModelSelectionForCatalog,
+  promptModelSelectionForOpenPlatform,
+  promptPlatformSelection,
+  runModelSelector,
+} from './prompts';

apps/kimi-code/src/tui/commands/info.ts

@@ -0,0 +1,255 @@
+import { release as osRelease, type as osType } from 'node:os';
+
+import type { McpServerInfo, SessionStatus, SessionUsage } from '@moonshot-ai/kimi-code-sdk';
+
+import { buildMcpStatusReportLines } from '../components/messages/mcp-status-panel';
+import { buildStatusReportLines } from '../components/messages/status-panel';
+import { buildUsageReportLines, UsagePanelComponent, type ManagedUsageReport } from '../components/messages/usage-panel';
+import { isExperimentalFlagEnabled } from './experimental-flags';
+import { quotaUsageRows } from '#/utils/usage/usage-format';
+import {
+  FEEDBACK_ISSUE_URL,
+  FEEDBACK_STATUS_CANCELLED,
+  FEEDBACK_STATUS_FALLBACK,
+  FEEDBACK_STATUS_NETWORK_ERROR,
+  FEEDBACK_STATUS_NOT_SIGNED_IN,
+  FEEDBACK_STATUS_SUBMITTING,
+  FEEDBACK_STATUS_SUCCESS,
+  FEEDBACK_STATUS_UPLOAD_FAILED,
+  FEEDBACK_TELEMETRY_EVENT,
+  feedbackIdLine,
+  feedbackSessionLine,
+  kimiCodeSignupUrl,
+  withFeedbackVersionPrefix,
+} from '../constant/feedback';
+import { DEFAULT_OAUTH_PROVIDER_NAME, isManagedUsageProvider } from '../constant/kimi-tui';
+import { submitFeedbackWithAttachments } from '../../feedback/feedback-attachments';
+import { formatErrorMessage } from '../utils/event-payload';
+import { openUrl } from '#/utils/open-url';
+import { promptFeedbackAttachment, promptFeedbackInput } from './prompts';
+import type { SlashCommandHost } from './dispatch';
+
+// ---------------------------------------------------------------------------
+// Feedback
+// ---------------------------------------------------------------------------
+
+export async function handleFeedbackCommand(host: SlashCommandHost): Promise<void> {
+  const fallback = (reason: string): void => {
+    host.showStatus(reason);
+    host.showStatus(FEEDBACK_ISSUE_URL);
+    openUrl(FEEDBACK_ISSUE_URL);
+  };
+
+  // Gate on the OAuth token rather than the active model's provider: a
+  // signed-in user running an API-key model can still submit feedback
+  // through the authenticated channel.
+  let signedIn = false;
+  try {
+    const status = await host.harness.auth.status(DEFAULT_OAUTH_PROVIDER_NAME);
+    signedIn = status.providers.some(
+      (provider) => provider.providerName === DEFAULT_OAUTH_PROVIDER_NAME && provider.hasToken,
+    );
+  } catch {
+    // The sign-in state is unreadable — keep the feedback entry usable by
+    // falling back to GitHub Issues instead of failing the command.
+    fallback(FEEDBACK_STATUS_FALLBACK);
+    return;
+  }
+  if (!signedIn) {
+    host.showStatus(FEEDBACK_STATUS_NOT_SIGNED_IN);
+    host.showStatus(kimiCodeSignupUrl());
+    host.showStatus(FEEDBACK_ISSUE_URL);
+    return;
+  }
+
+  // Stage 1: collect the free-form feedback text.
+  const input = await promptFeedbackInput(host);
+  if (input === undefined) {
+    host.showStatus(FEEDBACK_STATUS_CANCELLED);
+    return;
+  }
+
+  // Stage 2: ask whether to attach diagnostics (logs / codebase).
+  const level = await promptFeedbackAttachment(host);
+  if (level === undefined) {
+    host.showStatus(FEEDBACK_STATUS_CANCELLED);
+    return;
+  }
+
+  const version = withFeedbackVersionPrefix(host.state.appState.version);
+  const spinner = host.showLoginProgressSpinner(FEEDBACK_STATUS_SUBMITTING);
+  // Guarantee the spinner's underlying setInterval is always cleared, even when
+  // submitFeedback throws — otherwise the interval (and its per-frame
+  // requestRender) leaks for the rest of the session.
+  let stopped = false;
+  const stopSpinner = (opts: { ok: boolean; label: string }): void => {
+    if (stopped) return;
+    stopped = true;
+    spinner.stop(opts);
+  };
+  try {
+    const res = await host.harness.auth.submitFeedback({
+      content: input.value,
+      sessionId: host.state.appState.sessionId,
+      version,
+      os: `${osType()} ${osRelease()}`,
+      model: host.state.appState.model.length > 0 ? host.state.appState.model : null,
+    });
+
+    if (res.kind !== 'ok') {
+      stopSpinner({ ok: false, label: res.message });
+      fallback(FEEDBACK_STATUS_FALLBACK);
+      return;
+    }
+
+    // Stage 3: prepare and upload each requested attachment independently.
+    // Attachment failures are non-fatal partial failures — the text feedback
+    // already exists server-side — so a throw here degrades to the
+    // partial-failure status, never to the GitHub fallback in the outer catch.
+    let attachmentFailed = false;
+    try {
+      attachmentFailed = await submitFeedbackWithAttachments(host, res.feedbackId, level);
+    } catch {
+      attachmentFailed = true;
+    }
+
+    stopSpinner({ ok: true, label: FEEDBACK_STATUS_SUCCESS });
+    host.showStatus(feedbackSessionLine(host.state.appState.sessionId));
+    host.showStatus(feedbackIdLine(res.feedbackId));
+    host.track(FEEDBACK_TELEMETRY_EVENT);
+    if (attachmentFailed) {
+      host.showStatus(FEEDBACK_STATUS_UPLOAD_FAILED);
+    }
+  } catch (error) {
+    stopSpinner({ ok: false, label: FEEDBACK_STATUS_NETWORK_ERROR });
+    fallback(FEEDBACK_STATUS_FALLBACK);
+    throw error;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Info commands
+// ---------------------------------------------------------------------------
+
+interface SessionUsageResult {
+  readonly usage?: SessionUsage;
+  readonly error?: string;
+}
+
+interface RuntimeStatusResult {
+  readonly status?: SessionStatus;
+  readonly error?: string;
+}
+
+interface ManagedUsageResult {
+  readonly usage?: ManagedUsageReport;
+  readonly error?: string;
+}
+
+export async function showUsage(host: SlashCommandHost): Promise<void> {
+  const sessionUsage = await loadSessionUsageReport(host);
+  const managedUsage = await loadManagedUsageReport(host);
+  const reportArgs = {
+    sessionUsage: sessionUsage.usage,
+    sessionUsageError: sessionUsage.error,
+    contextUsage: host.state.appState.contextUsage,
+    contextTokens: host.state.appState.contextTokens,
+    maxContextTokens: host.state.appState.maxContextTokens,
+    managedUsage: managedUsage?.usage,
+    managedUsageError: managedUsage?.error,
+  };
+  const panel = new UsagePanelComponent(() => buildUsageReportLines(reportArgs), 'primary');
+  host.state.transcriptContainer.addChild(panel);
+  host.state.ui.requestRender();
+}
+
+export async function showStatusReport(host: SlashCommandHost): Promise<void> {
+  const [runtimeStatus, managedUsage] = await Promise.all([
+    loadRuntimeStatusReport(host),
+    loadManagedUsageReport(host),
+  ]);
+  const appState = host.state.appState;
+  const reportArgs = {
+    version: appState.version,
+    model: appState.model,
+    workDir: appState.workDir,
+    sessionId: appState.sessionId,
+    sessionTitle: appState.sessionTitle,
+    thinkingEffort: appState.thinkingEffort,
+    permissionMode: appState.permissionMode,
+    planMode: appState.planMode,
+    towerMode: appState.towerMode,
+    towerAvailable: isExperimentalFlagEnabled('tower'),
+    contextUsage: appState.contextUsage,
+    contextTokens: appState.contextTokens,
+    maxContextTokens: appState.maxContextTokens,
+    availableModels: appState.availableModels,
+    status: runtimeStatus.status,
+    statusError: runtimeStatus.error,
+    managedUsage: managedUsage?.usage,
+    managedUsageError: managedUsage?.error,
+  };
+  const panel = new UsagePanelComponent(() => buildStatusReportLines(reportArgs), 'primary', ' Status ');
+  host.state.transcriptContainer.addChild(panel);
+  host.state.ui.requestRender();
+}
+
+export async function showMcpServers(host: SlashCommandHost): Promise<void> {
+  let servers: readonly McpServerInfo[];
+  try {
+    if (host.session !== undefined) {
+      servers = await host.session.listMcpServers();
+    } else {
+      // v2 session-less: the MCP connection set is workspace-scoped, so it is
+      // inspectable before the first session exists.
+      servers = await host.harness.listWorkspaceMcpServers(host.state.appState.workDir);
+    }
+  } catch (error) {
+    host.showError(`Failed to load MCP servers: ${formatErrorMessage(error)}`);
+    return;
+  }
+
+  const title = servers.length > 0 ? ` MCP (${servers.length}) ` : ' MCP ';
+  const panel = new UsagePanelComponent(
+    () => buildMcpStatusReportLines({ servers }),
+    'primary',
+    title,
+  );
+  host.state.transcriptContainer.addChild(panel);
+  host.state.ui.requestRender();
+}
+
+async function loadSessionUsageReport(host: SlashCommandHost): Promise<SessionUsageResult> {
+  if (host.session === undefined) return {};
+  try {
+    return { usage: await host.session.getUsage() };
+  } catch (error) {
+    return { error: formatErrorMessage(error) };
+  }
+}
+
+async function loadRuntimeStatusReport(host: SlashCommandHost): Promise<RuntimeStatusResult> {
+  if (host.session === undefined) return {};
+  try {
+    return { status: await host.session.getStatus() };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+async function loadManagedUsageReport(host: SlashCommandHost): Promise<ManagedUsageResult | undefined> {
+  const alias = host.state.appState.model;
+  const providerKey = host.state.appState.availableModels[alias]?.provider;
+  if (!isManagedUsageProvider(providerKey)) return undefined;
+
+  let res;
+  try {
+    res = await host.harness.auth.getManagedUsage(providerKey);
+  } catch (error) {
+    return { error: formatErrorMessage(error) };
+  }
+  if (res.kind === 'error') {
+    return { error: res.message };
+  }
+  return { usage: { rows: quotaUsageRows(res.quota), extraUsage: res.quota.extraUsage } };
+}

apps/kimi-code/src/tui/commands/parse.ts

@@ -0,0 +1,14 @@
+import type { ParsedSlashInput } from './types';
+
+export function parseSlashInput(input: string): ParsedSlashInput | null {
+  if (!input.startsWith('/')) return null;
+  const trimmed = input.slice(1).trim();
+  if (trimmed.length === 0) return null;
+  const spaceIdx = trimmed.indexOf(' ');
+  const name = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
+  const args = spaceIdx === -1 ? '' : trimmed.slice(spaceIdx + 1).trim();
+  // Reject file paths (e.g. `/usr/local/bin`), but allow namespaced plugin
+  // commands whose name itself contains `/` (e.g. `plugin:frontend/component`).
+  if (name.includes('/') && !name.includes(':')) return null;
+  return { name, args };
+}

apps/kimi-code/src/tui/commands/plugin-commands.ts

@@ -0,0 +1,27 @@
+import type { PluginCommandDef } from '@moonshot-ai/kimi-code-sdk';
+
+import type { KimiSlashCommand } from './types';
+
+export interface PluginSlashCommands {
+  readonly commands: readonly KimiSlashCommand[];
+  /** Maps a namespaced command name (`plugin:command`) to its markdown body. */
+  readonly commandMap: ReadonlyMap<string, string>;
+}
+
+export function pluginCommandName(pluginId: string, name: string): string {
+  return `${pluginId}:${name}`;
+}
+
+export function buildPluginSlashCommands(defs: readonly PluginCommandDef[]): PluginSlashCommands {
+  const commandMap = new Map<string, string>();
+  const commands = defs.map((def) => {
+    const commandName = pluginCommandName(def.pluginId, def.name);
+    commandMap.set(commandName, def.body);
+    return {
+      name: commandName,
+      aliases: [],
+      description: def.description,
+    } satisfies KimiSlashCommand;
+  });
+  return { commands, commandMap };
+}

apps/kimi-code/src/tui/commands/plugins.ts

@@ -0,0 +1,901 @@
+import { homedir as osHomedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+
+import {
+  log,
+  type CapabilityStatus,
+  type PluginInfo,
+  type PluginSummary,
+  type Session,
+} from '@moonshot-ai/kimi-code-sdk';
+import { Markdown, Spacer } from '@moonshot-ai/pi-tui';
+
+import {
+  PluginInstallTrustConfirmComponent,
+  PluginMcpSelectorComponent,
+  PluginRemoveConfirmComponent,
+  PluginsPanelComponent,
+  type PluginInstallTrustConfirmResult,
+  type PluginMcpSelection,
+  type PluginRemoveConfirmResult,
+  type PluginsPanelSelection,
+  type PluginsPanelTabId,
+} from '../components/dialogs/plugins-selector';
+import {
+  buildPluginsInfoLines,
+  buildPluginsListLines,
+} from '../components/messages/plugins-status-panel';
+import { UsagePanelComponent } from '../components/messages/usage-panel';
+import { createMarkdownTheme } from '../theme/pi-tui-theme';
+import { formatErrorMessage } from '../utils/event-payload';
+import { createMarkdownOptions } from '../utils/markdown-options';
+import {
+  formatPluginSourceLabel,
+  isOfficialPluginInstall,
+  isOfficialPluginSource,
+} from '../utils/plugin-source-label';
+import {
+  KIMI_CODE_PLUGIN_MARKETPLACE_URL_ENV,
+  QUOTA_CONSUMING_PLUGIN_IDS,
+} from '#/constant/app';
+import {
+  loadPluginMarketplace,
+  withBuiltInEntries,
+  withMarketplaceLatestVersions,
+  type PluginMarketplace,
+  type PluginMarketplaceEntry,
+} from '#/utils/plugin-marketplace';
+import { openUrl } from '#/utils/open-url';
+import type { SlashCommandHost } from './dispatch';
+
+interface ShowPluginsPickerOptions {
+  readonly selectedId?: string;
+  readonly pluginHint?: {
+    readonly id: string;
+    readonly text: string;
+  };
+  readonly initialTab?: PluginsPanelTabId;
+  readonly marketplaceSource?: string;
+}
+
+interface PluginMcpServerHint {
+  readonly server: string;
+  readonly text: string;
+}
+
+interface ShowPluginMcpPickerOptions {
+  readonly selectedServer?: string;
+  readonly serverHint?: PluginMcpServerHint;
+}
+
+/** The plugin-management surface `/plugins` operates on. */
+type PluginApi = Pick<
+  Session,
+  | 'listPlugins'
+  | 'installPlugin'
+  | 'setPluginEnabled'
+  | 'setPluginMcpServerEnabled'
+  | 'removePlugin'
+  | 'reloadPlugins'
+  | 'getPluginInfo'
+>;
+
+/**
+ * Resolve the plugin-management API. Plugin state is app-global, so a
+ * session-less startup still gets a working `/plugins` through the harness's
+ * global facade; once a session exists the session's own API is used.
+ */
+async function resolvePluginApi(host: SlashCommandHost): Promise<PluginApi> {
+  if (host.session !== undefined) return host.session;
+  return {
+    listPlugins: () => host.harness.listPlugins(),
+    installPlugin: (source) => host.harness.installPlugin(source),
+    setPluginEnabled: (id, enabled) => host.harness.setPluginEnabled(id, enabled),
+    setPluginMcpServerEnabled: (id, server, enabled) =>
+      host.harness.setPluginMcpServerEnabled(id, server, enabled),
+    removePlugin: (id) => host.harness.removePlugin(id),
+    reloadPlugins: () => host.harness.reloadPlugins(),
+    getPluginInfo: (id) => host.harness.getPluginInfo(id),
+  };
+}
+
+export async function handlePluginsCommand(host: SlashCommandHost, rawArgs: string): Promise<void> {
+  const args = rawArgs.trim().split(/\s+/).filter((part) => part.length > 0);
+  const sub = args[0];
+  const rest = args.slice(1);
+  const session = await resolvePluginApi(host);
+
+  try {
+    if (sub === undefined) {
+      await showPluginsPicker(host);
+      return;
+    }
+    if (sub === 'list') {
+      await renderPluginsList(host);
+      return;
+    }
+    if (sub === 'install') {
+      const source = rest.join(' ').trim();
+      if (source.length === 0) {
+        host.showError('Usage: /plugins install <local-path-or-zip-url>');
+        return;
+      }
+      if (!(await confirmInstallTrust(host, source, isOfficialPluginSource(source)))) {
+        host.showStatus('Install cancelled.');
+        return;
+      }
+      const spinner = host.showProgressSpinner(`Installing plugin from ${truncateForStatus(source)}…`);
+      try {
+        await installPluginFromSource(host, source);
+        spinner.stop({ ok: true, label: `Install finished — see details below.` });
+      } catch (error) {
+        spinner.stop({ ok: false, label: `Install failed: ${formatErrorMessage(error)}` });
+        throw error;
+      }
+      return;
+    }
+    if (sub === 'marketplace') {
+      const marketplaceSource = rest.join(' ').trim() || undefined;
+      await showPluginsPicker(host, {
+        // Custom marketplaces often omit `tier`, so their entries land on the
+        // Curated tab (entry.tier !== 'official'). Open there when a custom
+        // source is supplied; otherwise the default catalog's official entries
+        // make Official the right landing tab.
+        initialTab: marketplaceSource === undefined ? 'official' : 'third-party',
+        marketplaceSource,
+      });
+      return;
+    }
+    if (sub === 'info') {
+      const id = rest[0];
+      if (id === undefined) {
+        await showPluginsPicker(host);
+        return;
+      }
+      await renderPluginInfo(host, id);
+      return;
+    }
+    if (sub === 'mcp') {
+      const action = rest[0];
+      const id = rest[1];
+      const server = rest[2];
+      if ((action !== 'enable' && action !== 'disable') || id === undefined || server === undefined) {
+        host.showError('Usage: /plugins mcp enable|disable <id> <server>');
+        return;
+      }
+      await session.setPluginMcpServerEnabled(id, server, action === 'enable');
+      host.showStatus(
+        `${action === 'enable' ? 'Enabled' : 'Disabled'} MCP server ${server} for ${id}. Run /reload or /new to apply.`,
+      );
+      return;
+    }
+    if (sub === 'enable' || sub === 'disable') {
+      const id = rest[0];
+      if (id === undefined) {
+        await showPluginsPicker(host);
+        return;
+      }
+      await applyPluginEnabled(host, id, sub === 'enable');
+      return;
+    }
+    if (sub === 'remove') {
+      const id = rest[0];
+      if (id === undefined) {
+        host.showError('Usage: /plugins remove <id>');
+        return;
+      }
+      if (!(await confirmRemovePlugin(host, id))) {
+        host.showStatus(`Remove cancelled: ${id}.`);
+        return;
+      }
+      await removePlugin(host, id);
+      return;
+    }
+    if (sub === 'reload') {
+      await reloadPlugins(host);
+      return;
+    }
+    const plugins = await session.listPlugins();
+    if (plugins.some((plugin) => plugin.id === sub)) {
+      await renderPluginInfo(host, sub);
+      return;
+    }
+    host.showError(`Unknown /plugins action: ${sub}. Run /plugins to choose interactively.`);
+  } catch (error) {
+    host.showError(`/plugins ${sub ?? ''} failed: ${formatErrorMessage(error)}`);
+  }
+}
+
+/**
+ * Resolve the capability API. Like plugin state, capability state is
+ * app-global on the v2 engine, so a session-less startup still gets
+ * readiness and installs through the harness's global facade; with a live
+ * session the session's own API is used.
+ */
+type CapabilityApi = Pick<Session, 'listCapabilities' | 'getCapability' | 'installCapability'>;
+
+async function resolveCapabilityApi(host: SlashCommandHost): Promise<CapabilityApi> {
+  if (host.session !== undefined) return host.session;
+  return host.harness;
+}
+
+function logCapabilityStatus(capability: CapabilityStatus, installed?: boolean): void {
+  const payload = {
+    capabilityId: capability.id,
+    pluginId: capability.pluginId,
+    installed,
+    supported: capability.supported,
+    state: capability.state,
+    version: capability.version,
+    install: capability.install,
+    steps: capability.steps,
+  };
+  const hasStepIssues = capability.steps.some((step) => step.state !== 'ok');
+  if (
+    capability.install.error !== undefined ||
+    (installed !== false && hasStepIssues)
+  ) {
+    log.warn('capability needs attention', payload);
+  } else {
+    log.info('capability status', payload);
+  }
+}
+
+async function showPluginsPicker(
+  host: SlashCommandHost,
+  options?: ShowPluginsPickerOptions,
+): Promise<void> {
+  let plugins: readonly PluginSummary[];
+  try {
+    plugins = await (await resolvePluginApi(host)).listPlugins();
+  } catch (error) {
+    host.showError(`Failed to load plugins: ${formatErrorMessage(error)}`);
+    return;
+  }
+
+  let capabilities: readonly CapabilityStatus[] = [];
+  try {
+    capabilities = await (await resolveCapabilityApi(host)).listCapabilities();
+  } catch (error) {
+    log.warn('capability status unavailable', { error });
+  }
+
+  const installedIds = new Set(plugins.map((plugin) => plugin.id));
+  for (const capability of capabilities) {
+    logCapabilityStatus(capability, installedIds.has(capability.pluginId ?? capability.id));
+  }
+
+  const panel = new PluginsPanelComponent({
+    installed: plugins,
+    installedIds,
+    capabilities,
+    catalogIsDefault: isDefaultMarketplaceCatalog(options?.marketplaceSource),
+    initialTab: options?.initialTab,
+    selectedId: options?.selectedId,
+    pluginHint: options?.pluginHint,
+    onSelect: (selection) => {
+      // Each branch of the handler either mounts the next view or restores the
+      // editor itself, so do not pre-restore here — that would flash the editor
+      // for in-place actions like toggling a plugin.
+      void handlePluginsPanelSelection(host, panel, selection).catch((error: unknown) => {
+        host.showError(`/plugins failed: ${formatErrorMessage(error)}`);
+      });
+    },
+    onCancel: () => {
+      host.restoreEditor();
+    },
+    // Every tab except Custom needs the catalog: Official/Curated list it,
+    // and Installed uses it to show update badges. The Installed/Custom tabs
+    // keep working even when the marketplace is unreachable (badges simply stay
+    // hidden until data arrives).
+    onRequestMarketplace: () => {
+      void loadMarketplaceCatalog(host, panel, options?.marketplaceSource, capabilities);
+    },
+  });
+  host.mountEditorReplacement(panel);
+  // Kick off the catalog fetch for any tab that needs it: Installed uses it for
+  // update badges, Official/Curated list it. Custom never reads the catalog,
+  // so skip the fetch there. Done here (after `panel` is initialized) rather
+  // than inside the component constructor, because the callback above closes
+  // over `panel`.
+  if (options?.initialTab !== 'custom') {
+    panel.setMarketplaceLoading();
+    void loadMarketplaceCatalog(host, panel, options?.marketplaceSource, capabilities);
+  }
+}
+
+/**
+ * Adapt a capability from the engine's registry into a catalog row. The
+ * engine is the single source of truth for what the built-in capabilities
+ * are — the CLI only renders them. The `capability:<id>` source marker
+ * routes installs through the capability flow (never a plain plugin
+ * install), so the row needs no real URL.
+ */
+function capabilityMarketplaceEntry(capability: CapabilityStatus): PluginMarketplaceEntry {
+  return {
+    id: capability.id,
+    displayName: capability.displayName,
+    description: capability.description,
+    tier: 'official',
+    source: `capability:${capability.id}`,
+    builtIn: true,
+  };
+}
+
+/**
+ * Injection is part of the DEFAULT catalog experience only: any explicit
+ * replacement (the slash-command source or a user-set env override) opts out
+ * wholesale. The dev marketplace server started by scripts/dev.mjs serves
+ * this repo's own catalog and marks itself, so it still counts as default.
+ */
+function isDefaultMarketplaceCatalog(
+  source: string | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if (source !== undefined) return false;
+  if (env[KIMI_CODE_PLUGIN_MARKETPLACE_URL_ENV] === undefined) return true;
+  return env['KIMI_CODE_PLUGIN_MARKETPLACE_FROM_DEV_SERVER'] === '1';
+}
+
+async function loadMarketplaceCatalog(
+  host: SlashCommandHost,
+  panel: PluginsPanelComponent,
+  source: string | undefined,
+  capabilities: readonly CapabilityStatus[],
+): Promise<void> {
+  const builtInEntries = isDefaultMarketplaceCatalog(source)
+    ? capabilities.map(capabilityMarketplaceEntry)
+    : undefined;
+  let marketplace: PluginMarketplace;
+  let catalog: PluginMarketplace;
+  try {
+    // Phase 1: render the catalog as soon as it arrives. Version lookups
+    // (GitHub releases/latest round trips) must not gate the first paint.
+    // Keep the raw parsed catalog for phase 2: injecting built-ins first
+    // would mask the matching catalog entries' GitHub sources behind
+    // `capability:<id>` rows, making their versions unresolvable.
+    catalog = await loadPluginMarketplace({
+      workDir: host.state.appState.workDir,
+      source,
+      skipLatestVersions: true,
+    });
+    marketplace =
+      builtInEntries !== undefined ? withBuiltInEntries(catalog, builtInEntries) : catalog;
+    panel.setMarketplace(marketplace.plugins, marketplace.source);
+    host.state.ui.requestRender();
+  } catch (error) {
+    // Any phase-1 failure (unreachable OR malformed catalog) surfaces as an
+    // error: the panel keeps built-in capability rows installable in the
+    // Official tab while the error is shown, and a broken catalog must not
+    // be masked as a successfully loaded, built-ins-only marketplace.
+    panel.setMarketplaceError(formatErrorMessage(error));
+    host.state.ui.requestRender();
+    return;
+  }
+  try {
+    // Phase 2: resolve latest versions in the background (against the raw
+    // catalog), re-apply the built-in injection so resolved versions flow
+    // onto capability rows, then refresh so update badges appear. Failures
+    // degrade to badge-less rows and never clobber the rendered list.
+    const enrichedCatalog = await withMarketplaceLatestVersions(catalog);
+    const enriched =
+      builtInEntries !== undefined
+        ? withBuiltInEntries(enrichedCatalog, builtInEntries)
+        : enrichedCatalog;
+    panel.setMarketplace(enriched.plugins, enriched.source);
+  } catch (error) {
+    log.warn('marketplace version lookup failed', { error });
+  }
+  host.state.ui.requestRender();
+}
+
+async function showPluginMcpPicker(
+  host: SlashCommandHost,
+  id: string,
+  options?: ShowPluginMcpPickerOptions,
+): Promise<void> {
+  let info: PluginInfo;
+  try {
+    info = await (await resolvePluginApi(host)).getPluginInfo(id);
+  } catch (error) {
+    host.showError(`Failed to load plugin MCP servers: ${formatErrorMessage(error)}`);
+    return;
+  }
+
+  host.mountEditorReplacement(
+    new PluginMcpSelectorComponent({
+      info,
+      selectedServer: options?.selectedServer,
+      serverHint: options?.serverHint,
+      onSelect: (selection) => {
+        // Every MCP action re-mounts a picker, so let the handler do the
+        // mounting — pre-restoring the editor here would flash on toggle.
+        void handlePluginMcpSelection(host, selection).catch((error: unknown) => {
+          host.showError(`/plugins mcp failed: ${formatErrorMessage(error)}`);
+        });
+      },
+      onCancel: () => {
+        host.restoreEditor();
+        void showPluginsPicker(host, { selectedId: id });
+      },
+    }),
+  );
+}
+
+async function confirmRemovePlugin(host: SlashCommandHost, id: string): Promise<boolean> {
+  let displayName = id;
+  try {
+    displayName = (await (await resolvePluginApi(host)).getPluginInfo(id)).displayName;
+  } catch {
+    // Keep the confirmation available even when plugin details cannot be loaded.
+  }
+
+  return new Promise((resolveConfirmed) => {
+    host.mountEditorReplacement(
+      new PluginRemoveConfirmComponent({
+        id,
+        displayName,
+        onDone: (result: PluginRemoveConfirmResult) => {
+          host.restoreEditor();
+          resolveConfirmed(result.kind === 'confirm');
+        },
+      }),
+    );
+  });
+}
+
+async function confirmInstallTrust(
+  host: SlashCommandHost,
+  label: string,
+  official: boolean,
+): Promise<boolean> {
+  // Kimi-built official plugins are trusted implicitly; anything else requires
+  // the user to explicitly opt in via the trust prompt.
+  if (official) return true;
+  return new Promise((resolveConfirmed) => {
+    host.mountEditorReplacement(
+      new PluginInstallTrustConfirmComponent({
+        label,
+        onDone: (result: PluginInstallTrustConfirmResult) => {
+          host.restoreEditor();
+          resolveConfirmed(result.kind === 'confirm');
+        },
+      }),
+    );
+  });
+}
+
+const CAPABILITY_POLL_INTERVAL_MS = 700;
+const CAPABILITY_POLL_ATTEMPTS = 260; // ~3 minutes of runtime setup budget
+
+/** Client-injected v2 entries install their runtime and plugin together.
+ * Trust keys on the parser-proof `builtIn` flag — the `capability:<id>`
+ * source string stays purely diagnostic. */
+function isCapabilityEntry(entry: PluginMarketplaceEntry): boolean {
+  return entry.builtIn === true;
+}
+
+/**
+ * Closed-set plugin id check for the post-remove note. What must not happen
+ * is answering membership by running `listCapabilities()`, which fires every
+ * entry's detector (seconds of probes) just to print one hint line.
+ */
+function isCapabilityPluginId(id: string): boolean {
+  return id === 'kimi-cu' || id === 'kimi-cu-win' || id === 'kimi-webbridge';
+}
+
+/** Poll a background capability install until it settles (or we run out of budget). */
+async function pollCapabilityInstall(
+  host: SlashCommandHost,
+  id: string,
+): Promise<CapabilityStatus | undefined> {
+  const api = await resolveCapabilityApi(host);
+  let previousProgress = '';
+  for (let attempt = 0; attempt < CAPABILITY_POLL_ATTEMPTS; attempt += 1) {
+    await new Promise((resolve) => {
+      setTimeout(resolve, CAPABILITY_POLL_INTERVAL_MS);
+    });
+    const status = await api.getCapability(id);
+    if (!status.install.running) return status;
+    const progress = `${status.install.step ?? ''}:${status.install.percent ?? ''}`;
+    if (progress !== previousProgress) {
+      previousProgress = progress;
+      log.info('capability install progress', {
+        capabilityId: id,
+        step: status.install.step,
+        percent: status.install.percent,
+      });
+    }
+  }
+  return undefined;
+}
+
+export const __pluginsCommandInternals = {
+  isCapabilityEntry,
+  installCapabilityFromPanel,
+  isDefaultMarketplaceCatalog,
+  pollCapabilityInstall,
+  removePlugin,
+};
+
+async function installCapabilityFromPanel(
+  host: SlashCommandHost,
+  panel: PluginsPanelComponent,
+  entry: PluginMarketplaceEntry,
+): Promise<void> {
+  const label = entry.displayName;
+  // Capability entries are official by construction; the trust prompt is
+  // reserved for unreviewed third-party plugins.
+  panel.setInstalling(truncateForStatus(label));
+  host.state.ui.requestRender();
+  const api = await resolveCapabilityApi(host);
+  log.info('capability install requested', { capabilityId: entry.id });
+  try {
+    // An install already running (started from another panel or client) is
+    // followed, not restarted — the service rejects duplicate starts even
+    // though the original is healthy.
+    const alreadyRunning = await api
+      .getCapability(entry.id)
+      .then((status) => status.install.running, () => false);
+    if (!alreadyRunning) {
+      await api.installCapability(entry.id);
+    } else {
+      log.info('following running capability install', { capabilityId: entry.id });
+    }
+  } catch (error) {
+    log.warn('capability install failed to start', { capabilityId: entry.id, error });
+    panel.clearInstalling();
+    host.state.ui.requestRender();
+    host.showError(`Failed to install ${label}: ${formatErrorMessage(error)}`);
+    host.restoreEditor();
+    return;
+  }
+  let result: CapabilityStatus | undefined;
+  try {
+    result = await pollCapabilityInstall(host, entry.id);
+  } catch (error) {
+    log.warn('capability install polling failed', { capabilityId: entry.id, error });
+    result = undefined;
+  }
+  panel.clearInstalling();
+  // Close the panel so the result lines land in the transcript, matching the
+  // plain plugin install flow.
+  host.restoreEditor();
+  if (result === undefined) {
+    host.showStatus(`${label} installation is still running in the background.`);
+    return;
+  }
+  logCapabilityStatus(result);
+  if (result.install.error !== undefined) {
+    host.showError(`${label} installation failed: ${result.install.error}`);
+    host.showStatus('Fix the reported error, then install again from /plugins.', 'warning');
+    return;
+  }
+  if (result.state !== 'ready') {
+    const permissionsRequired =
+      entry.id === 'kimi-cu' &&
+      result.steps.some((step) => step.id === 'permissions' && step.state !== 'ok');
+    if (permissionsRequired) {
+      host.showStatus(
+        'Grant Accessibility and Screen Recording in System Settings → Privacy & Security.',
+        'warning',
+      );
+    } else {
+      host.showError(
+        `${label} installation did not complete. Check the logs and install again from /plugins.`,
+      );
+    }
+    host.showStatus(PLUGIN_RELOAD_HINT, 'warning');
+    return;
+  }
+  if (entry.id === 'kimi-webbridge') {
+    host.showNotice(`${label} is installed.`);
+    host.state.transcriptContainer.addChild(new Spacer(1));
+    host.state.transcriptContainer.addChild(
+      new Markdown(WEBBRIDGE_POST_INSTALL_MARKDOWN, 2, 0, createMarkdownTheme(), undefined, createMarkdownOptions()),
+    );
+    host.state.ui.requestRender();
+    return;
+  }
+  host.showStatus(`${label} is installed.`);
+  host.showStatus(PLUGIN_RELOAD_HINT, 'warning');
+}
+
+async function installFromPanel(
+  host: SlashCommandHost,
+  panel: PluginsPanelComponent,
+  source: string,
+  label: string,
+  official: boolean,
+): Promise<void> {
+  if (!(await confirmInstallTrust(host, label, official))) {
+    host.showStatus(`Install cancelled: ${label}.`);
+    host.restoreEditor();
+    return;
+  }
+  // Official installs keep the panel mounted and show the inline installing
+  // state; third-party installs pass through a trust prompt that replaces the
+  // panel, so fall back to a transcript status for those.
+  if (official) {
+    panel.setInstalling(truncateForStatus(label));
+  } else {
+    host.showStatus(`Installing or updating ${label} from marketplace…`);
+  }
+  host.state.ui.requestRender();
+  try {
+    await installPluginFromSource(host, source);
+  } catch (error) {
+    if (official) {
+      panel.clearInstalling();
+      host.state.ui.requestRender();
+    } else {
+      // The trust prompt replaced the panel; re-mount it so the user can retry
+      // instead of being dropped back at the editor.
+      host.mountEditorReplacement(panel);
+    }
+    host.showError(`Failed to install ${label}: ${formatErrorMessage(error)}`);
+    return;
+  }
+  // Close the panel after installing so the result status and the
+  // "/reload or /new" tip are visible in the transcript.
+  host.restoreEditor();
+}
+
+async function applyPluginEnabled(
+  host: SlashCommandHost,
+  id: string,
+  enabled: boolean,
+  showStatus = true,
+): Promise<string> {
+  const session = await resolvePluginApi(host);
+  await session.setPluginEnabled(id, enabled);
+  let info: PluginInfo | undefined;
+  try {
+    info = await session.getPluginInfo(id);
+  } catch {
+    info = undefined;
+  }
+  const mcpHint =
+    enabled && info !== undefined && info.mcpServerCount > info.enabledMcpServerCount
+      ? ` Some MCP servers are disabled; re-enable with /plugins mcp enable ${id} <server>.`
+      : '';
+  if (showStatus) {
+    host.showStatus(`${enabled ? 'Enabled' : 'Disabled'} ${id}. Run /reload or /new to apply.${mcpHint}`);
+  }
+  const inlineMcpHint = mcpHint.length > 0 ? ' · MCP servers disabled' : '';
+  return `${pluginInlineChangeHint()}${inlineMcpHint}`;
+}
+
+async function handlePluginsPanelSelection(
+  host: SlashCommandHost,
+  panel: PluginsPanelComponent,
+  selection: PluginsPanelSelection,
+): Promise<void> {
+  switch (selection.kind) {
+    case 'toggle': {
+      const hint = await applyPluginEnabled(host, selection.id, selection.enabled, false);
+      await showPluginsPicker(host, {
+        initialTab: 'installed',
+        selectedId: selection.id,
+        pluginHint: { id: selection.id, text: hint },
+      });
+      return;
+    }
+    case 'remove':
+      if (!(await confirmRemovePlugin(host, selection.id))) {
+        host.showStatus(`Remove cancelled: ${selection.id}.`);
+        await showPluginsPicker(host, { initialTab: 'installed', selectedId: selection.id });
+        return;
+      }
+      await removePlugin(host, selection.id);
+      await showPluginsPicker(host, { initialTab: 'installed' });
+      return;
+    case 'mcp':
+      await showPluginMcpPicker(host, selection.id);
+      return;
+    case 'details':
+      host.restoreEditor();
+      await renderPluginInfo(host, selection.id);
+      return;
+    case 'reload':
+      await reloadPlugins(host);
+      await showPluginsPicker(host, { initialTab: 'installed' });
+      return;
+    case 'install':
+      if (isCapabilityEntry(selection.entry)) {
+        await installCapabilityFromPanel(host, panel, selection.entry);
+        return;
+      }
+      await installFromPanel(
+        host,
+        panel,
+        selection.entry.source,
+        selection.entry.displayName,
+        isOfficialPluginSource(selection.entry.source),
+      );
+      return;
+    case 'install-source':
+      await installFromPanel(
+        host,
+        panel,
+        selection.source,
+        selection.source,
+        isOfficialPluginSource(selection.source),
+      );
+      return;
+    case 'open-url':
+      host.restoreEditor();
+      openUrl(selection.url);
+      host.showStatus(`Opening the ${selection.label} page in your browser…`, 'success');
+      host.showStatus(`If it did not open, visit ${selection.url}`);
+      return;
+  }
+}
+
+async function handlePluginMcpSelection(
+  host: SlashCommandHost,
+  selection: PluginMcpSelection,
+): Promise<void> {
+  switch (selection.kind) {
+    case 'toggle':
+      await (
+        await resolvePluginApi(host)
+      ).setPluginMcpServerEnabled(selection.pluginId, selection.server, selection.enabled);
+      await showPluginMcpPicker(host, selection.pluginId, {
+        selectedServer: selection.server,
+        serverHint: {
+          server: selection.server,
+          text: pluginInlineChangeHint(),
+        },
+      });
+      return;
+    case 'back':
+      await showPluginsPicker(host, { selectedId: selection.pluginId });
+      return;
+  }
+}
+
+async function removePlugin(host: SlashCommandHost, id: string): Promise<void> {
+  await (await resolvePluginApi(host)).removePlugin(id);
+  host.showStatus(`Removed ${id}.`);
+  if (isCapabilityPluginId(id)) {
+    host.showStatus(
+      'Note: the runtime binaries were left untouched, but Kimi Code plugin wiring is disabled for new sessions. Restart Kimi Code before reinstalling from the Official tab.',
+    );
+    return;
+  }
+  host.showStatus(PLUGIN_RELOAD_HINT, 'warning');
+}
+
+async function renderPluginsList(
+  host: SlashCommandHost,
+  plugins?: readonly PluginSummary[],
+): Promise<void> {
+  const currentPlugins = plugins ?? (await (await resolvePluginApi(host)).listPlugins());
+  const title = ` Plugins (${currentPlugins.length}) `;
+  const panel = new UsagePanelComponent(
+    () => buildPluginsListLines({ plugins: currentPlugins }),
+    'primary',
+    title,
+  );
+  host.state.transcriptContainer.addChild(panel);
+  host.state.ui.requestRender();
+}
+
+async function renderPluginInfo(host: SlashCommandHost, id: string): Promise<void> {
+  const info = await (await resolvePluginApi(host)).getPluginInfo(id);
+  const panel = new UsagePanelComponent(
+    () => buildPluginsInfoLines({ info }),
+    'primary',
+    ` ${info.id} `,
+  );
+  host.state.transcriptContainer.addChild(panel);
+  host.state.ui.requestRender();
+}
+
+async function installPluginFromSource(
+  host: SlashCommandHost,
+  source: string,
+): Promise<void> {
+  const session = await resolvePluginApi(host);
+  const beforeList = await session.listPlugins();
+  const summary = await session.installPlugin(
+    resolvePluginInstallSource(source, host.state.appState.workDir),
+  );
+  showPluginInstallResult(host, beforeList, summary);
+}
+
+const PLUGIN_RELOAD_HINT = 'Run /new or /reload to apply plugin changes.';
+
+const WEBBRIDGE_POST_INSTALL_MARKDOWN = [
+  '*Two steps left to use Kimi Browser Extension:*',
+  '1. Install the browser extension',
+  '',
+  '   - [Chrome Web Store](https://chromewebstore.google.com/detail/kimi-webbridge/fldmhceldgbpfpkbgopacenieobmligc)',
+  '   - [Edge Add-ons](https://microsoftedge.microsoft.com/addons/detail/kimi-webbridge/bnlffdbcfnanfbknnlaflhlhkocccckg)',
+  '   - [Manual installation guide](https://www.kimi.com/code/docs/kimi-code-cli/customization/plugins.html#install-the-browser-extension)',
+  '',
+  '2. Run `/reload` or `/new` to apply it.',
+].join('\n');
+
+const PLUGIN_QUOTA_NOTE = 'Note: This plugin consumes your quota.';
+
+function showPluginInstallResult(
+  host: SlashCommandHost,
+  beforeList: readonly PluginSummary[],
+  summary: PluginSummary,
+): void {
+  const previous = beforeList.find((entry) => entry.id === summary.id);
+  const serverWord = summary.mcpServerCount === 1 ? 'server' : 'servers';
+  const mcpHint =
+    summary.mcpServerCount > 0
+      ? ` Declares ${summary.mcpServerCount} MCP ${serverWord}; enabled by default and configurable from /plugins.`
+      : '';
+  const action = describeInstallAction(previous, summary);
+  host.showStatus(`${action} (${summary.id}).${mcpHint}`);
+  host.showStatus(PLUGIN_RELOAD_HINT, 'warning');
+  // Gate on provenance, not just the id: a local/GitHub fork whose manifest
+  // reuses a billed plugin's id is not the official quota-consuming build.
+  if (QUOTA_CONSUMING_PLUGIN_IDS.includes(summary.id) && isOfficialPluginInstall(summary)) {
+    host.showStatus(PLUGIN_QUOTA_NOTE, 'warning');
+  }
+}
+
+function describeInstallAction(
+  previous: PluginSummary | undefined,
+  next: PluginSummary,
+): string {
+  const sourceLabel = formatPluginSourceLabel(next);
+  const versionFromTo = (prev?: string, cur?: string): string => {
+    if (prev === undefined || prev === cur) return cur === undefined ? '' : ` ${cur}`;
+    return ` ${prev} → ${cur ?? '-'}`;
+  };
+  if (previous === undefined) {
+    return `Installed ${next.displayName}${versionFromTo(undefined, next.version)} ${sourcePhrase(sourceLabel)}`;
+  }
+  if (sourceIdentity(previous) !== sourceIdentity(next)) {
+    const prevSourceLabel = formatPluginSourceLabel(previous);
+    return `Migrated ${next.displayName}: ${prevSourceLabel} → ${sourceLabel}${versionFromTo(previous.version, next.version)}`;
+  }
+  return `Updated ${next.displayName}${versionFromTo(previous.version, next.version)} ${sourcePhrase(sourceLabel)}`;
+}
+
+// formatPluginSourceLabel already prefixes zip-url hosts with "via", so adding
+// "from" would read as "from via <host>". Only prepend "from" otherwise.
+function sourcePhrase(sourceLabel: string): string {
+  return sourceLabel.startsWith('via ') ? sourceLabel : `from ${sourceLabel}`;
+}
+
+function sourceIdentity(plugin: PluginSummary): string {
+  if (plugin.source === 'github' && plugin.github !== undefined) {
+    return `github:${plugin.github.owner}/${plugin.github.repo}`;
+  }
+  return plugin.source;
+}
+
+function truncateForStatus(input: string): string {
+  const max = 80;
+  return input.length > max ? `${input.slice(0, max - 1)}…` : input;
+}
+
+async function reloadPlugins(host: SlashCommandHost): Promise<void> {
+  const summary = await (await resolvePluginApi(host)).reloadPlugins();
+  const line = `Reload: +${summary.added.length} -${summary.removed.length}` +
+    (summary.errors.length > 0 ? ` (${summary.errors.length} errors)` : '');
+  host.showStatus(line);
+  // Rebuild the TUI's plugin slash-command list from the reloaded service so
+  // newly added/enabled commands resolve in this session-less UI right away.
+  await host.refreshPluginCommands(host.session);
+}
+
+function resolvePluginInstallSource(source: string, workDir: string): string {
+  const trimmed = source.trim();
+  if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) return trimmed;
+  if (trimmed === '~') return osHomedir();
+  if (trimmed.startsWith('~/')) return join(osHomedir(), trimmed.slice(2));
+  return isAbsolute(trimmed) ? trimmed : resolve(workDir, trimmed);
+}
+
+function pluginInlineChangeHint(): string {
+  return 'run /reload or /new to apply';
+}

apps/kimi-code/src/tui/commands/prompts.ts

@@ -0,0 +1,251 @@
+import {
+  catalogModelToAlias,
+  resolveCatalogImport,
+  type Catalog,
+  type CatalogModel,
+  type ModelAlias,
+  type ThinkingEffort,
+} from '@moonshot-ai/kimi-code-sdk';
+import { capabilitiesForModel } from '@moonshot-ai/kimi-code-oauth';
+import type {
+  ManagedKimiCodeModelInfo,
+  OpenPlatformDefinition,
+} from '@moonshot-ai/kimi-code-oauth';
+
+import { ApiKeyInputDialogComponent, type ApiKeyInputResult } from '../components/dialogs/api-key-input-dialog';
+import { ChoicePickerComponent, type ChoiceOption } from '../components/dialogs/choice-picker';
+import { FeedbackInputDialogComponent, type FeedbackInputDialogResult } from '../components/dialogs/feedback-input-dialog';
+import { ModelSelectorComponent } from '../components/dialogs/model-selector';
+import { PlatformSelectorComponent } from '../components/dialogs/platform-selector';
+import type { SlashCommandHost } from './dispatch';
+
+export function promptPlatformSelection(host: SlashCommandHost): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    const selector = new PlatformSelectorComponent({
+      onSelect: (platformId) => {
+        host.restoreEditor();
+        resolve(platformId);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+        resolve(undefined);
+      },
+    });
+    host.mountEditorReplacement(selector);
+  });
+}
+
+export function promptLogoutProviderSelection(
+  host: SlashCommandHost,
+  options: readonly ChoiceOption[],
+  currentValue: string | undefined,
+): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    const picker = new ChoicePickerComponent({
+      title: 'Select a provider to log out',
+      options,
+      currentValue,
+      onSelect: (value) => {
+        host.restoreEditor();
+        resolve(value);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+        resolve(undefined);
+      },
+    });
+    host.mountEditorReplacement(picker);
+  });
+}
+
+export interface FeedbackPromptResult {
+  readonly value: string;
+}
+
+export function promptFeedbackInput(host: SlashCommandHost): Promise<FeedbackPromptResult | undefined> {
+  return new Promise((resolve) => {
+    const dialog = new FeedbackInputDialogComponent((result: FeedbackInputDialogResult) => {
+      host.restoreEditor();
+      resolve(result.kind === 'ok' ? { value: result.value } : undefined);
+    });
+    host.mountEditorReplacement(dialog);
+  });
+}
+
+export type FeedbackAttachmentLevel = 'none' | 'logs' | 'logs+codebase';
+
+const FEEDBACK_ATTACHMENT_OPTIONS: readonly ChoiceOption[] = [
+  { value: 'none', label: 'No attachment', description: 'Text feedback only' },
+  {
+    value: 'logs',
+    label: 'Logs only',
+    description: 'Upload wire events and diagnostic logs from this session',
+  },
+  {
+    value: 'logs+codebase',
+    label: 'Logs + codebase',
+    description:
+      'Include your codebase for deeper diagnosis. Sensitive files are automatically excluded — e.g. .env, config files, secret keys. We use attachments only for diagnosis and never share them.',
+    descriptionTone: 'warning',
+  },
+];
+
+export function promptFeedbackAttachment(
+  host: SlashCommandHost,
+): Promise<FeedbackAttachmentLevel | undefined> {
+  return new Promise((resolve) => {
+    const picker = new ChoicePickerComponent({
+      title: 'Share diagnostic info to help us investigate?',
+      options: FEEDBACK_ATTACHMENT_OPTIONS,
+      onSelect: (value) => {
+        host.restoreEditor();
+        resolve(value as FeedbackAttachmentLevel);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+        resolve(undefined);
+      },
+    });
+    host.mountEditorReplacement(picker);
+  });
+}
+
+export function promptApiKey(
+  host: SlashCommandHost,
+  platformName: string,
+  subtitleLines: readonly string[] = ['Your key will be saved to ~/.kimi-code/config.toml'],
+): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    const dialog = new ApiKeyInputDialogComponent(
+      platformName,
+      subtitleLines,
+      (result: ApiKeyInputResult) => {
+        host.restoreEditor();
+        resolve(result.kind === 'ok' ? result.value : undefined);
+      },
+    );
+    host.mountEditorReplacement(dialog);
+  });
+}
+
+/**
+ * Asks for the provider endpoint the catalog did not declare (or declared
+ * only as an env placeholder) — required for catalog imports whose protocol
+ * was guessed, where the built-in default endpoint would point at the wrong
+ * host. Esc cancels the import.
+ */
+export function promptBaseUrl(host: SlashCommandHost, platformName: string): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    const dialog = new ApiKeyInputDialogComponent(
+      platformName,
+      ['The catalog declares no endpoint for this provider — enter its base URL.'],
+      (result: ApiKeyInputResult) => {
+        host.restoreEditor();
+        resolve(result.kind === 'ok' ? result.value : undefined);
+      },
+      {
+        title: `Enter base URL for ${platformName}`,
+        mask: false,
+        emptyHint: 'Base URL cannot be empty.',
+      },
+    );
+    host.mountEditorReplacement(dialog);
+  });
+}
+
+export function promptCatalogProviderSelection(host: SlashCommandHost, catalog: Catalog): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    const options: ChoiceOption[] = Object.entries(catalog)
+      .filter(([, entry]) => resolveCatalogImport(entry).kind !== 'invalid')
+      .map(([id, entry]) => ({
+        value: id,
+        label: entry.name ?? id,
+        description:
+          typeof entry.api === 'string' && entry.api.length > 0 ? entry.api : undefined,
+      }))
+      .toSorted((a, b) => a.label.localeCompare(b.label));
+
+    if (options.length === 0) {
+      host.showError('Catalog has no providers with supported wire types.');
+      resolve(undefined);
+      return;
+    }
+
+    const picker = new ChoicePickerComponent({
+      title: 'Select a provider',
+      options,
+      searchable: true,
+      onSelect: (value) => {
+        host.restoreEditor();
+        resolve(value);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+        resolve(undefined);
+      },
+    });
+    host.mountEditorReplacement(picker);
+  });
+}
+
+export async function promptModelSelectionForOpenPlatform(
+  host: SlashCommandHost,
+  models: ManagedKimiCodeModelInfo[],
+  platform: OpenPlatformDefinition,
+): Promise<{ model: ManagedKimiCodeModelInfo; thinking: ThinkingEffort } | undefined> {
+  const modelDict: Record<string, ModelAlias> = {};
+  for (const m of models) {
+    modelDict[`${platform.id}/${m.id}`] = {
+      provider: platform.id,
+      model: m.id,
+      maxContextSize: m.contextLength,
+      capabilities: capabilitiesForModel(m),
+      displayName: m.displayName,
+    };
+  }
+  const selection = await runModelSelector(host, modelDict);
+  if (selection === undefined) return undefined;
+  const model = models.find((m) => `${platform.id}/${m.id}` === selection.alias);
+  return model ? { model, thinking: selection.thinking } : undefined;
+}
+
+export async function promptModelSelectionForCatalog(
+  host: SlashCommandHost,
+  providerId: string,
+  models: CatalogModel[],
+): Promise<{ model: CatalogModel; thinking: ThinkingEffort } | undefined> {
+  const modelDict: Record<string, ModelAlias> = {};
+  for (const m of models) {
+    modelDict[`${providerId}/${m.id}`] = catalogModelToAlias(providerId, m);
+  }
+  const selection = await runModelSelector(host, modelDict);
+  if (selection === undefined) return undefined;
+  const model = models.find((m) => `${providerId}/${m.id}` === selection.alias);
+  return model ? { model, thinking: selection.thinking } : undefined;
+}
+
+export function runModelSelector(
+  host: SlashCommandHost,
+  modelDict: Record<string, ModelAlias>,
+): Promise<{ alias: string; thinking: ThinkingEffort } | undefined> {
+  return new Promise((resolve) => {
+    const firstAlias = Object.keys(modelDict)[0] ?? '';
+    const caps = modelDict[firstAlias]?.capabilities ?? [];
+    const initialThinking = caps.includes('always_thinking') || caps.includes('thinking');
+    const selector = new ModelSelectorComponent({
+      models: modelDict,
+      currentValue: firstAlias,
+      currentThinkingEffort: initialThinking ? 'on' : 'off',
+      searchable: true,
+      onSelect: ({ alias, thinking }) => {
+        host.restoreEditor();
+        resolve({ alias, thinking });
+      },
+      onCancel: () => {
+        host.restoreEditor();
+        resolve(undefined);
+      },
+    });
+    host.mountEditorReplacement(selector);
+  });
+}

apps/kimi-code/src/tui/commands/provider.ts

@@ -0,0 +1,432 @@
+import {
+  applyCustomRegistryEntries,
+  fetchCustomRegistry,
+  type CustomRegistrySource,
+  type ManagedKimiConfigShape,
+} from '@moonshot-ai/kimi-code-oauth';
+import {
+  applyCatalogProvider,
+  catalogProviderModels,
+  CatalogFetchError,
+  DEFAULT_CATALOG_URL,
+  resolveCatalogImport,
+  SECONDARY_DERIVED_MODEL_ALIAS,
+  type Catalog,
+  type ThinkingEffort,
+} from '@moonshot-ai/kimi-code-sdk';
+
+import { createKimiCodeUserAgent } from '#/cli/version';
+import { fetchCatalogOrBuiltIn } from '#/utils/catalog-fetch';
+import { refreshKimiRegion } from '#/utils/region';
+import { ChoicePickerComponent } from '../components/dialogs/choice-picker';
+import {
+  CustomRegistryImportDialogComponent,
+  type CustomRegistryImportResult,
+} from '../components/dialogs/custom-registry-import';
+import {
+  ProviderManagerComponent,
+  type ProviderManagerOptions,
+} from '../components/dialogs/provider-manager';
+import { TabbedModelSelectorComponent } from '../components/dialogs/tabbed-model-selector';
+import { DEFAULT_OAUTH_PROVIDER_NAME } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import { thinkingEffortToConfig } from '../utils/thinking-config';
+import { effectiveModelForHost } from './config';
+import {
+  promptApiKey,
+  promptBaseUrl,
+  promptCatalogProviderSelection,
+} from './prompts';
+import type { SlashCommandHost } from './dispatch';
+
+// ---------------------------------------------------------------------------
+// /provider command
+// ---------------------------------------------------------------------------
+
+export async function handleProviderCommand(host: SlashCommandHost): Promise<void> {
+  const options = buildProviderManagerOptions(host);
+  const component = new ProviderManagerComponent(options);
+  host.mountEditorReplacement(component);
+}
+
+function buildProviderManagerOptions(host: SlashCommandHost): ProviderManagerOptions {
+  const activeProviderId =
+    host.state.appState.availableModels[host.state.appState.model]?.provider;
+  return {
+    providers: host.state.appState.availableProviders,
+    activeProviderId,
+    onAdd: () => {
+      void handleProviderAdd(host).catch((error: unknown) => {
+        host.showError(`Add provider failed: ${formatErrorMessage(error)}`);
+      });
+    },
+    onDeleteSource: (providerIds) => {
+      void handleProviderManagerDeleteSource(host, providerIds).catch((error: unknown) => {
+        host.showError(`Remove provider failed: ${formatErrorMessage(error)}`);
+      });
+    },
+    onClose: () => {
+      host.restoreEditor();
+    },
+  };
+}
+
+async function handleProviderManagerDeleteSource(
+  host: SlashCommandHost,
+  providerIds: readonly string[],
+): Promise<void> {
+  for (const providerId of providerIds) {
+    try {
+      await handleProviderDelete(host, providerId);
+    } catch (error) {
+      const msg = formatErrorMessage(error);
+      host.showError(`Failed to delete provider ${providerId}: ${msg}`);
+    }
+  }
+  reopenProviderManager(host);
+}
+
+async function handleProviderDelete(host: SlashCommandHost, providerId: string): Promise<void> {
+  if (providerId === DEFAULT_OAUTH_PROVIDER_NAME) {
+    await host.harness.auth.logout(DEFAULT_OAUTH_PROVIDER_NAME);
+    // Drop the process-wide region cache with the credential: derived
+    // endpoints (updates, marketplace, site links, telemetry) must fall back
+    // to the marker/default profile, not the logged-out region.
+    refreshKimiRegion();
+    await host.authFlow.refreshConfigAfterLogout();
+    return;
+  }
+
+  const activeProvider =
+    host.state.appState.availableModels[host.state.appState.model]?.provider;
+  const config = await host.harness.removeProvider(providerId);
+  if (activeProvider === providerId) {
+    await host.authFlow.refreshConfigAfterLogout();
+  } else {
+    host.setAppState({
+      availableProviders: config.providers ?? {},
+      availableModels: config.models ?? {},
+    });
+  }
+}
+
+async function handleProviderAdd(host: SlashCommandHost): Promise<void> {
+  const source = await promptProviderAddSource(host);
+  if (source === undefined) {
+    reopenProviderManager(host);
+    return;
+  }
+
+  if (source === 'known') {
+    await handleCatalogProviderAdd(host);
+    return;
+  }
+  const handled = await handleCustomRegistryAddViaDialog(host);
+  if (!handled) {
+    reopenProviderManager(host);
+  }
+}
+
+function reopenProviderManager(host: SlashCommandHost): void {
+  const options = buildProviderManagerOptions(host);
+  const component = new ProviderManagerComponent(options);
+  host.mountEditorReplacement(component);
+}
+
+function promptProviderAddSource(
+  host: SlashCommandHost,
+): Promise<'known' | 'custom' | undefined> {
+  return new Promise((resolve) => {
+    const picker = new ChoicePickerComponent({
+      title: 'Add provider',
+      options: [
+        { value: 'known', label: 'Known third-party provider' },
+        { value: 'custom', label: 'Custom registry (api.json)' },
+      ],
+      onSelect: (value) => {
+        host.restoreEditor();
+        resolve(value === 'known' || value === 'custom' ? value : undefined);
+      },
+      onCancel: () => {
+        host.restoreEditor();
+        resolve(undefined);
+      },
+    });
+    host.mountEditorReplacement(picker);
+  });
+}
+
+async function handleCatalogProviderAdd(host: SlashCommandHost): Promise<void> {
+  const controller = new AbortController();
+  const cancel = (): void => {
+    controller.abort();
+  };
+  host.cancelInFlight = cancel;
+
+  const spinner = host.showLoginProgressSpinner(`Fetching catalog from ${DEFAULT_CATALOG_URL}`);
+  let catalog: Catalog | undefined;
+  try {
+    const loaded = await fetchCatalogOrBuiltIn(DEFAULT_CATALOG_URL, {
+      signal: controller.signal,
+      userAgent: createKimiCodeUserAgent(),
+    });
+    catalog = loaded.catalog;
+    spinner.stop({
+      ok: true,
+      label: loaded.fromBuiltIn
+        ? 'Catalog loaded from built-in snapshot (models.dev unreachable).'
+        : 'Catalog loaded.',
+    });
+  } catch (error) {
+    if (controller.signal.aborted) {
+      spinner.stop({ ok: false, label: 'Aborted.' });
+    } else {
+      const hint = error instanceof CatalogFetchError ? ` (HTTP ${error.status})` : '';
+      spinner.stop({ ok: false, label: 'Failed to load catalog.' });
+      host.showError(`Failed to fetch catalog${hint}: ${formatErrorMessage(error)}`);
+    }
+  } finally {
+    if (host.cancelInFlight === cancel) host.cancelInFlight = undefined;
+  }
+
+  if (catalog === undefined) return;
+
+  const providerId = await promptCatalogProviderSelection(host, catalog);
+  if (providerId === undefined) return;
+  const entry = catalog[providerId];
+  if (entry === undefined) return;
+
+  const models = catalogProviderModels(entry);
+  if (models.length === 0) {
+    host.showError(`Provider "${providerId}" has no usable models in this catalog.`);
+    return;
+  }
+
+  let resolution = resolveCatalogImport(entry);
+  if (resolution.kind === 'needs-base-url') {
+    const entered = await promptBaseUrl(host, entry.name ?? providerId);
+    if (entered === undefined) return;
+    resolution = resolveCatalogImport(entry, entered);
+  }
+  if (resolution.kind !== 'ok') {
+    if (resolution.kind === 'invalid') {
+      if (resolution.reason === 'unknown-explicit-type') {
+        host.showError(
+          `Provider "${providerId}" declares protocol "${entry.type}" in the catalog, which this client version does not support.`,
+        );
+      } else if (resolution.reason === 'proprietary-sdk') {
+        host.showError(
+          `Provider "${providerId}" uses a proprietary SDK this client cannot speak (e.g. Amazon Bedrock or Cohere); it cannot be imported from the catalog.`,
+        );
+      } else {
+        host.showError(
+          `Base URL contains an env placeholder or is empty. Enter the resolved URL instead.`,
+        );
+      }
+    }
+    return;
+  }
+  const { wire, baseUrl } = resolution;
+
+  const apiKey = await promptApiKey(host, entry.name ?? providerId);
+  if (apiKey === undefined) return;
+
+  // Persist the provider and all its models immediately after the api key is
+  // entered. The model selector that follows is just a convenience to pick the
+  // default model; ESC leaves the provider in place without a default selection.
+  const existingConfig = await host.harness.getConfig();
+  if (existingConfig.providers[providerId] !== undefined) {
+    await host.harness.removeProvider(providerId);
+  }
+
+  const config = await host.harness.getConfig();
+  applyCatalogProvider(config, {
+    providerId,
+    wire,
+    baseUrl,
+    apiKey,
+    models,
+    selectedModelId: '', // no default yet; user picks in the model selector
+    thinking: false,    // will be resolved by the model selector
+  });
+
+  await host.harness.setConfig({
+    providers: config.providers,
+    models: config.models,
+  });
+
+  await host.authFlow.refreshConfigAfterLogin();
+  host.track('connect', { provider: providerId, method: 'catalog' });
+  host.showStatus(`Provider added: ${entry.name ?? providerId}`);
+  if (resolution.guessed) {
+    host.showStatus(
+      `Protocol guessed as "openai" for ${providerId} — edit "type" in config.toml if requests fail.`,
+    );
+  }
+
+  // Build a merged model dictionary that includes existing models plus the
+  // newly-persisted provider's models, so the tabbed selector shows every
+  // provider's tab (the new provider's tab starts active via initialTabId).
+  // The v1 runtime may carry the synthesized `__secondary__` derived entry —
+  // never selectable in a picker.
+  const stateModels = await host.harness.getConfig().then((c) => c.models ?? {});
+  const mergedModels = { ...stateModels };
+  delete mergedModels[SECONDARY_DERIVED_MODEL_ALIAS];
+
+  const selector = new TabbedModelSelectorComponent({
+    models: mergedModels,
+    currentValue: host.state.appState.model,
+    selectedValue: Object.keys(mergedModels).find((a) => a.startsWith(`${providerId}/`)),
+    currentThinkingEffort: host.state.appState.thinkingEffort,
+    initialTabId: providerId,
+    onSelect: ({ alias, thinking }) => {
+      host.restoreEditor();
+      void setDefaultModel(host, alias, thinking).catch((error: unknown) => {
+        host.showError(`Set default model failed: ${formatErrorMessage(error)}`);
+      });
+    },
+    onCancel: () => {
+      host.restoreEditor();
+    },
+  });
+  host.mountEditorReplacement(selector);
+}
+
+export async function setDefaultModel(
+  host: SlashCommandHost,
+  alias: string,
+  effort: ThinkingEffort,
+): Promise<void> {
+  // Resolve efforts the same way the /model path does (effectiveModelForHost
+  // applies overrides and the protocol-profile inference): catalog entries for
+  // e.g. Anthropic models declare no support_efforts on the alias, and without
+  // the inference an above-default pick would slip through as a persisted effort.
+  const model = host.state.appState.availableModels[alias];
+  const thinking = thinkingEffortToConfig(
+    effort,
+    model === undefined ? undefined : effectiveModelForHost(host, model),
+  );
+  if (host.session === undefined) {
+    // A first prompt may still be inside lazy creation: wait it out so the
+    // pick lands on the new session instead of racing its assembly (same
+    // coordination as the /model path).
+    await host.waitForLazyCreation();
+  }
+  await host.harness.setConfig({
+    defaultModel: alias,
+    thinking,
+  });
+  // Whether activation made the engine emit model_switch (it reached a live
+  // session AND changed the bound alias — both engines track only an actual
+  // change). Recorded at activation time rather than snapshotted at entry: a
+  // lazy session can come live while the config writes above are pending; a
+  // session created BY activation (v1) or a same-alias rebind does not count
+  // — both bind the model without an engine event.
+  let engineTrackedSwitch = await host.authFlow.refreshConfigAfterLogin();
+  // refreshConfigAfterLogin reactivates from the persisted config, so a pick
+  // the gate keeps session-only never reaches the runtime — apply it after
+  // the refresh, or the persisted value would clobber it.
+  if (thinking.effort === undefined && effort !== 'off' && effort !== 'on') {
+    engineTrackedSwitch =
+      (await host.authFlow.activateModelAfterLogin(alias, effort)) || engineTrackedSwitch;
+  }
+  // When the engine never emitted (no live session, or the alias was already
+  // bound), the TUI stays the sole producer for the pick.
+  if (!engineTrackedSwitch) {
+    host.track('model_switch', { model: alias });
+  }
+  host.showStatus(`Default model set to ${alias} with thinking ${effort}.`);
+}
+
+async function handleCustomRegistryAddViaDialog(host: SlashCommandHost): Promise<boolean> {
+  const value = await promptCustomRegistryImport(host);
+  if (value === undefined) return false;
+
+  const source: CustomRegistrySource = {
+    kind: 'apiJson',
+    url: value.url,
+    apiKey: value.apiKey,
+  };
+
+  let entries: Awaited<ReturnType<typeof fetchCustomRegistry>>;
+  try {
+    entries = await fetchCustomRegistry(source, { userAgent: createKimiCodeUserAgent() });
+  } catch (error) {
+    host.showError(`Failed to import registry: ${formatErrorMessage(error)}`);
+    return false;
+  }
+
+  const addedProviderIds = Object.values(entries).map((entry) => entry.id);
+  try {
+    const config = await host.harness.getConfig();
+    applyCustomRegistryEntries(
+      config as unknown as ManagedKimiConfigShape,
+      entries,
+      source,
+    );
+    await host.harness.setConfig({
+      providers: config.providers,
+      models: config.models,
+    });
+    await host.authFlow.refreshConfigAfterLogin();
+  } catch (error) {
+    host.showError(`Failed to apply registry: ${formatErrorMessage(error)}`);
+    return false;
+  }
+
+  const count = addedProviderIds.length;
+  if (count === 0) {
+    host.showStatus('Registry contained no providers.');
+    return false;
+  }
+  host.showStatus(
+    count === 1
+      ? 'Imported 1 provider from registry.'
+      : `Imported ${String(count)} providers from registry.`,
+    'success',
+  );
+
+  // Offer the model selector so the user can pick a default, just like the
+  // catalog (known-provider) flow. Copy without the v1-synthesized
+  // `__secondary__` derived entry — never selectable in a picker.
+  const stateModels = { ...(await host.harness.getConfig().then((c) => c.models ?? {})) };
+  delete stateModels[SECONDARY_DERIVED_MODEL_ALIAS];
+  const firstNewAlias = Object.keys(stateModels).find((a) =>
+    addedProviderIds.some((pid) => a.startsWith(`${pid}/`)),
+  );
+  const firstNewProvider = firstNewAlias
+    ? stateModels[firstNewAlias]?.provider
+    : addedProviderIds[0];
+  const selector = new TabbedModelSelectorComponent({
+    models: stateModels,
+    currentValue: host.state.appState.model,
+    selectedValue: firstNewAlias,
+    currentThinkingEffort: host.state.appState.thinkingEffort,
+    initialTabId: firstNewProvider,
+    onSelect: ({ alias, thinking }) => {
+      host.restoreEditor();
+      void setDefaultModel(host, alias, thinking).catch((error: unknown) => {
+        host.showError(`Set default model failed: ${formatErrorMessage(error)}`);
+      });
+    },
+    onCancel: () => {
+      host.restoreEditor();
+    },
+  });
+  host.mountEditorReplacement(selector);
+  return true;
+}
+
+function promptCustomRegistryImport(
+  host: SlashCommandHost,
+): Promise<{ readonly url: string; readonly apiKey: string } | undefined> {
+  return new Promise((resolve) => {
+    const dialog = new CustomRegistryImportDialogComponent(
+      (result: CustomRegistryImportResult) => {
+        host.restoreEditor();
+        resolve(result.kind === 'ok' ? result.value : undefined);
+      },
+    );
+    host.mountEditorReplacement(dialog);
+  });
+}

apps/kimi-code/src/tui/commands/registry.ts

@@ -0,0 +1,476 @@
+import { readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, relative, resolve } from 'pathe';
+
+import type { AutocompleteItem } from '@moonshot-ai/pi-tui';
+
+import { completeLeadingArg, type ArgCompletionSpec } from './complete-args';
+import type { KimiSlashCommand, SlashCommandAvailability } from './types';
+
+/** Subcommands offered when autocompleting `/goal <…>`. */
+const GOAL_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [
+  { value: 'status', description: 'Show the current goal' },
+  { value: 'pause', description: 'Pause the active goal' },
+  { value: 'resume', description: 'Resume a paused goal' },
+  { value: 'cancel', description: 'Cancel and remove the current goal' },
+  { value: 'replace', description: 'Replace the current goal with a new objective' },
+  { value: 'next', description: 'Queue an upcoming goal' },
+];
+
+const GOAL_NEXT_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [
+  { value: 'manage', description: 'Manage upcoming goals' },
+];
+
+const SWARM_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [
+  { value: 'on', description: 'Turn swarm mode on' },
+  { value: 'off', description: 'Turn swarm mode off' },
+];
+
+const TOWER_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [
+  { value: 'status', description: 'Report tower status' },
+  { value: 'teardown', description: 'Tear down the tower' },
+  { value: 'on', description: 'Turn tower mode on' },
+  { value: 'off', description: 'Turn tower mode off' },
+];
+
+const ADD_DIR_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [
+  { value: 'list', description: 'Show configured additional workspace directories' },
+];
+
+/** Argument autocompletion for the `/goal` command (subcommands). */
+export function goalArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
+  const nextMatch = argumentPrefix.match(/^next\s+(\S*)$/i);
+  if (nextMatch !== null) {
+    return (
+      completeLeadingArg(GOAL_NEXT_ARG_COMPLETIONS, nextMatch[1] ?? '')?.map((item) => ({
+        ...item,
+        value: `next ${item.value}`,
+      })) ?? null
+    );
+  }
+  return completeLeadingArg(GOAL_ARG_COMPLETIONS, argumentPrefix);
+}
+
+/** Argument autocompletion for the `/swarm` command (subcommands). */
+export function swarmArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
+  return completeLeadingArg(SWARM_ARG_COMPLETIONS, argumentPrefix);
+}
+
+/** Argument autocompletion for the `/tower` command (subcommands). */
+export function towerArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
+  return completeLeadingArg(TOWER_ARG_COMPLETIONS, argumentPrefix);
+}
+
+/** Argument autocompletion for the `/add-dir` command. */
+export function addDirArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
+  if (isPathLikeAddDirArgument(argumentPrefix)) {
+    return completeAddDirPath(argumentPrefix);
+  }
+  return completeLeadingArg(ADD_DIR_ARG_COMPLETIONS, argumentPrefix);
+}
+
+function isPathLikeAddDirArgument(argumentPrefix: string): boolean {
+  return argumentPrefix === '.' || argumentPrefix === '..' || argumentPrefix.startsWith('./') || argumentPrefix.startsWith('../') || argumentPrefix.startsWith('/') || argumentPrefix.startsWith('~');
+}
+
+function completeAddDirPath(argumentPrefix: string): AutocompleteItem[] | null {
+  const normalizedPrefix = argumentPrefix === '~' ? '~/' : argumentPrefix;
+  const expandedPrefix = expandHomePrefix(normalizedPrefix);
+  const parentInput = getDirectoryCompletionParentInput(normalizedPrefix, expandedPrefix);
+  const partialName = normalizedPrefix.endsWith('/') ? '' : basename(expandedPrefix);
+  const parentDir = resolveDirectoryCompletionParent(parentInput);
+  let entries;
+  try {
+    entries = readdirSync(parentDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+
+  const items: AutocompleteItem[] = [];
+  for (const entry of entries) {
+    if (entry.name === '.' || entry.name === '..' || entry.name.startsWith('.')) continue;
+    if (partialName.length > 0 && !entry.name.toLowerCase().startsWith(partialName.toLowerCase())) continue;
+    const absolutePath = join(parentDir, entry.name);
+    if (!isDirectoryPath(absolutePath, entry.isDirectory(), entry.isSymbolicLink())) continue;
+    const value = formatDirectoryCompletionValue(normalizedPrefix, parentInput, entry.name);
+    items.push({
+      value,
+      label: `${entry.name}/`,
+      description: absolutePath,
+    });
+  }
+
+  return items.length > 0 ? items : null;
+}
+
+function expandHomePrefix(argumentPrefix: string): string {
+  if (argumentPrefix === '~') return homedir();
+  if (argumentPrefix.startsWith('~/')) return join(homedir(), argumentPrefix.slice(2));
+  return argumentPrefix;
+}
+
+function getDirectoryCompletionParentInput(argumentPrefix: string, expandedPrefix: string): string {
+  if (argumentPrefix === '/') return '/';
+  if (argumentPrefix === '~/') return homedir();
+  if (argumentPrefix.endsWith('/')) return expandedPrefix.slice(0, -1);
+  return dirname(expandedPrefix);
+}
+
+function resolveDirectoryCompletionParent(parentInput: string): string {
+  if (parentInput === '~') return homedir();
+  if (parentInput.startsWith('~/')) return join(homedir(), parentInput.slice(2));
+  return resolve(parentInput);
+}
+
+function isDirectoryPath(path: string, isDirectory: boolean, isSymlink: boolean): boolean {
+  if (isDirectory) return true;
+  if (!isSymlink) return false;
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function formatDirectoryCompletionValue(argumentPrefix: string, parentInput: string, entryName: string): string {
+  if (argumentPrefix.startsWith('~/')) {
+    const home = homedir();
+    const homeRelative = relative(home, parentInput);
+    return `~${homeRelative.length > 0 ? `/${homeRelative}` : ''}/${entryName}/`;
+  }
+  if (argumentPrefix.startsWith('/')) {
+    return `${join(parentInput, entryName)}/`;
+  }
+  return `${join(parentInput, entryName)}/`;
+}
+
+export const BUILTIN_SLASH_COMMANDS = [
+  {
+    name: 'yolo',
+    aliases: ['yes'],
+    description: 'Ask When Needed mode: routine edits and commands run automatically; risky actions, questions, and plans still ask.',
+    priority: 101,
+    availability: 'always',
+  },
+  {
+    name: 'auto',
+    aliases: [],
+    description: 'Never Ask mode: never interrupts you; everything runs and is decided automatically.',
+    priority: 99,
+    availability: 'always',
+  },
+  {
+    name: 'permission',
+    aliases: [],
+    description: 'Select permission mode',
+    priority: 100,
+    availability: 'always',
+  },
+  {
+    name: 'settings',
+    aliases: ['config'],
+    description: 'Open TUI settings',
+    priority: 100,
+    availability: 'always',
+  },
+  {
+    name: 'plan',
+    aliases: [],
+    description: 'Toggle plan mode',
+    priority: 100,
+    availability: (args) => (args.trim().toLowerCase() === 'clear' ? 'idle-only' : 'always'),
+  },
+  {
+    name: 'swarm',
+    aliases: [],
+    description: 'Toggle swarm mode or run one task in swarm mode',
+    priority: 100,
+    argumentHint: '[on|off] | <task>',
+    completeArgs: swarmArgumentCompletions,
+    availability: 'idle-only',
+  },
+  {
+    name: 'tower',
+    aliases: [],
+    description: 'Report tower status, toggle tower mode, or turn it on with a base branch',
+    priority: 100,
+    argumentHint: '[status|teardown|on|off] | <base-branch>',
+    completeArgs: towerArgumentCompletions,
+    // Every form stays available while busy: base selections apply to the next
+    // TowerInit of the running coordinator turn, so /tower commands never wait
+    // for the previous one to finish.
+    availability: 'always',
+    experimentalFlag: 'tower',
+  },
+  {
+    name: 'model',
+    aliases: [],
+    description: 'Switch LLM model',
+    priority: 100,
+    availability: 'always',
+  },
+  {
+    name: 'secondary-model',
+    aliases: ['subagent-model'],
+    description: 'Configure the secondary model for subagents',
+    priority: 90,
+    availability: 'always',
+  },
+  {
+    name: 'effort',
+    aliases: ['thinking'],
+    description: 'Switch thinking effort',
+    priority: 95,
+    availability: 'always',
+  },
+  {
+    name: 'provider',
+    aliases: ['providers'],
+    description: 'Manage AI providers (add / delete / refresh)',
+    priority: 95,
+    availability: 'always',
+  },
+  {
+    name: 'btw',
+    aliases: [],
+    description: 'Ask a forked side agent a question',
+    priority: 90,
+    availability: 'always',
+  },
+  {
+    name: 'help',
+    aliases: ['h', '?'],
+    description: 'Show available commands and shortcuts',
+    priority: 80,
+    availability: 'always',
+  },
+  {
+    name: 'new',
+    aliases: ['clear'],
+    description: 'Start a fresh session in the current workspace',
+    priority: 80,
+  },
+  {
+    name: 'sessions',
+    aliases: ['resume'],
+    description: 'Browse and resume sessions',
+    priority: 80,
+  },
+  {
+    name: 'tasks',
+    aliases: ['task'],
+    description: 'Browse background tasks',
+    priority: 80,
+    availability: 'always',
+  },
+  {
+    name: 'mcp',
+    aliases: [],
+    description: 'Show MCP server status',
+    priority: 60,
+    availability: 'always',
+  },
+  {
+    name: 'plugins',
+    aliases: [],
+    description: 'Manage plugins',
+    priority: 60,
+    availability: 'always',
+  },
+  {
+    name: 'add-dir',
+    aliases: [],
+    description: 'Add or list an additional workspace directory',
+    priority: 60,
+    availability: 'idle-only',
+    argumentHint: '[list] | <path>',
+    completeArgs: addDirArgumentCompletions,
+  },
+  {
+    name: 'experiments',
+    aliases: ['experimental'],
+    description: 'Manage experimental features',
+    priority: 60,
+    availability: 'idle-only',
+  },
+  {
+    name: 'reload',
+    aliases: [],
+    description: 'Reload session and apply config.toml settings plus tui.toml UI preferences',
+    priority: 60,
+    availability: 'idle-only',
+  },
+  {
+    name: 'reload-tui',
+    aliases: [],
+    description: 'Reload only tui.toml UI preferences',
+    priority: 60,
+    availability: 'always',
+  },
+  {
+    name: 'compact',
+    aliases: [],
+    description: 'Compact the conversation context',
+    priority: 80,
+    argumentHint: '<instruction>',
+  },
+  {
+    name: 'goal',
+    aliases: [],
+    description: 'Start or manage an autonomous goal',
+    priority: 80,
+    argumentHint: '[status|pause|resume|cancel|replace|next] | <objective>',
+    completeArgs: goalArgumentCompletions,
+    // status / pause / cancel are always available; creation, replacement, and
+    // resume start (or restart) a turn and so are idle-only.
+    availability: (args) => {
+      const trimmed = args.trim();
+      if (trimmed === 'next' || trimmed.startsWith('next ')) return 'always';
+      return trimmed === '' || trimmed === 'status' || trimmed === 'pause' || trimmed === 'cancel'
+        ? 'always'
+        : 'idle-only';
+    },
+  },
+  {
+    name: 'init',
+    aliases: [],
+    description: 'Analyze the codebase and generate AGENTS.md',
+  },
+  {
+    name: 'fork',
+    aliases: [],
+    description: 'Fork the current session into a copy without switching to it',
+    priority: 80,
+  },
+  {
+    name: 'title',
+    aliases: ['rename'],
+    description: 'Set or show session title',
+    priority: 60,
+    argumentHint: '<title>',
+    availability: 'always',
+  },
+  {
+    name: 'usage',
+    aliases: [],
+    description: 'Show session tokens + context window + plan quotas',
+    priority: 60,
+    availability: 'always',
+  },
+  {
+    name: 'status',
+    aliases: [],
+    description: 'Show current session and runtime status',
+    priority: 60,
+    availability: 'always',
+  },
+  {
+    name: 'feedback',
+    aliases: ['bug'],
+    description: 'Send feedback to make Kimi Code better',
+    priority: 60,
+    availability: 'always',
+  },
+  {
+    name: 'undo',
+    aliases: [],
+    description: 'Withdraw the last prompt from the transcript',
+    priority: 80,
+    availability: 'idle-only',
+  },
+  {
+    name: 'editor',
+    aliases: [],
+    description: 'Set the external editor for Ctrl-G',
+    priority: 60,
+    availability: 'always',
+  },
+  {
+    name: 'theme',
+    aliases: [],
+    description: 'Set the terminal UI theme',
+    priority: 60,
+    availability: 'always',
+  },
+  {
+    name: 'logout',
+    aliases: ['disconnect'],
+    description: 'Log out of a configured provider',
+    priority: 40,
+  },
+  {
+    name: 'login',
+    aliases: [],
+    description: 'Select a platform and authenticate',
+    priority: 40,
+  },
+  {
+    name: 'export-md',
+    aliases: ['export'],
+    description: 'Export current session as a Markdown file',
+    priority: 40,
+  },
+  {
+    name: 'export-debug-zip',
+    aliases: [],
+    description: 'Export current session as a debug ZIP archive',
+    priority: 40,
+  },
+  {
+    name: 'copy',
+    aliases: [],
+    description: 'Copy the last assistant message to the clipboard',
+    priority: 40,
+  },
+  {
+    name: 'web',
+    aliases: [],
+    description: 'Open the current session in the Web UI by starting a new server',
+    priority: 40,
+    availability: 'always',
+  },
+  {
+    name: 'remote-control',
+    aliases: ['rc'],
+    description: 'Open the current session through Kimi Remote Control',
+    priority: 40,
+    availability: 'always',
+  },
+  {
+    name: 'exit',
+    aliases: ['quit', 'q'],
+    description: 'Exit the application',
+    priority: 20,
+  },
+  {
+    name: 'version',
+    aliases: [],
+    description: 'Show version information',
+    priority: 20,
+    availability: 'always',
+  },
+] as const satisfies readonly KimiSlashCommand[];
+
+export type BuiltinSlashCommand = (typeof BUILTIN_SLASH_COMMANDS)[number];
+export type BuiltinSlashCommandName = BuiltinSlashCommand['name'];
+
+export function findBuiltInSlashCommand(commandName: string): BuiltinSlashCommand | undefined {
+  const commands = BUILTIN_SLASH_COMMANDS as readonly KimiSlashCommand<BuiltinSlashCommandName>[];
+  return commands.find(
+    (command) => command.name === commandName || command.aliases.includes(commandName),
+  ) as BuiltinSlashCommand | undefined;
+}
+
+export function resolveSlashCommandAvailability(
+  command: KimiSlashCommand,
+  args: string,
+): SlashCommandAvailability {
+  const availability = command.availability ?? 'idle-only';
+  return typeof availability === 'function' ? availability(args) : availability;
+}
+
+export function sortSlashCommands(commands: readonly KimiSlashCommand[]): KimiSlashCommand[] {
+  return [...commands].toSorted(
+    (a, b) => (b.priority ?? 0) - (a.priority ?? 0) || a.name.localeCompare(b.name),
+  );
+}

apps/kimi-code/src/tui/commands/reload.ts

@@ -0,0 +1,86 @@
+import type { KimiConfig } from '@moonshot-ai/kimi-code-sdk';
+
+import { currentTheme, lightColors } from '#/tui/theme';
+import { loadTuiConfig, type TuiConfig } from '../config';
+import { setMarkdownRenderLatex } from '../utils/markdown-options';
+import type { SlashCommandHost } from './dispatch';
+import { setExperimentalFeatures } from './experimental-flags';
+
+export async function handleReloadTuiCommand(host: SlashCommandHost): Promise<void> {
+  const tuiConfig = await loadTuiConfig(undefined, (message) =>
+    host.showStatus(message, 'warning'),
+  );
+  await applyReloadedTuiConfig(host, tuiConfig);
+  host.showStatus('TUI config reloaded.', 'success');
+}
+
+export async function handleReloadCommand(host: SlashCommandHost): Promise<void> {
+  const tuiConfig = await loadTuiConfig(undefined, (message) =>
+    host.showStatus(message, 'warning'),
+  );
+  const session = host.session;
+
+  if (session !== undefined) {
+    const reloadedSession = await host.harness.reloadSession({
+      id: session.id,
+      forcePluginSessionStartReminder: true,
+    });
+    await host.reloadCurrentSessionView(reloadedSession, 'Session reloaded.');
+  }
+
+  const config = await host.harness.getConfig({ reload: true });
+  setExperimentalFeatures(await host.harness.getExperimentalFeatures());
+  if (session === undefined) {
+    // Session-less v2: rebuild the workspace-level dynamic commands too, so
+    // skill/plugin changes apply before the first session exists.
+    await host.refreshSkillCommands();
+    await host.refreshPluginCommands();
+  }
+  host.refreshSlashCommandAutocomplete();
+  applyRuntimeConfig(host, config);
+  await applyReloadedTuiConfig(host, tuiConfig);
+
+  if (session === undefined) {
+    // Still session-less on the v2 engine: refresh the lazy defaults too, so
+    // defaults edited externally (config.toml, a newly added default model)
+    // reach the first lazy-created session instead of staying stale.
+    await host.hydrateLazyConfigDefaults();
+    host.showStatus(
+      'Runtime and TUI config reloaded; no active session.',
+      'success',
+    );
+  }
+}
+
+export async function applyReloadedTuiConfig(
+  host: SlashCommandHost,
+  config: TuiConfig,
+): Promise<void> {
+  // Set the LaTeX toggle before applyTheme: theme application invalidates the
+  // transcript components, which rebuild their Markdown children and copy the
+  // options at construction — so the new value must be live by then.
+  setMarkdownRenderLatex(config.renderLatex ?? true);
+  const resolved = config.theme === 'auto'
+    ? (currentTheme.palette === lightColors ? 'light' : 'dark')
+    : undefined;
+  await host.applyTheme(config.theme, resolved);
+  host.refreshTerminalThemeTracking();
+  host.setAppState({
+    editorCommand: config.editorCommand,
+    disablePasteBurst: config.disablePasteBurst,
+    renderLatex: config.renderLatex,
+    cacheExpiryHint: config.cacheExpiryHint,
+    disableFeedbackSurvey: config.disableFeedbackSurvey,
+    notifications: config.notifications,
+    upgrade: config.upgrade,
+    statusLine: config.statusLine,
+  });
+  host.state.editor.setDisablePasteBurst(config.disablePasteBurst);
+}
+
+function applyRuntimeConfig(host: SlashCommandHost, config: KimiConfig): void {
+  host.setAppState({
+    availableModels: config.models ?? {},
+    availableProviders: config.providers ?? {},
+  });
+}

apps/kimi-code/src/tui/commands/resolve.ts

@@ -0,0 +1,157 @@
+import {
+  findBuiltInSlashCommand,
+  resolveSlashCommandAvailability,
+  type BuiltinSlashCommand,
+  type BuiltinSlashCommandName,
+} from './registry';
+import { isExperimentalFlagEnabled } from './experimental-flags';
+import { parseSlashInput } from './parse';
+import type { TUIState } from '../tui-state';
+import type {
+  KimiSlashCommand,
+  SlashCommandBusyReason,
+  SlashCommandInvalidReason,
+} from './types';
+
+export type SlashCommandIntent =
+  | { readonly kind: 'not-command' }
+  | {
+      readonly kind: 'builtin';
+      readonly command: BuiltinSlashCommand;
+      readonly name: BuiltinSlashCommandName;
+      readonly args: string;
+    }
+  | {
+      readonly kind: 'skill';
+      readonly commandName: string;
+      readonly skillName: string;
+      readonly args: string;
+    }
+  | {
+      readonly kind: 'plugin-command';
+      readonly commandName: string;
+      readonly pluginId: string;
+      readonly args: string;
+    }
+  | { readonly kind: 'message'; readonly input: string }
+  | {
+      readonly kind: 'blocked';
+      readonly commandName: string;
+      readonly reason: SlashCommandBusyReason;
+    }
+  | {
+      readonly kind: 'invalid';
+      readonly commandName: string;
+      readonly reason: SlashCommandInvalidReason;
+    };
+
+export interface ResolveSlashCommandInput {
+  readonly input: string;
+  readonly skillCommandMap: ReadonlyMap<string, string>;
+  readonly pluginCommandMap: ReadonlyMap<string, string>;
+  readonly isStreaming: boolean;
+  readonly isCompacting: boolean;
+}
+
+export function resolveSlashCommandInput(options: ResolveSlashCommandInput): SlashCommandIntent {
+  const parsed = parseSlashInput(options.input);
+  if (parsed === null) return { kind: 'not-command' };
+
+  const command = findBuiltInSlashCommand(parsed.name);
+  // `command` is a literal union where only some members carry `experimentalFlag`; widen to read it.
+  if (
+    command !== undefined &&
+    isExperimentalFlagEnabled((command as KimiSlashCommand).experimentalFlag)
+  ) {
+    const busyReason = slashCommandBusyReason(options);
+    if (
+      busyReason !== undefined &&
+      resolveSlashCommandAvailability(command, parsed.args) === 'idle-only'
+    ) {
+      return {
+        kind: 'blocked',
+        commandName: parsed.name,
+        reason: busyReason,
+      };
+    }
+    return {
+      kind: 'builtin',
+      command,
+      name: command.name,
+      args: parsed.args,
+    };
+  }
+
+  const skillName = resolveSkillCommand(options.skillCommandMap, parsed.name);
+  if (skillName !== undefined) {
+    // Skill activations are never blocked by a busy session: the TUI queues
+    // them behind the running turn exactly like normal messages (see
+    // sendSkillActivation), and Ctrl-S steers them as real activations, so
+    // skill commands can be issued any time.
+    return {
+      kind: 'skill',
+      commandName: parsed.name,
+      skillName,
+      args: parsed.args.trim(),
+    };
+  }
+
+  if (options.pluginCommandMap.has(parsed.name)) {
+    const busyReason = slashCommandBusyReason(options);
+    if (busyReason !== undefined) {
+      return {
+        kind: 'blocked',
+        commandName: parsed.name,
+        reason: busyReason,
+      };
+    }
+    const separator = parsed.name.indexOf(':');
+    const pluginId = separator === -1 ? parsed.name : parsed.name.slice(0, separator);
+    const commandName = separator === -1 ? '' : parsed.name.slice(separator + 1);
+    return {
+      kind: 'plugin-command',
+      commandName,
+      pluginId,
+      args: parsed.args.trim(),
+    };
+  }
+
+  return {
+    kind: 'message',
+    input: options.input,
+  };
+}
+
+export function resolveSkillCommand(
+  skillCommandMap: ReadonlyMap<string, string>,
+  commandName: string,
+): string | undefined {
+  return skillCommandMap.get(commandName) ?? skillCommandMap.get(`skill:${commandName}`);
+}
+
+export function slashCommandBusyReason(
+  options: Pick<ResolveSlashCommandInput, 'isStreaming' | 'isCompacting'>,
+): SlashCommandBusyReason | undefined {
+  if (options.isStreaming) return 'streaming';
+  if (options.isCompacting) return 'compacting';
+  return undefined;
+}
+
+export function slashBusyMessage(
+  commandName: string,
+  reason: SlashCommandBusyReason,
+): string {
+  if (reason === 'streaming') {
+    return `Cannot /${commandName} while streaming — press Esc or Ctrl-C first.`;
+  }
+  return `Cannot /${commandName} while compacting — wait for compaction to finish first.`;
+}
+
+/**
+ * Whether a delayed input restore is still safe: the editor must be empty
+ * (no newer draft) and still mounted (no editor-replacement panel opened
+ * meanwhile). Restores that run synchronously with submit do not need this.
+ */
+export function canRestoreSubmittedInput(host: { state: TUIState }): boolean {
+  return host.state.editor.getText().length === 0 && !host.state.editorReplacementMounted;
+}

apps/kimi-code/src/tui/commands/session.ts

@@ -0,0 +1,219 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import type { Session } from '@moonshot-ai/kimi-code-sdk';
+
+import { detectInstallSource } from '#/cli/update/source';
+import { copyTextToClipboard } from '#/utils/clipboard/clipboard-text';
+import { detectShellEnvironment } from '#/utils/process/shell-env';
+import { quoteShellArg } from '#/utils/shell-quote';
+import { toTerminalHyperlink } from '#/utils/terminal-hyperlink';
+import { LLM_NOT_SET_MESSAGE, NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
+import { isAbortError } from '../utils/errors';
+import { formatErrorMessage } from '../utils/event-payload';
+import { buildExportMarkdown } from '../utils/export-markdown';
+import type { SlashCommandHost } from './dispatch';
+
+// ---------------------------------------------------------------------------
+// Session commands
+// ---------------------------------------------------------------------------
+
+export async function handleTitleCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const title = args.trim();
+  if (title.length === 0) {
+    const current = host.state.appState.sessionTitle;
+    host.showStatus(
+      current !== null && current.length > 0
+        ? `Session title: ${current}`
+        : `Session title: (not set) — id: ${host.state.appState.sessionId}`,
+    );
+    return;
+  }
+
+  let session = host.session;
+  if (session === undefined) {
+    // Setting a title needs a live session; lazy-create it on first use (the
+    // bare read-only form above works session-less).
+    session = await host.ensureSession();
+    if (session === undefined) return;
+  }
+
+  const newTitle = title.slice(0, 200);
+  try {
+    await host.harness.renameSession({ id: session.id, title: newTitle });
+  } catch (error) {
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to set title: ${msg}`);
+    return;
+  }
+  host.showStatus(`Session title set to: ${newTitle}`);
+}
+
+export async function handleForkCommand(host: SlashCommandHost, args: string): Promise<void> {
+  void args;
+  const session = host.session;
+  if (session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  const sourceTitle = forkSourceTitle(host, session);
+  try {
+    const forked = await host.harness.forkSession({
+      id: session.id,
+      title: `Fork: ${sourceTitle}`,
+    });
+    const forkId = forked.id;
+    try {
+      await forked.close();
+    } catch (error) {
+      const msg = formatErrorMessage(error);
+      host.showError(`Session forked (${forkId}), but failed to release its runtime: ${msg}`);
+      return;
+    }
+    // Stay in the source session: switching to the fork would close the
+    // source, killing its in-flight turn and background tasks. The fork is
+    // an independent copy the user can switch to explicitly via /sessions,
+    // or enter from a new CLI process with the printed resume command.
+    const command = forkResumeCommand(host.state.appState.workDir, forkId);
+    let clipboardNote: string;
+    try {
+      const method = await copyTextToClipboard(command);
+      // OSC 52 delivery is fire-and-forget: terminals without OSC 52 support
+      // silently drop the sequence, so only native delivery may claim success
+      // (same wording convention as /copy).
+      clipboardNote =
+        method === 'native'
+          ? 'Command copied to clipboard'
+          : 'Command copied via terminal escape sequence (unverified)';
+    } catch {
+      clipboardNote = 'Failed to copy command to clipboard';
+    }
+    host.showStatus(
+      `Session forked (${forkId}). Still in the original session; switch to the fork via /sessions.\n` +
+        `  To enter the fork in a new process, run: ${command}\n` +
+        `  ${clipboardNote}`,
+    );
+  } catch (error) {
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to fork session: ${msg}`);
+  }
+}
+
+function forkResumeCommand(workDir: string, forkId: string): string {
+  const dir = quoteShellArg(workDir);
+  // cmd.exe's `cd` only updates the given drive's remembered directory — a
+  // terminal on a different drive stays put, and the resume then runs in the
+  // wrong working directory. `pushd` switches drive + directory in both
+  // cmd.exe and PowerShell (`cd /d` would break PowerShell).
+  const changeDir = process.platform === 'win32' ? `pushd ${dir}` : `cd ${dir}`;
+  return `${changeDir} && kimi --resume ${quoteShellArg(forkId)}`;
+}
+
+function forkSourceTitle(host: SlashCommandHost, session: Session): string {
+  const currentTitle = host.state.appState.sessionTitle?.trim();
+  if (currentTitle !== undefined && currentTitle.length > 0) return currentTitle;
+
+  const summaryTitle =
+    typeof session.summary?.title === 'string' ? session.summary.title.trim() : '';
+  return summaryTitle.length > 0 ? summaryTitle : session.id;
+}
+
+export async function handleExportMdCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const session = host.session;
+  if (session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  host.showStatus('Exporting session as Markdown…');
+  try {
+    const context = await session.getContext();
+    if (context.history.length === 0) {
+      host.showError('No messages to export.');
+      return;
+    }
+
+    const now = new Date();
+    const shortId = session.id.slice(0, 8);
+    const timestamp = now.toISOString().replaceAll(/[-:]/g, '').replace(/T/, '-').slice(0, 15);
+    const defaultName = `kimi-export-${shortId}-${timestamp}.md`;
+
+    const trimmedArgs = args.trim();
+    const outputPath = trimmedArgs.length > 0
+      ? resolve(trimmedArgs)
+      : resolve(host.state.appState.workDir, defaultName);
+
+    const md = buildExportMarkdown({
+      sessionId: session.id,
+      workDir: host.state.appState.workDir,
+      history: context.history,
+      tokenCount: context.tokenCount,
+      now,
+    });
+
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, md, 'utf-8');
+
+    const linked = toTerminalHyperlink(outputPath, pathToFileURL(outputPath).href);
+    host.showNotice(`Exported ${String(context.history.length)} messages`, linked);
+  } catch (error) {
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to export session: ${msg}`);
+  }
+}
+
+export async function handleExportDebugZipCommand(host: SlashCommandHost): Promise<void> {
+  const session = host.session;
+  if (session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  host.showStatus('Exporting session…');
+  try {
+    const installSource = await detectInstallSource();
+    const shellEnv = detectShellEnvironment();
+    const result = await host.harness.exportSession({
+      id: session.id,
+      version: host.state.appState.version,
+      installSource,
+      shellEnv,
+      includeGlobalLog: true,
+    });
+    const linked = toTerminalHyperlink(result.zipPath, pathToFileURL(result.zipPath).href);
+    host.showNotice('Export complete', linked);
+  } catch (error) {
+    const msg = formatErrorMessage(error);
+    host.showError(`Failed to export session: ${msg}`);
+  }
+}
+
+export async function handleInitCommand(host: SlashCommandHost): Promise<void> {
+  const session = host.session;
+  if (host.state.appState.model.trim().length === 0 || session === undefined) {
+    host.showError(LLM_NOT_SET_MESSAGE);
+    return;
+  }
+
+  host.deferUserMessages = true;
+  host.beginSessionRequest();
+  try {
+    await session.init();
+    host.track('init_complete');
+    host.streamingUI.finalizeTurn((item) => {
+      host.sendQueuedMessage(session, item);
+    });
+  } catch (error) {
+    if (isAbortError(error)) {
+      host.setAppState({ streamingPhase: 'idle' });
+      host.resetLivePane();
+      return;
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    host.failSessionRequest(`Init failed: ${msg}`);
+  } finally {
+    host.deferUserMessages = false;
+  }
+}

apps/kimi-code/src/tui/commands/skills.ts

@@ -0,0 +1,48 @@
+import type { Session, SkillSummary } from '@moonshot-ai/kimi-code-sdk';
+
+import type { KimiSlashCommand } from './types';
+
+export type SkillListSession = Pick<Session, 'listSkills'>;
+
+export interface SkillSlashCommands {
+  readonly commands: readonly KimiSlashCommand[];
+  readonly commandMap: ReadonlyMap<string, string>;
+}
+
+export function isUserActivatableSkill(skill: SkillSummary): boolean {
+  return (
+    skill.type === undefined ||
+    skill.type === 'prompt' ||
+    skill.type === 'inline' ||
+    skill.type === 'flow'
+  );
+}
+
+function compareSkillSlashCommands(a: SkillSummary, b: SkillSummary): number {
+  return (
+    getSkillSlashCommandGroup(a.source) - getSkillSlashCommandGroup(b.source) ||
+    a.name.localeCompare(b.name)
+  );
+}
+
+function getSkillSlashCommandGroup(source: SkillSummary['source']): number {
+  return source === 'builtin' ? 0 : 1;
+}
+
+export function buildSkillSlashCommands(skills: readonly SkillSummary[]): SkillSlashCommands {
+  const commandMap = new Map<string, string>();
+  const sortedSkills = [...skills].toSorted(compareSkillSlashCommands);
+  const commands = sortedSkills.filter(isUserActivatableSkill).map((skill) => {
+    const commandName =
+      skill.source === 'builtin' || skill.isSubSkill === true
+        ? skill.name
+        : `skill:${skill.name}`;
+    commandMap.set(commandName, skill.name);
+    return {
+      name: commandName,
+      aliases: [],
+      description: skill.description ?? '',
+    };
+  });
+  return { commands, commandMap };
+}

apps/kimi-code/src/tui/commands/swarm.ts

@@ -0,0 +1,159 @@
+import type { PermissionMode } from '@moonshot-ai/kimi-code-sdk';
+
+import {
+  SwarmStartPermissionPromptComponent,
+  type SwarmStartPermissionChoice,
+} from '../components/dialogs/swarm-start-permission-prompt';
+import {
+  SwarmModeMarkerComponent,
+  type SwarmModeMarkerState,
+} from '../components/messages/swarm-markers';
+import { LLM_NOT_SET_MESSAGE, NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import { PERMISSION_MODE_DESCRIPTIONS, PERMISSION_MODE_DISPLAY_NAMES } from '../utils/permission-mode';
+import type { SlashCommandHost } from './dispatch';
+
+export async function handleSwarmCommand(host: SlashCommandHost, args: string): Promise<void> {
+  if (host.session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  const prompt = args.trim();
+  const mode = swarmModeSubcommand(prompt);
+  if (mode !== undefined) {
+    await applySwarmMode(host, mode, `/swarm ${prompt}`);
+    return;
+  }
+
+  if (prompt.length === 0) {
+    await applySwarmMode(host, !host.state.appState.swarmMode, '/swarm');
+    return;
+  }
+
+  if (host.state.appState.model.trim().length === 0) {
+    host.showError(LLM_NOT_SET_MESSAGE);
+    return;
+  }
+
+  if (host.state.appState.permissionMode === 'manual') {
+    showSwarmStartPermissionPrompt(host, `/swarm ${prompt}`, 'Swarm task not started.', (choice) =>
+      startSwarmWithPermission(host, prompt, choice),
+    );
+    return;
+  }
+
+  await startSwarmTask(host, prompt);
+}
+
+function showSwarmStartPermissionPrompt(
+  host: SlashCommandHost,
+  commandText: string,
+  cancelStatus: string,
+  onSelect: (choice: SwarmStartPermissionChoice) => Promise<void>,
+): void {
+  const cancelStart = (): void => {
+    host.restoreInputText(commandText);
+    host.showStatus(cancelStatus);
+  };
+  host.mountEditorReplacement(
+    new SwarmStartPermissionPromptComponent({
+      onSelect: (choice) => {
+        host.restoreEditor();
+        void onSelect(choice);
+      },
+      onCancel: cancelStart,
+    }),
+  );
+}
+
+async function startSwarmWithPermission(
+  host: SlashCommandHost,
+  prompt: string,
+  choice: SwarmStartPermissionChoice,
+): Promise<void> {
+  if (choice === 'auto' || choice === 'yolo') {
+    if (!(await setPermissionForSwarm(host, choice))) return;
+  }
+  await startSwarmTask(host, prompt);
+}
+
+async function setPermissionForSwarm(host: SlashCommandHost, mode: PermissionMode): Promise<boolean> {
+  try {
+    await host.requireSession().setPermission(mode);
+  } catch (error) {
+    host.showError(`Failed to set permission mode: ${formatErrorMessage(error)}`);
+    return false;
+  }
+  host.setAppState({ permissionMode: mode });
+  host.showNotice(`Permission mode: ${PERMISSION_MODE_DISPLAY_NAMES[mode]}`);
+  host.showStatus(PERMISSION_MODE_DESCRIPTIONS[mode], 'warning');
+  return true;
+}
+
+async function startSwarmTask(host: SlashCommandHost, prompt: string): Promise<void> {
+  if (!host.state.appState.swarmMode && !(await setSwarmMode(host, true, 'task'))) {
+    return;
+  }
+  renderSwarmModeMarker(host, 'active');
+  host.sendNormalUserInput(prompt);
+}
+
+async function applySwarmMode(
+  host: SlashCommandHost,
+  enabled: boolean,
+  commandText: string,
+): Promise<void> {
+  if (enabled && host.state.appState.swarmMode) {
+    host.showStatus('Swarm mode is already on.');
+    return;
+  }
+  if (!enabled && !host.state.appState.swarmMode) {
+    host.showStatus('Swarm mode is already off.');
+    return;
+  }
+  if (enabled && host.state.appState.permissionMode === 'manual') {
+    showSwarmStartPermissionPrompt(host, commandText, 'Swarm mode not enabled.', async (choice) => {
+      if ((choice === 'auto' || choice === 'yolo') && !(await setPermissionForSwarm(host, choice))) {
+        return;
+      }
+      if (!(await setSwarmMode(host, true, 'manual'))) return;
+      renderSwarmModeMarker(host, 'active');
+    });
+    return;
+  }
+  if (!(await setSwarmMode(host, enabled, 'manual'))) return;
+  renderSwarmModeMarker(host, enabled ? 'active' : 'inactive');
+}
+
+async function setSwarmMode(
+  host: SlashCommandHost,
+  enabled: boolean,
+  trigger: 'manual' | 'task',
+): Promise<boolean> {
+  try {
+    await host.requireSession().setSwarmMode(enabled, trigger);
+  } catch (error) {
+    host.showError(
+      `Failed to ${enabled ? 'enable' : 'disable'} swarm mode: ${formatErrorMessage(error)}`,
+    );
+    return false;
+  }
+  host.setAppState({ swarmMode: enabled });
+  host.state.swarmModeEntry = enabled ? trigger : undefined;
+  return true;
+}
+
+function swarmModeSubcommand(input: string): boolean | undefined {
+  const command = input.toLowerCase();
+  if (command === 'on') return true;
+  if (command === 'off') return false;
+  return undefined;
+}
+
+function renderSwarmModeMarker(host: SlashCommandHost, state: SwarmModeMarkerState): void {
+  host.state.transcriptContainer.addChild(
+    new SwarmModeMarkerComponent(state),
+  );
+  host.state.ui.requestRender();
+}

apps/kimi-code/src/tui/commands/tower.ts

@@ -0,0 +1,90 @@
+import type { Session } from '@moonshot-ai/kimi-code-sdk';
+
+import { TOWER_STATUS_PROMPT, TOWER_TEARDOWN_PROMPT } from '../constant/kimi-tui';
+import { formatErrorMessage } from '../utils/event-payload';
+import type { SlashCommandHost } from './dispatch';
+
+export async function handleTowerCommand(host: SlashCommandHost, args: string): Promise<void> {
+  const input = args.trim();
+  const sub = input.toLowerCase();
+
+  if (sub === 'on') {
+    await applyTowerMode(host, true);
+    return;
+  }
+  if (sub === 'off') {
+    await applyTowerMode(host, false);
+    return;
+  }
+  if (sub === '' || sub === 'status') {
+    host.sendNormalUserInput(TOWER_STATUS_PROMPT);
+    return;
+  }
+  if (sub === 'teardown') {
+    host.sendNormalUserInput(TOWER_TEARDOWN_PROMPT);
+    return;
+  }
+
+  await startTowerWithBase(host, input);
+}
+
+async function startTowerWithBase(host: SlashCommandHost, base: string): Promise<void> {
+  // `/tower <base>` is manual activation too: it turns tower mode on and pins
+  // the branch missions merge back into (the engine validates that it is a
+  // local branch). Only the agent can never enter the mode by itself.
+  const wasActive = host.state.appState.towerMode;
+  if (!(await setTowerMode(host, true, base))) return;
+  host.showNotice(wasActive ? `Tower base: ${base}` : `Tower mode: ON (base: ${base})`);
+}
+
+async function applyTowerMode(host: SlashCommandHost, enabled: boolean): Promise<void> {
+  const wasActive = host.state.appState.towerMode;
+  // The setter is idempotent engine-side, so always reassert — a stale cache
+  // must not leave the authoritative mode unchanged.
+  if (!(await setTowerMode(host, enabled))) return;
+  if (wasActive === enabled) {
+    host.showStatus(`Tower mode is already ${enabled ? 'on' : 'off'}.`);
+    return;
+  }
+  host.showNotice(enabled ? 'Tower mode: ON' : 'Tower mode: OFF');
+}
+
+async function setTowerMode(
+  host: SlashCommandHost,
+  enabled: boolean,
+  base?: string,
+): Promise<boolean> {
+  const session = await requireSessionEnsured(host);
+  if (session === undefined) return false;
+  try {
+    await session.setTowerMode(enabled, base);
+    // The engine may silently refuse entry (flag off, feature not assembled
+    // until a restart, another session owning the workspace tower) — confirm
+    // the mode actually took before reporting success.
+    const status = await session.getStatus();
+    const effective = status.towerMode ?? false;
+    if (effective !== enabled) {
+      host.setAppState({ towerMode: effective });
+      host.showError(
+        enabled
+          ? 'Tower mode could not be enabled — another session owns this workspace tower, or the experiment is off / was just turned on and needs a restart.'
+          : 'Tower mode could not be disabled.',
+      );
+      return false;
+    }
+  } catch (error) {
+    host.showError(
+      `Failed to ${enabled ? 'enable' : 'disable'} tower mode: ${formatErrorMessage(error)}`,
+    );
+    return false;
+  }
+  host.setAppState({ towerMode: enabled });
+  return true;
+}
+
+async function requireSessionEnsured(host: SlashCommandHost): Promise<Session | undefined> {
+  if (host.session !== undefined) return host.session;
+  // v2 session-less: lazy-create the session, then toggle — the same path
+  // the first prompt takes.
+  return host.ensureSession();
+}

apps/kimi-code/src/tui/commands/types.ts

@@ -0,0 +1,30 @@
+import type { AutocompleteItem, SlashCommand } from '@moonshot-ai/pi-tui';
+
+export type SlashCommandAvailability = 'always' | 'idle-only';
+
+export interface KimiSlashCommand<Name extends string = string> extends SlashCommand {
+  readonly name: Name;
+  readonly aliases: readonly string[];
+  readonly description: string;
+  readonly priority?: number;
+  readonly availability?: SlashCommandAvailability | ((args: string) => SlashCommandAvailability);
+  /** When set, the command is hidden from the palette and blocked unless this flag is enabled.
+   * A plain string: the gating flag may live in either engine's registry (v1 core or v2 domain). */
+  readonly experimentalFlag?: string;
+  /**
+   * Generic argument autocompletion. `argumentPrefix` is the text typed after
+   * `/<command> `; return suggestions or `null`. Declared as a plain function
+   * property (not a method) so passing it around is `this`-free. Adapted to
+   * pi-tui's `getArgumentCompletions` in the autocomplete setup.
+   */
+  readonly completeArgs?: (argumentPrefix: string) => AutocompleteItem[] | null;
+}
+
+export interface ParsedSlashInput {
+  readonly name: string;
+  readonly args: string;
+}
+
+export type SlashCommandBusyReason = 'streaming' | 'compacting';
+
+export type SlashCommandInvalidReason = 'unknown';

apps/kimi-code/src/tui/commands/undo.ts

@@ -0,0 +1,558 @@
+import type { Component } from '@moonshot-ai/pi-tui';
+import type { ContextMessage } from '@moonshot-ai/kimi-code-sdk';
+import { isKimiError } from '@moonshot-ai/kimi-code-sdk';
+
+import { WelcomeComponent } from '../components/chrome/welcome';
+import { CompactionComponent } from '../components/dialogs/compaction';
+import {
+  UndoSelectorComponent,
+  type UndoChoice,
+} from '../components/dialogs/undo-selector';
+import { AgentGroupComponent } from '../components/messages/agent-group';
+import { AgentSwarmProgressComponent } from '../components/messages/agent-swarm-progress';
+import { AssistantMessageComponent } from '../components/messages/assistant-message';
+import { BackgroundAgentStatusComponent } from '../components/messages/background-agent-status';
+import { CronMessageComponent } from '../components/messages/cron-message';
+import { ReadGroupComponent } from '../components/messages/read-group';
+import { SkillActivationComponent } from '../components/messages/skill-activation';
+import { PluginCommandComponent } from '../components/messages/plugin-command';
+import { ThinkingComponent } from '../components/messages/thinking';
+import { ToolCallComponent } from '../components/messages/tool-call';
+import { UserMessageComponent } from '../components/messages/user-message';
+import { NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
+import type { TranscriptEntry } from '../types';
+import { formatErrorMessage } from '../utils/event-payload';
+import { getTranscriptComponentEntry } from '../utils/transcript-component-metadata';
+import { nextTranscriptId } from '../utils/transcript-id';
+import type { SlashCommandHost } from './dispatch';
+
+// ---------------------------------------------------------------------------
+// Undo command
+// ---------------------------------------------------------------------------
+
+interface UndoAvailability {
+  readonly maxCount: number;
+  readonly stoppedAtCompaction: boolean;
+}
+
+type UndoSessionContext = Awaited<
+  ReturnType<NonNullable<SlashCommandHost['session']>['getContext']>
+>;
+
+const UNDO_LIMIT_STATUS_TURN_ID = 'undo-limit-status';
+
+export async function handleUndoCommand(
+  host: SlashCommandHost,
+  args: string = '',
+): Promise<void> {
+  if (host.state.appState.streamingPhase !== 'idle') {
+    host.showError('Cannot undo while streaming — press Esc or Ctrl-C first.');
+    return;
+  }
+
+  const trimmed = args.trim();
+  if (trimmed.length === 0) {
+    await showUndoSelector(host);
+    return;
+  }
+
+  const count = parseUndoCount(trimmed);
+  if (count === undefined) {
+    host.showError('Usage: /undo [count], where count is a positive integer.');
+    return;
+  }
+
+  const session = host.session;
+  if (session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  const availability = await resolveUndoAvailability(host);
+  if (count > availability.maxCount) {
+    showUndoLimitStatus(host, formatUndoLimitMessage(count, availability));
+    return;
+  }
+
+  await undoByCount(host, count);
+}
+
+async function undoByCount(host: SlashCommandHost, count: number): Promise<boolean> {
+  const session = host.session;
+  if (session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return false;
+  }
+
+  const entries = host.state.transcriptEntries;
+  const lastUserIndex = findUndoAnchorEntryIndex(entries, count);
+  if (lastUserIndex === undefined) {
+    showUndoLimitStatus(host, 'Nothing to undo.');
+    return false;
+  }
+  // When the anchor is a bundled prompt, its skill activation cards sit
+  // before it (contiguous, marked at submission/replay time) and are removed
+  // together with it.
+
+  try {
+    await session.undoHistory(count);
+  } catch (error) {
+    const limit = undoLimitFromError(error);
+    if (limit !== undefined) {
+      showUndoLimitStatus(host, formatUndoLimitMessage(limit.requestedCount, limit));
+      return false;
+    }
+    const message = formatErrorMessage(error);
+    host.showError(`Failed to undo: ${message}`);
+    return false;
+  }
+  host.noteContextCut?.();
+  await refreshTodoPanel(host);
+
+  const children = host.state.transcriptContainer.children;
+  const lastUserComponentIndex = findUndoAnchorComponentIndex(children, count);
+  if (lastUserComponentIndex !== undefined) {
+    // A hook result may interleave between the bundle's cards and its prompt
+    // and survives undo in the engine, so it is skipped (kept) while the
+    // cards around it are removed. Only the contiguous marked run belongs to
+    // this submission: a standalone `/skill` card is unmarked and never
+    // swept. Structural removal only: the container's ref-checked render
+    // cache detects the child-list change; no tree-wide invalidate needed.
+    const groupChildIndices = new Set<number>();
+    for (let i = lastUserComponentIndex - 1; i >= 0; i--) {
+      const entry = getTranscriptComponentEntry(children[i]!);
+      if (entry?.bundledWithPrompt === true) {
+        groupChildIndices.add(i);
+        continue;
+      }
+      if (entry?.hookResult === true) continue;
+      break;
+    }
+    removeUndoContextComponents(children, lastUserComponentIndex, groupChildIndices);
+  }
+
+  const groupEntryIndices = new Set<number>();
+  for (let i = lastUserIndex - 1; i >= 0; i--) {
+    const prev = entries[i];
+    if (prev?.bundledWithPrompt === true) {
+      groupEntryIndices.add(i);
+      continue;
+    }
+    if (prev?.hookResult === true) continue;
+    break;
+  }
+  const preservedEntries = entries.filter(
+    (entry, index) =>
+      !(
+        (index >= lastUserIndex || groupEntryIndices.has(index)) &&
+        isUndoContextEntry(entry)
+      ),
+  );
+  entries.splice(0, entries.length, ...preservedEntries);
+
+  if (entries.length === 0) {
+    renderWelcome(host);
+  }
+
+  host.state.ui.requestRender();
+  return true;
+}
+
+async function refreshTodoPanel(host: SlashCommandHost): Promise<void> {
+  const session = host.session;
+  if (session === undefined) return;
+  try {
+    const todos = await session.getTodos();
+    if (todos.length > 0 && todos.every((todo) => todo.status === 'done')) {
+      host.streamingUI.setTodoList([]);
+      return;
+    }
+    host.streamingUI.setTodoList(todos);
+  } catch {
+    return;
+  }
+}
+
+async function showUndoSelector(host: SlashCommandHost): Promise<void> {
+  if (host.session === undefined) {
+    host.showError(NO_ACTIVE_SESSION_MESSAGE);
+    return;
+  }
+
+  const availability = await resolveUndoAvailability(host);
+  const choices = createUndoChoices(
+    host.state.transcriptEntries,
+    host.state.transcriptContainer.children,
+    availability.maxCount,
+  );
+  if (choices.length === 0) {
+    showUndoLimitStatus(host, formatNothingToUndoMessage(availability));
+    return;
+  }
+
+  host.mountEditorReplacement(
+    new UndoSelectorComponent({
+      choices,
+      onSelect: (choice) => {
+        void undoByCount(host, choice.count).then((undone) => {
+          if (undone) {
+            host.restoreInputText(choice.input);
+            return;
+          }
+          host.restoreEditor();
+        });
+      },
+      onCancel: () => {
+        host.restoreEditor();
+      },
+    }),
+  );
+}
+
+function parseUndoCount(args: string): number | undefined {
+  const value = args.trim();
+  if (value.length === 0) return 1;
+  if (!/^[1-9]\d*$/.test(value)) return undefined;
+  const count = Number(value);
+  return Number.isSafeInteger(count) ? count : undefined;
+}
+
+async function resolveUndoAvailability(
+  host: SlashCommandHost,
+): Promise<UndoAvailability> {
+  const local = undoAvailabilityFromTranscript(
+    host.state.transcriptEntries,
+    host.state.transcriptContainer.children,
+  );
+  const context = await getSessionContext(host.session);
+  if (context === undefined) return local;
+
+  const activeContext = undoAvailabilityFromContext(context.history);
+  return {
+    maxCount: Math.min(local.maxCount, activeContext.maxCount),
+    stoppedAtCompaction:
+      local.stoppedAtCompaction || activeContext.stoppedAtCompaction,
+  };
+}
+
+async function getSessionContext(
+  session: SlashCommandHost['session'],
+): Promise<UndoSessionContext | undefined> {
+  const getContext = (
+    session as { getContext?: () => Promise<UndoSessionContext> } | undefined
+  )?.getContext;
+  if (session === undefined || getContext === undefined) return undefined;
+  try {
+    return await getContext.call(session);
+  } catch {
+    return undefined;
+  }
+}
+
+function undoAvailabilityFromTranscript(
+  entries: readonly TranscriptEntry[],
+  children: readonly Component[],
+): UndoAvailability {
+  const { anchors, stoppedAtCompaction } = activeUndoAnchorEntries(entries, children);
+  return {
+    maxCount: anchors.length,
+    stoppedAtCompaction,
+  };
+}
+
+function undoAvailabilityFromContext(
+  history: readonly ContextMessage[],
+): UndoAvailability {
+  let maxCount = 0;
+  let stoppedAtCompaction = false;
+
+  for (let i = history.length - 1; i >= 0; i--) {
+    const message = history[i];
+    if (message === undefined) continue;
+    if (message.origin?.kind === 'injection') continue;
+    if (message.origin?.kind === 'compaction_summary') {
+      stoppedAtCompaction = true;
+      break;
+    }
+    if (isContextUndoAnchor(message)) maxCount++;
+  }
+
+  return { maxCount, stoppedAtCompaction };
+}
+
+function isContextUndoAnchor(message: ContextMessage): boolean {
+  if (message.role !== 'user') return false;
+  const origin = message.origin;
+  if (origin === undefined || origin.kind === 'user') return true;
+  if (origin.kind === 'skill_activation') {
+    return origin.trigger === 'user-slash';
+  }
+  if (origin.kind === 'plugin_command') {
+    return origin.trigger === 'user-slash';
+  }
+  return false;
+}
+
+function createUndoChoices(
+  entries: readonly TranscriptEntry[],
+  children: readonly Component[],
+  maxCount: number,
+): readonly UndoChoice[] {
+  if (maxCount <= 0) return [];
+  const anchors = activeUndoAnchorEntries(entries, children).anchors.slice(-maxCount);
+  return anchors.map((entry, index) => ({
+    id: entry.id,
+    count: anchors.length - index,
+    input: formatUndoChoiceInput(entry),
+    label: formatUndoChoiceLabel(entry),
+  }));
+}
+
+function activeUndoAnchorEntries(
+  entries: readonly TranscriptEntry[],
+  children: readonly Component[],
+): { readonly anchors: readonly TranscriptEntry[]; readonly stoppedAtCompaction: boolean } {
+  const lastCompactionChildIndex = children.findLastIndex(
+    (child) => child instanceof CompactionComponent,
+  );
+  if (lastCompactionChildIndex >= 0) {
+    return {
+      anchors: children
+        .slice(lastCompactionChildIndex + 1)
+        .map((child) => getTranscriptComponentEntry(child))
+        .filter((entry): entry is TranscriptEntry => entry !== undefined)
+        .filter(isUndoAnchorEntry),
+      stoppedAtCompaction: true,
+    };
+  }
+
+  const lastCompactionEntryIndex = entries.findLastIndex(
+    (entry) => entry.compactionData !== undefined,
+  );
+  const activeEntries =
+    lastCompactionEntryIndex >= 0 ? entries.slice(lastCompactionEntryIndex + 1) : entries;
+  return {
+    anchors: activeEntries.filter(isUndoAnchorEntry),
+    stoppedAtCompaction: lastCompactionEntryIndex >= 0,
+  };
+}
+
+function formatUndoChoiceLabel(
+  entry: TranscriptEntry,
+): string {
+  if (entry.kind === 'skill_activation') {
+    const name = singleLine(
+      entry.skillName ?? entry.content.replace(/^Activated skill:\s*/, ''),
+    );
+    const args = singleLine(entry.skillArgs ?? '');
+    if (name.length === 0) return 'Skill: unknown';
+    return args.length > 0 ? `/${name} ${args}` : `/${name}`;
+  }
+  if (entry.kind === 'plugin_command' && entry.pluginCommandData !== undefined) {
+    return formatPluginCommandSlash(entry.pluginCommandData) ?? 'User message';
+  }
+
+  const content = singleLine(entry.content);
+  const imageCount = entry.imageAttachmentIds?.length ?? 0;
+  if (content.length > 0) return content;
+  if (imageCount > 0) {
+    return `User message (${String(imageCount)} ${imageCount === 1 ? 'image' : 'images'})`;
+  }
+  return 'User message';
+}
+
+function formatUndoChoiceInput(entry: TranscriptEntry): string {
+  if (entry.kind === 'skill_activation') {
+    const name = singleLine(
+      entry.skillName ?? entry.content.replace(/^Activated skill:\s*/, ''),
+    );
+    const args = singleLine(entry.skillArgs ?? '');
+    if (name.length === 0) return '';
+    return args.length > 0 ? `/${name} ${args}` : `/${name}`;
+  }
+  if (entry.kind === 'plugin_command' && entry.pluginCommandData !== undefined) {
+    return formatPluginCommandSlash(entry.pluginCommandData) ?? entry.content;
+  }
+  return entry.content;
+}
+
+function formatPluginCommandSlash(data: NonNullable<TranscriptEntry['pluginCommandData']>): string | undefined {
+  const name = `${data.pluginId}:${data.commandName}`;
+  const args = singleLine(data.args ?? '');
+  if (name.length === 0) return undefined;
+  return args.length > 0 ? `/${name} ${args}` : `/${name}`;
+}
+
+function singleLine(text: string): string {
+  return text.replaceAll(/\s+/g, ' ').trim();
+}
+
+function formatUndoLimitMessage(
+  requestedCount: number,
+  availability: UndoAvailability,
+): string {
+  const reason = availability.stoppedAtCompaction ? ' after the last compaction' : '';
+  const requested = formatPromptCount(requestedCount);
+  const max = formatPromptCount(availability.maxCount);
+  return `Cannot undo ${requested}; only ${max} can be undone in the active context${reason}.`;
+}
+
+function formatNothingToUndoMessage(availability: UndoAvailability): string {
+  if (availability.stoppedAtCompaction) {
+    return 'Nothing to undo after the last compaction.';
+  }
+  return 'Nothing to undo.';
+}
+
+function formatPromptCount(count: number): string {
+  return `${String(count)} ${count === 1 ? 'prompt' : 'prompts'}`;
+}
+
+function showUndoLimitStatus(host: SlashCommandHost, message: string): void {
+  host.appendTranscriptEntry({
+    id: nextTranscriptId(),
+    kind: 'status',
+    turnId: UNDO_LIMIT_STATUS_TURN_ID,
+    renderMode: 'plain',
+    content: message,
+  });
+}
+
+function undoLimitFromError(
+  error: unknown,
+): (UndoAvailability & { readonly requestedCount: number }) | undefined {
+  if (!isKimiError(error)) return undefined;
+  const details = error.details;
+  if (details?.['reason'] !== 'undo_limit') return undefined;
+  const requestedCount = details['requestedCount'];
+  const maxCount = details['undoableCount'];
+  const stoppedAtCompaction = details['stoppedAtCompaction'];
+  if (
+    typeof requestedCount !== 'number' ||
+    typeof maxCount !== 'number' ||
+    typeof stoppedAtCompaction !== 'boolean'
+  ) {
+    return undefined;
+  }
+  return { requestedCount, maxCount, stoppedAtCompaction };
+}
+
+function isUndoAnchorEntry(entry: TranscriptEntry): boolean {
+  return (
+    entry.kind === 'user' ||
+    (entry.kind === 'skill_activation' &&
+      entry.skillTrigger === 'user-slash' &&
+      entry.bundledWithPrompt !== true) ||
+    entry.kind === 'plugin_command'
+  );
+}
+
+function findUndoAnchorEntryIndex(
+  entries: readonly TranscriptEntry[],
+  count: number,
+): number | undefined {
+  let found = 0;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry !== undefined && isUndoAnchorEntry(entry)) {
+      found++;
+      if (found === count) return i;
+    }
+  }
+  return undefined;
+}
+
+function isUndoContextEntry(entry: TranscriptEntry): boolean {
+  switch (entry.kind) {
+    case 'user':
+    case 'assistant':
+    case 'tool_call':
+    case 'thinking':
+    case 'skill_activation':
+    case 'plugin_command':
+    case 'cron':
+      return true;
+    case 'status':
+    case 'goal':
+      return entry.turnId !== undefined;
+    case 'welcome':
+      return false;
+  }
+}
+
+function findUndoAnchorComponentIndex(
+  children: readonly Component[],
+  count: number,
+): number | undefined {
+  let found = 0;
+  for (let i = children.length - 1; i >= 0; i--) {
+    const child = children[i];
+    if (child !== undefined && isUndoAnchorComponent(child)) {
+      found++;
+      if (found === count) return i;
+    }
+  }
+  return undefined;
+}
+
+function removeUndoContextComponents(
+  children: Component[],
+  startIndex: number,
+  additionalIndices: ReadonlySet<number>,
+): void {
+  for (let i = children.length - 1; i >= 0; i--) {
+    const child = children[i];
+    if (
+      child !== undefined &&
+      (i >= startIndex || additionalIndices.has(i)) &&
+      isUndoContextComponent(child)
+    ) {
+      children.splice(i, 1);
+    }
+  }
+}
+
+function isUndoAnchorComponent(child: Component): boolean {
+  const entry = getTranscriptComponentEntry(child);
+  return (
+    child instanceof UserMessageComponent ||
+    (child instanceof SkillActivationComponent &&
+      child.trigger === 'user-slash' &&
+      entry?.bundledWithPrompt !== true) ||
+    child instanceof PluginCommandComponent
+  );
+}
+
+function isUndoContextComponent(child: Component): boolean {
+  const entry = getTranscriptComponentEntry(child);
+  if (entry !== undefined) {
+    return isUndoContextEntry(entry);
+  }
+
+  return (
+    child instanceof UserMessageComponent ||
+    child instanceof AssistantMessageComponent ||
+    child instanceof ThinkingComponent ||
+    child instanceof ToolCallComponent ||
+    child instanceof AgentGroupComponent ||
+    child instanceof AgentSwarmProgressComponent ||
+    child instanceof ReadGroupComponent ||
+    child instanceof SkillActivationComponent ||
+    child instanceof PluginCommandComponent ||
+    child instanceof BackgroundAgentStatusComponent ||
+    child instanceof CronMessageComponent
+  );
+}
+
+function renderWelcome(host: SlashCommandHost): void {
+  if (
+    host.state.transcriptContainer.children.some(
+      (child) => child instanceof WelcomeComponent,
+    )
+  ) {
+    return;
+  }
+  host.state.transcriptContainer.addChild(
+    new WelcomeComponent(host.state.appState),
+  );
+}