larkin 0.2.70

package/dist/setup/setup-bind.mjs

@@ -0,0 +1,337 @@
+#!/usr/bin/env bun
+// Internal setup stage: bind an existing lark-cli bot profile to its App-ID Agent.
+import { spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { fileURLToPath } from "node:url";
+import { TargetRootLayout } from "../platform/root-layout.mjs";
+import { planSingleRootBinding } from "./setup-binding.mjs";
+import { discoverPiModelCatalog } from "../runtime/pi-model-catalog.mjs";
+import { configureBuiltinPiProviderModel } from "../runtime/pi-provider-config.mjs";
+import { terminalSetupQuestioner } from "./setup-agent-choice.mjs";
+import { beginBuiltinPiCredentialTransaction, createOfficialPiAuthInteraction, createOfficialPiModelRuntime, runOfficialPiLogin, verifyOfficialPiProviderTurn, } from "../runtime/pi-official-auth.mjs";
+import * as larkinConfigImport from "../platform/config.mjs";
+import { resolveOfficialLarkCli } from "../app/official-lark-cli.mjs";
+const larkinConfig = larkinConfigImport;
+const layout = TargetRootLayout.fromConfigDir(larkinConfig.resolveConfigDir(process.env));
+const CFG_DIR = layout.root;
+const CFG_FILE = layout.configFile;
+const APP_ID = /^cli_[A-Za-z0-9]+$/;
+const LARK_CFG_DIR = larkinConfig.resolveLarkConfigDir(process.env, CFG_DIR);
+fs.mkdirSync(LARK_CFG_DIR, { recursive: true, mode: 0o700 });
+const larkEnv = () => ({ ...process.env, LARKSUITE_CLI_CONFIG_DIR: LARK_CFG_DIR });
+const argv = process.argv.slice(2);
+const flag = (name) => {
+    const index = argv.indexOf(name);
+    return index >= 0 ? argv[index + 1] : undefined;
+};
+const has = (name) => argv.includes(name);
+const options = {
+    agent: flag("--agent"),
+    profile: flag("--profile"),
+    runtime: flag("--runtime"),
+    selectionFile: flag("--selection-file"),
+    yes: has("--yes"),
+    list: has("--list"),
+    help: has("--help") || has("-h"),
+};
+const nonInteractive = options.yes || Boolean(options.profile);
+const say = (...args) => console.log(...args);
+const die = (message) => {
+    console.error(`✗ ${message}`);
+    process.exit(1);
+};
+async function ask(question) {
+    if (nonInteractive)
+        return "";
+    const input = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => input.question(question, (answer) => {
+        input.close();
+        resolve(answer.trim());
+    }));
+}
+function larkJson(args) {
+    const env = larkEnv();
+    const official = resolveOfficialLarkCli({ env });
+    const result = spawnSync(official.command, [...official.argsPrefix, ...args], { encoding: "utf8", env });
+    const stdout = result.stdout || "";
+    const stderr = result.stderr || "";
+    try {
+        return { ok: result.status === 0, json: JSON.parse(stdout), raw: stdout, err: stderr };
+    }
+    catch {
+        return { ok: false, json: null, raw: stdout, err: stderr || stdout };
+    }
+}
+function openAuthUrl(url) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "rundll32.exe" : "xdg-open";
+    const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+    const result = spawnSync(command, args, { stdio: "ignore", timeout: 5_000 });
+    return result.status === 0;
+}
+function listProfiles() {
+    const result = larkJson(["profile", "list"]);
+    if (!result.ok || !Array.isArray(result.json)) {
+        die("读取 lark-cli profile 失败；未修改 Agent 配置，请检查隔离 profile 后重试 setup");
+    }
+    return result.json;
+}
+async function pickProfile() {
+    if (options.profile) {
+        if (!APP_ID.test(options.profile))
+            die(`profile ${options.profile} 不是合法 App ID`);
+        return { name: options.profile, appId: options.profile, active: true };
+    }
+    const profiles = listProfiles();
+    if (profiles.length === 0)
+        die("lark-cli 里还没有 bot profile。请运行 larkin setup 创建或连接机器人");
+    say("\n可复用的飞书机器人（lark-cli profiles）：");
+    profiles.forEach((profile, index) => say(`  [${index + 1}] ${profile.name}  appId=${profile.appId}${profile.active ? "  (当前活跃，默认)" : ""}`));
+    say("  （创建新机器人请退出后运行 larkin setup）");
+    const activeIndex = Math.max(0, profiles.findIndex((profile) => profile.active));
+    const answer = await ask(`选择 profile（回车=${activeIndex + 1}）: `);
+    const selected = answer === "" ? activeIndex : Number(answer) - 1;
+    if (!(selected >= 0 && selected < profiles.length))
+        die("无效的 profile 选择");
+    return profiles[selected];
+}
+function verifyBot(profile) {
+    const result = larkJson(["--profile", profile.name, "im", "+chat-list", "--as", "bot", "--json"]);
+    const response = result.json;
+    if (!result.ok || !response || !response.ok)
+        die("bot 校验失败；未修改 Agent 配置，请检查 profile 凭证后重试 setup");
+    const verified = response;
+    if (verified.identity !== "bot")
+        die(`profile ${profile.name} 未返回 bot identity；未修改 Agent 配置，请重试 setup`);
+    say(`\n✓ profile 校验：${profile.name}  appId=${profile.appId}  identity=bot`);
+    return verified.data?.chats || [];
+}
+function validateRuntime(runtime) {
+    const catalog = larkinConfig.loadRuntimeModels();
+    if (!catalog[runtime])
+        die(`"${runtime}" 不是合法 runtime。合法值: ${Object.keys(catalog).join(", ")}`);
+}
+function loadConfig() {
+    return larkinConfig.loadConfig(process.env, { mint: () => crypto.randomUUID() });
+}
+function readSetupSelection(fileArg) {
+    if (!fileArg)
+        return null;
+    const file = path.resolve(fileArg);
+    if (path.dirname(file) !== path.resolve(CFG_DIR) || !/^\.setup-agent-choice-\d+-[A-Za-z0-9-]+\.json$/.test(path.basename(file))) {
+        die("setup Agent 选择文件路径无效");
+    }
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink()
+        || (typeof process.getuid === "function" && stat.uid !== process.getuid())
+        || (stat.mode & 0o777) !== 0o600)
+        die("setup Agent 选择文件必须是当前用户拥有的 0600 普通文件");
+    const bytes = fs.readFileSync(file, "utf8");
+    fs.unlinkSync(file);
+    const raw = JSON.parse(bytes);
+    if (!raw || !["pi", "codex", "claude"].includes(raw.runtime))
+        die("setup Agent 选择无效");
+    return raw;
+}
+function fabricateAttachment(root, serverId) {
+    const directory = path.join(root, "computer", "servers", serverId);
+    fs.mkdirSync(directory, { recursive: true });
+    const file = path.join(directory, "runner.state.json");
+    if (fs.existsSync(file))
+        return;
+    const attachment = {
+        kind: "computer-attachment",
+        serverId,
+        serverSlug: "feishu",
+        serverMachineId: crypto.randomUUID(),
+        machineId: crypto.randomUUID(),
+        apiKey: `sk_computer_local_${crypto.randomBytes(16).toString("hex")}`,
+        serverUrl: "http://127.0.0.1:8787",
+        attachedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(file, JSON.stringify(attachment, null, 2), { mode: 0o600 });
+}
+function safeProviderFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/\b(?:401|403)\b|unauth|invalid.*(?:key|token)|credential/i.test(message)) {
+        return new Error("内置 Pi provider 拒绝认证（401/403）；请重新登录或检查 credential");
+    }
+    if (/timeout|超时|ETIMEDOUT/i.test(message))
+        return new Error("内置 Pi provider readiness 超时；请检查网络和 endpoint");
+    if (/ENOTFOUND|ECONN|fetch failed|network|TLS/i.test(message))
+        return new Error("内置 Pi provider endpoint 不可达；请检查网络、TLS 和 Base URL");
+    if (/model|模型/i.test(message))
+        return new Error("内置 Pi provider 不接受所选模型；请检查 provider/model");
+    return new Error("内置 Pi provider readiness 失败；credential/config 已回滚，请检查 provider 状态后重试");
+}
+function printAgents(config) {
+    const names = Object.keys(config.agents);
+    if (!names.length) {
+        say("尚未配置 Agent。");
+        return;
+    }
+    say("已配置 Agents：");
+    for (const name of names) {
+        const agent = config.agents[name];
+        say(`  ${name === config.activeAgent ? "*" : " "} ${name}: profile=${agent.feishuProfile} runtime=${agent.runtime} model=${agent.model}`);
+    }
+}
+export async function main() {
+    if (has("--model")) {
+        die("setup 不支持配置 model；请用 larkin model <id> 单独切换（bun run model -- <id>，带合法值校验）");
+    }
+    if (options.help) {
+        say(`larkin setup（内部绑定阶段）
+
+用法:
+  larkin setup --profile <已有profile> [参数]
+
+参数（都可省略；单 bot 单 agent 场景零参数即可）:
+  --agent <App ID>     必须与所选 profile 的 App ID 一致；缺省自动使用该 App ID
+  --profile <name>     复用已有 lark-cli profile（可用 profile 名或 appId；缺省交互选择）
+  --runtime <runtime>  pi / codex / claude；缺省沿用已有 agent 的 runtime，全新 agent 默认 pi
+  --yes                非交互接受默认项
+  --list               查看已经配置的 Agent
+  --help               显示帮助
+
+普通用户请直接运行 larkin setup；该内部阶段只负责绑定已取得的凭证。
+模型不在 setup 配置：沿用已有值（换 runtime 时重置为该 runtime 默认），切换用 larkin model <id>。`);
+        return;
+    }
+    const loaded = loadConfig();
+    const config = loaded.config;
+    const selection = readSetupSelection(options.selectionFile);
+    if (options.list) {
+        printAgents(config);
+        return;
+    }
+    say("=== larkin 多 Agent onboarding ===");
+    const profile = await pickProfile();
+    if (typeof profile?.appId !== "string" || !APP_ID.test(profile.appId) || profile.name !== profile.appId) {
+        die("profile name 与合法 App ID 必须完全一致；未修改 Agent 配置，请重新运行 larkin setup 刷新 profile");
+    }
+    if (!options.profile)
+        verifyBot(profile);
+    const requestedAgent = options.agent || profile.appId;
+    const prior = config.agents[profile.appId];
+    const runtime = selection?.runtime || options.runtime || prior?.runtime || "pi";
+    const piDistribution = runtime === "pi"
+        ? (selection?.runtime === "pi" ? selection.distribution : prior?.piDistribution || "external")
+        : undefined;
+    validateRuntime(runtime);
+    const defaultModel = larkinConfig.defaultModelFor(runtime);
+    const selectedModel = selection?.runtime === "pi" && selection.distribution === "builtin" ? selection.model : undefined;
+    const targetModelId = selectedModel || (prior?.runtime === runtime ? prior.model : defaultModel);
+    let runtimeModels = larkinConfig.loadRuntimeModels()[runtime];
+    if (runtime === "pi" && piDistribution === "builtin") {
+        runtimeModels = [{ id: targetModelId, supportedReasoningEfforts: [] }];
+    }
+    else if (runtime === "pi") {
+        const piCatalog = await discoverPiModelCatalog({
+            cwd: layout.workspaceDir(profile.appId),
+            ...(process.env.PI_CODING_AGENT_DIR ? { agentDir: process.env.PI_CODING_AGENT_DIR } : {}),
+        });
+        const effective = piCatalog.models.find((model) => model.id === piCatalog.effectiveModel);
+        runtimeModels = [{ id: "default", supportedReasoningEfforts: effective?.supportedReasoningEfforts || [] }, ...piCatalog.models];
+    }
+    const targetModel = runtimeModels.find((model) => model.id === targetModelId);
+    if (!targetModel)
+        die(`目标模型 ${runtime}/${targetModelId} 不在 runtime 模型目录中；未修改 Agent 配置`);
+    const stored = planSingleRootBinding({
+        config: larkinConfig.toStored(config),
+        profile,
+        requestedAgent,
+        runtime: selection?.runtime || options.runtime,
+        ...(selection?.runtime === "pi" ? { piDistribution: selection.distribution } : {}),
+        ...(selectedModel ? { model: selectedModel } : {}),
+        defaultModel,
+        supportedReasoningEfforts: targetModel.supportedReasoningEfforts || [],
+        now: new Date().toISOString(),
+    });
+    const bound = stored.agents[profile.appId];
+    fs.mkdirSync(CFG_DIR, { recursive: true });
+    let providerTransaction = null;
+    let providerPublished = false;
+    const authAlreadyCompleted = selection?.runtime === "pi" && selection.distribution === "builtin"
+        && selection.authCompleted === true;
+    const readinessAlreadyCompleted = authAlreadyCompleted
+        && selection.readinessCompleted === true;
+    const authAbort = new AbortController();
+    const cancelProviderTransaction = (signal) => {
+        authAbort.abort();
+        if (!providerPublished)
+            providerTransaction?.rollback();
+        process.exit(signal === "SIGINT" ? 130 : 143);
+    };
+    const onSigint = () => cancelProviderTransaction("SIGINT");
+    const onSigterm = () => cancelProviderTransaction("SIGTERM");
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+    let authQuestioner = null;
+    try {
+        providerTransaction = selection?.runtime === "pi" && selection.distribution === "builtin"
+            && !authAlreadyCompleted ? beginBuiltinPiCredentialTransaction(CFG_DIR, profile.appId)
+            : null;
+        if (selection?.runtime === "pi" && selection.distribution === "builtin") {
+            const official = selection.preset === "official" ? selection : null;
+            const configured = official ? null : configureBuiltinPiProviderModel(CFG_DIR, profile.appId, selection);
+            const providerId = official?.providerId || configured.provider;
+            const authType = official?.authType || "api_key";
+            let piRuntime = null;
+            if (!authAlreadyCompleted) {
+                piRuntime = await createOfficialPiModelRuntime(CFG_DIR, profile.appId);
+                authQuestioner = terminalSetupQuestioner();
+                say(`正在通过捆绑官方 Pi 登录 ${providerId}（${authType}）…`);
+                try {
+                    await runOfficialPiLogin(piRuntime, providerId, authType, createOfficialPiAuthInteraction({
+                        questioner: authQuestioner,
+                        report: (message) => say(message),
+                        openUrl: openAuthUrl,
+                        signal: authAbort.signal,
+                    }));
+                }
+                catch {
+                    throw new Error(`官方 Pi ${providerId} 登录失败或已取消；credential/config 未修改`);
+                }
+            }
+            if (!readinessAlreadyCompleted) {
+                piRuntime ??= await createOfficialPiModelRuntime(CFG_DIR, profile.appId);
+                say("正在验证内置 Pi provider（受控单轮，不发送飞书消息）…");
+                try {
+                    if (!(process.env.LARKIN_TEST_SKIP_BUILTIN_PI_PROVIDER_TURN === "1" && process.env.LARKIN_TEST_BOT_REGISTER_MODULE)) {
+                        await verifyOfficialPiProviderTurn(piRuntime, selection.model, authAbort.signal);
+                    }
+                }
+                catch (error) {
+                    throw safeProviderFailure(error);
+                }
+            }
+        }
+        larkinConfig.commitSetupConfig(process.env, loaded.revision, stored);
+        providerTransaction?.commit();
+        providerPublished = true;
+    }
+    catch (error) {
+        providerTransaction?.rollback();
+        throw error;
+    }
+    finally {
+        authQuestioner?.close?.();
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+    }
+    fabricateAttachment(layout.root, stored.serverId);
+    say(`\n✓ 已写配置: ${CFG_FILE}`);
+    say(`  agent=${profile.appId}  runtime=${bound.runtime}  model=${bound.model}`);
+    say(`  单服务 serverId=${stored.serverId}  larkinHome=${layout.root}`);
+    say("\n启动这个 Agent：");
+    say("  larkin start                     # 单服务启动全部已配置 Agent");
+    say(`  larkin start --agent ${profile.appId}  # 仅调试这个 Agent`);
+    say("创建独立飞书机器人 + Agent：");
+    say("  larkin setup");
+}
+if (path.resolve(process.argv[1] || "") === path.resolve(fileURLToPath(import.meta.url))) {
+    main().catch((error) => die(error instanceof Error ? error.message : String(error)));
+}

package/dist/setup/setup-binding.mjs

@@ -0,0 +1,52 @@
+function cloneAgent(agent) {
+    const chatMentionPolicies = { ...(agent.chatMentionPolicies || {}) };
+    for (const chatId of agent.noMentionChats || [])
+        chatMentionPolicies[chatId] = "free";
+    return {
+        runtime: agent.runtime,
+        model: agent.model,
+        ...(agent.piDistribution ? { piDistribution: agent.piDistribution } : {}),
+        ...(agent.effort ? { effort: agent.effort } : {}),
+        ...(agent.mentionPolicy ? { mentionPolicy: agent.mentionPolicy } : {}),
+        ...(Object.keys(chatMentionPolicies).length ? { chatMentionPolicies } : {}),
+        ...(agent.createdAt ? { createdAt: agent.createdAt } : {}),
+    };
+}
+export function planSingleRootBinding({ config, profile, requestedAgent, runtime, piDistribution, model, defaultModel, supportedReasoningEfforts, now, }) {
+    if (!/^cli_[A-Za-z0-9]+$/.test(profile.appId))
+        throw new Error(`profile.appId 不是合法飞书 App ID：${profile.appId}`);
+    if (typeof defaultModel !== "string" || !defaultModel)
+        throw new Error("defaultModel 必须由 runtime 模型目录显式提供");
+    if (!Array.isArray(supportedReasoningEfforts) || supportedReasoningEfforts.some((effort) => typeof effort !== "string" || !effort)) {
+        throw new Error("supportedReasoningEfforts 必须由目标模型目录显式提供为字符串数组");
+    }
+    if (requestedAgent && requestedAgent !== profile.appId) {
+        throw new Error(`--agent 必须与 profile App ID 一致：${requestedAgent} != ${profile.appId}`);
+    }
+    const agents = Object.fromEntries(Object.entries(config.agents).map(([key, agent]) => [key, cloneAgent(agent)]));
+    const prior = agents[profile.appId];
+    const nextRuntime = runtime || prior?.runtime || "pi";
+    const nextPiDistribution = nextRuntime === "pi"
+        ? piDistribution || (prior?.runtime === "pi" ? prior.piDistribution : undefined)
+        : undefined;
+    if (prior) {
+        const { effort, piDistribution: _priorPiDistribution, ...withoutEffort } = prior;
+        agents[profile.appId] = {
+            ...withoutEffort,
+            runtime: nextRuntime,
+            model: model || (prior.runtime === nextRuntime ? prior.model : defaultModel),
+            ...(nextPiDistribution ? { piDistribution: nextPiDistribution } : {}),
+            ...(effort && supportedReasoningEfforts.includes(effort) ? { effort } : {}),
+        };
+    }
+    else {
+        agents[profile.appId] = { runtime: nextRuntime, model: model || "default", ...(nextPiDistribution ? { piDistribution: nextPiDistribution } : {}), createdAt: now };
+    }
+    return {
+        version: 4,
+        serverId: config.serverId,
+        mentionPolicy: config.mentionPolicy || "require",
+        activeAgent: config.activeAgent || profile.appId,
+        agents,
+    };
+}

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "larkin",
+  "version": "0.2.70",
+  "private": false,
+  "larkinPackageRole": "npm-published",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "SECURITY.md",
+    "CONTRIBUTING.md",
+    "artifacts/release/THIRD_PARTY_NOTICES.txt"
+  ],
+  "packageManager": "bun@1.3.14",
+  "license": "Apache-2.0",
+  "type": "module",
+  "description": "把 Codex、Claude Code 和 Pi Agent Runtime 接到飞书的本地 Runtime Host",
+  "bin": {
+    "larkin": "dist/app/cli.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eddiearc/larkin.git"
+  },
+  "scripts": {
+    "clean": "bun run scripts/clean.mjs",
+    "typecheck": "bun run scripts/typecheck.mjs",
+    "build": "bun run scripts/build.mjs",
+    "prepare": "bun run build",
+    "version:bump": "bun run scripts/bump-version.mjs",
+    "release:check-version": "bun run scripts/check-release-version.mjs",
+    "release:smoke": "bun run scripts/release/smoke.ts",
+    "publication:check": "bun run scripts/check-publication.mjs",
+    "publication:check:tree": "bun run scripts/check-publication.mjs --tree-only",
+    "licenses:generate": "bun run scripts/generate-third-party-notices.mjs --output artifacts/release/THIRD_PARTY_NOTICES.txt",
+    "licenses:check": "bun run scripts/generate-third-party-notices.mjs --check",
+    "test:standalone-acceptance": "LARKIN_RUN_STANDALONE_BINARY_ACCEPTANCE=1 bun test --max-concurrency 1 test/integration/build/standalone-binary-acceptance.test.mjs",
+    "test:standalone-setup-workflow": "LARKIN_RUN_STANDALONE_SETUP_WORKFLOW=1 bun test --max-concurrency 1 test/integration/build/standalone-setup-workflow.test.mjs",
+    "test:pi-preflight-standalone": "LARKIN_RUN_PI_PREFLIGHT_STANDALONE=1 bun test --max-concurrency 1 test/integration/build/pi-prompt-preflight-standalone.test.mjs",
+    "test:unit": "bun test --max-concurrency 1 test/unit",
+    "test:frontend": "bun run vitest run --config src/dashboard/web/vitest.config.mjs",
+    "test:integration": "bun test --max-concurrency 1 test/integration",
+    "test:e2e": "bun test --max-concurrency 1 test/e2e",
+    "test:git-dependency": "LARKIN_RUN_GIT_DEPENDENCY_TEST=1 bun test --max-concurrency 1 test/integration/package/git-dependency-install.test.mjs",
+    "test:pi-model-catalog": "bun test --max-concurrency 1 test/unit/runtime/pi-model-catalog.test.mjs",
+    "test:live:three-agent": "bun test --max-concurrency 1 test/live/three-agent-live-acceptance.test.mjs",
+    "test:live:pi-catalog": "bun test --max-concurrency 1 test/live/pi-model-catalog-live.test.mjs",
+    "test:live:pi-local-rpc-oauth": "LARKIN_RUN_PI_LOCAL_RPC_OAUTH_E2E=1 bun test --max-concurrency 1 test/live/pi-local-rpc-oauth-live.test.mjs",
+    "test:live:pi-local-rpc-provider": "LARKIN_RUN_PI_LOCAL_RPC_OAUTH_E2E=1 LARKIN_PI_LOCAL_RPC_REQUIRE_MODEL_OVERRIDE=1 bun test --max-concurrency 1 test/live/pi-local-rpc-oauth-live.test.mjs",
+    "setup": "bun run dist/app/setup.mjs",
+    "status": "bun run dist/app/agent-config.mjs agents",
+    "agents": "bun run dist/app/agent-config.mjs agents",
+    "model": "bun run dist/app/agent-config.mjs model",
+    "runtime": "bun run dist/app/agent-config.mjs runtime",
+    "effort": "bun run dist/app/agent-config.mjs effort",
+    "chats": "bun run dist/app/agent-config.mjs chats",
+    "start": "bun run dist/app/run.mjs",
+    "test": "bun run typecheck && bun run build && bun run test:frontend && bun run test:unit && bun run test:integration && bun run test:e2e",
+    "test:live:lark-passthrough": "bun test --max-concurrency 1 test/live/lark-passthrough-live.test.mjs",
+    "test:live:document-comment": "bun run build && bun test --max-concurrency 1 test/live/document-comment-live.test.mjs",
+    "test:telemetry:lgtm": "bun run build && bun run scripts/telemetry/lgtm-acceptance.ts",
+    "test:live:card-interaction": "bun test --max-concurrency 1 test/live/card-interaction-live.test.mjs",
+    "test:live:card-interaction-evidence": "bun run test/live/card-interaction-evidence-driver.mjs",
+    "test:live:runtime-agent-interface-v2": "bun test --max-concurrency 1 test/live/runtime-agent-interface-v2-live.test.mjs",
+    "test:live:runtime-agent-interface-v2:read-only": "LARKIN_RUN_RUNTIME_AGENT_INTERFACE_V2_LIVE=1 bun test --max-concurrency 1 test/live/runtime-agent-interface-v2-live.test.mjs",
+    "test:live:runtime-agent-interface-v2:hold-host": "bun run build && bun run test/live/runtime-agent-interface-v2-hold-host.mjs app/runtime-process.mjs",
+    "test:eval:long-running-im-progress": "bun run build && bun test --max-concurrency 1 test/live/long-running-im-progress-live.test.mjs",
+    "test:eval:pi-subagents-background": "bun run build && bun test --max-concurrency 1 test/live/pi-subagents-background-live.test.mjs",
+    "test:eval:pi-bash-timeout": "bun run build && bun test --max-concurrency 1 test/live/pi-bash-timeout-live.test.mjs",
+    "test:eval:runtime-agent-interface-v2": "bun test --max-concurrency 1 test/unit/evals/runtime-agent-interface-v2.test.mjs",
+    "test:eval:authoritative-freshness-gate": "bun test --max-concurrency 1 test/unit/evals/authoritative-freshness-gate.test.mjs",
+    "test:eval:agent-experience-v6": "bun test --max-concurrency 1 test/unit/evals/agent-experience-v6.test.mjs",
+    "test:eval:public-contribution-governance": "bun test --max-concurrency 1 test/unit/evals/public-contribution-governance.test.mjs",
+    "test:live:public-contribution-governance": "bun test --max-concurrency 1 test/live/public-contribution-governance-live.test.mjs",
+    "test:eval:authoritative-freshness-gate:native": "bun run build && LARKIN_RUN_AUTHORITATIVE_FRESHNESS_EVAL=1 bun test --max-concurrency 1 test/live/authoritative-freshness-gate-agent-eval.test.mjs",
+    "test:live:authoritative-freshness-gate": "bun test --max-concurrency 1 test/live/authoritative-freshness-gate-live.test.mjs",
+    "test:eval:runtime-agent-interface-v2:native": "bun run build && LARKIN_RUN_RUNTIME_AGENT_INTERFACE_V2_EVAL=1 bun test --max-concurrency 1 test/live/runtime-agent-interface-v2-agent-eval.test.mjs",
+    "test:live:agent-cli-routing-codex": "bun run build && LARKIN_RUN_AGENT_CLI_ROUTING_CODEX_LIVE=1 bun test --max-concurrency 1 test/live/agent-cli-routing-codex-live.test.mjs"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "0.83.0",
+    "@larksuite/channel": "^0.4.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/resources": "^2.10.0",
+    "@opentelemetry/sdk-trace-base": "^2.10.0",
+    "@opentelemetry/sdk-trace-node": "^2.10.0",
+    "@radix-ui/react-dialog": "^1.1.21",
+    "lucide-react": "^1.26.0",
+    "proper-lockfile": "4.1.2",
+    "qrcode-terminal": "^0.12.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "undici": "8.5.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.3.3",
+    "@testing-library/jest-dom": "^7.0.0",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@tintinweb/pi-subagents": "0.14.3",
+    "@types/node": "^26.1.1",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "@vitejs/plugin-react": "^6.0.4",
+    "jsdom": "^29.1.1",
+    "playwright-core": "^1.61.1",
+    "tailwindcss": "^4.3.3",
+    "typescript": "^7.0.2",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10"
+  }
+}