open-tui-orchestrator 0.9.6

package/scripts/core/host-model.mjs

@@ -0,0 +1,323 @@
+// 发起窗 model/thinking level 继承：检测「发起本 orchestrator 的那个 TUI 窗口」当前实际使用的
+// model 与 thinking effort，让发起的子窗与发起窗保持一致（宿主自适应的延伸：同窗即同 agent，
+// 取值逐字透传，无需跨 agent 映射）。
+//
+// 检测数据源（全部本地只读，任何一步失败都降级而非抛错）：
+//   codex    — CODEX_THREAD_ID 定位当日 rollout jsonl，取最后出现的 "model"/"reasoning_effort"；
+//              回退 ~/.codex/config.toml 的 model / model_reasoning_effort。
+//   kimi     — ~/.kimi-code/sessions/<wd_*>/session_*/state.json 按 cwd 匹配、updatedAt 最新者
+//              认定为发起会话，读其 agents/main/wire.jsonl 尾部最后一条 llm.request 的
+//              modelAlias/thinkingEffort；回退 config.toml 的 default_model / [thinking].effort。
+//   pi       — ~/.pi/agent/settings.json 的 defaultModel / defaultThinkingLevel。
+//   opencode — ~/.config/opencode/opencode.json(c) 顶层 model；opencode 无 effort 概念。
+//   openclaw — 配置世界隔离，返回 null（不动它）。
+//
+// 优先级：显式 ORCH_MODEL / ORCH_EFFORT 环境变量 > 本模块检测值 > CLI 自身默认。
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {loadProfile} from './print-profile.mjs';
+
+// 合法 model/effort 值绝不含空白与引号；脏值一律丢弃（下游会拼进 ps1/argv，防注入）。
+function clean(v) {
+  const s = String(v ?? '').trim();
+  return s && !/[\s"']/.test(s) ? s : null;
+}
+
+function readTailLines(file, bytes = 262144) {
+  let fd;
+  try {
+    const size = fs.statSync(file).size;
+    if (!size) return [];
+    fd = fs.openSync(file, 'r');
+    const start = Math.max(0, size - bytes);
+    const buf = Buffer.alloc(size - start);
+    fs.readSync(fd, buf, 0, buf.length, start);
+    return buf.toString('utf8').split(/\r?\n/);
+  } catch { return []; }
+  finally { if (fd !== undefined) { try { fs.closeSync(fd); } catch { /* ignore */ } } }
+}
+
+// 从后往前扫 JSONL 行，返回最后一条满足 test(line) 的可解析记录；末行可能正在写入，解析失败即跳过。
+function lastJsonlRecord(lines, test) {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line || !test(line)) continue;
+    try { return JSON.parse(line); } catch { /* 半行/坏行跳过 */ }
+  }
+  return null;
+}
+
+function lastMatch(text, re) {
+  let m, last = null;
+  while ((m = re.exec(text)) !== null) last = m[1];
+  return clean(last);
+}
+
+function parseTomlScalar(text, key) {
+  const m = new RegExp('^' + key + '\\s*=\\s*"([^"]+)"', 'm').exec(text);
+  return clean(m && m[1]);
+}
+
+// ---------------------------------------------------------------- codex ----
+function codexRolloutFile(sessionsDir, threadId) {
+  // sessions/<YYYY>/<MM>/<DD>/rollout-*<threadId>.jsonl；目录名可字典序倒排，发起会话必在最近几天。
+  let years = [];
+  try { years = fs.readdirSync(sessionsDir).filter((d) => /^\d{4}$/.test(d)).sort().reverse(); } catch { return null; }
+  outer: for (const y of years.slice(0, 1)) {
+    let months = [];
+    try { months = fs.readdirSync(path.join(sessionsDir, y)).filter((d) => /^\d{2}$/.test(d)).sort().reverse(); } catch { continue; }
+    for (const mo of months.slice(0, 2)) {
+      let days = [];
+      try { days = fs.readdirSync(path.join(sessionsDir, y, mo)).filter((d) => /^\d{2}$/.test(d)).sort().reverse(); } catch { continue; }
+      for (const d of days.slice(0, 4)) {
+        const dir = path.join(sessionsDir, y, mo, d);
+        let files = [];
+        try { files = fs.readdirSync(dir); } catch { continue; }
+        const hit = files.find((f) => f.includes(threadId) && f.endsWith('.jsonl'));
+        if (hit) return path.join(dir, hit);
+      }
+    }
+    break outer; // 只查最近一个年份目录
+  }
+  return null;
+}
+
+function detectCodex({ env, codexHome }) {
+  const home = codexHome || env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  const tid = clean(env.CODEX_THREAD_ID) || clean(env.CODEX_SESSION_ID);
+  let model = null, effort = null, source = null;
+  if (tid) {
+    const file = codexRolloutFile(path.join(home, 'sessions'), tid);
+    if (file) {
+      const tail = readTailLines(file).join('\n');
+      model = lastMatch(tail, /"model":"([^"]+)"/g);
+      effort = lastMatch(tail, /"reasoning_effort":"([^"]+)"/g);
+      if (model || effort) source = 'codex-rollout';
+    }
+  }
+  if (!model || !effort) {
+    try {
+      const toml = fs.readFileSync(path.join(home, 'config.toml'), 'utf8');
+      if (!model) model = parseTomlScalar(toml, 'model');
+      if (!effort) effort = parseTomlScalar(toml, 'model_reasoning_effort');
+      if ((model || effort) && !source) source = 'codex-config';
+    } catch { /* 无 config.toml 就算了 */ }
+  }
+  return model || effort ? { model, effort, source } : null;
+}
+
+// ----------------------------------------------------------------- kimi ----
+function kimiHostSession(sessionsRoot, cwd) {
+  const norm = (p) => String(p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+  const want = norm(cwd);
+  let best = null;
+  let wds = [];
+  try { wds = fs.readdirSync(sessionsRoot); } catch { return null; }
+  for (const wd of wds) {
+    const wdDir = path.join(sessionsRoot, wd);
+    let sessions = [];
+    try { sessions = fs.readdirSync(wdDir); } catch { continue; }
+    for (const s of sessions) {
+      const stateFile = path.join(wdDir, s, 'state.json');
+      try {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+        if (norm(state.cwd) !== want) continue;
+        const at = Number(state.updatedAt) || 0;
+        if (!best || at > best.at) best = { at, dir: path.join(wdDir, s) };
+      } catch { /* 坏 state.json 跳过 */ }
+    }
+  }
+  return best && best.dir;
+}
+
+function detectKimi({ cwd, kimiHome, env = process.env }) {
+  const home = kimiHome || env.KIMI_CODE_HOME || path.join(os.homedir(), '.kimi-code');
+  let model = null, effort = null, source = null;
+  const sessionDir = cwd && kimiHostSession(path.join(home, 'sessions'), cwd);
+  if (sessionDir) {
+    const rec = lastJsonlRecord(
+      readTailLines(path.join(sessionDir, 'agents', 'main', 'wire.jsonl')),
+      (line) => line.includes('"llm.request"'),
+    );
+    if (rec) {
+      model = clean(rec.modelAlias) || clean(rec.model);
+      effort = clean(rec.thinkingEffort);
+      if (model || effort) source = 'kimi-wire';
+    }
+  }
+  if (!model || !effort) {
+    try {
+      const toml = fs.readFileSync(path.join(home, 'config.toml'), 'utf8');
+      if (!model) model = parseTomlScalar(toml, 'default_model');
+      if (!effort) {
+        const sec = /\[thinking\]([^\[]*)/.exec(toml);
+        if (sec) effort = parseTomlScalar(sec[1], 'effort');
+      }
+      if ((model || effort) && !source) source = 'kimi-config';
+    } catch { /* ignore */ }
+  }
+  return model || effort ? { model, effort, source } : null;
+}
+
+// ------------------------------------------------------------------- pi ----
+function detectPi({ piHome }) {
+  const home = piHome || path.join(os.homedir(), '.pi');
+  try {
+    const s = JSON.parse(fs.readFileSync(path.join(home, 'agent', 'settings.json'), 'utf8'));
+    const model = clean(s.defaultModel);
+    const effort = clean(s.defaultThinkingLevel);
+    return model || effort ? { model, effort, source: 'pi-settings' } : null;
+  } catch { return null; }
+}
+
+// ------------------------------------------------------------- opencode ----
+function parseJsonc(text) {
+  try { return JSON.parse(text); } catch { /* 继续走清洗 */ }
+  const stripped = String(text)
+    .split(/\r?\n/).filter((l) => !/^\s*\/\//.test(l)).join('\n')
+    .replace(/,\s*([}\]])/g, '$1');
+  try { return JSON.parse(stripped); } catch { return null; }
+}
+
+function detectOpenCode({ configHome }) {
+  const dir = configHome || path.join(os.homedir(), '.config', 'opencode');
+  for (const name of ['opencode.json', 'opencode.jsonc']) {
+    try {
+      const cfg = parseJsonc(fs.readFileSync(path.join(dir, name), 'utf8'));
+      const model = clean(cfg && cfg.model);
+      if (model) return { model, effort: null, source: 'opencode-config' };
+    } catch { /* 尝试下一个文件名 */ }
+  }
+  return null;
+}
+
+// --------------------------------------------------------------- claude ----
+// Claude Code settings: ~/.claude/settings.json 顶层 model（别名或完整 id）；
+// effort 读取 settings 的 "effort"（存在时）。缺失即 null，绝不猜。
+function detectClaude({ claudeHome, env = process.env }) {
+  const home = claudeHome || env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  for (const name of ['settings.json', path.join('..', '.claude.json')]) {
+    try {
+      const file = path.join(home, name);
+      if (!fs.existsSync(file)) continue;
+      const cfg = JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
+      const model = typeof cfg?.model === 'string' && cfg.model.trim() ? cfg.model.trim() : '';
+      const effort = typeof cfg?.effort === 'string' && cfg.effort.trim() ? cfg.effort.trim() : '';
+      if (model || effort) return { model: model || null, effort: effort || null, source: 'claude-settings' };
+    } catch { /* try next */ }
+  }
+  return null;
+}
+
+// --------------------------------------------------------------- profile ----
+// print-class 画像 agent 的 model/effort 探测：由画像的可选 modelDetection 规格描述
+// （adapt 自动做精确候选发现，也可手填）。规格形态：
+//   modelDetection: { env:["<ID>_MODEL"], config:[{file:"~/.x.conf.yml", modelKey:"model", effortKey:"effort"}] }
+// 只读精确键名，绝不猜测；缺失即 null（回退该 CLI 自身默认，或用 ORCH_MODEL/ORCH_EFFORT 显式指定）。
+export function readProfileKey(file, key, jsonc) {
+  let text = fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '');
+  if (/\.jsonc$/i.test(file) || jsonc) text = text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
+  if (/\.jsonc?$/i.test(file) || jsonc) {
+    const value = JSON.parse(text)?.[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : '';
+  }
+  const re = new RegExp('^\\s*' + key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s*:\\s*["\']?([^"\'#\\r\\n]+)', 'm');
+  const m = re.exec(text);
+  return m && m[1].trim() ? m[1].trim() : '';
+}
+// YAML 风格「节内键」读取：model: 节下的 default / reasoning_effort 等嵌套键（JSON 亦支持）。
+// 只读精确节点名与精确键名，绝不猜测。
+export function readSectionKey(file, section, key, jsonc) {
+  let text = fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, '');
+  const esc = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  if (/\.jsonc?$/i.test(file) || jsonc) {
+    let obj = null;
+    try { obj = JSON.parse(text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '')); } catch { obj = null; }
+    const v = obj && obj[section] && obj[section][key];
+    return typeof v === 'string' && v.trim() ? v.trim() : '';
+  }
+  const lines = text.split(/\r?\n/);
+  const secRe = new RegExp('^(\\s*)' + esc(section) + '\\s*:\\s*$');
+  for (let i = 0; i < lines.length; i++) {
+    const m = secRe.exec(lines[i]);
+    if (!m) continue;
+    const indent = m[1].length;
+    for (let j = i + 1; j < lines.length; j++) {
+      const line = lines[j];
+      if (!line.trim() || /^\s*#/.test(line)) continue;
+      const ind = /^(\s*)/.exec(line)[1].length;
+      if (ind <= indent) break;
+      const hit = new RegExp('^\\s*' + esc(key) + '\\s*:\\s*["\']?([^"\'#\\r\\n]+)').exec(line);
+      if (hit && hit[1].trim()) return hit[1].trim();
+    }
+  }
+  return '';
+}
+
+// 该 agent 是否具备「档位继承探测」能力（原生适配器或带 modelDetection 的画像）。
+// 用于「无记录 → 宿主自身配置兜底」时打印明确声明（禁止静默换档）；openclaw/纯自定义单元不适用。
+export function hasModelDetector(agent, env = process.env) {
+  if (['codex', 'kimi', 'pi', 'opencode', 'claude'].includes(String(agent || ''))) return true;
+  try { return !!(loadProfile(agent, env) || {}).modelDetection; } catch { return false; }
+}
+
+function detectProfile({ id, env = process.env }) {
+  const profile = loadProfile(id, env);
+  const md = profile && profile.modelDetection;
+  if (!md) return null;
+  let model = '', effort = '';
+  for (const name of md.env || []) { if (!model && env[name]) model = String(env[name]).trim(); }
+  for (const name of md.effortEnv || []) { if (!effort && env[name]) effort = String(env[name]).trim(); }
+  for (const c of md.config || []) {
+    try {
+      const home = env.USERPROFILE || env.HOME || os.homedir();
+      const raw = String(c.file || '');
+      // ~ 展开 + $VAR/${VAR} 环境变量展开（如 $HERMES_HOME/config.yaml）；变量未定义时保持字面量、文件不存在即跳过。
+      const expanded = raw.startsWith('~') ? path.join(home, raw.slice(1))
+        : raw.replace(/\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?/g, (m, name) => env[name] || m);
+      const file = path.resolve(expanded);
+      if (!expanded || !fs.existsSync(file)) continue;
+      const readIn = (sec, k) => (sec ? readSectionKey(file, sec, k) : readProfileKey(file, k));
+      if (!model && c.modelKey) model = readIn(c.section, c.modelKey);
+      if (!effort && c.effortKey) effort = readIn(c.effortSection || c.section, c.effortKey);
+    } catch { /* try next */ }
+  }
+  return model || effort ? { model: model || null, effort: effort || null, source: 'profile:' + id } : null;
+}
+
+// --------------------------------------------------------------- 调度 ------
+export function detectHostModelEffort(agent, { cwd, env = process.env, homes = {} } = {}) {
+  try {
+    switch (String(agent || '')) {
+      case 'codex': return detectCodex({ env, codexHome: homes.codex });
+      case 'kimi': return detectKimi({ cwd, kimiHome: homes.kimi, env });
+      case 'pi': return detectPi({ piHome: homes.pi });
+      case 'opencode': return detectOpenCode({ configHome: homes.opencode });
+      case 'claude': return detectClaude({ claudeHome: homes.claude, env });
+      default: {
+        const profiled = detectProfile({ id: String(agent || ''), env });
+        if (profiled) return profiled;
+        return null; // openclaw 与未知 agent：不检测
+      }
+    }
+  } catch { return null; } // 检测绝不让引擎崩
+}
+
+// 引擎初始化时调用一次：把检测到的发起窗 model/effort 写回 env，下游所有适配器
+// （codex -m/-c 注入、kimi -m、pi --model/--thinking、opencode --model）都消费
+// ORCH_MODEL/ORCH_EFFORT，一次写回处处生效。显式 env 优先，只补空缺。
+export function inheritHostModelEffort(agent, { cwd, env = process.env, homes = {} } = {}) {
+  if (env.NODE_TEST_CONTEXT) return null; // 测试确定性：node --test 下不碰真实宿主状态
+  if (env.ORCH_MODEL && env.ORCH_EFFORT) return null;
+  const detected = detectHostModelEffort(agent, { cwd, env, homes });
+  if (!detected) return null;
+  if (!env.ORCH_MODEL && detected.model) env.ORCH_MODEL = detected.model;
+  if (!env.ORCH_EFFORT && detected.effort) env.ORCH_EFFORT = detected.effort;
+  // kimi CLI 无 effort 旗标；官方按进程渠道是 KIMI_MODEL_THINKING_EFFORT（kimi provider 生效，
+  // 其它 provider 类型读取与否由 CLI 决定，不生效时窗回退 config.toml [thinking].effort）。
+  if (agent === 'kimi' && detected.effort && !env.KIMI_MODEL_THINKING_EFFORT) {
+    env.KIMI_MODEL_THINKING_EFFORT = detected.effort;
+  }
+  return detected;
+}

package/scripts/core/host-probe.mjs

@@ -0,0 +1,16 @@
+import {spawnSync} from 'node:child_process';
+// 主机 CLI 探测原语：冷启动/杀软扫描会偶发把单次 spawnSync 拖过 10s（实测后台引擎两次
+// 在启动 ~11s 处因 --help 探测超时被误判 CLI_MISSING），因此对超时做有限重试；
+// 确定性失败（非 0 退出、ENOENT 等）不重试。超时/次数可用 env 覆盖（测试与现场调优用）。
+export function probeCli(bin,args,{env=process.env,timeoutMs,attempts}={}) {
+  const t=Number(timeoutMs??env.ORCH_HOST_PROBE_TIMEOUT_MS)||10000;
+  const n=Math.max(1,Math.floor(Number(attempts??env.ORCH_HOST_PROBE_ATTEMPTS)||2));
+  let last;
+  for(let i=0;i<n;i++){
+    const r=spawnSync(bin,args,{env,encoding:'utf8',windowsHide:true,shell:false,timeout:t});
+    last={status:r.status,error:r.error?String(r.error):null,stdout:String(r.stdout||''),stderr:String(r.stderr||''),out:String((r.stdout||'')+(r.stderr||''))};
+    if(last.status===0)return last;
+    if(!/ETIMEDOUT|timed out/i.test(last.error||''))return last;
+  }
+  return last;
+}

package/scripts/core/inactive-window.mjs

@@ -0,0 +1,32 @@
+import {spawn,spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+import {powershellExe} from './contracts.mjs';
+
+// 锚定 SystemRoot 的 powershell.exe：裸名会先按进程 cwd（任意工作区）解析，防二进制投毒。
+const PS_EXE=powershellExe();
+
+// Windows command-line quoting, including quotes and trailing backslashes.
+export function quoteWindowsArgument(value){
+ const text=String(value);
+ if(text.includes('\0'))throw new Error('Invalid NUL in window argument');
+ return '"'+text.replace(/(\\*)"/g,'$1$1\\"').replace(/\\+$/g,'$&$&')+'"';
+}
+export function spawnInactiveWindow(file,args,cwd,{invoke=spawnSync}={}){
+ const payload=Buffer.from(JSON.stringify({file,parameters:args.map(quoteWindowsArgument).join(' '),cwd}),'utf8').toString('base64');
+ const result=invoke(PS_EXE,['-NoProfile','-NonInteractive','-File',fileURLToPath(new URL('./inactive-window.ps1',import.meta.url)),'-Payload',payload],{cwd,windowsHide:true,shell:false,encoding:'utf8',timeout:15000});
+ if(result.error||result.status!==0)throw new Error('INACTIVE_WINDOW_LAUNCH_FAILED: '+(result.error?.message||result.stderr||result.status));
+}
+
+// Start the same Win32 no-activate helper without holding the scheduler while
+// Windows Terminal finishes creating its window. The helper briefly restores
+// the initiating foreground window and exits on its own.
+export function spawnInactiveWindowDetached(file,args,cwd,{invoke=spawn}={}){
+ const payload=Buffer.from(JSON.stringify({file,parameters:args.map(quoteWindowsArgument).join(' '),cwd}),'utf8').toString('base64');
+ let child;
+ try{
+  child=invoke(PS_EXE,['-NoProfile','-NonInteractive','-File',fileURLToPath(new URL('./inactive-window.ps1',import.meta.url)),'-Payload',payload],{cwd,windowsHide:true,shell:false,stdio:'ignore'});
+ }catch(error){throw new Error('INACTIVE_WINDOW_LAUNCH_FAILED: '+(error?.message||String(error)));}
+ if(!child||typeof child.unref!=='function')throw new Error('INACTIVE_WINDOW_LAUNCH_FAILED: helper did not return a detached process');
+ child.unref();
+ return child;
+}

package/scripts/core/inactive-window.ps1

@@ -0,0 +1,36 @@
+param([Parameter(Mandatory=$true)][string]$Payload)
+$ErrorActionPreference='Stop'
+try {
+  $request=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($Payload)) | ConvertFrom-Json
+  Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class OrchestratorInactiveShell {
+ [StructLayout(LayoutKind.Sequential,CharSet=CharSet.Unicode)] public struct Startup {
+  public int cb; public string reserved,desktop,title; public uint x,y,xSize,ySize,xCount,yCount,fill,flags;
+  public short show,reserved2;public IntPtr reservedPtr,input,output,error;
+ }
+ [StructLayout(LayoutKind.Sequential)] public struct ProcessInfo {public IntPtr process,thread;public uint pid,tid;}
+ [DllImport("kernel32.dll",CharSet=CharSet.Unicode,SetLastError=true)]
+ static extern bool CreateProcessW(string app,System.Text.StringBuilder command,IntPtr pa,IntPtr ta,bool inherit,uint flags,IntPtr env,string cwd,ref Startup startup,out ProcessInfo info);
+ [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+ [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();
+ [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr handle);
+ public static void Launch(string file,string parameters,string cwd){
+  var baseline=GetForegroundWindow();
+  var s=new Startup();s.cb=Marshal.SizeOf(s);s.flags=1;s.show=4;ProcessInfo p;
+  if(!CreateProcessW(file,new System.Text.StringBuilder("\""+file+"\" "+parameters),IntPtr.Zero,IntPtr.Zero,false,0x10,IntPtr.Zero,cwd,ref s,out p))throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
+  CloseHandle(p.thread);CloseHandle(p.process);
+  var until=Environment.TickCount+2500;
+  while(Environment.TickCount<until){
+   if(baseline!=IntPtr.Zero&&GetForegroundWindow()!=baseline)SetForegroundWindow(baseline);
+   System.Threading.Thread.Sleep(20);
+  }
+ }
+}
+'@
+  [OrchestratorInactiveShell]::Launch([string]$request.file,[string]$request.parameters,[string]$request.cwd)
+} catch {
+  [Console]::Error.WriteLine('INACTIVE_WINDOW_LAUNCH_FAILED: '+$_.Exception.Message)
+  exit 1
+}

package/scripts/core/kimi-host.mjs

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {probeCli} from './host-probe.mjs';
+const HELP_FLAGS=['--prompt','--output-format','--auto'];
+export function resolveKimiHost(env=process.env) {
+  const explicit=env.ORCH_CLI||env.KIMI_EXE;
+  const candidates=explicit?[path.resolve(explicit)]:[
+    ...String(env.PATH||env.Path||'').split(path.delimiter).filter(Boolean).flatMap(dir=>['kimi.exe','kimi.cmd','kimi'].map(n=>path.join(dir,n))),
+    ...(env.USERPROFILE?[path.join(env.USERPROFILE,'.kimi-code','bin','kimi.exe')]:[]),
+  ];
+  const rejected=[];
+  for(const file of [...new Set(candidates)]) {
+    if(!fs.existsSync(file)||!fs.statSync(file).isFile())continue;
+    let bin=file,prefixArgs=[];
+    if(!/\.exe$/i.test(file)) {
+      if(/\.[cm]?js$/i.test(file)) {
+        const sibling=path.join(path.dirname(file),'node.exe');bin=fs.existsSync(sibling)?sibling:process.execPath;prefixArgs=[file];
+      } else {
+        // The extensionless native launcher sits next to kimi.exe; prefer the explicit exe.
+        const sibling=path.join(path.dirname(file),'kimi.exe');if(!fs.existsSync(sibling))continue;bin=sibling;
+      }
+    }
+    const label=[bin,...prefixArgs].join(' ');
+    const help=probeCli(bin,[...prefixArgs,'--help'],{env});
+    const missing=HELP_FLAGS.filter(f=>!help.out.includes(f));
+    if(help.status!==0||missing.length){rejected.push(`${label}: --help ${help.error?'probe error '+help.error:'exit '+help.status}${missing.length?'; missing '+missing.join(' '):''}`);continue;}
+    const versionResult=probeCli(bin,[...prefixArgs,'--version'],{env});
+    const version=versionResult.stdout.trim();
+    if(versionResult.status!==0||!/^\d+\.\d+\.\d+$/.test(version)){rejected.push(`${label}: --version ${versionResult.error?'probe error '+versionResult.error:'exit '+versionResult.status+'; unusable output '+JSON.stringify(version.slice(0,120))}`);continue;}
+    return {agent:'kimi',config:{id:'kimi',label:'Kimi Code CLI',version,bin,prefixArgs,available:true,native:prefixArgs.length===0,completionMarker:'__ORCH_DONE__',modelEnv:'ORCH_MODEL'}};
+  }
+  throw new Error(`CLI_MISSING: kimi; no supported installed Kimi Code CLI found. No fallback or automatic install. Tried: ${rejected.join(' | ')||'no candidate found on disk'}`);
+}
+// Base argv for `kimi -p` (print mode auto-approves routine tool calls per product
+// contract; --prompt cannot combine with --auto/--yolo). The prompt itself is
+// appended by the caller as the final argv element. `-m` MUST precede `-p`: kimi's
+// parser binds `-p`'s value greedily, so `-p -m <model> <prompt>` mis-parses the
+// model as a positional subcommand ("unknown command '<model>'").
+export function kimiArgs(config,{model}={}) {
+  return [...(config.prefixArgs||[]),...(model&&String(model).trim()&&!/\s/.test(String(model))?['-m',String(model).trim()]:[]),'-p'];
+}

package/scripts/core/kimi-runtime.mjs

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {spawn} from 'node:child_process';
+import {kimiArgs} from './kimi-host.mjs';
+import {nativeArgumentLines} from './native-argv.mjs';
+
+const quote=(s)=>"'"+String(s).replaceAll("'","''")+"'";
+
+// Parse `kimi -p --output-format stream-json` event stream: the last assistant
+// message content wins; meta lines (system.version / session.resume_hint) and
+// tool progress on stderr are ignored.
+export function kimiAssistantText(raw) {
+  let final='';
+  for(const line of String(raw).split(/\r?\n/)) {
+    if(!line.trim())continue;
+    try {
+      const ev=JSON.parse(line);
+      if(ev.type&&/error/i.test(String(ev.type)))throw new Error('KIMI_RESPONSE_FAILED: '+String(ev.message||ev.content||ev.type));
+      if(ev.role==='assistant'&&typeof ev.content==='string'&&ev.content.trim())final=ev.content;
+    } catch(error) {
+      if(error.message&&error.message.startsWith('KIMI_RESPONSE_FAILED'))throw error;
+      // ignore non-JSON lines / partial events
+    }
+  }
+  return final;
+}
+
+// kimi 冷启动实测 ~295s（全新会话首次规划调用），远超 codex(60s)/pi(60s)/opencode(90s) 的默认拆块
+// 超时——90s 默认下 kimi 发起的全新请求规划必超时、回退单块 inline 不开窗。默认按 adapter 放宽到
+// 360s（实测值 + 余量）；ORCH_DECOMPOSE_TIMEOUT_MS 显式设置时仍优先。
+export const KIMI_DECOMPOSE_TIMEOUT_DEFAULT_MS = 360000;
+export function plannerTimeoutMs(env = process.env) {
+  const v = Number(env.ORCH_DECOMPOSE_TIMEOUT_MS);
+  return Number.isFinite(v) && v > 0 ? v : KIMI_DECOMPOSE_TIMEOUT_DEFAULT_MS;
+}
+
+export async function runKimiPlanner(config,prompt,cwd) {
+  // kimi's parser binds -p's value greedily: the prompt must immediately follow
+  // -p, before any further flags (same rule as the window argv; b3d3600).
+  const args=[...kimiArgs(config,{model:process.env.ORCH_MODEL}),prompt,'--output-format','stream-json'];
+  return new Promise((resolve,reject)=>{
+    const child=spawn(config.bin,args,{cwd,env:process.env,windowsHide:true,shell:false,stdio:['ignore','pipe','pipe']});
+    let raw='',errorText='',timedOut=false;
+    const timer=setTimeout(()=>{timedOut=true;child.kill();},plannerTimeoutMs());
+    child.stdout.on('data',(b)=>{raw+=b;if(raw.length>8000000)child.kill();});
+    child.stderr.on('data',(b)=>{errorText+=b;});
+    child.on('error',(e)=>{clearTimeout(timer);reject(e);});
+    child.on('exit',(code)=>{
+      clearTimeout(timer);
+      try {
+        if(timedOut||code!==0)throw new Error(timedOut?'KIMI_PLANNER_TIMEOUT':'KIMI_PLANNER_FAILED: exit '+code);
+        const final=kimiAssistantText(raw);
+        if(!final)throw new Error('KIMI_PLANNER_EMPTY_RESPONSE'+(errorText?': '+String(errorText).slice(0,300):''));
+        resolve({final});
+      } catch(e){reject(e);}
+    });
+  });
+}
+
+export function writeKimiLauncher(config,{key,prompt,suffix,workspace,temp}) {
+  const stem=String(key+'-'+suffix).replace(/[^a-zA-Z0-9_-]/g,'-');
+  const token=/【本块唯一标识】\s*([A-Za-z0-9][A-Za-z0-9_-]*)/.exec(prompt)?.[1];
+  if(!token)throw new Error('Kimi window requires a completion token');
+  fs.mkdirSync(temp,{recursive:true});
+  const lp=path.join(temp,'win-launch-'+stem+'.ps1');
+  const pidf=path.join(temp,'window-'+stem+'.pid');
+  const pf=path.join(temp,'agent-win-'+stem+'.md');
+  const rf=path.join(temp,'win-'+stem+'.result.json');
+  const log=path.join(temp,'win-'+stem+'.out.log');
+  fs.writeFileSync(pf,prompt,'utf8');
+  const args=kimiArgs(config,{model:process.env.ORCH_MODEL});
+  const body=[
+    "$ErrorActionPreference = 'Continue'",
+    'trap { exit 0 }',
+    `$PID | Set-Content -LiteralPath ${quote(pidf)} -Encoding UTF8`,
+    '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8',
+    '$OutputEncoding = [System.Text.Encoding]::UTF8',
+    'chcp 65001 | Out-Null',
+    '[Console]::InputEncoding = [System.Text.Encoding]::UTF8',
+    'Write-Host "============================================="',
+    'Write-Host "  KIMI TASK RUNNING - closes automatically on completion"',
+    'Write-Host "============================================="',
+    `Set-Location -LiteralPath ${quote(workspace)}`,
+    `$env:ORCH_WINDOW = '1'`,
+    `$token = ${quote(token)}`,
+    `$log = ${quote(log)}`,
+    `$resultFile = ${quote(rf)}`,
+    "function Write-Result {",
+    "  param([int]$code,[string]$report)",
+    "  try {",
+    "    $json = '{\"__EXIT__\":' + $code + ',\"__DONE__\":true,\"__REPORT__\":' + (ConvertTo-Json $report -Compress) + '}'",
+    "    $d = Split-Path -Parent $resultFile; if ($d -and -not (Test-Path -LiteralPath $d)) { New-Item -ItemType Directory -Force -Path $d | Out-Null }",
+    "    Set-Content -LiteralPath $resultFile -Value ($json + \"`r`n__EXIT__=\" + $code) -Encoding UTF8",
+    "    try { Set-Content -LiteralPath ($resultFile + '.self-closed') -Value '1' -Encoding ASCII } catch { }",
+    "  } catch { }",
+    "}",
+    "$p = (Get-Content -Raw -Encoding UTF8 '"+String(pf).replace(/'/g,"''")+"').Trim()",
+    "if ([string]::IsNullOrWhiteSpace($p)) { Write-Result 2 ''; exit 0 }",
+    // kimi takes the prompt as an argv element: fold it into the array BEFORE the
+    // Windows PowerShell 5.1 native-argv fix-up so embedded quotes/newlines survive.
+    "$agentArgs = @(" + args.map(quote).join(',') + ') + @($p)',
+    ...nativeArgumentLines(),
+    // kimi 把 version/thinking/进度等诊断写到 stderr；2>&1 合并时 PS5.1 会把每行包成 ErrorRecord
+    // 刷出红色 NativeCommandError 块（纯外观）。过一道 ErrorRecord 还原：诊断行以普通文本进日志，
+    // 窗内不再刷红，stdout 的完成 token 不受影响。
+    `& ${quote(config.bin)} @agentArgs 2>&1 | ForEach-Object { if ($_ -is [System.Management.Automation.ErrorRecord]) { $_.TargetObject } else { $_ } } | Tee-Object -FilePath $log`,
+    "$code = $LASTEXITCODE",
+    // kimi -p exits on its own after the turn; capture the tail containing the token.
+    "$report = ''",
+    "if (Test-Path -LiteralPath $log) {",
+    "  $lines = Get-Content -LiteralPath $log -Encoding UTF8 -ErrorAction SilentlyContinue",
+    "  $hit = $lines | Where-Object { $_.Contains($token) } | Select-Object -Last 1",
+    "  if ($hit) { $report = $hit } else { $report = ($lines | Select-Object -Last 3) -join \"`n\" }",
+    "}",
+    "Write-Result $code $report",
+    'exit 0',
+  ].join('\r\n');
+  fs.writeFileSync(lp,'\uFEFF'+body,'utf8');
+  return {lp,pidf,pf,rf,log};
+}
+
+export async function waitKimiResult(rf,timeoutMs,pidf) {
+  const end=Date.now()+timeoutMs;
+  while(Date.now()<end) {
+    if(fs.existsSync(rf)) {
+      try {
+        // Write-Result appends a human-readable `__EXIT__=N` trailer line (read by
+        // readExitCode); only the first line is the JSON record.
+        const r=JSON.parse(fs.readFileSync(rf,'utf8').replace(/^\uFEFF/,'').split(/\r?\n/)[0]);
+        return {done:true,exitCode:r.__EXIT__,text:r.__REPORT__||''};
+      } catch {}
+    }
+    if(fs.existsSync(pidf)) {
+      const pid=Number(fs.readFileSync(pidf,'utf8').replace(/^\uFEFF/,''));
+      try{process.kill(pid,0);}catch{return {done:true,exitCode:1,text:'Kimi launcher exited without result'};}
+    }
+    await new Promise((r)=>setTimeout(r,300));
+  }
+  return {done:false,exitCode:null,text:'Kimi completion timeout'};
+}

package/scripts/core/lease-lock.ps1

@@ -0,0 +1,32 @@
+param([string]$Directory,[string]$Ticket,[int]$Owner,[string]$Started)
+$ErrorActionPreference='Stop'
+# Mutex wait is tunable: on a loaded machine many contenders legitimately queue past 20s
+# (nine parents contending for eight slots blew the old hard-coded wait under full-suite load).
+$waitMs=60000
+try { if ($env:ORCH_MUTEX_WAIT_MS) { $waitMs=[int]$env:ORCH_MUTEX_WAIT_MS } } catch { }
+if ($waitMs -lt 1000) { $waitMs=1000 }
+$hash=[Security.Cryptography.SHA256]::Create()
+$name='Local\TuiOrchestrator.Leases.'+[BitConverter]::ToString($hash.ComputeHash([Text.Encoding]::UTF8.GetBytes($Directory.ToLowerInvariant()))).Replace('-','')
+$mutex=[Threading.Mutex]::new($false,$name)
+$held=$false
+try {
+  try {$held=$mutex.WaitOne($waitMs)} catch [Threading.AbandonedMutexException] {$held=$true}
+  if(-not $held){exit 2}
+  [IO.File]::WriteAllText($Ticket+'.ready','ready')
+  $poll=0
+  while(-not [IO.File]::Exists($Ticket+'.release')) {
+    # Owner liveness is a slow CIM query: check it every ~1s, but poll the release file every 100ms
+    # so the ticket files are deleted within ~100ms of the caller releasing (was ~1s, which left
+    # visible residue and cost a slow query per poll).
+    if (($poll % 10) -eq 0) {
+      $p=Get-CimInstance Win32_Process -Filter ('ProcessId='+$Owner) -ErrorAction SilentlyContinue
+      if(-not $p -or $p.CreationDate.ToUniversalTime().ToString('o') -ne $Started){break}
+    }
+    $poll++
+    Start-Sleep -Milliseconds 100
+  }
+} finally {
+  if($held){$mutex.ReleaseMutex()}
+  $mutex.Dispose()
+  foreach($suffix in @('.ready','.release')){[IO.File]::Delete($Ticket+$suffix)}
+}