@openagents-org/agent-launcher 0.2.182 → 0.2.184

package/src/adapters/codearts.js

@@ -0,0 +1,316 @@
+/**
+ * CodeArts Agent adapter — Huawei Cloud's 码道 (CodeArts) code agent CLI.
+ *
+ * The CLI is built on OpenCode. Its binary (shipped as `agentkernel`, installed
+ * as `codearts`) takes OpenCode's `run --format json`, streams OpenCode's JSON
+ * events and resumes with `--session`, so the stream parsing, sessions, stop
+ * control and failure taxonomy are OpenCodeAdapter's. What differs is how the
+ * CLI is found, launched and authenticated (verified against 26.9.3):
+ *
+ *   - Installed by Huawei's own script (install.sh / install.ps1) into
+ *     ~/.codeartsdoer/installers, never npm. What PATH finds there is a wrapper
+ *     (`codearts.cmd` / a shell script) that sets the CLI's environment and runs
+ *     bin/codearts(.exe). The adapter runs that binary itself with the same
+ *     environment: through the .cmd it would need a cmd.exe host, and an
+ *     attached console is what makes an OpenCode-based CLI open its TUI instead
+ *     of running headless.
+ *   - Non-interactive commands authenticate with a Huawei Cloud access key
+ *     pair and nothing else — CODEARTS_CLI_AK / CODEARTS_CLI_SK. The browser
+ *     sign-in the TUI offers does not reach them: without the pair, `auth list`,
+ *     `models` and `run` all fail with "认证失败，没有设置环境变量
+ *     CODEARTS_CLI_AK/CODEARTS_CLI_SK".
+ *   - `run` has no --dir; the working directory is the spawn cwd.
+ *   - `--auto` runs tools in always_allow mode. A headless run has nobody to
+ *     answer a permission prompt; the daemon is the approval boundary, as it is
+ *     for every other agent here.
+ *   - A model the account cannot use is reported on stderr — "error: 未找到模型：
+ *     …" — and the CLI still exits 0 with nothing on stdout.
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const OpenCodeAdapter = require('./opencode');
+const { whichBinary } = require('../paths');
+const { isWslBinary } = require('../wsl');
+
+const IS_WINDOWS = process.platform === 'win32';
+
+/** Newest CLI this adapter was checked against. Newer still runs, flagged. */
+const CODEARTS_TESTED_VERSION = '26.9.3';
+
+/**
+ * Used only when `codearts models` can't be read. What an account may run is
+ * decided by Huawei Cloud per account: the `huaweicloud-maas/deepseek-v3.2`
+ * from Huawei's getting-started guide was not in a real account's list
+ * (2026-09-15, which listed GLM-5.2, GLM-5.2-ArkTS-SPARK and OpenPangu-2.0
+ * Flash/Pro), and every message to it failed.
+ */
+const DEFAULT_MODEL = 'huaweicloud-maas/GLM-5.2';
+
+/** How long a read of `codearts models` is trusted, and how long a failed one waits. */
+const MODEL_LIST_TTL_MS = 10 * 60_000;
+const MODEL_LIST_RETRY_MS = 60_000;
+
+/** Where the CLI itself sends people to create the access key it needs. */
+const AKSK_URL = 'https://codearts.huaweicloud.com/portal/settings/cli-auth';
+
+const DOWNLOAD_URL = 'https://codearts.huaweicloud.com/download.html';
+
+const FAILURE_MESSAGES = {
+  cli_not_found: `CodeArts Agent CLI not found. Install it (${DOWNLOAD_URL}) and try again.`,
+  cli_not_executable: 'CodeArts Agent CLI was found but could not be started. Reinstall it, then retry.',
+  unsupported_version: 'This CodeArts Agent CLI version is not supported. Update it with `codearts upgrade` and retry.',
+  model_missing: "No model is configured for CodeArts Agent. Set CODEARTS_MODEL (provider/model) in this agent's configuration, then retry.",
+  credential_missing: `CodeArts Agent needs a Huawei Cloud access key. Set CODEARTS_CLI_AK and CODEARTS_CLI_SK in this agent's configuration (create them at ${AKSK_URL}), then retry.`,
+  auth_failed: 'Huawei Cloud rejected the access key, or this account has no CodeArts seat. Check CODEARTS_CLI_AK / CODEARTS_CLI_SK and ask your administrator for a seat if needed, then retry.',
+  provider_not_configured: 'CodeArts Agent has no usable model provider. Check CODEARTS_MODEL, then retry.',
+  model_not_found: "This account can't use the configured model. Pick one from the model list in this agent's configuration (or run `codearts models`), set CODEARTS_MODEL, then retry.",
+  rate_limited: 'The model service is rate-limiting requests. Wait a moment and retry.',
+  network_error: 'CodeArts Agent could not reach Huawei Cloud (network or service error). Retry shortly.',
+  provider_server_error: 'The model service returned a server error. Retry shortly.',
+  timeout: 'CodeArts Agent timed out before producing a reply. Retry; if it persists, check the model configuration.',
+  stream_parse_error: 'CodeArts Agent produced output this version could not parse. Update the CLI, or open diagnostics.',
+  empty_response: 'CodeArts Agent finished without producing a final reply. Retry; if it persists, open diagnostics.',
+  incomplete_run: 'CodeArts Agent stopped mid-task right after a tool call and never produced a final reply — its progress notes are shown above. Send "continue" to pick up where it left off.',
+  process_crashed: 'CodeArts Agent exited unexpectedly. Open diagnostics or retry.',
+  cwd_unavailable: "CodeArts Agent's working directory is not accessible. Check the agent's configured path (or agent home) permissions.",
+  unknown_error: 'CodeArts Agent failed for an undetermined reason. Open diagnostics or retry.',
+};
+
+/**
+ * The CLI's own error line. On failure it prints a chunk of its bundled source
+ * before the line that matters, and classifying that source text would find
+ * "network" or "timeout" in someone's variable names — so only this line counts.
+ */
+function errorLine(text) {
+  const matches = String(text || '').match(/^\s*error:\s*(.+)$/gm);
+  if (!matches) return '';
+  return matches[matches.length - 1].replace(/^\s*error:\s*/, '').trim();
+}
+
+class CodeArtsAdapter extends OpenCodeAdapter {
+  /** Where Huawei's installer puts the CLI. */
+  static installRoot(home = os.homedir()) {
+    return path.join(home, '.codeartsdoer', 'installers');
+  }
+
+  /**
+   * Where a command that belongs to no project (listing models) runs. Created
+   * on demand; falls back to the home directory if it cannot be.
+   */
+  static probeDir(home = os.homedir()) {
+    const dir = path.join(home, '.openagents', 'probe');
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      return dir;
+    } catch {
+      return home;
+    }
+  }
+
+  /**
+   * `codearts models` prints a table, not OpenCode's one id per line:
+   *
+   *   model_id                              model_name
+   *   ------------------------------------------------
+   *   huaweicloud-maas/GLM-5.2              GLM-5.2
+   */
+  static parseModels(out) {
+    const ids = [];
+    for (const line of String(out || '').split(/\r?\n/)) {
+      const id = line.trim().split(/\s+/)[0] || '';
+      if (/^[A-Za-z0-9][\w.-]*\/\S+$/.test(id) && !ids.includes(id)) ids.push(id);
+    }
+    return ids;
+  }
+
+  _cliLabel() {
+    return 'CodeArts Agent';
+  }
+
+  _installHint() {
+    return `Install it from ${DOWNLOAD_URL}`;
+  }
+
+  _failureMessages() {
+    return FAILURE_MESSAGES;
+  }
+
+  _findOpencodeBinary() {
+    const exe = IS_WINDOWS ? 'codearts.exe' : 'codearts';
+    const native = path.join(CodeArtsAdapter.installRoot(), 'bin', exe);
+    if (fs.existsSync(native)) return native;
+
+    // Somewhere else on PATH — a relocated install, or one inside WSL. When
+    // that is the installer's wrapper, run the binary beside it instead.
+    const found = whichBinary('codearts');
+    if (!found) return null;
+    if (!isWslBinary(found)) {
+      const sibling = path.join(path.dirname(found), 'bin', exe);
+      if (fs.existsSync(sibling)) return sibling;
+    }
+    return found;
+  }
+
+  _spawnEnv() {
+    const configDir = path.join(os.homedir(), '.codeartsdoer');
+    return {
+      ...(this.agentEnv || process.env),
+      // What the installer's wrapper sets before it runs the binary, set the
+      // same unconditional way: an OPENCODE_CONFIG inherited from the user's
+      // own OpenCode would otherwise point this CLI at the wrong config.
+      //
+      // One line of the wrapper is deliberately left out:
+      // NODE_TLS_REJECT_UNAUTHORIZED=0 turns off certificate checks for every
+      // request the CLI makes, and a headless run has not been seen to need it.
+      SCENARIO: 'codeartsdoer',
+      KERNEL_DATA_DIR: path.join(configDir, 'cli-data'),
+      KERNEL_CONFIG_DIR: configDir,
+      OPENCODE_CHANNEL: 'latest',
+      OPENCODE_CONFIG: path.join(configDir, 'codearts_cli.json'),
+      OPENCODE_CONFIG_FILE: 'codearts_cli.json,codearts_cli.jsonc',
+      OPENCODE_MODE: 'tui',
+      PLUGIN_ENV: 'hc',
+      OPENCODE_DISABLE_MODELS_FETCH: '1',
+      OPENCODE_DISABLE_AUTOUPDATE: 'true',
+      OPENCODE_ALWAYS_NOTIFY_UPDATE: 'false',
+      CODEARTS_DISABLE_AUTO_UPDATE: 'true',
+      CODEAGENT_USE_MESSAGE_FEEDBACK: 'false',
+      OMO_SEND_ANONYMOUS_TELEMETRY: '0',
+    };
+  }
+
+  _buildRunArgs({ model, sessionId }) {
+    const args = ['run', '--format', 'json', '--auto', '--model', model];
+    if (sessionId) args.push('--session', sessionId);
+    return args;
+  }
+
+  /**
+   * The configured model, else the first one this account's `codearts models`
+   * lists, else DEFAULT_MODEL. Always a model: an OpenCode-based `run` with
+   * none waits for an interactive pick that never comes.
+   */
+  _resolveModel() {
+    const env = this.agentEnv || process.env;
+    const configured = String(env.CODEARTS_MODEL || '').trim();
+    if (configured) return configured;
+    return this._listModelIds()[0] || DEFAULT_MODEL;
+  }
+
+  /**
+   * The ids `codearts models` lists for this agent's access key, cached. It
+   * takes a few seconds (it asks Huawei Cloud), so it is read once per key and
+   * not per message; a failed read is retried after a minute rather than on
+   * every message.
+   */
+  _listModelIds() {
+    const env = this.agentEnv || process.env;
+    const key = String(env.CODEARTS_CLI_AK || '');
+    const now = Date.now();
+    const cached = this._modelList;
+    if (cached && cached.key === key) {
+      const ttl = cached.ids.length ? MODEL_LIST_TTL_MS : MODEL_LIST_RETRY_MS;
+      if (now - cached.at < ttl) return cached.ids;
+    }
+    let ids = [];
+    const binary = this._opencodeBinary || this._findOpencodeBinary();
+    if (binary && this._credentialState() === 'present') {
+      try {
+        const out = execFileSync(binary, ['models'], {
+          encoding: 'utf-8',
+          timeout: 20_000,
+          windowsHide: true,
+          env: this._spawnEnv(),
+          // The CLI sets up a `.codeartsdoer/` project folder in whatever
+          // directory it starts in. A listing belongs to no project, so it runs
+          // in one of ours rather than in the daemon's working directory.
+          cwd: CodeArtsAdapter.probeDir(),
+          stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        ids = CodeArtsAdapter.parseModels(out);
+        if (ids.length) this._log(`CodeArts models for this key: ${ids.join(', ')}`);
+      } catch (e) {
+        this._log(`codearts models failed: ${errorLine(e && e.stderr) || (e && e.message) || e}`);
+      }
+    }
+    this._modelList = { key, ids, at: now };
+    return ids;
+  }
+
+  // No OpenAI-compatible gateway to declare: models come from Huawei Cloud.
+  _customBaseUrl() {
+    return '';
+  }
+
+  _ensureCustomProviderConfig() {}
+
+  /** The access key pair is the only credential a non-interactive run accepts. */
+  _credentialState() {
+    const env = this.agentEnv || process.env;
+    const has = (k) => !!String(env[k] || '').trim();
+    return has('CODEARTS_CLI_AK') && has('CODEARTS_CLI_SK') ? 'present' : 'missing';
+  }
+
+  /**
+   * Versions are date-shaped (26.9.3). No floor: nothing older is known to
+   * break, and refusing a working CLI on a guess is worse than trying it.
+   */
+  static _classifyVersion(version) {
+    if (!version || !/^\d+\.\d+/.test(String(version))) return 'unknown';
+    return OpenCodeAdapter._cmpVer(version, CODEARTS_TESTED_VERSION) > 0 ? 'degraded' : 'ok';
+  }
+
+  /**
+   * OpenCode's taxonomy, plus the refusals this CLI words its own way: a model
+   * the account can't use, a missing or rejected key pair (both in Chinese) and
+   * a missing seat.
+   */
+  static _classifyFailure(input = {}) {
+    const result = super._classifyFailure(input);
+    const hay = [
+      input.stderr,
+      input.stdout,
+      input.stdoutErr && input.stdoutErr.message,
+    ].filter(Boolean).join(' ');
+    // Checked first: its wording ends "或当前未登录", which is not an auth failure
+    // when the same key lists models fine.
+    if (/未找到模型|模型不存在/.test(hay)) {
+      return { ...result, category: 'model_not_found' };
+    }
+    if (/认证失败|CODEARTS_CLI_AK|CODEARTS_CLI_SK|\bseat\b/i.test(hay)) {
+      return { ...result, category: 'auth_failed' };
+    }
+    return result;
+  }
+
+  /**
+   * An exit 0 with no reply is only "empty" when the CLI said nothing. This one
+   * exits 0 after printing its error to stderr, which OpenCode's reading
+   * reported as an empty response and hid the reason.
+   */
+  static _outcomeForCleanExit(args = {}) {
+    const outcome = super._outcomeForCleanExit(args);
+    const line = errorLine(args.stderr);
+    if (!outcome.failure || outcome.failure.category !== 'empty_response' || !line) return outcome;
+    const cls = this._classifyFailure({ code: 0, signal: null, stdout: '', stderr: line });
+    return {
+      failure: {
+        category: cls.category === 'unknown_error' || cls.category === 'stream_parse_error' ? 'unknown_error' : cls.category,
+        diagnostic: `exit 0, stderr: ${line}`,
+        detail: OpenCodeAdapter._redact(line).slice(0, 200),
+      },
+    };
+  }
+}
+
+CodeArtsAdapter.DEFAULT_MODEL = DEFAULT_MODEL;
+CodeArtsAdapter.AKSK_URL = AKSK_URL;
+CodeArtsAdapter.errorLine = errorLine;
+
+module.exports = CodeArtsAdapter;

package/src/adapters/index.js

@@ -26,6 +26,7 @@ const AntigravityAdapter = require('./antigravity');
 const CommandCodeAdapter = require('./commandcode');
 const OpenWorkerAdapter = require('./openworker');
 const CodeBuddyAdapter = require('./codebuddy');
+const CodeArtsAdapter = require('./codearts');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -49,11 +50,12 @@ const ADAPTER_MAP = {
   commandcode: CommandCodeAdapter,
   openworker: OpenWorkerAdapter,
   codebuddy: CodeBuddyAdapter,
+  codearts: CodeArtsAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi, deepseek, antigravity, commandcode, openworker, codebuddy)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi, deepseek, antigravity, commandcode, openworker, codebuddy, codearts)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -87,6 +89,7 @@ module.exports = {
   AntigravityAdapter,
   CommandCodeAdapter,
   OpenWorkerAdapter,
+  CodeArtsAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/adapters/kimi-stream.js

@@ -26,6 +26,8 @@
 
 'use strict';
 
+const crypto = require('crypto');
+
 // ---------------------------------------------------------------------------
 // Version / product classification
 // ---------------------------------------------------------------------------
@@ -270,6 +272,30 @@ function buildKimiEnv(agentEnv) {
   return { env, viaEnvProvider: true };
 }
 
+// ---------------------------------------------------------------------------
+// Session journal location
+// ---------------------------------------------------------------------------
+
+/**
+ * The directory Kimi Code CLI files a working directory's sessions under:
+ * `<KIMI_CODE_HOME>/sessions/<key>/<session id>/`. Mirrors the CLI's own
+ * `encodeWorkDirKey` (v0.42.0): `wd_` + a slug of the last path segment + `_` +
+ * the first 12 hex of sha256 over the path with `\` turned into `/` and no
+ * trailing slash. Case is kept, so `C:\Users\86177` → `wd_86177_5d6fa4a9b53d`.
+ */
+function encodeKimiWorkDirKey(workDir) {
+  const normalized = String(workDir).replace(/\\/g, '/').replace(/\/+$/, '');
+  let slug = (normalized.split('/').pop() ?? normalized)
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40)
+    .replace(/^-+|-+$/g, '');
+  if (slug === '' || slug === '.' || slug === '..') slug = 'workspace';
+  const hash = crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 12);
+  return `wd_${slug}_${hash}`;
+}
+
 // ---------------------------------------------------------------------------
 // Error classification
 // ---------------------------------------------------------------------------
@@ -292,13 +318,28 @@ function extractStderrError(stderrText) {
 
 /**
  * Classify a failed run into a user-facing message.
- * @param {{code: number|null, signal: string|null, stderrText: string, retryMessage: string}} info
+ * @param {{code: number|null, signal: string|null, stderrText: string, retryMessage: string, timedOutMs?: number}} info
+ *   `timedOutMs` is set when the adapter's idle watchdog stopped the run after
+ *   that long without any sign of progress.
  * @returns {{kind: string, userMessage: string}}
  */
 function classifyKimiError(info) {
-  const { code, signal, stderrText, retryMessage } = info || {};
+  const { code, signal, stderrText, retryMessage, timedOutMs } = info || {};
   const detail = extractStderrError(stderrText) || redactSecrets(retryMessage || '');
 
+  // The watchdog's own stop wins: the signal it leaves behind (SIGINT on
+  // Windows) explains nothing, and stderr by then holds whatever tools printed.
+  if (timedOutMs) {
+    const minutes = Math.max(1, Math.round(timedOutMs / 60000));
+    return {
+      kind: 'timeout',
+      userMessage:
+        `Kimi showed no progress for about ${minutes} min and was stopped. ` +
+        'Send the request again, or break a long task into smaller steps.' +
+        (detail ? `\n\nDetails: ${detail}` : ''),
+    };
+  }
+
   if (/auth_error|401|unauthorized|invalid.{0,20}(api.?key|token)|credential/i.test(detail)) {
     return {
       kind: 'auth',
@@ -351,6 +392,7 @@ module.exports = {
   toolPreview,
   buildKimiArgs,
   buildKimiEnv,
+  encodeKimiWorkDirKey,
   extractStderrError,
   classifyKimiError,
   DEFAULT_KIMI_MODEL,

package/src/adapters/kimi.js

@@ -47,6 +47,7 @@ const {
   redactSecrets,
   classifyKimiVersion,
   classifyKimiError,
+  encodeKimiWorkDirKey,
 } = require('./kimi-stream');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -54,10 +55,13 @@ const IS_WINDOWS = process.platform === 'win32';
 const DEFAULT_BASE_URL = 'https://api.moonshot.ai/v1';
 const DEFAULT_MODEL = 'kimi-k2.6';
 
-// Idle watchdog: if stdout is silent this long while a run is in flight we
-// nudge the user; after MAX consecutive silences we kill the (possibly hung)
-// process. Kimi's provider retry backoff can reach ~1 min between attempts,
-// so the kill threshold stays generous.
+// Idle watchdog: if a run shows no sign of life this long we nudge the user;
+// after MAX consecutive silences we kill the (possibly hung) process. Sign of
+// life is any stdout or stderr, or a write to the run's session journal. The
+// journal is the only trace a subagent leaves: print mode never forwards its
+// events, so a main agent waiting on an `Agent` tool call is otherwise mute.
+// Kimi's provider retry backoff can reach ~1 min between attempts, so the kill
+// threshold stays generous.
 const WATCHDOG_INTERVAL_MS = 15_000;
 const WATCHDOG_NUDGE_AT = 2;     // ~30s of silence → "still working"
 const WATCHDOG_MAX = 20;         // ~5 min of silence → kill
@@ -67,6 +71,27 @@ const WATCHDOG_MAX = 20;         // ~5 min of silence → kill
 const VERSION_CACHE_TTL_MS = 5 * 60 * 1000;
 const _kimiVersionCache = new Map(); // binPath -> { version, product, at }
 
+/** Newest mtime (ms) of a directory and everything under it, `depth` levels deep. */
+function newestMtimeMs(dir, depth) {
+  let newest = 0;
+  let entries;
+  try {
+    newest = fs.statSync(dir).mtimeMs;
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return newest;
+  }
+  for (const entry of entries) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (depth > 0) newest = Math.max(newest, newestMtimeMs(p, depth - 1));
+    } else {
+      try { newest = Math.max(newest, fs.statSync(p).mtimeMs); } catch {}
+    }
+  }
+  return newest;
+}
+
 class KimiAdapter extends LlmDirectAdapter {
   constructor(opts) {
     super({
@@ -106,6 +131,10 @@ class KimiAdapter extends LlmDirectAdapter {
     this._channelProcesses = {};  // channel → in-flight child process
     this._stoppingChannels = new Set();
     this._loggedCliMode = false;
+    // Watchdog timings live on the instance so tests can run them in ms.
+    this._watchdogIntervalMs = WATCHDOG_INTERVAL_MS;
+    this._watchdogNudgeAt = WATCHDOG_NUDGE_AT;
+    this._watchdogMax = WATCHDOG_MAX;
     this._sessionsFile = path.join(
       os.homedir(), '.openagents', 'sessions',
       `${this.workspaceId}_${this.agentName}_kimi.json`,
@@ -577,8 +606,9 @@ class KimiAdapter extends LlmDirectAdapter {
       if (result.userStopped) return;
 
       // Stale-session handling: a resume that died/erred with nothing useful →
-      // clear and retry fresh once.
-      if (resumeId && !result.ok && !result.anyOutput && attempt === 0) {
+      // clear and retry fresh once. A watchdog stop is not a stale session, and
+      // retrying it would just repeat the long task.
+      if (resumeId && !result.ok && !result.anyOutput && !result.timedOutMs && attempt === 0) {
         this._log(`Resume of session ${resumeId} failed — clearing and retrying fresh`);
         this._clearSession(channel);
         continue;
@@ -598,6 +628,7 @@ class KimiAdapter extends LlmDirectAdapter {
           signal: result.exitSignal,
           stderrText: result.stderrText,
           retryMessage: result.retryMessage,
+          timedOutMs: result.timedOutMs,
         });
         try { await this.sendError(channel, userMessage); } catch {}
       } else {
@@ -611,16 +642,53 @@ class KimiAdapter extends LlmDirectAdapter {
     try { return fs.statSync(p).isDirectory(); } catch { return false; }
   }
 
+  /**
+   * Snapshot the session journals that exist before a run starts, so the
+   * watchdog can tell this run's writes from other sessions' in the same
+   * working directory. Kimi files them under
+   * <KIMI_CODE_HOME>/sessions/<workdir key>/<session id>/.
+   */
+  _watchKimiSessions(env, workingDir, args) {
+    const home = env.KIMI_CODE_HOME || path.join(os.homedir(), '.kimi-code');
+    const bucket = path.join(home, 'sessions', encodeKimiWorkDirKey(workingDir));
+    let known = [];
+    try { known = fs.readdirSync(bucket); } catch {}
+    const s = args.indexOf('-S');
+    return { bucket, known: new Set(known), resumeId: s >= 0 ? args[s + 1] : null };
+  }
+
+  /**
+   * Newest write (ms) inside this run's session journals: the resumed session,
+   * plus any session created since the run started. A second fresh run in the
+   * same directory can be counted too; that only ever keeps a run alive
+   * longer, never stops one early. 0 when there is nothing to look at.
+   */
+  _latestKimiSessionWrite(watch) {
+    let names;
+    try { names = fs.readdirSync(watch.bucket); } catch { return 0; }
+    let latest = 0;
+    for (const name of names) {
+      const resumed = !!watch.resumeId &&
+        (name === watch.resumeId || name === `session_${watch.resumeId}`);
+      if (watch.known.has(name) && !resumed) continue;
+      latest = Math.max(latest, newestMtimeMs(path.join(watch.bucket, name), 3));
+    }
+    return latest;
+  }
+
   /**
    * Spawn one `kimi -p … --output-format stream-json` run, stream-parse it,
    * and resolve a summary:
    *   { ok, finalText, sessionId, anyOutput, userStopped,
-   *     exitCode, exitSignal, stderrText, retryMessage }
-   * `ok` is exit code 0; `finalText` is the LAST assistant text of the turn.
+   *     exitCode, exitSignal, stderrText, retryMessage, timedOutMs }
+   * `ok` is exit code 0; `finalText` is the LAST assistant text of the turn;
+   * `timedOutMs` is non-zero when the idle watchdog stopped the run.
    */
   _runKimi(channel, kimiBin, args, workingDir) {
     const { env: cleanEnv } = buildKimiEnv(this.agentEnv || process.env);
     const [cmd, ...spawnArgs] = this._spawnableCmd(kimiBin, args);
+    // Before the spawn, so the session this run creates shows up as new.
+    const sessionWatch = this._watchKimiSessions(cleanEnv, workingDir, args);
 
     this._log(`Spawning kimi in ${workingDir}: ${redactArgs([kimiBin, ...args]).join(' ')}`);
 
@@ -644,6 +712,7 @@ class KimiAdapter extends LlmDirectAdapter {
       exitSignal: null,
       stderrText: '',
       retryMessage: '',
+      timedOutMs: 0,
     };
 
     return new Promise((resolve) => {
@@ -651,6 +720,8 @@ class KimiAdapter extends LlmDirectAdapter {
       let watchdogTimer = null;
       let fallbackTimer = null;
       let lastDataMs = Date.now();
+      let seenSessionWriteMs = lastDataMs;
+      let loggedSessionAlive = false;
       let silences = 0;
       let queue = Promise.resolve();
 
@@ -713,8 +784,11 @@ class KimiAdapter extends LlmDirectAdapter {
       });
 
       // stderr: `error: ...` lines carry the fatal cause; collected for
-      // classification, never surfaced verbatim as an assistant reply.
+      // classification, never surfaced verbatim as an assistant reply. Tool
+      // progress also lands here in print mode, so it counts as life.
       proc.stderr.on('data', (chunk) => {
+        lastDataMs = Date.now();
+        silences = 0;
         state.stderrText += chunk.toString('utf-8');
         if (state.stderrText.length > 64 * 1024) {
           state.stderrText = state.stderrText.slice(-32 * 1024);
@@ -722,21 +796,47 @@ class KimiAdapter extends LlmDirectAdapter {
       });
 
       // Idle watchdog
+      const intervalMs = this._watchdogIntervalMs;
       watchdogTimer = setInterval(async () => {
         if (settled) return;
         const elapsed = Date.now() - lastDataMs;
-        if (elapsed < WATCHDOG_INTERVAL_MS) { silences = 0; return; }
+        if (elapsed < intervalMs) { silences = 0; return; }
+        // Both pipes are quiet. A subagent still working only shows up in the
+        // session journal, so a fresh write there resets the count too.
+        const wrote = this._latestKimiSessionWrite(sessionWatch);
+        if (wrote > seenSessionWriteMs) {
+          seenSessionWriteMs = wrote;
+          lastDataMs = Date.now();
+          silences = 0;
+          if (!loggedSessionAlive) {
+            loggedSessionAlive = true;
+            this._log(`Watchdog: kimi quiet on ${channel} but its session is still being written — keeping it alive`);
+          }
+          return;
+        }
         silences++;
-        lastDataMs = Date.now();
-        if (silences === WATCHDOG_NUDGE_AT) {
+        // Deliberately NOT touching lastDataMs here: it marks the last real
+        // sign of life, and the data handlers above already reset `silences`
+        // themselves. Refreshing it on a silent tick parked the next tick's
+        // `elapsed` right on the interval boundary, where an early-firing
+        // timer (routine on Windows) read as "data just arrived" and reset
+        // the count — so a genuinely hung run was never stopped.
+        if (silences === this._watchdogNudgeAt) {
           try { await this.sendStatus(channel, 'Still working...'); } catch {}
         }
-        if (silences >= WATCHDOG_MAX) {
-          this._log(`Watchdog: kimi silent ${silences * 15}s on ${channel} — killing`);
-          if (!state.stderrText) state.stderrText = 'error: Kimi became unresponsive and was stopped.';
+        if (silences >= this._watchdogMax) {
+          // Stop ticking before the (awaited) kill: _stopProcess can take
+          // seconds to escalate, and a tick landing inside that wait would
+          // re-log, re-kill and keep inflating timedOutMs past the budget.
+          clearInterval(watchdogTimer);
+          const silentMs = silences * intervalMs;
+          this._log(`Watchdog: kimi silent ${Math.round(silentMs / 1000)}s on ${channel} — killing`);
+          // Its own field, not stderr: tool noise already there used to leave
+          // the user with nothing but the signal name.
+          state.timedOutMs = silentMs;
           await this._stopProcess(proc);
         }
-      }, WATCHDOG_INTERVAL_MS);
+      }, intervalMs);
 
       // Finalize only once BOTH the process has exited AND stdout has ended,
       // so the final buffered lines are never dropped (same race as Cline on