larkin 0.2.74 → 0.2.76

package/assets/larkin-mark-template.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <path fill="#000" d="M8 35.5C11.2 20.8 22.4 9.8 39.8 6l-7.1 13.7 5.9 5.8L56 10.1l-5.1 31.5C39.3 54.4 22.2 56.8 8 47.4Z"/>
+</svg>

package/assets/larkin-mark.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-labelledby="title desc">
+  <title id="title">LARKIN</title>
+  <desc id="desc">A swift lark built from three folded ribbons.</desc>
+  <path fill="#00B8D9" d="M8 35.5C11.2 20.8 22.4 9.8 39.8 6l-9.4 18.2-13.2 15Z"/>
+  <path fill="#1456F0" d="M8 35.5c11.8 8.2 24.7 8.7 35.4-.6L56 23.8l-5.1 17.8C39.3 54.4 22.2 56.8 8 47.4Z"/>
+  <path fill="#A3402C" d="M13.8 38.2c3.7-10.4 12.1-18.3 25.4-21.7l-7.1 13.8-9.3 11.2c-3.1-.6-6.1-1.7-9-3.3Z"/>
+</svg>

package/dist/agent/context-prompt.cjs

@@ -16,7 +16,7 @@ const agent_cli_capabilities_js_1 = require("./agent-cli-capabilities.cjs");
  * 5. 版本化：每次实质改动 bump LARKIN_STANDING_PROMPT_VERSION，并同步 eval 数据集/graders/断言。
  * 6. 用 eval 验证：行为变化必须配套固定场景 + rubric（evals/*、test/support/*-grader.mjs、live 测试）。
  */
-exports.LARKIN_STANDING_PROMPT_VERSION = "larkin-standing-v18";
+exports.LARKIN_STANDING_PROMPT_VERSION = "larkin-standing-v19";
 /**
  * Agent 间协作唤醒引导（issue #75）：纯文本 @ 不会产生飞书 mention 事件，
  * 必须由模型直接构造真实的 mention 元素；`--mention` 扩展参数已移除。
@@ -154,7 +154,7 @@ class ContextPromptBuilder {
             "For the known canonical Inbox poll, scoped chat/thread history, and exact send/reply recipes specified here, execute them directly; you must not read or re-read a skill file or reference merely to rediscover or confirm their command syntax.",
             `For a task that starts from an exact group name and asks for user and bot counts, after the required Inbox poll use this known canonical two-read recipe directly: first run \`${executable} im +chat-search --query '<exact_group_name>' --json\`, require one result with an exact name match and confirm its \`oc_\` chat id, then run \`${executable} im chats get --chat-id <confirmed_oc_chat_id> --json\` and answer from its \`user_count\` and \`bot_count\`. This group user/bot counts recipe uses exactly two post-poll business read calls; you must not read or re-read a skill or reference, open help or schema, invoke bare \`lark-cli\`, call \`chat.members\` or \`+chat-members-list\`, fall back to \`+chat-list\`, or add shell filters or output truncation. If the exact name is not a unique visible match, the chat id is not confirmed, or either count is missing, fail visibly without another discovery path or a guess.`,
             "This narrow direct-recipe rule does not waive required skill safety gates, authorization, identity, freshness, or other safety checks. Unknown commands or high-risk operations still require the applicable skill/reference guidance or help.",
-            "The Larkin wrapper derives the stable per-intent idempotency key; do not pass `--idempotency-key` in an ordinary send or reply recipe.",
+            "The Larkin wrapper derives the stable per-intent idempotency key; do not pass `--idempotency-key` in an ordinary send or reply recipe. A successful write result carrying `duplicate: true` means the provider returned the earlier delivery for the same derived key: the message was already delivered and no new message was created. Do not resend the same command after a `duplicate: true` result; treat the message as delivered. To deliberately send identical content again as a fresh intent (e.g., a new reminder), pass an explicit new `--idempotency-key`, which the wrapper respects instead of deriving its own.",
             "Both `freshness_unavailable` and `freshness_conflict` are pre-commit, provider-not-reached results. If a retry is warranted for an unchanged exact operation, rerun the identical safe ordinary command: `--text` for a direct literal or the same deterministic `--content` dataflow for a tool source. The wrapper reuses its derived key. If the target or body changes after reconsideration, run the revised ordinary command and let the wrapper derive a new key. A result with `committed=true` must not be repeated; ambiguous termination follows the existing wrapper same-key recovery contract.",
             "For multiline `--markdown` or `--text` content in zsh or bash, prefer shell ANSI-C quoting so the command passes one argument with real newline characters: `--markdown $'First line\\nSecond line'` or `--text $'First line\\nSecond line'`. Putting `\"First line\\nSecond line\"` in ordinary double quotes is wrong: ordinary quotes do not decode `\\n`, so lark-cli and Feishu receive a backslash followed by the letter `n`. A literal multiline argument containing real newline characters is also valid. If ANSI-C-quoted content contains an apostrophe, use a safe shell single-quote splice or the literal-newline form; never use `eval`, `echo`, a temporary file, or unsafe variable interpolation to construct the body.",
             ...FEISHU_IM_COMMAND_GROUPS.map(([label, suffixes]) => `- ${label}: ${suffixes.map((suffix) => `\`${executable} ${suffix}\``).join(", ")}.`),

package/dist/agent/context-prompt.mjs

@@ -13,7 +13,7 @@ import { agentCliPromptCapabilities } from "./agent-cli-capabilities.mjs";
  * 5. 版本化：每次实质改动 bump LARKIN_STANDING_PROMPT_VERSION，并同步 eval 数据集/graders/断言。
  * 6. 用 eval 验证：行为变化必须配套固定场景 + rubric（evals/*、test/support/*-grader.mjs、live 测试）。
  */
-export const LARKIN_STANDING_PROMPT_VERSION = "larkin-standing-v18";
+export const LARKIN_STANDING_PROMPT_VERSION = "larkin-standing-v19";
 /**
  * Agent 间协作唤醒引导（issue #75）：纯文本 @ 不会产生飞书 mention 事件，
  * 必须由模型直接构造真实的 mention 元素；`--mention` 扩展参数已移除。
@@ -151,7 +151,7 @@ export class ContextPromptBuilder {
             "For the known canonical Inbox poll, scoped chat/thread history, and exact send/reply recipes specified here, execute them directly; you must not read or re-read a skill file or reference merely to rediscover or confirm their command syntax.",
             `For a task that starts from an exact group name and asks for user and bot counts, after the required Inbox poll use this known canonical two-read recipe directly: first run \`${executable} im +chat-search --query '<exact_group_name>' --json\`, require one result with an exact name match and confirm its \`oc_\` chat id, then run \`${executable} im chats get --chat-id <confirmed_oc_chat_id> --json\` and answer from its \`user_count\` and \`bot_count\`. This group user/bot counts recipe uses exactly two post-poll business read calls; you must not read or re-read a skill or reference, open help or schema, invoke bare \`lark-cli\`, call \`chat.members\` or \`+chat-members-list\`, fall back to \`+chat-list\`, or add shell filters or output truncation. If the exact name is not a unique visible match, the chat id is not confirmed, or either count is missing, fail visibly without another discovery path or a guess.`,
             "This narrow direct-recipe rule does not waive required skill safety gates, authorization, identity, freshness, or other safety checks. Unknown commands or high-risk operations still require the applicable skill/reference guidance or help.",
-            "The Larkin wrapper derives the stable per-intent idempotency key; do not pass `--idempotency-key` in an ordinary send or reply recipe.",
+            "The Larkin wrapper derives the stable per-intent idempotency key; do not pass `--idempotency-key` in an ordinary send or reply recipe. A successful write result carrying `duplicate: true` means the provider returned the earlier delivery for the same derived key: the message was already delivered and no new message was created. Do not resend the same command after a `duplicate: true` result; treat the message as delivered. To deliberately send identical content again as a fresh intent (e.g., a new reminder), pass an explicit new `--idempotency-key`, which the wrapper respects instead of deriving its own.",
             "Both `freshness_unavailable` and `freshness_conflict` are pre-commit, provider-not-reached results. If a retry is warranted for an unchanged exact operation, rerun the identical safe ordinary command: `--text` for a direct literal or the same deterministic `--content` dataflow for a tool source. The wrapper reuses its derived key. If the target or body changes after reconsideration, run the revised ordinary command and let the wrapper derive a new key. A result with `committed=true` must not be repeated; ambiguous termination follows the existing wrapper same-key recovery contract.",
             "For multiline `--markdown` or `--text` content in zsh or bash, prefer shell ANSI-C quoting so the command passes one argument with real newline characters: `--markdown $'First line\\nSecond line'` or `--text $'First line\\nSecond line'`. Putting `\"First line\\nSecond line\"` in ordinary double quotes is wrong: ordinary quotes do not decode `\\n`, so lark-cli and Feishu receive a backslash followed by the letter `n`. A literal multiline argument containing real newline characters is also valid. If ANSI-C-quoted content contains an apostrophe, use a safe shell single-quote splice or the literal-newline form; never use `eval`, `echo`, a temporary file, or unsafe variable interpolation to construct the body.",
             ...FEISHU_IM_COMMAND_GROUPS.map(([label, suffixes]) => `- ${label}: ${suffixes.map((suffix) => `\`${executable} ${suffix}\``).join(", ")}.`),

package/dist/app/lark-cli.mjs

@@ -269,6 +269,24 @@ function parseCommentReply(argv) {
         throw new Error("comment reply 的 --text 超过 20000 字符");
     return { messageId, text };
 }
+const IM_WRITE_MEMO_LIMIT = 512;
+// 只标注、不拦截：每次成功写把「实际生效的幂等 key → 服务端返回的 message_id」记进备忘。
+// 同 key 再次成功且服务端返回同一个 message_id，说明服务端走了幂等去重（没有产生新消息），
+// 返回 true 供输出标注 duplicate。拦截权始终在服务端，备忘不会吞掉任何发送。
+function recordImWriteMemo(store, key, messageId) {
+    let duplicate = false;
+    store.mutateJson("freshnessState", { version: 1, cursors: {} }, (state) => {
+        state.im_write_memo ??= {};
+        const prior = state.im_write_memo[key];
+        if (prior && prior.message_id === messageId)
+            duplicate = true;
+        state.im_write_memo[key] = { message_id: messageId, updated_at: new Date().toISOString() };
+        const keys = Object.keys(state.im_write_memo);
+        for (const stale of keys.slice(0, Math.max(0, keys.length - IM_WRITE_MEMO_LIMIT)))
+            delete state.im_write_memo[stale];
+    });
+    return duplicate;
+}
 function runCommentReply(argv, privateEnv, io, dependencies, store) {
     const input = parseCommentReply(argv);
     const targetKey = store.resolveInboxMessageTarget(input.messageId);
@@ -499,9 +517,12 @@ function parseHistory(result, target, requireBotIdentity = false) {
     }
     return { messages };
 }
-function intentId(target, cursor, argv) {
+// 防重编号只由 target + argv 决定：同一逻辑命令的重试永远得到同一个 key，
+// 服务端幂等去重才能生效。cursor（freshness 水位）会随每次观察读/冲突合并推进，
+// 掺入会让「已送达但回执丢失」的重试漂移成新 key，从而发出第二条消息。
+function intentId(target, argv) {
     const fingerprint = createHash("sha256")
-        .update(JSON.stringify([target, cursor, argv])).digest("hex");
+        .update(JSON.stringify([target, argv])).digest("hex");
     return `larkin-${fingerprint.slice(0, 32)}`;
 }
 function emitFreshnessError(io, input) {
@@ -709,6 +730,26 @@ function emitNativeResult(result, io) {
     }
     return result.status ?? (result.signal ? portableSignalCode(result.signal) : 1);
 }
+function emitDuplicatedWrite(result, io, input) {
+    let providerResponse;
+    try {
+        providerResponse = JSON.parse(result.stdout || "");
+    }
+    catch {
+        providerResponse = { raw_stdout: result.stdout || "" };
+    }
+    const providerDocument = providerResponse && typeof providerResponse === "object" && !Array.isArray(providerResponse)
+        ? providerResponse
+        : { provider_response: providerResponse };
+    io.stdout(`${JSON.stringify({
+        ...providerDocument,
+        ok: true,
+        duplicate: true,
+        target: input.target,
+        ...(result.stderr ? { provider_stderr_present: true } : {}),
+    })}\n`);
+    return 0;
+}
 function emitCommittedUnverified(result, io, input) {
     let providerResponse;
     try {
@@ -817,7 +858,16 @@ export function runLarkCli(argv, env = process.env, dependencies = {}) {
             store.mergeFreshnessCursor(targetKey, gated.current, mergeFeishuImCursor, generation);
             return 3;
         }
-        const write = callNative(botArgv(effectiveArgv, intentId(targetKey, gated.current, effectiveArgv)), privateEnv, io, nativeDependencies);
+        const intentKey = policyFlagValue(effectiveArgv, "--idempotency-key") ?? intentId(targetKey, effectiveArgv);
+        const write = callNative(botArgv(effectiveArgv, intentKey), privateEnv, io, nativeDependencies);
+        const writeMessage = writeResponseMessage(write);
+        const duplicate = !write.error && write.status === 0 && writeMessage
+            ? recordImWriteMemo(store, intentKey, writeMessage.message_id) : false;
+        if (duplicate) {
+            observeSuccessfulWrite(write, target, targetKey, store, generation);
+            emitDuplicatedWrite(write, io, { target: targetKey });
+            return 0;
+        }
         if (!write.error && write.status === 0 && !observeSuccessfulWrite(write, target, targetKey, store, generation)) {
             const responseMessage = writeResponseMessage(write);
             try {

package/dist/app/official-lark-cli.cjs

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OFFICIAL_LARK_CLI_INSTALL = exports.OFFICIAL_LARK_CLI_VERSION = void 0;
+exports.invalidateOfficialLarkCliProbeCache = invalidateOfficialLarkCliProbeCache;
 exports.probeOfficialLarkCli = probeOfficialLarkCli;
 exports.resolveOfficialLarkCli = resolveOfficialLarkCli;
 exports.installOfficialLarkCli = installOfficialLarkCli;
@@ -65,29 +66,29 @@ function officialPackage(executable) {
     }
     return null;
 }
-function probeOfficialLarkCli(dependencies = {}) {
-    const executable = loginShellPath(dependencies);
-    if (!executable)
-        return {
-            state: "missing",
-            reason: "真实 login shell 找不到官方 lark-cli",
-            nextAction: `运行 larkin setup，并确认执行：${exports.OFFICIAL_LARK_CLI_INSTALL}`,
-        };
-    const command = officialPackage(executable);
-    if (!command)
-        return {
-            state: "conflict",
-            reason: `真实 login shell 的 lark-cli 不是兼容的官方 @larksuite/cli ${exports.OFFICIAL_LARK_CLI_VERSION}: ${executable}`,
-            nextAction: "移除或调整冲突入口后重新运行 larkin setup",
-        };
+/**
+ * 进程内缓存（仅生产路径，即未注入 spawn/shell 时生效）：登录 shell 探测
+ * 是阻塞 spawnSync，且用户的 .zshrc/.zprofile（nvm 等）偶发需要数十秒才能
+ * 返回，daemon 热路径上反复探测会把启动拖到分钟级。同一进程内 PATH/SHELL
+ * 不变，解析结果也不会变，因此只探测一次。
+ */
+let productionProbeKey = null;
+let productionProbe = null;
+/** setup 安装/升级官方 CLI 后调用，使同一进程内的后续解析重新探测。 */
+function invalidateOfficialLarkCliProbeCache() {
+    productionProbeKey = null;
+    productionProbe = null;
+}
+/** 对已确认是官方 @larksuite/cli 的入口做版本与 bind 能力验证（shell 与 PATH 两路共用）。 */
+function validateOfficialCommand(command, env, spawn) {
     if (!compatibleVersion(command.version))
         return {
             state: "outdated",
-            reason: `真实 login shell 的官方 @larksuite/cli ${command.version} 低于最低兼容版本 ${exports.OFFICIAL_LARK_CLI_VERSION}`,
+            reason: `官方 lark-cli ${command.version} 低于最低兼容版本 ${exports.OFFICIAL_LARK_CLI_VERSION}: ${command.command}`,
             nextAction: `升级：${exports.OFFICIAL_LARK_CLI_INSTALL}`,
         };
-    const version = (dependencies.spawn ?? node_child_process_1.spawnSync)(command.command, ["--version"], {
-        encoding: "utf8", env: dependencies.env ?? process.env,
+    const version = spawn(command.command, ["--version"], {
+        encoding: "utf8", env,
     });
     if (version.status !== 0 || version.error || !String(version.stdout || "").includes(command.version))
         return {
@@ -95,8 +96,8 @@ function probeOfficialLarkCli(dependencies = {}) {
             reason: `官方 lark-cli 版本执行验证失败: ${command.command}`,
             nextAction: `重新安装：${exports.OFFICIAL_LARK_CLI_INSTALL}`,
         };
-    const bindHelp = (dependencies.spawn ?? node_child_process_1.spawnSync)(command.command, ["config", "bind", "--help"], {
-        encoding: "utf8", env: dependencies.env ?? process.env,
+    const bindHelp = spawn(command.command, ["config", "bind", "--help"], {
+        encoding: "utf8", env,
     });
     const bindText = `${bindHelp.stdout || ""}\n${bindHelp.stderr || ""}`;
     if (bindHelp.status !== 0 || bindHelp.error || !/--source/.test(bindText) || !/lark-channel/.test(bindText) || !/--identity/.test(bindText))
@@ -107,6 +108,72 @@ function probeOfficialLarkCli(dependencies = {}) {
         };
     return { state: "ready", command };
 }
+/**
+ * PATH 直接解析快路径：daemon（launchd）的 PATH 通常已包含官方 lark-cli，
+ * 此时完全不需要拉起登录 shell（这是启动变慢的主要来源之一）。
+ * 仅当 PATH 解析出可用的官方 CLI 时才返回结果；否则返回 null 回退到
+ * 登录 shell 探测（保留对 shell 自定义 PATH 环境的兼容）。
+ */
+function probePathResolution(env) {
+    const dirs = String(env.PATH || "").split(node_path_1.default.delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        const candidate = node_path_1.default.resolve(dir, "lark-cli");
+        try {
+            if (!node_fs_1.default.statSync(candidate).isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const command = officialPackage(candidate);
+        if (!command)
+            return null;
+        return validateOfficialCommand(command, env, node_child_process_1.spawnSync);
+    }
+    return null;
+}
+function probeOfficialLarkCliUncached(dependencies) {
+    const env = dependencies.env ?? process.env;
+    if (!dependencies.spawn && !dependencies.shell) {
+        const fromPath = probePathResolution(env);
+        if (fromPath)
+            return fromPath;
+    }
+    const executable = loginShellPath(dependencies);
+    if (!executable)
+        return {
+            state: "missing",
+            reason: "真实 login shell 找不到官方 lark-cli",
+            nextAction: `运行 larkin setup，并确认执行：${exports.OFFICIAL_LARK_CLI_INSTALL}`,
+        };
+    const command = officialPackage(executable);
+    if (!command)
+        return {
+            state: "conflict",
+            reason: `真实 login shell 的 lark-cli 不是兼容的官方 @larksuite/cli ${exports.OFFICIAL_LARK_CLI_VERSION}: ${executable}`,
+            nextAction: "移除或调整冲突入口后重新运行 larkin setup",
+        };
+    if (!compatibleVersion(command.version))
+        return {
+            state: "outdated",
+            reason: `真实 login shell 的官方 @larksuite/cli ${command.version} 低于最低兼容版本 ${exports.OFFICIAL_LARK_CLI_VERSION}`,
+            nextAction: `升级：${exports.OFFICIAL_LARK_CLI_INSTALL}`,
+        };
+    return validateOfficialCommand(command, env, dependencies.spawn ?? node_child_process_1.spawnSync);
+}
+function probeOfficialLarkCli(dependencies = {}) {
+    if (!dependencies.spawn && !dependencies.shell) {
+        const env = dependencies.env ?? process.env;
+        const key = `${env.SHELL || ""}|${env.PATH || ""}`;
+        if (productionProbe && productionProbeKey === key)
+            return productionProbe;
+        const probe = probeOfficialLarkCliUncached({ env });
+        productionProbeKey = key;
+        productionProbe = probe;
+        return probe;
+    }
+    return probeOfficialLarkCliUncached(dependencies);
+}
 function resolveOfficialLarkCli(dependencies = {}) {
     const result = probeOfficialLarkCli(dependencies);
     if (result.state !== "ready")
@@ -120,6 +187,7 @@ function installOfficialLarkCli(dependencies = {}) {
     });
     if (result.status !== 0 || result.error)
         throw new Error(`官方 lark-cli 安装失败（exit=${result.status ?? "none"}）`);
+    invalidateOfficialLarkCliProbeCache();
     return resolveOfficialLarkCli(dependencies);
 }
 async function ensureOfficialLarkCliForSetup(input) {

package/dist/app/official-lark-cli.mjs

@@ -55,29 +55,29 @@ function officialPackage(executable) {
     }
     return null;
 }
-export function probeOfficialLarkCli(dependencies = {}) {
-    const executable = loginShellPath(dependencies);
-    if (!executable)
-        return {
-            state: "missing",
-            reason: "真实 login shell 找不到官方 lark-cli",
-            nextAction: `运行 larkin setup，并确认执行：${OFFICIAL_LARK_CLI_INSTALL}`,
-        };
-    const command = officialPackage(executable);
-    if (!command)
-        return {
-            state: "conflict",
-            reason: `真实 login shell 的 lark-cli 不是兼容的官方 @larksuite/cli ${OFFICIAL_LARK_CLI_VERSION}: ${executable}`,
-            nextAction: "移除或调整冲突入口后重新运行 larkin setup",
-        };
+/**
+ * 进程内缓存（仅生产路径，即未注入 spawn/shell 时生效）：登录 shell 探测
+ * 是阻塞 spawnSync，且用户的 .zshrc/.zprofile（nvm 等）偶发需要数十秒才能
+ * 返回，daemon 热路径上反复探测会把启动拖到分钟级。同一进程内 PATH/SHELL
+ * 不变，解析结果也不会变，因此只探测一次。
+ */
+let productionProbeKey = null;
+let productionProbe = null;
+/** setup 安装/升级官方 CLI 后调用，使同一进程内的后续解析重新探测。 */
+export function invalidateOfficialLarkCliProbeCache() {
+    productionProbeKey = null;
+    productionProbe = null;
+}
+/** 对已确认是官方 @larksuite/cli 的入口做版本与 bind 能力验证（shell 与 PATH 两路共用）。 */
+function validateOfficialCommand(command, env, spawn) {
     if (!compatibleVersion(command.version))
         return {
             state: "outdated",
-            reason: `真实 login shell 的官方 @larksuite/cli ${command.version} 低于最低兼容版本 ${OFFICIAL_LARK_CLI_VERSION}`,
+            reason: `官方 lark-cli ${command.version} 低于最低兼容版本 ${OFFICIAL_LARK_CLI_VERSION}: ${command.command}`,
             nextAction: `升级：${OFFICIAL_LARK_CLI_INSTALL}`,
         };
-    const version = (dependencies.spawn ?? spawnSync)(command.command, ["--version"], {
-        encoding: "utf8", env: dependencies.env ?? process.env,
+    const version = spawn(command.command, ["--version"], {
+        encoding: "utf8", env,
     });
     if (version.status !== 0 || version.error || !String(version.stdout || "").includes(command.version))
         return {
@@ -85,8 +85,8 @@ export function probeOfficialLarkCli(dependencies = {}) {
             reason: `官方 lark-cli 版本执行验证失败: ${command.command}`,
             nextAction: `重新安装：${OFFICIAL_LARK_CLI_INSTALL}`,
         };
-    const bindHelp = (dependencies.spawn ?? spawnSync)(command.command, ["config", "bind", "--help"], {
-        encoding: "utf8", env: dependencies.env ?? process.env,
+    const bindHelp = spawn(command.command, ["config", "bind", "--help"], {
+        encoding: "utf8", env,
     });
     const bindText = `${bindHelp.stdout || ""}\n${bindHelp.stderr || ""}`;
     if (bindHelp.status !== 0 || bindHelp.error || !/--source/.test(bindText) || !/lark-channel/.test(bindText) || !/--identity/.test(bindText))
@@ -97,6 +97,72 @@ export function probeOfficialLarkCli(dependencies = {}) {
         };
     return { state: "ready", command };
 }
+/**
+ * PATH 直接解析快路径：daemon（launchd）的 PATH 通常已包含官方 lark-cli，
+ * 此时完全不需要拉起登录 shell（这是启动变慢的主要来源之一）。
+ * 仅当 PATH 解析出可用的官方 CLI 时才返回结果；否则返回 null 回退到
+ * 登录 shell 探测（保留对 shell 自定义 PATH 环境的兼容）。
+ */
+function probePathResolution(env) {
+    const dirs = String(env.PATH || "").split(path.delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        const candidate = path.resolve(dir, "lark-cli");
+        try {
+            if (!fs.statSync(candidate).isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const command = officialPackage(candidate);
+        if (!command)
+            return null;
+        return validateOfficialCommand(command, env, spawnSync);
+    }
+    return null;
+}
+function probeOfficialLarkCliUncached(dependencies) {
+    const env = dependencies.env ?? process.env;
+    if (!dependencies.spawn && !dependencies.shell) {
+        const fromPath = probePathResolution(env);
+        if (fromPath)
+            return fromPath;
+    }
+    const executable = loginShellPath(dependencies);
+    if (!executable)
+        return {
+            state: "missing",
+            reason: "真实 login shell 找不到官方 lark-cli",
+            nextAction: `运行 larkin setup，并确认执行：${OFFICIAL_LARK_CLI_INSTALL}`,
+        };
+    const command = officialPackage(executable);
+    if (!command)
+        return {
+            state: "conflict",
+            reason: `真实 login shell 的 lark-cli 不是兼容的官方 @larksuite/cli ${OFFICIAL_LARK_CLI_VERSION}: ${executable}`,
+            nextAction: "移除或调整冲突入口后重新运行 larkin setup",
+        };
+    if (!compatibleVersion(command.version))
+        return {
+            state: "outdated",
+            reason: `真实 login shell 的官方 @larksuite/cli ${command.version} 低于最低兼容版本 ${OFFICIAL_LARK_CLI_VERSION}`,
+            nextAction: `升级：${OFFICIAL_LARK_CLI_INSTALL}`,
+        };
+    return validateOfficialCommand(command, env, dependencies.spawn ?? spawnSync);
+}
+export function probeOfficialLarkCli(dependencies = {}) {
+    if (!dependencies.spawn && !dependencies.shell) {
+        const env = dependencies.env ?? process.env;
+        const key = `${env.SHELL || ""}|${env.PATH || ""}`;
+        if (productionProbe && productionProbeKey === key)
+            return productionProbe;
+        const probe = probeOfficialLarkCliUncached({ env });
+        productionProbeKey = key;
+        productionProbe = probe;
+        return probe;
+    }
+    return probeOfficialLarkCliUncached(dependencies);
+}
 export function resolveOfficialLarkCli(dependencies = {}) {
     const result = probeOfficialLarkCli(dependencies);
     if (result.state !== "ready")
@@ -110,6 +176,7 @@ export function installOfficialLarkCli(dependencies = {}) {
     });
     if (result.status !== 0 || result.error)
         throw new Error(`官方 lark-cli 安装失败（exit=${result.status ?? "none"}）`);
+    invalidateOfficialLarkCliProbeCache();
     return resolveOfficialLarkCli(dependencies);
 }
 export async function ensureOfficialLarkCliForSetup(input) {

package/dist/runtime/claude-model-catalog.cjs

@@ -85,7 +85,30 @@ function parseCatalog(value) {
         throw new Error("Claude model catalog has no visible local default");
     return { models, effectiveModel, defaultSupportedReasoningEfforts: efforts(defaultRow || {}) };
 }
+/**
+ * 进程内缓存：同一 claude 可执行文件的模型目录在进程生命周期内不变，
+ * daemon 启动时多个 claude agent 只需探测一次（每次探测都要 spawn 一个
+ * claude CLI 进程做 list_models 控制请求）。失败不缓存以便重试；测试注入
+ * runClaudeControl 时绕过缓存，保持测试隔离。
+ */
+const discoveryCache = new Map();
 async function discoverClaudeModelCatalog(options = {}) {
+    if (!options.runClaudeControl) {
+        const key = `${options.command || options.env?.LARKIN_CLAUDE_COMMAND || "claude"}`;
+        const cached = discoveryCache.get(key);
+        if (cached)
+            return cached;
+        const pending = discoverClaudeModelCatalogUncached(options);
+        discoveryCache.set(key, pending);
+        pending.catch(() => {
+            if (discoveryCache.get(key) === pending)
+                discoveryCache.delete(key);
+        });
+        return pending;
+    }
+    return discoverClaudeModelCatalogUncached(options);
+}
+async function discoverClaudeModelCatalogUncached(options) {
     const execute = options.runClaudeControl ?? runClaudeControl;
     const request = { type: "control_request", request_id: "larkin-model-list", request: { subtype: "list_models" } };
     try {

package/dist/runtime/claude-model-catalog.mjs

@@ -82,7 +82,30 @@ function parseCatalog(value) {
         throw new Error("Claude model catalog has no visible local default");
     return { models, effectiveModel, defaultSupportedReasoningEfforts: efforts(defaultRow || {}) };
 }
+/**
+ * 进程内缓存：同一 claude 可执行文件的模型目录在进程生命周期内不变，
+ * daemon 启动时多个 claude agent 只需探测一次（每次探测都要 spawn 一个
+ * claude CLI 进程做 list_models 控制请求）。失败不缓存以便重试；测试注入
+ * runClaudeControl 时绕过缓存，保持测试隔离。
+ */
+const discoveryCache = new Map();
 export async function discoverClaudeModelCatalog(options = {}) {
+    if (!options.runClaudeControl) {
+        const key = `${options.command || options.env?.LARKIN_CLAUDE_COMMAND || "claude"}`;
+        const cached = discoveryCache.get(key);
+        if (cached)
+            return cached;
+        const pending = discoverClaudeModelCatalogUncached(options);
+        discoveryCache.set(key, pending);
+        pending.catch(() => {
+            if (discoveryCache.get(key) === pending)
+                discoveryCache.delete(key);
+        });
+        return pending;
+    }
+    return discoverClaudeModelCatalogUncached(options);
+}
+async function discoverClaudeModelCatalogUncached(options) {
     const execute = options.runClaudeControl ?? runClaudeControl;
     const request = { type: "control_request", request_id: "larkin-model-list", request: { subtype: "list_models" } };
     try {

package/dist/runtime/codex-model-catalog.cjs

@@ -93,7 +93,30 @@ function parseCatalog(value) {
         throw new Error("Codex model catalog has no visible local default");
     return { models, effectiveModel };
 }
+/**
+ * 进程内缓存：同一 codex 可执行文件的模型目录在进程生命周期内不变，
+ * daemon 启动时多个 codex agent 只需探测一次（每次探测都要 spawn 一个
+ * codex app-server 进程）。失败不缓存以便重试；测试注入 runCodexAppServer
+ * 时绕过缓存，保持测试隔离。
+ */
+const discoveryCache = new Map();
 async function discoverCodexModelCatalog(options = {}) {
+    if (!options.runCodexAppServer) {
+        const key = `${options.command || options.env?.LARKIN_CODEX_COMMAND || "codex"}`;
+        const cached = discoveryCache.get(key);
+        if (cached)
+            return cached;
+        const pending = discoverCodexModelCatalogUncached(options);
+        discoveryCache.set(key, pending);
+        pending.catch(() => {
+            if (discoveryCache.get(key) === pending)
+                discoveryCache.delete(key);
+        });
+        return pending;
+    }
+    return discoverCodexModelCatalogUncached(options);
+}
+async function discoverCodexModelCatalogUncached(options) {
     const execute = options.runCodexAppServer ?? runCodexAppServer;
     const request = { id: "larkin-model-list", method: "model/list", params: { limit: 100, includeHidden: false } };
     try {

package/dist/runtime/codex-model-catalog.mjs

@@ -90,7 +90,30 @@ function parseCatalog(value) {
         throw new Error("Codex model catalog has no visible local default");
     return { models, effectiveModel };
 }
+/**
+ * 进程内缓存：同一 codex 可执行文件的模型目录在进程生命周期内不变，
+ * daemon 启动时多个 codex agent 只需探测一次（每次探测都要 spawn 一个
+ * codex app-server 进程）。失败不缓存以便重试；测试注入 runCodexAppServer
+ * 时绕过缓存，保持测试隔离。
+ */
+const discoveryCache = new Map();
 export async function discoverCodexModelCatalog(options = {}) {
+    if (!options.runCodexAppServer) {
+        const key = `${options.command || options.env?.LARKIN_CODEX_COMMAND || "codex"}`;
+        const cached = discoveryCache.get(key);
+        if (cached)
+            return cached;
+        const pending = discoverCodexModelCatalogUncached(options);
+        discoveryCache.set(key, pending);
+        pending.catch(() => {
+            if (discoveryCache.get(key) === pending)
+                discoveryCache.delete(key);
+        });
+        return pending;
+    }
+    return discoverCodexModelCatalogUncached(options);
+}
+async function discoverCodexModelCatalogUncached(options) {
     const execute = options.runCodexAppServer ?? runCodexAppServer;
     const request = { id: "larkin-model-list", method: "model/list", params: { limit: 100, includeHidden: false } };
     try {

package/dist/runtime/pi-model-catalog.cjs

@@ -63,8 +63,32 @@ function findExactPiModel(reference, models) {
         return undefined;
     return models.find((model) => piModelId(model) === reference);
 }
+/**
+ * 进程内缓存：同一个 pi 可执行文件的模型目录在进程生命周期内不变。
+ * daemon 启动时 3 个 pi agent 会各发起一次发现探测（每个都 spawn 一个 pi 进程
+ * 并做 RPC 握手，约 5s），缓存后只 spawn 一次；失败不缓存以便重试。
+ * 测试注入 options.spawn 时绕过缓存，保持测试隔离。
+ */
+const discoveryCache = new Map();
 /** Discover only through Pi's structured RPC protocol; no table parsing or static fallback. */
 async function discoverPiModelCatalog(options) {
+    if (!options.spawn) {
+        const command = options.command ?? options.env?.LARKIN_PI_COMMAND ?? process.env.LARKIN_PI_COMMAND ?? "pi";
+        const key = `${command}|${options.env?.PI_CODING_AGENT_DIR ?? ""}|${options.agentDir ?? ""}`;
+        const cached = discoveryCache.get(key);
+        if (cached)
+            return cached;
+        const pending = discoverPiModelCatalogUncached(options);
+        discoveryCache.set(key, pending);
+        pending.catch(() => {
+            if (discoveryCache.get(key) === pending)
+                discoveryCache.delete(key);
+        });
+        return pending;
+    }
+    return discoverPiModelCatalogUncached(options);
+}
+async function discoverPiModelCatalogUncached(options) {
     const spawn = options.spawn ?? ((command, args, spawnOptions) => (0, node_child_process_1.spawn)(command, [...args], spawnOptions));
     const command = options.command ?? options.env?.LARKIN_PI_COMMAND ?? process.env.LARKIN_PI_COMMAND ?? "pi";
     const child = spawn(command, ["--mode", "rpc", "--no-session"], {

package/dist/runtime/pi-model-catalog.mjs

@@ -22,8 +22,32 @@ export function findExactPiModel(reference, models) {
         return undefined;
     return models.find((model) => piModelId(model) === reference);
 }
+/**
+ * 进程内缓存：同一个 pi 可执行文件的模型目录在进程生命周期内不变。
+ * daemon 启动时 3 个 pi agent 会各发起一次发现探测（每个都 spawn 一个 pi 进程
+ * 并做 RPC 握手，约 5s），缓存后只 spawn 一次；失败不缓存以便重试。
+ * 测试注入 options.spawn 时绕过缓存，保持测试隔离。
+ */
+const discoveryCache = new Map();
 /** Discover only through Pi's structured RPC protocol; no table parsing or static fallback. */
 export async function discoverPiModelCatalog(options) {
+    if (!options.spawn) {
+        const command = options.command ?? options.env?.LARKIN_PI_COMMAND ?? process.env.LARKIN_PI_COMMAND ?? "pi";
+        const key = `${command}|${options.env?.PI_CODING_AGENT_DIR ?? ""}|${options.agentDir ?? ""}`;
+        const cached = discoveryCache.get(key);
+        if (cached)
+            return cached;
+        const pending = discoverPiModelCatalogUncached(options);
+        discoveryCache.set(key, pending);
+        pending.catch(() => {
+            if (discoveryCache.get(key) === pending)
+                discoveryCache.delete(key);
+        });
+        return pending;
+    }
+    return discoverPiModelCatalogUncached(options);
+}
+async function discoverPiModelCatalogUncached(options) {
     const spawn = options.spawn ?? ((command, args, spawnOptions) => nodeSpawn(command, [...args], spawnOptions));
     const command = options.command ?? options.env?.LARKIN_PI_COMMAND ?? process.env.LARKIN_PI_COMMAND ?? "pi";
     const child = spawn(command, ["--mode", "rpc", "--no-session"], {

package/dist/runtime/runtime-host.cjs

@@ -793,10 +793,13 @@ function createRuntimeHost(options) {
             let activeCount = 0;
             let recoveringCount = 0;
             const startupFailures = [];
-            for (const config of configs) {
+            // Agents start concurrently: each Agent's runtime session is independent,
+            // and serial startup multiplied every per-Agent handshake (login-shell
+            // probe + runtime RPC discovery) by the Agent count.
+            const startups = configs.map(async (config) => {
                 if (managed.has(config.agentId)) {
                     activeCount += 1;
-                    continue;
+                    return;
                 }
                 const stateStore = options.stateStoreFor?.(config.agentId);
                 const persisted = stateStore
@@ -851,7 +854,8 @@ function createRuntimeHost(options) {
                 }
                 agent.poller = setInterval(() => reconcileExternalConsumption(agent), 250);
                 agent.poller.unref?.();
-            }
+            });
+            await Promise.all(startups);
             if (configs.length > 0 && activeCount === 0 && recoveringCount === 0) {
                 throw new Error(`No runtime Agent started: ${startupFailures.join("; ")}`);
             }

package/dist/runtime/runtime-host.mjs

@@ -785,10 +785,13 @@ export function createRuntimeHost(options) {
             let activeCount = 0;
             let recoveringCount = 0;
             const startupFailures = [];
-            for (const config of configs) {
+            // Agents start concurrently: each Agent's runtime session is independent,
+            // and serial startup multiplied every per-Agent handshake (login-shell
+            // probe + runtime RPC discovery) by the Agent count.
+            const startups = configs.map(async (config) => {
                 if (managed.has(config.agentId)) {
                     activeCount += 1;
-                    continue;
+                    return;
                 }
                 const stateStore = options.stateStoreFor?.(config.agentId);
                 const persisted = stateStore
@@ -843,7 +846,8 @@ export function createRuntimeHost(options) {
                 }
                 agent.poller = setInterval(() => reconcileExternalConsumption(agent), 250);
                 agent.poller.unref?.();
-            }
+            });
+            await Promise.all(startups);
             if (configs.length > 0 && activeCount === 0 && recoveringCount === 0) {
                 throw new Error(`No runtime Agent started: ${startupFailures.join("; ")}`);
             }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "larkin",
-  "version": "0.2.74",
+  "version": "0.2.76",
   "private": false,
   "larkinPackageRole": "npm-published",
   "files": [
     "dist/",
+    "assets/",
     "README.md",
     "LICENSE",
     "SECURITY.md",