larkin 0.4.2 → 0.4.5

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 };
             };
@@ -1422,6 +1440,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 recovery in progress");
             let recovery;
             try {
                 recovery = await runtimeHost.recoverSession(agentId, reason);
@@ -1429,6 +1448,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 +1488,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),