@kikimoradev/kcloud 1.5.1 → 1.5.2

package/dist/main.js

@@ -1602,11 +1602,13 @@ const agentAdmissionSchema = z.object({
 	monitor: agentAdmissionStateSchema.nullable(),
 	executor: agentAdmissionStateSchema.nullable()
 }).meta({ id: "AgentAdmission" });
+const nodeUpdateAwaits = ["start", "end"];
 const admissionHoldSchema = z.object({
 	pools: z.array(sessionRoleSchema),
 	sessions: z.int().nonnegative(),
 	target: z.string().nullable(),
-	updating: z.boolean()
+	updating: z.boolean(),
+	awaits: z.enum(nodeUpdateAwaits)
 }).meta({ id: "AdmissionHold" });
 const nodeStateSchema = z.enum([
 	"pending",
@@ -1679,7 +1681,12 @@ const poolUsageSchema = z.object({
 	memoryMaxBytes: z.int().nonnegative().nullable(),
 	cpus: z.number().nonnegative().nullable(),
 	memoryKills: z.int().nonnegative(),
-	processors: z.int().positive().nullable().optional()
+	processors: z.int().positive().nullable().optional(),
+	earlierRun: z.object({
+		memoryBytes: z.int().nonnegative().nullable(),
+		holds: z.boolean()
+	}).meta({ id: "EarlierPoolRun" }).nullable().optional(),
+	limitRaised: z.boolean().optional()
 }).meta({ id: "PoolUsage" });
 const nodePoolSchema = z.object({
 	slots: z.int().nonnegative(),
@@ -1790,6 +1797,7 @@ const nodeUpdateSchema = z.object({
 	sessions: z.int().nonnegative(),
 	since: z.iso.datetime().nullable(),
 	held: z.array(sessionRoleSchema),
+	awaits: z.enum(nodeUpdateAwaits),
 	last: z.object({
 		outcome: z.enum([
 			"updated",
@@ -4507,7 +4515,11 @@ const sessionFailures = {
 	launcherRefused: "refused by the session starter"
 };
 const sessionFailureText = (reason) => reason === null ? "-" : sessionFailures[reason] ?? reason;
-const unsupportedReasons = { node_outdated: "the node runs a version that reports no pools" };
+const unsupportedReasons = {
+	node_outdated: "the node runs a version that reports no pools",
+	configure_failed: "the host did not take the limits",
+	configure_failing: "the node keeps failing to apply the limits, so sessions run without them until it succeeds"
+};
 const enforcementText = ({ state, reason }) => {
 	switch (state) {
 		case "enforced": return "The node holds each pool to the CPU and memory of its split.";
@@ -4538,6 +4550,12 @@ const memoryOf$1 = (pool) => {
 	return memoryMaxBytes === null ? bytesOf(memoryBytes) : `${bytesOf(memoryBytes)} of ${bytesOf(memoryMaxBytes)}`;
 };
 const roles = ["monitor", "executor"];
+const earlierRunTexts = (pools) => roles.flatMap((role) => {
+	const earlier = pools[role].usage?.earlierRun ?? null;
+	if (earlier === null) return [];
+	return [`The ${role} pool shares its memory with the sessions of the earlier run of the node, which use ${earlier.memoryBytes === null ? "an unknown amount" : bytesOf(earlier.memoryBytes)}${earlier.holds ? "; new sessions wait until they end" : ""}.`];
+});
+const limitRaisedTexts = (pools) => roles.filter((role) => pools[role].usage?.limitRaised === true).map((role) => `The ${role} pool keeps its memory limit above its share while its sessions use more; new sessions wait until they use less.`);
 const workOf = (role, { taskId, taskTitle, readable }) => {
 	if (readable === false) return "another project";
 	if (taskId === null) return role === "monitor" ? "monitor cycle" : "-";
@@ -4593,6 +4611,8 @@ const poolsText = (pools, split) => {
 		...pools.agentsSlice == null ? [] : [agentsSliceText(pools.agentsSlice)],
 		...pools.refused == null ? [] : [refusedText(pools.refused)],
 		...pools.layout == null ? [] : layoutTexts(pools.layout, split),
+		...earlierRunTexts(pools),
+		...limitRaisedTexts(pools),
 		renderTable([
 			{ header: "POOL" },
 			{ header: "SLOTS IN USE" },
@@ -4831,7 +4851,7 @@ const admissionRowsOf = (agent) => {
 const admissionHoldRowsOf = ({ runtime }) => {
 	const hold = runtime.admissionHold;
 	if (hold == null) return [];
-	if (hold.updating) return [["admissions", `held while the node updates to ${hold.target ?? "-"}`]];
+	if (hold.updating || hold.awaits === "start") return [["admissions", `held while the node updates to ${hold.target ?? "-"}`]];
 	const all = hold.pools.includes("monitor");
 	const noun = all ? "session" : "executor session";
 	const waits = `${String(hold.sessions)} ${noun}${hold.sessions === 1 ? "" : "s"}`;
@@ -9923,7 +9943,9 @@ const updateOf = ({ update }) => {
 	if (update === null) return "not reported";
 	switch (update.state) {
 		case "current": return "current";
-		case "waiting": return heldPoolsOf(update).includes("monitor") ? `admissions held for ${update.target ?? "-"}, waits for ${sessionsText(update.sessions, "session")}` : `executor admissions held for ${update.target ?? "-"}, waits for ${sessionsText(update.sessions, "executor session")}; monitors go on until the executor pool is empty`;
+		case "waiting":
+			if (update.awaits === "start") return `admissions held while the node updates to ${update.target ?? "-"}`;
+			return heldPoolsOf(update).includes("monitor") ? `admissions held for ${update.target ?? "-"}, waits for ${sessionsText(update.sessions, "session")}` : `executor admissions held for ${update.target ?? "-"}, waits for ${sessionsText(update.sessions, "executor session")}; monitors go on until the executor pool is empty`;
 		case "updating": return `updating to ${update.target ?? "-"}`;
 		case "failed": return `failed to reach ${update.target ?? "-"}, runs its previous version`;
 		case "unmanaged": return "updated with its platform";

package/package.json

@@ -15,7 +15,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.1",
+  "version": "1.5.2",
   "dependencies": {
     "@clack/prompts": "1.8.1",
     "@modelcontextprotocol/server": "2.1.0",