larkin 0.2.74 → 0.2.75

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/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.75",
   "private": false,
   "larkinPackageRole": "npm-published",
   "files": [
     "dist/",
+    "assets/",
     "README.md",
     "LICENSE",
     "SECURITY.md",