larkin 0.4.2 → 0.4.6

package/dist/app/agent-config.mjs

@@ -11,6 +11,8 @@ import { isChannelReconnecting, projectAgentReadiness } from "./agent-readiness.
 import { requestAgentUpsert } from "./local-control.mjs";
 import * as larkinConfig from "../platform/config.mjs";
 import { managedOfficialLarkCli } from "./agent-lark-cli-workspace.mjs";
+import { assertBuiltinPiAgentDirectory, piAgentDirectory } from "../runtime/pi-provider-config.mjs";
+import { traceProcessBoundary } from "../platform/process-boundary-trace.mjs";
 function safeDocumentCommentCapabilities(configDir, profile) {
     try {
         return {
@@ -49,15 +51,15 @@ const die = (message) => {
         console.error("  下一步: larkin config --help");
     process.exit(1);
 };
-if (!kind || !["agents", "model", "runtime", "effort", "chats", "config"].includes(kind)) {
-    die("用法: larkin agents | larkin config <show|mention|apply> | larkin model [<id>] | larkin runtime [<id>] [--model <id>] | larkin effort [<level>|clear] | larkin chats [free|strict <oc_id>]");
+if (!kind || !["agents", "model", "runtime", "effort", "pi-distribution", "chats", "config"].includes(kind)) {
+    die("用法: larkin agents | larkin config <show|mention|apply> | larkin model [<id>] | larkin runtime [<id>] [--model <id>] | larkin pi-distribution [show|builtin|external] | larkin effort [<level>|clear] | larkin chats [free|strict <oc_id>]");
 }
 const allowedValueFlags = {
     agents: new Set(), model: new Set(["--agent"]), runtime: new Set(["--agent", "--model"]),
-    effort: new Set(["--agent"]), chats: new Set(["--agent"]), config: new Set(["--agent", "--chat"]),
+    effort: new Set(["--agent"]), "pi-distribution": new Set(["--agent", "--snapshot"]), chats: new Set(["--agent"]), config: new Set(["--agent", "--chat"]),
 };
 const allowedBooleanFlags = {
-    agents: new Set(["--json"]), model: new Set(), runtime: new Set(), effort: new Set(), chats: new Set(), config: new Set(["--json"]),
+    agents: new Set(["--json"]), model: new Set(), runtime: new Set(), effort: new Set(), "pi-distribution": new Set(["--import-external-profile"]), chats: new Set(), config: new Set(["--json"]),
 };
 const parsedValues = new Map();
 const parsedBooleans = new Set();
@@ -91,6 +93,7 @@ const flagAgent = parsedValues.get("--agent");
 const flagModel = parsedValues.get("--model");
 const flagChat = parsedValues.get("--chat");
 const flagJson = parsedBooleans.has("--json");
+const importExternalProfile = parsedBooleans.has("--import-external-profile");
 const value = positionals[0];
 function assertOnlyFlags(valueFlags, booleanFlags = []) {
     const allowedValues = new Set(valueFlags);
@@ -122,6 +125,11 @@ else if (kind === "effort") {
     if (positionals.length > 1)
         die("用法: larkin effort [<level>|clear|default] [--agent <App ID>]");
 }
+else if (kind === "pi-distribution") {
+    assertOnlyFlags(["--agent", "--snapshot"], ["--import-external-profile"]);
+    if (positionals.length > 1)
+        die("用法: larkin pi-distribution [show|builtin|external] [--agent <App ID>] [--snapshot <private-file>]");
+}
 else if (kind === "chats") {
     assertOnlyFlags(["--agent"]);
     if (![0, 2].includes(positionals.length))
@@ -169,6 +177,21 @@ const loaded = (() => {
 const { configDir, file, config } = loaded;
 if (!fs.existsSync(file))
     die("未找到 Larkin 配置，请运行 larkin setup");
+const snapshotFile = parsedValues.get("--snapshot");
+if (kind === "pi-distribution" && value === "rollback") {
+    if (importExternalProfile)
+        die("--import-external-profile 只允许与 builtin 一起使用");
+    if (!snapshotFile || flagAgent || positionals.length !== 1)
+        die("用法: larkin pi-distribution rollback --snapshot <private-file>");
+    try {
+        const result = larkinConfig.rollbackConfig(process.env, snapshotFile);
+        say(JSON.stringify({ ok: true, rolledBackAgent: result.agentId, revision: result.revision }));
+    }
+    catch (error) {
+        die(`回滚失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    process.exit(0);
+}
 if (kind === "agents") {
     const list = Object.values(config.agents || {});
     const daemon = readProcessState(config.larkinHome).daemon;
@@ -266,12 +289,19 @@ if (kind === "agents") {
             && !!status?.inboundVerifiedAt
             && Date.parse(status.inboundVerifiedAt) >= Date.parse(String(daemon.startedAt || 0));
         const commentDiagnostic = projectDocumentCommentDiagnostic(commentCapability, status);
+        const projectedReadiness = projectAgentReadiness({ agentId: agent.agentId, daemon, status });
         say(`  ${agent.name}${agent.name === config.activeAgent ? " [active]" : ""}`);
         const effectiveModel = status?.session?.runtime === agent.runtime && status.session.model ? status.session.model : agent.model;
         const effectiveEffort = status?.session?.runtime === agent.runtime && status.session.reasoningEffort ? status.session.reasoningEffort : agent.effort;
         say(`    runtime=${agent.runtime}  model=${effectiveModel}${effectiveModel !== agent.model ? `  stored=${agent.model}` : ""}${effectiveEffort ? `  effort=${effectiveEffort}` : ""}`);
-        if (status?.runtimeReadiness)
-            say(`    runtime readiness=${status.runtimeReadiness.state || "incompatible"}${status.runtimeReadiness.reason ? `：${status.runtimeReadiness.reason}` : ""}${status.runtimeReadiness.nextAction ? `；下一步：${status.runtimeReadiness.nextAction}` : ""}`);
+        if (status?.runtimeReadiness) {
+            const current = projectedReadiness.readiness.runtime_ready;
+            const state = status.runtimeReadiness.state === "ready" && !current ? "unavailable" : status.runtimeReadiness.state || "incompatible";
+            const staleReason = status.runtimeReadiness.state === "ready" && !current
+                ? "：ready 证据不属于当前 owned daemon epoch 或当前 session，已拒绝展示为 ready"
+                : status.runtimeReadiness.reason ? `：${status.runtimeReadiness.reason}` : "";
+            say(`    runtime readiness=${state}${staleReason}${status.runtimeReadiness.nextAction ? `；下一步：${status.runtimeReadiness.nextAction}` : ""}`);
+        }
         if (status?.runtimeReadiness?.executable)
             say(`    runtime executable=${status.runtimeReadiness.executable}${status.runtimeReadiness.version ? `  version=${status.runtimeReadiness.version}` : ""}`);
         say(`    bot=${bot ? `${bot.name}(${bot.open_id})` : "（未连接过，无身份缓存）"}`);
@@ -405,6 +435,43 @@ if (!key) {
 }
 const selectedKey = key;
 const agent = config.agents[selectedKey];
+if (kind === "pi-distribution") {
+    traceProcessBoundary(process.env, "agent-config:pi-distribution-loaded", { configDir, agentId: selectedKey, targetDir: piAgentDirectory(configDir, selectedKey), requested: value || "show", importExternalProfile });
+    const requested = value || "show";
+    if (importExternalProfile && requested !== "builtin")
+        die("--import-external-profile 只允许与 builtin 一起使用");
+    if (requested === "show") {
+        say(JSON.stringify({ agentId: selectedKey, runtime: agent.runtime, piDistribution: agent.piDistribution ?? "external" }));
+        process.exit(0);
+    }
+    if (requested !== "builtin" && requested !== "external")
+        die("Pi distribution 只允许 show/builtin/external");
+    if (agent.runtime !== "pi")
+        die(`Agent ${selectedKey} 不是 Pi runtime`);
+    if (!snapshotFile)
+        die("修改 Pi distribution 必须提供 --snapshot <private-file>");
+    if (requested === "builtin" && !importExternalProfile) {
+        try {
+            assertBuiltinPiAgentDirectory(piAgentDirectory(configDir, selectedKey));
+        }
+        catch {
+            die("内置 Pi provider 尚未为该 Agent 配置；请先运行 larkin setup 完成内置 Pi provider 配置，或使用 --import-external-profile");
+        }
+    }
+    try {
+        const result = larkinConfig.mutateConfig(process.env, { kind: "set-agent-pi-distribution", agentId: selectedKey, distribution: requested }, { kind: "user" }, {
+            snapshotFile: snapshotFile, ...(importExternalProfile ? { importExternalProfile: true } : {}),
+        });
+        traceProcessBoundary(process.env, "agent-config:pi-distribution-persisted", { configDir, agentId: selectedKey, targetDir: piAgentDirectory(configDir, selectedKey), requested, applyState: result.applyState });
+        say(JSON.stringify({ ok: true, agentId: selectedKey, piDistribution: requested, revision: result.revision, applyState: result.applyState }));
+    }
+    catch (error) {
+        if (importExternalProfile)
+            die("Pi external profile import failed; no secret or private path was disclosed");
+        die(`Pi distribution 修改失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    process.exit(0);
+}
 const catalog = larkinConfig.loadRuntimeModels();
 if ((["model", "effort"].includes(kind || "") && agent.runtime === "codex") || (kind === "runtime" && value === "codex")) {
     try {

package/dist/app/agent-readiness.cjs

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRuntimeReadinessCurrent = isRuntimeReadinessCurrent;
+exports.isCurrentOwnedDaemon = isCurrentOwnedDaemon;
 exports.isChannelReconnecting = isChannelReconnecting;
 exports.projectAgentReadiness = projectAgentReadiness;
 const process_state_js_1 = require("../platform/process-state.cjs");
@@ -7,6 +9,19 @@ function timestamp(value) {
     const parsed = Date.parse(String(value || ""));
     return Number.isFinite(parsed) ? parsed : null;
 }
+function isRuntimeReadinessCurrent(readiness, daemonStartedAt) {
+    if (readiness?.state !== "ready")
+        return false;
+    const observedAt = timestamp(readiness.observedAt);
+    const epoch = timestamp(daemonStartedAt);
+    return observedAt !== null && epoch !== null && observedAt >= epoch;
+}
+function isCurrentOwnedDaemon(daemon) {
+    return daemon?.state === "owned"
+        && Number(daemon.pid) > 0
+        && typeof daemon.processStartToken === "string" && daemon.processStartToken.length > 0
+        && timestamp(daemon.startedAt) !== null;
+}
 function isChannelReconnecting(status) {
     const reconnectingAt = timestamp(status?.reconnectingAt);
     const connectedAt = timestamp(status?.connectedAt);
@@ -16,9 +31,14 @@ function isChannelReconnecting(status) {
 }
 function projectAgentReadiness(input) {
     const status = input.status ?? null;
-    const daemonOwned = (0, process_state_js_1.daemonHasAgent)(input.daemon, input.agentId);
+    const daemonOwned = isCurrentOwnedDaemon(input.daemon) && (0, process_state_js_1.daemonHasAgent)(input.daemon, input.agentId);
     const daemonStartedAt = timestamp(input.daemon.startedAt);
     const connectedAt = timestamp(status?.connectedAt);
+    // A resumed session deliberately retains its original creation time.  Its
+    // current daemon-epoch proof is the fresh session observation, not that
+    // historic creation timestamp.
+    const sessionObservedAt = timestamp(status?.session?.lastSeenAt) ?? timestamp(status?.session?.startedAt);
+    const sessionCurrent = daemonStartedAt !== null && sessionObservedAt !== null && sessionObservedAt >= daemonStartedAt;
     const channelConnected = daemonOwned
         && status?.connectedVia === "channel"
         && daemonStartedAt !== null
@@ -26,7 +46,7 @@ function projectAgentReadiness(input) {
         && connectedAt >= daemonStartedAt;
     const readiness = {
         daemon_owned: daemonOwned,
-        runtime_ready: status?.runtimeReadiness?.state === "ready",
+        runtime_ready: daemonOwned && sessionCurrent && isRuntimeReadinessCurrent(status?.runtimeReadiness, input.daemon.startedAt),
         channel_connected: channelConnected,
         channel_not_reconnecting: !isChannelReconnecting(status),
     };

package/dist/app/agent-readiness.mjs

@@ -3,6 +3,19 @@ function timestamp(value) {
     const parsed = Date.parse(String(value || ""));
     return Number.isFinite(parsed) ? parsed : null;
 }
+export function isRuntimeReadinessCurrent(readiness, daemonStartedAt) {
+    if (readiness?.state !== "ready")
+        return false;
+    const observedAt = timestamp(readiness.observedAt);
+    const epoch = timestamp(daemonStartedAt);
+    return observedAt !== null && epoch !== null && observedAt >= epoch;
+}
+export function isCurrentOwnedDaemon(daemon) {
+    return daemon?.state === "owned"
+        && Number(daemon.pid) > 0
+        && typeof daemon.processStartToken === "string" && daemon.processStartToken.length > 0
+        && timestamp(daemon.startedAt) !== null;
+}
 export function isChannelReconnecting(status) {
     const reconnectingAt = timestamp(status?.reconnectingAt);
     const connectedAt = timestamp(status?.connectedAt);
@@ -12,9 +25,14 @@ export function isChannelReconnecting(status) {
 }
 export function projectAgentReadiness(input) {
     const status = input.status ?? null;
-    const daemonOwned = daemonHasAgent(input.daemon, input.agentId);
+    const daemonOwned = isCurrentOwnedDaemon(input.daemon) && daemonHasAgent(input.daemon, input.agentId);
     const daemonStartedAt = timestamp(input.daemon.startedAt);
     const connectedAt = timestamp(status?.connectedAt);
+    // A resumed session deliberately retains its original creation time.  Its
+    // current daemon-epoch proof is the fresh session observation, not that
+    // historic creation timestamp.
+    const sessionObservedAt = timestamp(status?.session?.lastSeenAt) ?? timestamp(status?.session?.startedAt);
+    const sessionCurrent = daemonStartedAt !== null && sessionObservedAt !== null && sessionObservedAt >= daemonStartedAt;
     const channelConnected = daemonOwned
         && status?.connectedVia === "channel"
         && daemonStartedAt !== null
@@ -22,7 +40,7 @@ export function projectAgentReadiness(input) {
         && connectedAt >= daemonStartedAt;
     const readiness = {
         daemon_owned: daemonOwned,
-        runtime_ready: status?.runtimeReadiness?.state === "ready",
+        runtime_ready: daemonOwned && sessionCurrent && isRuntimeReadinessCurrent(status?.runtimeReadiness, input.daemon.startedAt),
         channel_connected: channelConnected,
         channel_not_reconnecting: !isChannelReconnecting(status),
     };

package/dist/app/binary-entry.mjs

@@ -55,6 +55,12 @@ async function dispatchInternal(mode, rest) {
             process.title = "pi-rpc";
             process.env.PI_CODING_AGENT = "true";
             process.emitWarning = (() => { });
+            // The Pi package's normal Bun CLI registers OAuth loaders before starting.
+            // Larkin invokes its RPC entrypoint directly, so do the same here; otherwise
+            // an OAuth-backed compact falls back to a dynamic module import unavailable in
+            // a compiled standalone binary.
+            const { registerBunOAuthFlows } = await import("@earendil-works/pi-ai/bun-oauth");
+            registerBunOAuthFlows();
             const { main: piMain } = await import("@earendil-works/pi-coding-agent");
             const { invokeBuiltinPiRpc } = await import("../runtime/pi-inline-extensions.mjs");
             await invokeBuiltinPiRpc(piMain, rest);

package/dist/app/cli.mjs

@@ -29,6 +29,7 @@ const routes = {
     model: ["agent-config", "model"],
     runtime: ["agent-config", "runtime"],
     effort: ["agent-config", "effort"],
+    "pi-distribution": ["agent-config", "pi-distribution"],
     chats: ["agent-config", "chats"],
     config: ["agent-config", "config"],
     session: ["session-cli"],
@@ -58,6 +59,9 @@ List every configured Agent and its current local status. Use --json for daemon/
 Show or change an Agent model.`,
     runtime: `Usage: larkin runtime [<runtime>] [--agent <App ID>] [--model <model>]
 Show or change an Agent runtime.`,
+    "pi-distribution": `Usage: larkin pi-distribution [show|builtin|external] [--agent <App ID>] [--snapshot <private-file>] [--import-external-profile]
+       larkin pi-distribution rollback --snapshot <private-file>
+Show or change one Pi Agent distribution. builtin requires configured provider state, or explicitly imports the external Pi 0.84.2 profile with --import-external-profile; all changes support config-lock CAS rollback.`,
     effort: `Usage: larkin effort [<level>|clear|default] [--agent <App ID>]
 Show or change an Agent reasoning effort; clear/default restores the Runtime default.`,
     chats: `Usage: larkin chats [--agent <App ID>]

package/dist/app/run.mjs

@@ -11,6 +11,7 @@ import { acquireProcessLock, readProcessState, terminateOwnedProcess, waitForPro
 import { hydrateRuntimeAgent, syncAgentProfile } from "./runtime-agent-config.mjs";
 import { cleanupStaleAgentControlSocket, createSupervisorControlServer, initializeControlAuthority, removeControlAuthority, requestDashboardRecovery, } from "./local-control.mjs";
 import { internalCommandSpec, processCommandToken } from "./internal-command.mjs";
+import { traceProcessBoundary } from "../platform/process-boundary-trace.mjs";
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const die = (message) => { console.error(`✗ ${message}`); process.exit(1); };
 export function selectedAgentIds(argv, available) {
@@ -63,8 +64,11 @@ export async function stopDashboardWithinBound(child, configDir, signal = "SIGTE
     return await waitForChildExit(child, Math.max(250, Math.min(2_000, timeoutMs))) ? "killed" : "unowned";
 }
 export async function main() {
+    process.env.LARKIN_DAEMON_EPOCH ||= new Date().toISOString();
     const argv = process.argv.slice(2);
     const { configDir, file: configFile, config } = larkinConfig.loadConfig(process.env);
+    for (const agent of Object.values(config.agents))
+        traceProcessBoundary(process.env, "supervisor:config-loaded", { configDir, agentId: agent.agentId, targetDir: path.join(configDir, "providers", "pi", agent.agentId) });
     if (!fs.existsSync(configFile))
         die(`没找到配置 ${configFile}，先跑 larkin setup`);
     if (!config.serverId || !Object.keys(config.agents).length)
@@ -193,6 +197,8 @@ export async function main() {
     };
     if (argv.includes("--dry-run"))
         runtimeEnv.LARKIN_FEISHU_DRYRUN = "1";
+    for (const agent of agents)
+        traceProcessBoundary(runtimeEnv, "supervisor:daemon-env-prepared", { configDir, agentId: agent.agentId, targetDir: path.join(configDir, "providers", "pi", agent.agentId) });
     let stopping = false;
     let dashboard = null;
     // Set when the daemon-restart path stops the dashboard on purpose (port
@@ -218,6 +224,8 @@ export async function main() {
     // external process manager (launchd) takes over as the final respawn layer.
     const launchDaemon = () => {
         daemon = spawn(daemonSpec.command, daemonSpec.args, { env: runtimeEnv, stdio: "inherit" });
+        for (const agent of agents)
+            traceProcessBoundary(runtimeEnv, "supervisor:daemon-spawned", { configDir, agentId: agent.agentId, targetDir: path.join(configDir, "providers", "pi", agent.agentId), childPid: daemon.pid ?? null });
         daemon.once("exit", (code, signal) => {
             if (stopping) {
                 resolveDaemonFinal?.({ code, signal });

package/dist/app/runtime-process.mjs

@@ -7,6 +7,7 @@ import { createNativeRuntimeAdapter } from "../runtime/runtime-adapters.mjs";
 import { createRuntimeHost } from "../runtime/runtime-host.mjs";
 import { createAgentStateStore } from "../agent/agent-state-store.mjs";
 import { loadConfig, markConfigApplied, runtimeConfigSignature } from "../platform/config.mjs";
+import { traceProcessBoundary } from "../platform/process-boundary-trace.mjs";
 import { createAgentControlServer } from "./local-control.mjs";
 import { hydrateRuntimeAgent, syncAgentProfile } from "./runtime-agent-config.mjs";
 import { loadTelemetryConfig } from "../platform/telemetry-config.mjs";
@@ -53,6 +54,7 @@ export async function main(env = process.env, overrides = {}) {
         channelPackage = await import(pathToFileURL(path.resolve(env.LARKIN_TEST_CHANNEL_MODULE)).href);
     }
     const adapters = new Map();
+    env.LARKIN_DAEMON_EPOCH ||= new Date().toISOString();
     const runtimeHost = overrides.runtimeHost ?? createRuntimeHost({
         promptBuilder: new ContextPromptBuilder(),
         stateStoreFor(agentId) {
@@ -91,6 +93,9 @@ export async function main(env = process.env, overrides = {}) {
         throw new Error("LARKIN_HOME/LARKIN_CONFIG_DIR required");
     if (!env.LARKIN_CONTROL_AUTHORIZATION)
         throw new Error("LARKIN_CONTROL_AUTHORIZATION required");
+    const loaded = loadConfig(env);
+    for (const agent of Object.values(loaded.config.agents))
+        traceProcessBoundary(env, "daemon:config-loaded", { configDir: loaded.configDir, agentId: agent.agentId, targetDir: path.join(loaded.configDir, "providers", "pi", agent.agentId) });
     controlServer = createAgentControlServer({
         larkinHome: env.LARKIN_HOME,
         authorityToken: env.LARKIN_CONTROL_AUTHORIZATION,
@@ -110,7 +115,14 @@ export async function main(env = process.env, overrides = {}) {
         },
     });
     await controlServer.start();
-    await markConfigAppliedAfterRuntimeReady(env, hostShell.agents, hostShell.start());
+    for (const agent of hostShell.agents)
+        traceProcessBoundary(env, "daemon:before-runtime-ready", { configDir: loaded.configDir, agentId: agent.agentId, targetDir: path.join(loaded.configDir, "providers", "pi", agent.agentId) });
+    const runtimeStart = hostShell.start().catch((error) => {
+        for (const agent of hostShell.agents)
+            traceProcessBoundary(env, "daemon:runtime-ready-failure", { configDir: loaded.configDir, agentId: agent.agentId, targetDir: path.join(loaded.configDir, "providers", "pi", agent.agentId), error });
+        throw error;
+    });
+    await markConfigAppliedAfterRuntimeReady(env, hostShell.agents, runtimeStart);
 }
 if (path.resolve(process.argv[1] || "") === path.resolve(fileURLToPath(import.meta.url))) {
     main().catch((error) => { console.error(`✗ ${error instanceof Error ? error.message : String(error)}`); process.exit(1); });

package/dist/dashboard/dashboard-view-model.mjs

@@ -7,6 +7,7 @@ import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath } from "node:url";
 import { readJson, readProcessState } from "../platform/process-state.mjs";
+import { isRuntimeReadinessCurrent } from "../app/agent-readiness.mjs";
 import { isAllowedDashboardAvatarUrl } from "./dashboard-avatar.mjs";
 import { collectWorkspaceEntry as collectTypedWorkspaceEntry } from "./dashboard-workspace.mjs";
 import { buildFingerprint, packageVersion } from "../platform/build-info.mjs";
@@ -429,7 +430,7 @@ export function projectStatusTimeline(status) {
     ].sort((x, y) => new Date(String(y.at)).getTime() - new Date(String(x.at)).getTime()).slice(0, 30);
     return { activityLog, deliverLog, recentErrors, lastActivity, lastDeliver, feed };
 }
-async function collectAgentStatus(a, configDir, piModelResolver) {
+async function collectAgentStatus(a, configDir, daemonStartedAt, piModelResolver) {
     const dir = a.stateDir;
     const botIdentity = readJson(path.join(dir, "bot-identity.json"), null);
     const status = readJson(path.join(dir, "status.json"), {});
@@ -476,6 +477,14 @@ async function collectAgentStatus(a, configDir, piModelResolver) {
     }
     // 本 agent 专属时间线：三路历史合并按时间倒序，不是全局一条汇总——每个 agent 只看自己的故事。
     const { recentErrors, lastActivity, lastDeliver, feed } = projectStatusTimeline(status);
+    const statusReadiness = status.runtimeReadiness;
+    const sessionStartedAt = finiteTime(status.session?.startedAt);
+    const daemonEpoch = finiteTime(daemonStartedAt);
+    const sessionCurrent = sessionStartedAt !== null && daemonEpoch !== null && sessionStartedAt >= daemonEpoch;
+    const runtimeReadiness = sessionCurrent && isRuntimeReadinessCurrent(statusReadiness, daemonStartedAt)
+        || statusReadiness?.state !== "ready"
+        ? statusReadiness || null
+        : { ...statusReadiness, state: "unavailable", reason: "Runtime readiness evidence is stale for the current daemon epoch." };
     // 提醒：不只给数量，给完整列表——待触发按最近到期优先排前面，已触发/已取消按最近的排在后面。
     const pendingReminders = reminders.filter((r) => r.status === "scheduled" || r.status === "pending")
         .sort((x, y) => new Date(String(x.fireAt)).getTime() - new Date(String(y.fireAt)).getTime());
@@ -492,7 +501,7 @@ async function collectAgentStatus(a, configDir, piModelResolver) {
         runtime: a.runtime,
         model: status.session?.runtime === a.runtime && status.session?.model ? String(status.session.model) : a.model,
         effort: status.session?.runtime === a.runtime && status.session?.reasoningEffort ? String(status.session.reasoningEffort) : a.effort || null,
-        runtimeReadiness: status.runtimeReadiness || null,
+        runtimeReadiness,
         credentialReady: fs.existsSync(path.join(configDir, "bots", `${a.feishuProfile}.json`)),
         bot: botIdentity ? {
             name: botIdentity.name,
@@ -542,7 +551,7 @@ export async function collectStatus(options = {}) {
         uptimeSec: daemonStatus?.startedAt ? ageSec(daemonStatus.startedAt) : null,
         agents: Array.isArray(daemonStatus?.agents) ? daemonStatus.agents.filter((id) => typeof id === "string") : [],
     };
-    const statuses = (await Promise.all(agents.map((a) => collectAgentStatus(a, configDir, options.piModelResolver)))).map((agent) => {
+    const statuses = (await Promise.all(agents.map((a) => collectAgentStatus(a, configDir, daemon.startedAt, options.piModelResolver)))).map((agent) => {
         return { ...agent, ...projectAgentHealth(agent, daemon) };
     });
     return {

package/dist/feishu/host-shell.cjs

@@ -200,6 +200,11 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
         return store;
     };
     const hostState = new host_business_state_js_1.HostStateProjection(stateStore, log);
+    const markRuntimeTransition = (agent, reason) => {
+        hostState.updateStatus(agent, {
+            runtimeReadiness: { runtime: agent.runtime, state: "unavailable", reason, nextAction: "Wait for the current daemon epoch to publish Runtime readiness.", observedAt: new Date().toISOString() },
+        });
+    };
     const recordInboundDeliveryFailure = (agent, code) => {
         const at = new Date().toISOString();
         const reason = "Inbound Runtime delivery failed non-retryably; durable Inbox/ledger state is retained for recovery.";
@@ -1231,19 +1236,21 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
             return;
         if (message.type === "agent-status") {
             log("agent:status", message.agentId, message.status);
+            const observedAt = new Date().toISOString();
             if (message.status === "error" || message.status === "inactive")
                 hostState.updateStatus(agent, {
-                    runtimeReadiness: message.readiness?.state && message.readiness.state !== "ready" ? message.readiness : {
+                    runtimeReadiness: message.readiness?.state && message.readiness.state !== "ready" ? { ...message.readiness, observedAt } : {
                         runtime: agent.runtime,
                         state: message.status === "error" ? "incompatible" : "missing",
                         reason: message.status === "error" ? message.error || "Runtime entered an error state" : "Runtime is inactive",
+                        observedAt,
                     },
                 });
             else if (message.readiness)
-                hostState.updateStatus(agent, { runtimeReadiness: message.readiness });
+                hostState.updateStatus(agent, { runtimeReadiness: { ...message.readiness, observedAt } });
             else if (message.status === "active")
                 hostState.updateStatus(agent, { runtimeReadiness: {
-                        runtime: agent.runtime, state: "ready",
+                        runtime: agent.runtime, state: "ready", observedAt,
                     } });
             if (message.status === "active") {
                 const redeliveryTimer = setTimeout(() => {
@@ -1375,8 +1382,10 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
                 const status = hostState.readStatus(agent);
                 const turns = status.session && typeof status.session === "object"
                     ? Math.max(0, Number(status.session.turns) || 0) : 0;
-                const runtimeReady = Boolean(status.runtimeReadiness && typeof status.runtimeReadiness === "object"
-                    && status.runtimeReadiness.state === "ready");
+                const sessionStartedAt = status.session && typeof status.session === "object"
+                    ? Date.parse(String(status.session.startedAt || "")) : Number.NaN;
+                const sessionCurrent = Number.isFinite(sessionStartedAt) && sessionStartedAt >= Date.parse(daemonStartedAt);
+                const runtimeReady = sessionCurrent && (0, agent_readiness_js_1.isRuntimeReadinessCurrent)(status.runtimeReadiness, daemonStartedAt);
                 const pendingCount = stateStore(agent).withInboxTransaction(() => stateStore(agent).readNdjson("inbox").length);
                 return { turns, runtimeReady, ...connectionState(status), pendingCount };
             };
@@ -1385,6 +1394,7 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
                 throw Object.assign(new Error(`Agent ${agentId} channel is not connected`), { code: "channel_unavailable", ...initialProjection });
             if (initialProjection.reconnecting)
                 throw Object.assign(new Error(`Agent ${agentId} channel is reconnecting`), { code: "channel_reconnecting", ...initialProjection });
+            markRuntimeTransition(agent, "Runtime session reset in progress");
             let reset;
             try {
                 reset = await runtimeHost.resetSession(agentId);
@@ -1401,11 +1411,17 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
                         delete record.state.sessions[agent.runtime];
                     record.store.writeJson("agentState", record.state);
                 }
-                if (!reset.sessionId)
+                if (!reset.sessionId) {
+                    const observedAt = new Date().toISOString();
                     hostState.updateStatus(agent, {
-                        session: { runtime: agent.runtime, id: null, launchId: null, startedAt: new Date().toISOString(),
-                            lastSeenAt: null, lastTurnAt: null, turns: 0 }, runtimeReadiness: { runtime: agent.runtime, state: "ready" },
+                        session: { runtime: agent.runtime, id: null, launchId: null, startedAt: observedAt,
+                            lastSeenAt: null, lastTurnAt: null, turns: 0 },
+                        runtimeReadiness: { runtime: agent.runtime, state: "ready", observedAt },
                     });
+                }
+                else if (reset.runtimeReady) {
+                    hostState.updateStatus(agent, { runtimeReadiness: { runtime: agent.runtime, state: "ready", observedAt: new Date().toISOString() } });
+                }
             }
             catch (error) {
                 const projection = readinessProjection();
@@ -1452,8 +1468,10 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
                 const status = hostState.readStatus(agent);
                 const turns = status.session && typeof status.session === "object"
                     ? Math.max(0, Number(status.session.turns) || 0) : 0;
-                const runtimeReady = Boolean(status.runtimeReadiness && typeof status.runtimeReadiness === "object"
-                    && status.runtimeReadiness.state === "ready");
+                const sessionStartedAt = status.session && typeof status.session === "object"
+                    ? Date.parse(String(status.session.startedAt || "")) : Number.NaN;
+                const sessionCurrent = Number.isFinite(sessionStartedAt) && sessionStartedAt >= Date.parse(daemonStartedAt);
+                const runtimeReady = sessionCurrent && (0, agent_readiness_js_1.isRuntimeReadinessCurrent)(status.runtimeReadiness, daemonStartedAt);
                 const pendingCount = stateStore(agent).withInboxTransaction(() => stateStore(agent).readNdjson("inbox").length);
                 return { turns, runtimeReady, ...connectionState(status), pendingCount };
             };
@@ -1469,6 +1487,9 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
             catch (error) {
                 throw Object.assign(error instanceof Error ? error : new Error(String(error)), readinessProjection());
             }
+            if (recovery.runtimeReady) {
+                hostState.updateStatus(agent, { runtimeReadiness: { runtime: agent.runtime, state: "ready", observedAt: new Date().toISOString() } });
+            }
             const record = agentStates.get(agentId);
             try {
                 if (record) {
@@ -1506,6 +1527,8 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
         async start() {
             try {
                 node_fs_1.default.mkdirSync(larkinHome, { recursive: true });
+                for (const agent of agents)
+                    markRuntimeTransition(agent, "Current daemon epoch starting");
                 node_fs_1.default.writeFileSync(node_path_1.default.join(larkinHome, "daemon-status.json"), JSON.stringify({
                     ...(0, process_inspect_cjs_1.currentProcessMetadata)((0, internal_command_js_1.processCommandToken)("daemon", "app/runtime-process.mjs")), pid: process.pid, startedAt: daemonStartedAt,
                     agents: agents.map((agent) => agent.agentId),

package/dist/feishu/host-shell.mjs

@@ -19,7 +19,7 @@ import { readDocumentCommentSubscription, verifyCallbackProbe } from "../platfor
 import { loadConfig, resolveMentionPolicy } from "../platform/config.mjs";
 import { processCommandToken } from "../app/internal-command.mjs";
 import { managedOfficialLarkCli } from "../app/agent-lark-cli-workspace.mjs";
-import { isChannelReconnecting } from "../app/agent-readiness.mjs";
+import { isChannelReconnecting, isRuntimeReadinessCurrent } from "../app/agent-readiness.mjs";
 import { documentCommentMessageId, documentCommentNoticeType, projectDocumentCommentEnvelope, resolveDocumentCommentContext, } from "./document-comment.mjs";
 const PENDING_DOCUMENT_COMMENT_LIMIT = 256;
 function isRecord(value) {
@@ -160,6 +160,11 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
         return store;
     };
     const hostState = new HostStateProjection(stateStore, log);
+    const markRuntimeTransition = (agent, reason) => {
+        hostState.updateStatus(agent, {
+            runtimeReadiness: { runtime: agent.runtime, state: "unavailable", reason, nextAction: "Wait for the current daemon epoch to publish Runtime readiness.", observedAt: new Date().toISOString() },
+        });
+    };
     const recordInboundDeliveryFailure = (agent, code) => {
         const at = new Date().toISOString();
         const reason = "Inbound Runtime delivery failed non-retryably; durable Inbox/ledger state is retained for recovery.";
@@ -1191,19 +1196,21 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
             return;
         if (message.type === "agent-status") {
             log("agent:status", message.agentId, message.status);
+            const observedAt = new Date().toISOString();
             if (message.status === "error" || message.status === "inactive")
                 hostState.updateStatus(agent, {
-                    runtimeReadiness: message.readiness?.state && message.readiness.state !== "ready" ? message.readiness : {
+                    runtimeReadiness: message.readiness?.state && message.readiness.state !== "ready" ? { ...message.readiness, observedAt } : {
                         runtime: agent.runtime,
                         state: message.status === "error" ? "incompatible" : "missing",
                         reason: message.status === "error" ? message.error || "Runtime entered an error state" : "Runtime is inactive",
+                        observedAt,
                     },
                 });
             else if (message.readiness)
-                hostState.updateStatus(agent, { runtimeReadiness: message.readiness });
+                hostState.updateStatus(agent, { runtimeReadiness: { ...message.readiness, observedAt } });
             else if (message.status === "active")
                 hostState.updateStatus(agent, { runtimeReadiness: {
-                        runtime: agent.runtime, state: "ready",
+                        runtime: agent.runtime, state: "ready", observedAt,
                     } });
             if (message.status === "active") {
                 const redeliveryTimer = setTimeout(() => {
@@ -1335,8 +1342,10 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                 const status = hostState.readStatus(agent);
                 const turns = status.session && typeof status.session === "object"
                     ? Math.max(0, Number(status.session.turns) || 0) : 0;
-                const runtimeReady = Boolean(status.runtimeReadiness && typeof status.runtimeReadiness === "object"
-                    && status.runtimeReadiness.state === "ready");
+                const sessionStartedAt = status.session && typeof status.session === "object"
+                    ? Date.parse(String(status.session.startedAt || "")) : Number.NaN;
+                const sessionCurrent = Number.isFinite(sessionStartedAt) && sessionStartedAt >= Date.parse(daemonStartedAt);
+                const runtimeReady = sessionCurrent && isRuntimeReadinessCurrent(status.runtimeReadiness, daemonStartedAt);
                 const pendingCount = stateStore(agent).withInboxTransaction(() => stateStore(agent).readNdjson("inbox").length);
                 return { turns, runtimeReady, ...connectionState(status), pendingCount };
             };
@@ -1345,6 +1354,7 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                 throw Object.assign(new Error(`Agent ${agentId} channel is not connected`), { code: "channel_unavailable", ...initialProjection });
             if (initialProjection.reconnecting)
                 throw Object.assign(new Error(`Agent ${agentId} channel is reconnecting`), { code: "channel_reconnecting", ...initialProjection });
+            markRuntimeTransition(agent, "Runtime session reset in progress");
             let reset;
             try {
                 reset = await runtimeHost.resetSession(agentId);
@@ -1361,11 +1371,17 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                         delete record.state.sessions[agent.runtime];
                     record.store.writeJson("agentState", record.state);
                 }
-                if (!reset.sessionId)
+                if (!reset.sessionId) {
+                    const observedAt = new Date().toISOString();
                     hostState.updateStatus(agent, {
-                        session: { runtime: agent.runtime, id: null, launchId: null, startedAt: new Date().toISOString(),
-                            lastSeenAt: null, lastTurnAt: null, turns: 0 }, runtimeReadiness: { runtime: agent.runtime, state: "ready" },
+                        session: { runtime: agent.runtime, id: null, launchId: null, startedAt: observedAt,
+                            lastSeenAt: null, lastTurnAt: null, turns: 0 },
+                        runtimeReadiness: { runtime: agent.runtime, state: "ready", observedAt },
                     });
+                }
+                else if (reset.runtimeReady) {
+                    hostState.updateStatus(agent, { runtimeReadiness: { runtime: agent.runtime, state: "ready", observedAt: new Date().toISOString() } });
+                }
             }
             catch (error) {
                 const projection = readinessProjection();
@@ -1412,8 +1428,10 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                 const status = hostState.readStatus(agent);
                 const turns = status.session && typeof status.session === "object"
                     ? Math.max(0, Number(status.session.turns) || 0) : 0;
-                const runtimeReady = Boolean(status.runtimeReadiness && typeof status.runtimeReadiness === "object"
-                    && status.runtimeReadiness.state === "ready");
+                const sessionStartedAt = status.session && typeof status.session === "object"
+                    ? Date.parse(String(status.session.startedAt || "")) : Number.NaN;
+                const sessionCurrent = Number.isFinite(sessionStartedAt) && sessionStartedAt >= Date.parse(daemonStartedAt);
+                const runtimeReady = sessionCurrent && isRuntimeReadinessCurrent(status.runtimeReadiness, daemonStartedAt);
                 const pendingCount = stateStore(agent).withInboxTransaction(() => stateStore(agent).readNdjson("inbox").length);
                 return { turns, runtimeReady, ...connectionState(status), pendingCount };
             };
@@ -1429,6 +1447,9 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
             catch (error) {
                 throw Object.assign(error instanceof Error ? error : new Error(String(error)), readinessProjection());
             }
+            if (recovery.runtimeReady) {
+                hostState.updateStatus(agent, { runtimeReadiness: { runtime: agent.runtime, state: "ready", observedAt: new Date().toISOString() } });
+            }
             const record = agentStates.get(agentId);
             try {
                 if (record) {
@@ -1466,6 +1487,8 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
         async start() {
             try {
                 fs.mkdirSync(larkinHome, { recursive: true });
+                for (const agent of agents)
+                    markRuntimeTransition(agent, "Current daemon epoch starting");
                 fs.writeFileSync(path.join(larkinHome, "daemon-status.json"), JSON.stringify({
                     ...currentProcessMetadata(processCommandToken("daemon", "app/runtime-process.mjs")), pid: process.pid, startedAt: daemonStartedAt,
                     agents: agents.map((agent) => agent.agentId),