larkin 0.4.1 → 0.4.5

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(() => {
@@ -1284,7 +1291,10 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
         if (message.type === "session") {
             const record = agentStates.get(agent.agentId);
             if (record && record.state.sessions[message.runtime] !== message.sessionId) {
-                record.state.sessions[message.runtime] = message.sessionId;
+                if (message.sessionId)
+                    record.state.sessions[message.runtime] = message.sessionId;
+                else
+                    delete record.state.sessions[message.runtime];
                 saveAgentState(record);
                 log(`持久化 agent=${agent.name} runtime=${message.runtime} sessionId=${message.sessionId}`);
             }
@@ -1372,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 };
             };
@@ -1382,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);
@@ -1398,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();
@@ -1432,9 +1451,85 @@ function createHostShell({ env = process.env, runtimeHost, channelPackage, event
                     : unavailable ? "reset committed but Runtime/channel readiness is unavailable"
                         : "reset committed but readiness did not converge before timeout" };
         },
+        async recoverSession(agentId, reason, waitReadyMs = 30_000) {
+            const agent = agents.find((candidate) => candidate.agentId === agentId);
+            if (!agent)
+                throw Object.assign(new Error(`未知 Agent: ${agentId}`), { code: "unknown_agent" });
+            if (reason !== "context-overflow")
+                throw Object.assign(new Error("unsupported recovery reason"), { code: "recovery_refused" });
+            if (!runtimeHost.recoverSession)
+                throw Object.assign(new Error("Runtime session recovery 尚未就绪"), { code: "recovery_unavailable" });
+            const connectionState = (status = hostState.readStatus(agent)) => {
+                const connectedAt = Date.parse(String(status.connectedAt || ""));
+                const channelConnected = Number.isFinite(connectedAt) && connectedAt >= Date.parse(daemonStartedAt) - 1000;
+                return { channelConnected, reconnecting: (0, agent_readiness_js_1.isChannelReconnecting)(status) };
+            };
+            const readinessProjection = () => {
+                const status = hostState.readStatus(agent);
+                const turns = status.session && typeof status.session === "object"
+                    ? Math.max(0, Number(status.session.turns) || 0) : 0;
+                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 };
+            };
+            const initialProjection = readinessProjection();
+            if (!initialProjection.channelConnected)
+                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);
+            }
+            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) {
+                    if (recovery.sessionId)
+                        record.state.sessions[agent.runtime] = recovery.sessionId;
+                    else
+                        delete record.state.sessions[agent.runtime];
+                    record.store.writeJson("agentState", record.state);
+                }
+            }
+            catch (error) {
+                const projection = readinessProjection();
+                return { recoveryCommitted: true, generationChanged: recovery.generationChanged, sessionChanged: recovery.sessionChanged,
+                    ...projection, rearmedCount: recovery.rearmedCount, replayStatus: "pending", remainingPendingCount: projection.pendingCount,
+                    readyForFreshScenario: false, inboundObserved: false, code: "state_persistence_failed",
+                    error: "recovery committed but Agent session state persistence failed" };
+            }
+            const deadline = Date.now() + Math.max(0, waitReadyMs);
+            let projection = readinessProjection();
+            do {
+                projection = readinessProjection();
+                if (projection.turns === 0 && projection.runtimeReady && projection.channelConnected && !projection.reconnecting)
+                    break;
+                if (Date.now() >= deadline)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(25, Math.max(1, deadline - Date.now()))));
+            } while (true);
+            const replayStatus = projection.pendingCount === 0 ? "consumed" : "pending";
+            const ready = projection.turns === 0 && projection.runtimeReady && projection.channelConnected && !projection.reconnecting;
+            return { recoveryCommitted: true, generationChanged: recovery.generationChanged, sessionChanged: recovery.sessionChanged,
+                ...projection, rearmedCount: recovery.rearmedCount, replayStatus, remainingPendingCount: projection.pendingCount,
+                readyForFreshScenario: ready, inboundObserved: false,
+                ...(!ready ? { code: "recovery_timeout", error: "recovery committed but Runtime/channel readiness did not converge before timeout" } : {}) };
+        },
         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(() => {
@@ -1244,7 +1251,10 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
         if (message.type === "session") {
             const record = agentStates.get(agent.agentId);
             if (record && record.state.sessions[message.runtime] !== message.sessionId) {
-                record.state.sessions[message.runtime] = message.sessionId;
+                if (message.sessionId)
+                    record.state.sessions[message.runtime] = message.sessionId;
+                else
+                    delete record.state.sessions[message.runtime];
                 saveAgentState(record);
                 log(`持久化 agent=${agent.name} runtime=${message.runtime} sessionId=${message.sessionId}`);
             }
@@ -1332,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 };
             };
@@ -1342,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);
@@ -1358,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();
@@ -1392,9 +1411,85 @@ export function createHostShell({ env = process.env, runtimeHost, channelPackage
                     : unavailable ? "reset committed but Runtime/channel readiness is unavailable"
                         : "reset committed but readiness did not converge before timeout" };
         },
+        async recoverSession(agentId, reason, waitReadyMs = 30_000) {
+            const agent = agents.find((candidate) => candidate.agentId === agentId);
+            if (!agent)
+                throw Object.assign(new Error(`未知 Agent: ${agentId}`), { code: "unknown_agent" });
+            if (reason !== "context-overflow")
+                throw Object.assign(new Error("unsupported recovery reason"), { code: "recovery_refused" });
+            if (!runtimeHost.recoverSession)
+                throw Object.assign(new Error("Runtime session recovery 尚未就绪"), { code: "recovery_unavailable" });
+            const connectionState = (status = hostState.readStatus(agent)) => {
+                const connectedAt = Date.parse(String(status.connectedAt || ""));
+                const channelConnected = Number.isFinite(connectedAt) && connectedAt >= Date.parse(daemonStartedAt) - 1000;
+                return { channelConnected, reconnecting: isChannelReconnecting(status) };
+            };
+            const readinessProjection = () => {
+                const status = hostState.readStatus(agent);
+                const turns = status.session && typeof status.session === "object"
+                    ? Math.max(0, Number(status.session.turns) || 0) : 0;
+                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 };
+            };
+            const initialProjection = readinessProjection();
+            if (!initialProjection.channelConnected)
+                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);
+            }
+            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) {
+                    if (recovery.sessionId)
+                        record.state.sessions[agent.runtime] = recovery.sessionId;
+                    else
+                        delete record.state.sessions[agent.runtime];
+                    record.store.writeJson("agentState", record.state);
+                }
+            }
+            catch (error) {
+                const projection = readinessProjection();
+                return { recoveryCommitted: true, generationChanged: recovery.generationChanged, sessionChanged: recovery.sessionChanged,
+                    ...projection, rearmedCount: recovery.rearmedCount, replayStatus: "pending", remainingPendingCount: projection.pendingCount,
+                    readyForFreshScenario: false, inboundObserved: false, code: "state_persistence_failed",
+                    error: "recovery committed but Agent session state persistence failed" };
+            }
+            const deadline = Date.now() + Math.max(0, waitReadyMs);
+            let projection = readinessProjection();
+            do {
+                projection = readinessProjection();
+                if (projection.turns === 0 && projection.runtimeReady && projection.channelConnected && !projection.reconnecting)
+                    break;
+                if (Date.now() >= deadline)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(25, Math.max(1, deadline - Date.now()))));
+            } while (true);
+            const replayStatus = projection.pendingCount === 0 ? "consumed" : "pending";
+            const ready = projection.turns === 0 && projection.runtimeReady && projection.channelConnected && !projection.reconnecting;
+            return { recoveryCommitted: true, generationChanged: recovery.generationChanged, sessionChanged: recovery.sessionChanged,
+                ...projection, rearmedCount: recovery.rearmedCount, replayStatus, remainingPendingCount: projection.pendingCount,
+                readyForFreshScenario: ready, inboundObserved: false,
+                ...(!ready ? { code: "recovery_timeout", error: "recovery committed but Runtime/channel readiness did not converge before timeout" } : {}) };
+        },
         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),