@kikimoradev/kcloud 1.11.0 → 1.11.2

package/dist/main.js

@@ -929,6 +929,7 @@ const errorCodes = Object.keys({
 	"release.hidden": "rule_violation",
 	"release.unavailable": "rule_violation",
 	"release.unsupported": "rule_violation",
+	"release.none_stable": "rule_violation",
 	"agent.not_found": "not_found",
 	"agent.invalid_slug": "rule_violation",
 	"agent.slug_taken": "conflict",
@@ -1165,7 +1166,11 @@ const agentEventSchema = z.discriminatedUnion("event", [
 	z.looseObject({
 		...roleEnvelope("task.started"),
 		taskId: z.string(),
-		title: z.string()
+		title: z.string(),
+		sourceLabel: z.string().optional(),
+		sourceUrl: z.string().optional(),
+		attempt: countSchema.optional(),
+		maxAttempts: countSchema.optional()
 	}),
 	z.looseObject({
 		...roleEnvelope("task.finished"),
@@ -1179,7 +1184,11 @@ const agentEventSchema = z.discriminatedUnion("event", [
 		attempt: countSchema.optional(),
 		maxAttempts: countSchema.optional(),
 		sessionId: z.string().optional(),
-		error: z.string().optional()
+		error: z.string().optional(),
+		sourceLabel: z.string().optional(),
+		sourceUrl: z.string().optional(),
+		handedOff: z.boolean().optional(),
+		handoffReason: z.string().optional()
 	}),
 	z.looseObject({
 		...roleEnvelope("task.retryScheduled"),
@@ -1471,6 +1480,108 @@ z.object({
 	source: agentTaskSourceSchema,
 	staleReason: agentTaskStaleReasonSchema
 }).meta({ id: "AgentTaskView" });
+const taskSourceSchema = z.object({
+	label: z.string(),
+	url: z.string().nullable()
+}).meta({ id: "TaskSource" });
+const overviewTaskOutcomeSchema = z.enum([
+	"running",
+	"done",
+	"failed",
+	"retrying",
+	"handedOff"
+]);
+const overviewTaskSchema = z.object({
+	taskId: z.string(),
+	title: z.string(),
+	source: taskSourceSchema.nullable(),
+	attempts: z.int().nonnegative(),
+	maxAttempts: z.int().nullable(),
+	startedAt: z.iso.datetime(),
+	finishedAt: z.iso.datetime().nullable(),
+	outcome: overviewTaskOutcomeSchema,
+	error: z.string().nullable(),
+	costUsd: z.number(),
+	durationMs: z.int().nonnegative(),
+	headline: z.string().nullable(),
+	handoffReason: z.string().nullable()
+}).meta({ id: "OverviewTask" });
+const overviewGroupSchema = z.object({
+	source: taskSourceSchema.nullable(),
+	title: z.string(),
+	tasks: z.array(overviewTaskSchema),
+	totals: z.object({
+		durationMs: z.int().nonnegative(),
+		costUsd: z.number()
+	})
+}).meta({ id: "OverviewGroup" });
+const attentionBase = {
+	taskId: z.string(),
+	title: z.string(),
+	source: taskSourceSchema.nullable(),
+	finishedAt: z.iso.datetime()
+};
+const attentionItemSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("failed"),
+		...attentionBase,
+		attempts: z.int().nonnegative(),
+		maxAttempts: z.int().nullable(),
+		error: z.string().nullable()
+	}),
+	z.object({
+		kind: z.literal("retried"),
+		...attentionBase,
+		attempts: z.int().nonnegative()
+	}),
+	z.object({
+		kind: z.literal("handedOff"),
+		...attentionBase,
+		reason: z.string().nullable()
+	})
+]).meta({ id: "AttentionItem" });
+const workloadSchema = z.object({
+	tasksDone: z.int().nonnegative(),
+	tasksFailed: z.int().nonnegative(),
+	tasksHandedOff: z.int().nonnegative(),
+	tasksCostUsd: z.number(),
+	averageTaskMs: z.int().nonnegative().nullable(),
+	cycles: z.int().nonnegative(),
+	cyclesCostUsd: z.number()
+}).meta({ id: "Workload" });
+z.object({
+	window: z.object({
+		from: z.iso.datetime(),
+		to: z.iso.datetime()
+	}),
+	source: agentTaskSourceSchema,
+	staleReason: agentTaskStaleReasonSchema,
+	lastEventAt: z.iso.datetime().nullable(),
+	current: overviewTaskSchema.nullable(),
+	last: overviewTaskSchema.nullable(),
+	lastCycle: z.object({
+		finishedAt: z.iso.datetime(),
+		ok: z.boolean().nullable(),
+		addedTasks: z.int().nonnegative().nullable()
+	}).nullable(),
+	queue: z.object({
+		pending: z.int().nonnegative(),
+		inProgress: z.int().nonnegative(),
+		failed: z.int().nonnegative()
+	}).nullable(),
+	lastSession: z.object({
+		role: agentRoleSchema.nullable(),
+		startedAt: z.iso.datetime()
+	}).nullable(),
+	costTodayUsd: z.number(),
+	attention: z.array(attentionItemSchema),
+	groups: z.array(overviewGroupSchema),
+	moreTasks: z.int().nonnegative(),
+	health: z.object({
+		day: workloadSchema,
+		week: workloadSchema
+	})
+}).meta({ id: "AgentOverview" });
 z.object({
 	title: z.string().trim().min(1).max(200).optional(),
 	description: z.string().trim().min(1).max(maxTaskDescriptionLength)
@@ -2378,6 +2489,7 @@ const auditActionSchema = z.enum([
 	"tool.deleted",
 	"tool.copied",
 	"release.visibility_changed",
+	"release.stability_changed",
 	"agent.created",
 	"agent.updated",
 	"agent.deleted",
@@ -2515,6 +2627,8 @@ z.object({
 //#endregion
 //#region ../../packages/contracts/src/releases.ts
 const kikimoraVersionSchema = z.string().regex(versionTagPattern);
+const latestKikimoraVersion = "latest";
+const kikimoraVersionChoiceSchema = z.union([kikimoraVersionSchema, z.literal(latestKikimoraVersion)]);
 const releaseSummarySchema = z.object({
 	version: kikimoraVersionSchema,
 	claudeCodeVersion: z.string().nullable(),
@@ -2522,14 +2636,20 @@ const releaseSummarySchema = z.object({
 	imageCreatedAt: z.iso.datetime().nullable(),
 	gitRevision: z.string().nullable(),
 	releaseNotesUrl: z.url().nullable(),
-	supported: z.boolean()
+	supported: z.boolean(),
+	stable: z.boolean()
 }).meta({ id: "ReleaseSummary" });
-z.object({ items: z.array(releaseSummarySchema) }).meta({ id: "ReleaseList" });
+z.object({
+	items: z.array(releaseSummarySchema),
+	latest: kikimoraVersionSchema.nullable()
+}).meta({ id: "ReleaseList" });
 const releaseAdminSchema = releaseSummarySchema.extend({
 	available: z.boolean(),
 	hidden: z.boolean(),
 	hiddenAt: z.iso.datetime().nullable(),
 	hiddenBy: idSchema.nullable(),
+	stableAt: z.iso.datetime().nullable(),
+	stableBy: idSchema.nullable(),
 	syncedAt: z.iso.datetime(),
 	lastSyncError: z.string().nullable()
 }).meta({ id: "ReleaseAdmin" });
@@ -2539,6 +2659,7 @@ z.object({
 	lastSyncError: z.string().nullable()
 }).meta({ id: "ReleaseAdminList" });
 z.object({ hidden: z.boolean() }).meta({ id: "SetReleaseVisibilityBody" });
+z.object({ stable: z.boolean() }).meta({ id: "SetReleaseStabilityBody" });
 z.object({ version: kikimoraVersionSchema });
 const repositoryStatusSchema = z.enum([
 	"ok",
@@ -2849,7 +2970,8 @@ const restartReasonSchema = z.enum([
 	"tool_changed",
 	"spec_drift",
 	"spec_version",
-	"release_unsupported"
+	"release_unsupported",
+	"latest_release"
 ]);
 const containerHealthSchema = z.enum([
 	"none",
@@ -2941,6 +3063,8 @@ const agentListItemSchema = z.object({
 	name: z.string(),
 	slug: slugSchema,
 	kikimoraVersion: z.string(),
+	followsLatest: z.boolean(),
+	pendingKikimoraVersion: z.string().nullable(),
 	state: agentStateSchema,
 	observedState: agentObservedStateSchema,
 	desiredState: agentDesiredStateSchema,
@@ -2950,6 +3074,7 @@ const agentListItemSchema = z.object({
 	retryAt: z.iso.datetime().nullable(),
 	progress: agentProgressSchema.nullable(),
 	availableActions: z.array(agentActionSchema),
+	stateSince: z.iso.datetime().nullable(),
 	updatedAt: z.iso.datetime()
 }).meta({ id: "AgentListItem" });
 const agentNodeSchema = z.object({
@@ -3006,7 +3131,7 @@ const createAgentBodySchema = z.object({
 	name: agentNameSchema,
 	slug: slugSchema.optional(),
 	description: agentDescriptionSchema,
-	kikimoraVersion: kikimoraVersionSchema,
+	kikimoraVersion: kikimoraVersionChoiceSchema,
 	nodeId: idSchema,
 	requiredCapabilities: requiredCapabilitiesSchema.optional(),
 	claudeCredentialId: idSchema.optional(),
@@ -3025,7 +3150,7 @@ const updateAgentSectionsSchema = z.object({
 		slug: slugSchema.optional(),
 		description: agentDescriptionSchema
 	}).optional(),
-	version: kikimoraVersionSchema.optional(),
+	version: kikimoraVersionChoiceSchema.optional(),
 	credentials: z.object({
 		claudeCredentialId: idSchema.optional(),
 		githubCredentialId: idSchema.optional(),
@@ -4662,6 +4787,7 @@ const agentHints = {
 	"agent.node_unsuitable": "The node lacks a capability the agent requires; kcloud nodes show <node> lists what it offers.",
 	"node.offline": "The node of the agent is not connected; kcloud nodes show <node> tells when it was last seen.",
 	"account.queue_empty": "The queue of Claude accounts of the project is empty; kcloud projects accounts add <account> --project <name> puts one in it.",
+	"release.none_stable": "No release is stable yet, so latest points at no release; kcloud releases list shows the releases to pick one of.",
 	"node.outdated": "The node of the agent runs an older release; kcloud nodes show <node> names the release it runs and its update."
 };
 const agentFrom = async (run, reference, project) => {
@@ -5011,7 +5137,7 @@ const agentPlanOf = (agent) => ({
 	name: agent.name,
 	slug: agent.slug,
 	description: agent.description,
-	kikimoraVersion: agent.kikimoraVersion,
+	kikimoraVersion: agent.followsLatest ? latestKikimoraVersion : agent.kikimoraVersion,
 	...agent.node === null ? {} : { nodeId: agent.node.id },
 	requiredCapabilities: agent.requiredCapabilities,
 	gitCredentialIds: agent.gitCredentials.map(({ id }) => id),
@@ -5084,6 +5210,9 @@ const acceptedAgentChange = (run, document) => {
 };
 //#endregion
 //#region src/commands/agents/config.ts
+const releaseOf = ({ kikimoraVersion, followsLatest }) => followsLatest ? `latest (${kikimoraVersion})` : kikimoraVersion;
+const nodeAppliedReasons = /* @__PURE__ */ new Set(["latest_release"]);
+const awaitsRestart = ({ restartRequired, restartReasons }) => restartRequired && (restartReasons.length === 0 || restartReasons.some((reason) => !nodeAppliedReasons.has(reason)));
 const agentsOf = async (scope, project) => {
 	const projects = project === void 0 ? (await projectsOf(scope)).map(({ id, slug }) => ({
 		id,
@@ -5144,8 +5273,8 @@ const configCommands = (adaptersOf) => [
 				agent.project,
 				agent.slug,
 				agent.state,
-				agent.kikimoraVersion,
-				agent.restartRequired ? "restart" : "-",
+				releaseOf(agent),
+				awaitsRestart(agent) ? "restart" : "-",
 				agent.id
 			])));
 		}
@@ -5198,7 +5327,7 @@ const configCommands = (adaptersOf) => [
 			const file = invocation.values.file;
 			if (file === void 0) throw new UsageError("agents set needs --file <path>.", "The file holds the sections to change; kcloud agents show <agent> --json shows the current ones.");
 			const agent = await changedAgent(run.api, agentId, acceptedAgentChange(run, await documentOf(run, file)));
-			return printed(run, agent, (changed) => changed.restartRequired ? `Changed ${changed.name}; it needs ${changeTakerOf(changed)} to take the change.` : `Changed ${changed.name}.`);
+			return printed(run, agent, (changed) => awaitsRestart(changed) ? `Changed ${changed.name}; it needs ${changeTakerOf(changed)} to take the change.` : `Changed ${changed.name}.`);
 		}
 	}),
 	defineCommand({
@@ -5302,6 +5431,7 @@ const gitCredentialLinesOf = ({ gitCredentials }) => gitCredentials.length === 0
 	serverUrl,
 	label
 ]))];
+const nextReleaseRowsOf = ({ pendingKikimoraVersion }) => pendingKikimoraVersion == null ? [] : [["next release", `${pendingKikimoraVersion} after the current session`]];
 const detailsOf = (agent) => [
 	renderTable([{ header: "FIELD" }, { header: "VALUE" }], [
 		["name", agent.name],
@@ -5309,7 +5439,8 @@ const detailsOf = (agent) => [
 		["state", agent.state],
 		["wanted", agent.desiredState],
 		["observed", agent.observedState],
-		["release", agent.kikimoraVersion],
+		["release", releaseOf(agent)],
+		...nextReleaseRowsOf(agent),
 		["claude code", claudeCodeOf(agent)],
 		["claude account", claudeAccountOf(agent)],
 		["node", agent.node === null ? "none" : `${agent.node.name} (${agent.node.state})`],
@@ -5324,7 +5455,7 @@ const detailsOf = (agent) => [
 		...admissionRowsOf(agent),
 		...admissionHoldRowsOf(agent),
 		...poolLimitRowsOf(agent),
-		["pending", agent.restartRequired ? agent.restartReasons.join(", ") : "-"],
+		["pending", awaitsRestart(agent) ? agent.restartReasons.join(", ") : "-"],
 		["actions", agent.availableActions.join(", ")],
 		["version", String(agent.version)],
 		["id", agent.id]
@@ -5373,11 +5504,16 @@ const placedNodeId = async (run, { projectId, given, ask }) => {
 //#region src/commands/agents/create.ts
 const catalogueOf = async (api, projectId) => {
 	const path = { params: { path: { id: projectId } } };
+	const credentials = dataOf("list the credentials of the project", await api.GET("/projects/{id}/credentials", path), agentHints).items;
+	const repositories = dataOf("list the repositories of the project", await api.GET("/projects/{id}/repositories", path), agentHints).items;
+	const tools = dataOf("list the tools of the project", await api.GET("/projects/{id}/tools", path), agentHints).items;
+	const { items, latest } = dataOf("list the releases", await api.GET("/releases"));
 	return {
-		credentials: dataOf("list the credentials of the project", await api.GET("/projects/{id}/credentials", path), agentHints).items,
-		repositories: dataOf("list the repositories of the project", await api.GET("/projects/{id}/repositories", path), agentHints).items,
-		tools: dataOf("list the tools of the project", await api.GET("/projects/{id}/tools", path), agentHints).items,
-		releases: dataOf("list the releases", await api.GET("/releases")).items.map(({ version }) => version)
+		credentials,
+		repositories,
+		tools,
+		releases: items.map(({ version }) => version),
+		latest
 	};
 };
 const serversOf = (catalogue, chosen) => {
@@ -5497,6 +5633,21 @@ const requiredCapabilitiesOf = (given) => {
 };
 const requirementOf = (required) => required === void 0 ? {} : { requiredCapabilities: [...required] };
 const localTimezone = () => Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+const releaseChoicesOf = ({ releases, latest }) => [...latest === null ? [] : [{
+	value: latestKikimoraVersion,
+	label: `latest (now ${latest})`
+}], ...releases.map((version) => ({
+	value: version,
+	label: version
+}))];
+const checkedRelease = ({ releases, latest }, release) => {
+	if (release === "latest") {
+		if (latest !== null) return release;
+		throw new CliError("No release is stable yet, so latest points at no release.", "kcloud releases list shows the releases to pick one of.");
+	}
+	if (releases.includes(release)) return release;
+	throw new CliError(`${release} is not a release an agent can run.`, releases.length === 0 ? "The catalogue holds no release yet; an administrator syncs it under Releases in the panel." : `kcloud releases list shows ${releases.join(", ")}.`);
+};
 const askedPlan = async (run, projectId, values, required) => {
 	const nodeId = await placedNodeId(run, {
 		projectId,
@@ -5508,14 +5659,10 @@ const askedPlan = async (run, projectId, values, required) => {
 		message: "The name of the agent",
 		validate: (value) => value.trim() === "" ? "cannot be empty" : void 0
 	});
-	const release = values.release ?? await run.prompt.select({
+	const release = checkedRelease(catalogue, values.release ?? await run.prompt.select({
 		message: "The Kikimora release it runs",
-		choices: catalogue.releases.map((version) => ({
-			value: version,
-			label: version
-		}))
-	});
-	if (!catalogue.releases.includes(release)) throw new CliError(`${release} is not a release an agent can run.`, catalogue.releases.length === 0 ? "The catalogue holds no release yet; an administrator syncs it under Releases in the panel." : `kcloud releases list shows ${catalogue.releases.join(", ")}.`);
+		choices: releaseChoicesOf(catalogue)
+	}));
 	const repositories = await chosenRepositories(run.prompt, catalogue);
 	const gitCredentialIds = await chosenGitCredentials(run.prompt, catalogue, repositories);
 	return {
@@ -5567,7 +5714,7 @@ const createCommand = (adaptersOf) => defineCommand({
 		["--require <capability,...>", `what its node has to offer: ${nodeCapabilityNames.join(", ")}`],
 		["--file <path>", "the whole agent as JSON, or - to read stdin"],
 		["--name <name>", "the name of the agent, instead of asking"],
-		["--release <x.y.z>", "the Kikimora release it runs, instead of asking"],
+		["--release <x.y.z|latest>", "the Kikimora release it runs, or latest to follow the newest stable one, instead of asking"],
 		["--monitor-prompt-file <path>", "the prompt of the monitor, instead of asking"],
 		["--executor-prompt-file <path>", "the prompt of the executor, instead of asking"],
 		["--timezone <zone>", "the timezone of the agent (default: this machine's)"],
@@ -6311,6 +6458,165 @@ const observabilityCommands = (adaptersOf) => [
 	})
 ];
 //#endregion
+//#region src/commands/agents/overview.ts
+const none = "-";
+const agentOverviewOf = async (api, agentId) => dataOf("show the overview of the agent", await api.GET("/agents/{id}/overview", { params: { path: { id: agentId } } }), agentHints);
+const staleReasons = {
+	stopped: "the agent is not running",
+	unreachable: "the agent did not answer on its control socket",
+	timeout: "the agent did not answer in time"
+};
+const nameOf = (task) => task.source === null ? task.taskId : `${task.source.label} (${task.taskId})`;
+const money = (amount) => `$${amount.toFixed(2)}`;
+const minutesOf = (ms) => `${Math.round(ms / 6e4)} min`;
+const counted = (count, one, many) => `${count} ${count === 1 ? one : many}`;
+const attemptsOf = (task) => task.maxAttempts === null ? `attempt ${task.attempts}` : `attempt ${task.attempts} of ${task.maxAttempts}`;
+const nowText = (overview) => {
+	const lines = [];
+	const { current, last, queue, lastCycle } = overview;
+	if (current !== null && overview.source === "projection") {
+		lines.push(`Last known: ${nameOf(current)} ${current.title}, started ${current.startedAt}, ${attemptsOf(current)}`);
+		if (overview.staleReason !== null) lines.push(`Not current: ${staleReasons[overview.staleReason]}.`);
+	} else if (current !== null) {
+		lines.push(`Working on ${nameOf(current)} ${current.title}, since ${current.startedAt}, ${attemptsOf(current)}`);
+		if (current.source?.url != null) lines.push(`Source: ${current.source.url}`);
+	} else if (last !== null) {
+		lines.push(`Last: ${nameOf(last)} ${last.title}, ${last.outcome}, finished ${last.finishedAt ?? none}`);
+		if (last.headline !== null) lines.push(`Result: ${last.headline}`);
+	} else lines.push("No task in the last 7 days.");
+	if (queue !== null) lines.push(`Queue: ${queue.pending} pending, ${queue.failed} failed`);
+	if (lastCycle !== null) {
+		const added = lastCycle.addedTasks === null ? "" : lastCycle.addedTasks === 0 ? ", found nothing new" : `, added ${counted(lastCycle.addedTasks, "task", "tasks")}`;
+		lines.push(`Last review of new work: ${lastCycle.finishedAt}${added}`);
+	}
+	return lines.join("\n");
+};
+const attentionLine = (item) => {
+	const name = `${nameOf(item)} ${item.title}`;
+	switch (item.kind) {
+		case "failed": return `failed after ${counted(item.attempts, "attempt", "attempts")}: ${name}${item.error === null ? "" : `: ${item.error}`}`;
+		case "retried": return `succeeded on attempt ${item.attempts}: ${name}`;
+		case "handedOff": return `handed off to a person: ${name}${item.reason === null ? "" : `: ${item.reason}`}`;
+	}
+};
+const attentionText = (overview) => overview.attention.length === 0 ? "Nothing needs attention." : overview.attention.map(attentionLine).join("\n");
+const groupRows = (group) => {
+	const [newest] = group.tasks;
+	const head = [
+		group.source?.label ?? newest?.taskId ?? none,
+		group.title,
+		String(group.tasks.length),
+		newest?.outcome ?? none,
+		minutesOf(group.totals.durationMs),
+		money(group.totals.costUsd),
+		newest?.finishedAt ?? none
+	];
+	if (group.tasks.length < 2) return [head];
+	return [head, ...group.tasks.map((task) => [
+		`  ${task.taskId}`,
+		task.title,
+		"",
+		task.attempts > 1 ? `${task.outcome}, ${counted(task.attempts, "attempt", "attempts")}` : task.outcome,
+		minutesOf(task.durationMs),
+		money(task.costUsd),
+		task.finishedAt ?? none
+	])];
+};
+const recentText = (overview, agent) => {
+	if (overview.groups.length === 0) return "No work in the last 7 days.";
+	const lines = [renderTable([
+		{ header: "SOURCE" },
+		{ header: "TITLE" },
+		{
+			header: "TASKS",
+			align: "right"
+		},
+		{ header: "OUTCOME" },
+		{
+			header: "TIME",
+			align: "right"
+		},
+		{
+			header: "COST",
+			align: "right"
+		},
+		{ header: "FINISHED" }
+	], overview.groups.flatMap(groupRows))];
+	if (overview.moreTasks > 0) lines.push(`${counted(overview.moreTasks, "more task", "more tasks")}: kcloud agents tasks list ${agent}`);
+	if (overview.source === "projection" && overview.staleReason !== null) lines.push(`No results from memory: ${staleReasons[overview.staleReason]}.`);
+	return lines.join("\n");
+};
+const healthRow = (label, workload) => [
+	label,
+	String(workload.tasksDone),
+	String(workload.tasksFailed),
+	String(workload.tasksHandedOff),
+	money(workload.tasksCostUsd),
+	workload.averageTaskMs === null ? none : minutesOf(workload.averageTaskMs),
+	`${workload.cycles} (${money(workload.cyclesCostUsd)})`
+];
+const healthText = (overview) => {
+	const lines = [renderTable([
+		{ header: "WINDOW" },
+		{
+			header: "DONE",
+			align: "right"
+		},
+		{
+			header: "FAILED",
+			align: "right"
+		},
+		{
+			header: "HANDED OFF",
+			align: "right"
+		},
+		{
+			header: "TASK COST",
+			align: "right"
+		},
+		{
+			header: "AVERAGE",
+			align: "right"
+		},
+		{
+			header: "REVIEWS",
+			align: "right"
+		}
+	], [healthRow("24 hours", overview.health.day), healthRow("7 days", overview.health.week)]), `Cost today: ${money(overview.costTodayUsd)}`];
+	if (overview.lastSession !== null) lines.push(`Last session: ${overview.lastSession.role ?? "unknown"}, ${overview.lastSession.startedAt}`);
+	return lines.join("\n");
+};
+const overviewText = (overview, agent = "<agent>") => [
+	"NOW",
+	nowText(overview),
+	"",
+	`NEEDS ATTENTION (${overview.attention.length})`,
+	attentionText(overview),
+	"",
+	"RECENT WORK",
+	recentText(overview, agent),
+	"",
+	"HOW IT GOES",
+	healthText(overview)
+].join("\n");
+const overviewCommand = (adaptersOf) => defineCommand({
+	name: "overview",
+	summary: "Show what an agent does now, what needs attention and how its work goes.",
+	usage: "agents overview <agent> [--project <name>]",
+	optionsUsage: [...agentUsage],
+	options: { ...agentOption },
+	positionals: {
+		min: 1,
+		max: 1
+	},
+	run: async (invocation) => {
+		const run = await runOf(adaptersOf, invocation);
+		const agent = invocation.positionals[0];
+		const agentId = await agentFrom(run, agent, invocation.values.project);
+		return printed(run, await agentOverviewOf(run.api, agentId), (overview) => overviewText(overview, agent));
+	}
+});
+//#endregion
 //#region src/commands/agents/streams.ts
 const streamOptions = {
 	...agentOption,
@@ -6675,6 +6981,7 @@ const createAgentsCommand = (adaptersOf) => defineGroup({
 		tasksCommand(adaptersOf),
 		backupsCommand(adaptersOf),
 		restoreCommand(adaptersOf),
+		overviewCommand(adaptersOf),
 		...observabilityCommands(adaptersOf),
 		...streamCommands(adaptersOf),
 		dashboardCommand(adaptersOf)
@@ -7623,7 +7930,7 @@ const agentTools = [
 	defineTool({
 		name: "agent_create",
 		title: "Create an agent",
-		description: "Create an agent in a project. The node it runs on, the git provider credentials, repositories and tools are named by the ids that nodes_list, credentials_list, repositories_list and tools_list return; gitCredentialIds takes one git provider credential for each server of its repositories; agent_show with asPlan shows a complete example. The agent works on the queue of Claude accounts of its project, which project_accounts_list shows. requiredCapabilities names what the node has to offer, from the offered list of nodes_list; the instance refuses a node that lacks one. The agent stays stopped until agent_action starts it.",
+		description: "Create an agent in a project. The node it runs on, the git provider credentials, repositories and tools are named by the ids that nodes_list, credentials_list, repositories_list and tools_list return; gitCredentialIds takes one git provider credential for each server of its repositories; agent_show with asPlan shows a complete example. The agent works on the queue of Claude accounts of its project, which project_accounts_list shows. requiredCapabilities names what the node has to offer, from the offered list of nodes_list; the instance refuses a node that lacks one. kikimoraVersion takes a release of releases_list, or \"latest\" to follow the newest stable release, which the agent then moves to between sessions; the instance refuses \"latest\" with release.none_stable while no release is stable. The agent stays stopped until agent_action starts it.",
 		operations: ["createAgent"],
 		safety: "write",
 		input: z.object({
@@ -7638,7 +7945,7 @@ const agentTools = [
 	defineTool({
 		name: "agent_update",
 		title: "Change an agent",
-		description: "Change sections of an agent; the credentials section names its git provider credentials as gitCredentialIds, and takes the repositories section in the same change. Without version the change applies to the version read just before it. When restartRequired comes back true, agent_action start or update applies the change, whichever availableActions offers.",
+		description: "Change sections of an agent; the credentials section names its git provider credentials as gitCredentialIds, and takes the repositories section in the same change. sections.version names the Kikimora release, one of releases_list, or \"latest\" to follow the newest stable release. Without version the change applies to the version read just before it. When restartRequired comes back true with a reason other than latest_release, agent_action start or update applies the change, whichever availableActions offers. latest_release alone needs no action: the node moves the agent onto the pending release after its current session, and a restart would replace the container in the middle of one.",
 		operations: ["updateAgent"],
 		safety: "write",
 		input: z.object({
@@ -8927,6 +9234,15 @@ const sources = {
 	}
 };
 const observabilityTools = [
+	defineTool({
+		name: "agent_overview",
+		title: "Show the overview of an agent",
+		description: "Show what an agent works on, what needs attention, its recent work grouped by the source of each task, and its counts and costs over 24 hours and 7 days.",
+		operations: ["getAgentOverview"],
+		safety: "read",
+		input: z.object({ ...agentFields }),
+		run: async (reference, run) => agentOverviewOf(run.api, await agentIdOf(run, reference))
+	}),
 	defineTool({
 		name: "agent_sessions",
 		title: "List the sessions of an agent",
@@ -10639,11 +10955,17 @@ const providerTools = [
 const releaseTools = [defineTool({
 	name: "releases_list",
 	title: "List releases",
-	description: "List the Kikimora releases an agent can run, with the Claude Code and Playwright MCP versions each one ships.",
+	description: "List the Kikimora releases an agent can run, with the Claude Code and Playwright MCP versions each one ships and whether it is stable, and the version \"latest\" points at now, null when no release is stable.",
 	operations: ["listReleases"],
 	safety: "read",
 	input: z.object({}),
-	run: async (_, run) => dataOf("list the releases", await run.api.GET("/releases")).items
+	run: async (_, run) => {
+		const { latest, items } = dataOf("list the releases", await run.api.GET("/releases"));
+		return {
+			latest,
+			items
+		};
+	}
 })];
 //#endregion
 //#region src/commands/repositories.ts
@@ -11844,13 +12166,31 @@ const createProvidersCommand = (adaptersOf) => defineGroup({
 });
 //#endregion
 //#region src/commands/releases.ts
+const latestLineOf = ({ latest }) => latest === null ? "No release is stable yet." : `Latest points at ${latest}.`;
+const releasesOf = (listed) => listed.items.length === 0 ? "The catalogue holds no release an agent can run." : [
+	renderTable([
+		{ header: "VERSION" },
+		{ header: "STABLE" },
+		{ header: "CLAUDE CODE" },
+		{ header: "PLAYWRIGHT MCP" },
+		{ header: "PUBLISHED" }
+	], listed.items.map((release) => [
+		release.version,
+		release.stable ? "yes" : "no",
+		release.claudeCodeVersion ?? "-",
+		release.playwrightMcpVersion ?? "-",
+		release.imageCreatedAt ?? "-"
+	])),
+	"",
+	latestLineOf(listed)
+].join("\n");
 const createReleasesCommand = (adaptersOf) => defineGroup({
 	name: "releases",
 	summary: "The Kikimora releases an agent can run.",
 	usage: "releases <command>",
 	subcommands: [defineCommand({
 		name: "list",
-		summary: "List the releases you can give an agent.",
+		summary: "List the releases you can give an agent, and the one latest points at.",
 		usage: "releases list",
 		options: {},
 		positionals: {
@@ -11860,17 +12200,7 @@ const createReleasesCommand = (adaptersOf) => defineGroup({
 		run: async (invocation) => {
 			const run = await runOf(adaptersOf, invocation);
 			const releases = dataOf("list the releases", await run.api.GET("/releases"));
-			return printed(run, releases, (listed) => listed.items.length === 0 ? "The catalogue holds no release an agent can run." : renderTable([
-				{ header: "VERSION" },
-				{ header: "CLAUDE CODE" },
-				{ header: "PLAYWRIGHT MCP" },
-				{ header: "PUBLISHED" }
-			], listed.items.map((release) => [
-				release.version,
-				release.claudeCodeVersion ?? "-",
-				release.playwrightMcpVersion ?? "-",
-				release.imageCreatedAt ?? "-"
-			])));
+			return printed(run, releases, releasesOf);
 		}
 	})]
 });

package/package.json

@@ -15,7 +15,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.11.0",
+  "version": "1.11.2",
   "dependencies": {
     "@clack/prompts": "1.8.1",
     "@modelcontextprotocol/server": "2.3.0",