@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/tools/job.ts

@@ -2,9 +2,10 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@prometheus-ai/tui";
 import { Text } from "@prometheus-ai/tui";
 import { prompt } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
-import { type AsyncJob, type AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
+import { z } from "zod/v4";
+import type { AsyncJob, AsyncJobManager } from "../async";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { shimmerEnabled, shimmerText } from "../modes/theme/shimmer";
 import type { Theme } from "../modes/theme/theme";
 import jobDescription from "../prompts/tools/job.md" with { type: "text" };
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
@@ -23,7 +24,7 @@ import {
 import { ToolError } from "./tool-errors";
 
 const jobSchema = z.object({
-	poll: z.array(z.string()).optional().describe("job ids to wait for"),
+	poll: z.array(z.string()).optional().describe("job ids to wait for; omit to wait on all running jobs"),
 	cancel: z.array(z.string()).optional().describe("job ids to cancel"),
 	list: z.boolean().optional().describe("snapshot all jobs"),
 });
@@ -65,6 +66,19 @@ export interface JobToolDetails {
 	cancelled?: { id: string; status: CancelStatus }[];
 }
 
+/**
+ * A poll snapshot where every watched job is still running and nothing was
+ * cancelled — pure "still waiting" noise once a newer poll exists. The TUI
+ * keeps such a block un-finalized (displaceable) so a follow-up `job` call
+ * replaces it instead of stacking another waiting frame in the transcript.
+ */
+export function isWaitingPollDetails(details: unknown): boolean {
+	const d = details as JobToolDetails | undefined;
+	if (!d || !Array.isArray(d.jobs) || d.jobs.length === 0) return false;
+	if (d.cancelled?.length) return false;
+	return d.jobs.every(job => job?.status === "running");
+}
+
 export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 	readonly name = "job";
 	readonly approval = "read" as const;
@@ -78,11 +92,6 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		this.description = prompt.render(jobDescription);
 	}
 
-	static createIf(session: ToolSession): JobTool | null {
-		if (!isBackgroundJobSupportEnabled(session.settings)) return null;
-		return new JobTool(session);
-	}
-
 	async execute(
 		_toolCallId: string,
 		params: JobParams,
@@ -162,6 +171,9 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			return {
 				content: [{ type: "text", text: message }],
 				details: { jobs: [] },
+				// Nothing found / nothing to wait for is noise once consumed —
+				// the follow-up call has already corrected course.
+				useless: true,
 			};
 		}
 
@@ -172,9 +184,16 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			return this.#buildResult(manager, [...cancelledJobs, ...jobsToWatch], cancelOutcomes);
 		}
 
-		// Wait until at least one running job finishes, the wait duration elapses, or the call is aborted.
+		// Wait until at least one running job finishes, the wait window elapses,
+		// or the call is aborted. With `async.pollWaitDuration` set to `smart`,
+		// the window adapts: it starts at the ladder floor and climbs as the agent
+		// polls in a tight loop, then resets to the floor once the agent steps
+		// away from polling (see AsyncJobManager.nextPollWaitMs). Any fixed value
+		// waits that exact duration every time.
 		const racePromises: Promise<unknown>[] = runningJobs.map(j => j.promise);
-		const waitMs = parseWaitDurationMs(this.session.settings.get("async.pollWaitDuration"));
+		const pollSetting = this.session.settings.get("async.pollWaitDuration");
+		const smartPoll = pollSetting === "smart";
+		const waitMs = smartPoll ? manager.nextPollWaitMs(ownerId) : parseWaitDurationMs(pollSetting);
 		const { promise: timeoutPromise, resolve: timeoutResolve } = Promise.withResolvers<void>();
 		const timeoutHandle = setTimeout(() => timeoutResolve(), waitMs);
 		racePromises.push(timeoutPromise);
@@ -220,6 +239,11 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			manager.unwatchJobs(watchedJobIds);
 			clearTimeout(timeoutHandle);
 			if (progressTimer) clearInterval(progressTimer);
+			if (smartPoll) {
+				// Reset the idle-gap clock: escalate if the agent polls again soon,
+				// drop back to the floor once it goes quiet for a while.
+				manager.recordPollWaitEnd(ownerId);
+			}
 		}
 
 		return this.#buildResult(manager, allTrackedJobs, cancelOutcomes);
@@ -325,12 +349,17 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			}
 		}
 
+		const details: JobToolDetails = {
+			jobs: jobResults,
+			...(cancelOutcomes.length ? { cancelled: cancelOutcomes.map(({ id, status }) => ({ id, status })) } : {}),
+		};
 		return {
 			content: [{ type: "text", text: lines.join("\n").trimEnd() }],
-			details: {
-				jobs: jobResults,
-				...(cancelOutcomes.length ? { cancelled: cancelOutcomes.map(({ id, status }) => ({ id, status })) } : {}),
-			},
+			details,
+			// A poll where everything is still running carries no new information
+			// once a later poll exists — same predicate the TUI uses to displace
+			// stale waiting frames.
+			...(isWaitingPollDetails(details) ? { useless: true } : {}),
 		};
 	}
 }
@@ -355,7 +384,7 @@ const PREVIEW_LINE_WIDTH = 80;
 function statusToIcon(status: JobSnapshot["status"]): ToolUIStatus {
 	switch (status) {
 		case "completed":
-			return "success";
+			return "done";
 		case "failed":
 			return "error";
 		case "cancelled":
@@ -378,6 +407,30 @@ function statusToColor(status: JobSnapshot["status"]): ToolUIColor {
 	}
 }
 
+/**
+ * Task job results are delivered in the model-facing `<task-result>` envelope
+ * (prompts/tools/task-summary.md) so the parent agent can parse status and the
+ * `agent://` pointer. The wrapper markup is noise to a human — preview the
+ * inner <output>/<preview> body instead.
+ */
+function stripTaskResultEnvelope(text: string): string {
+	if (!text.startsWith("<task-result")) return text;
+	const body = /<(output|preview)(?:\s[^>]*)?>\n?([\s\S]*?)\n?<\/\1>/.exec(text)?.[2];
+	return body?.trim() || text;
+}
+
+/**
+ * Pretty-printed JSON output wastes the collapsed one-line preview on a lone
+ * "{" — flatten structured-looking bodies onto a single line. Slice first:
+ * downstream truncation keeps at most a few hundred columns, so collapsing
+ * whitespace across a multi-KB body would be pure waste.
+ */
+function flattenStructuredPreview(text: string): string {
+	const first = text[0];
+	if (first !== "{" && first !== "[") return text;
+	return text.slice(0, PREVIEW_LINES_EXPANDED * PREVIEW_LINE_WIDTH * 2).replace(/\s+/g, " ");
+}
+
 function describeTarget(args: JobRenderArgs | undefined): string {
 	const poll = args?.poll ?? [];
 	const cancel = args?.cancel ?? [];
@@ -396,7 +449,7 @@ export const jobToolRenderer = {
 	inline: true,
 
 	renderCall(args: JobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const text = renderStatusLine({ icon: "pending", title: "Job", description: describeTarget(args) }, uiTheme);
+		const text = renderStatusLine({ icon: "pending", title: describeTarget(args) || "Job" }, uiTheme);
 		return new Text(text, 0, 0);
 	},
 
@@ -410,31 +463,34 @@ export const jobToolRenderer = {
 
 		if (jobs.length === 0) {
 			const fallback = result.content?.find(c => c.type === "text")?.text || "No jobs to process";
-			const header = renderStatusLine({ icon: "warning", title: "Job", description: describeTarget(args) }, uiTheme);
+			const header = renderStatusLine({ icon: "warning", title: describeTarget(args) || "Job" }, uiTheme);
 			return new Text([header, formatEmptyMessage(fallback, uiTheme)].join("\n"), 0, 0);
 		}
 
 		const counts = { completed: 0, failed: 0, cancelled: 0, running: 0 };
 		for (const job of jobs) counts[job.status]++;
 
+		// The title already carries the running count, so meta lists only the
+		// settled categories — "waiting on 19 of 19 · 19 running" read awkward.
 		const meta: string[] = [];
 		if (counts.completed > 0) meta.push(uiTheme.fg("success", `${counts.completed} done`));
 		if (counts.failed > 0) meta.push(uiTheme.fg("error", `${counts.failed} failed`));
 		if (counts.cancelled > 0) meta.push(uiTheme.fg("warning", `${counts.cancelled} cancelled`));
-		if (counts.running > 0) meta.push(uiTheme.fg("accent", `${counts.running} running`));
 
 		const headerIcon: ToolUIStatus = counts.failed > 0 ? "warning" : counts.running > 0 ? "info" : "success";
+		const jobsNoun = jobs.length === 1 ? "job" : "jobs";
 		const description =
 			counts.running > 0
-				? `waiting on ${counts.running} of ${jobs.length}`
-				: `${jobs.length} ${jobs.length === 1 ? "job" : "jobs"} settled`;
+				? counts.running === jobs.length
+					? `waiting on ${jobs.length} ${jobsNoun}`
+					: `waiting on ${counts.running} of ${jobs.length} ${jobsNoun}`
+				: `${jobs.length} ${jobsNoun} settled`;
 
 		const header = renderStatusLine(
 			{
 				icon: headerIcon,
 				spinnerFrame: counts.running > 0 ? options.spinnerFrame : undefined,
-				title: "Job",
-				description,
+				title: description,
 				meta,
 			},
 			uiTheme,
@@ -455,11 +511,18 @@ export const jobToolRenderer = {
 
 		let cached: RenderCache | undefined;
 		return {
-			render(width: number): string[] {
+			render(width: number): readonly string[] {
 				const expanded = options.expanded;
 				const spinnerFrame = options.spinnerFrame ?? 0;
-				const key = new Hasher().bool(expanded).u32(width).u32(spinnerFrame).digest();
-				if (cached?.key === key) return cached.lines;
+				// Running-job labels shimmer while the poll block is live; the band
+				// phase is Date.now()-sampled at render time, so serving cached bytes
+				// would pin it to the ~12.5fps spinner-glyph cadence instead of the
+				// 30fps redraw. Bypass the cache while any row animates, and key on
+				// the animation state so a sealed block never hits stale shimmered
+				// bytes (spinnerFrame falls back to 0 on both sides of the seal).
+				const shimmerActive = counts.running > 0 && options.spinnerFrame !== undefined && shimmerEnabled();
+				const key = new Hasher().bool(expanded).u32(width).u32(spinnerFrame).bool(shimmerActive).digest();
+				if (!shimmerActive && cached?.key === key) return cached.lines;
 
 				const itemLines = renderTreeList<JobSnapshot>(
 					{
@@ -475,7 +538,9 @@ export const jobToolRenderer = {
 								job.status === "running" ? options.spinnerFrame : undefined,
 							);
 							const typeBadge = formatBadge(job.type, statusToColor(job.status), uiTheme);
-							const idText = uiTheme.fg("muted", job.id);
+							// Task jobs label themselves with their agent id, which is also
+							// the job id — drop the id column instead of stuttering it twice.
+							const idPart = job.label.trim() === job.id ? "" : ` ${uiTheme.fg("muted", job.id)}`;
 							const rawLabelLines = (job.label || "(no label)").split(/\r?\n/);
 							const maxLabelLines = expanded ? LABEL_LINES_EXPANDED : LABEL_LINES_COLLAPSED;
 							const visibleLabelLines = rawLabelLines
@@ -486,13 +551,25 @@ export const jobToolRenderer = {
 								visibleLabelLines[visibleLabelLines.length - 1] = `${last} …`;
 							}
 							const durationText = uiTheme.fg("dim", formatDuration(job.durationMs));
-							const headLabel = uiTheme.fg("toolOutput", visibleLabelLines[0] ?? "");
-							lines.push(`${icon} ${idText} ${typeBadge} ${headLabel} ${durationText}`);
+							// Running rows in a live block shimmer their label; once the block
+							// stops animating (sealed, or a settled snapshot — spinnerFrame
+							// cleared) they render static so scrollback never keeps a mid-sweep
+							// shimmer band.
+							const live = job.status === "running" && options.spinnerFrame !== undefined;
+							const headRaw = visibleLabelLines[0] ?? "";
+							const headLabel = live
+								? shimmerEnabled()
+									? shimmerText(headRaw, uiTheme)
+									: uiTheme.fg("accent", headRaw)
+								: uiTheme.fg("toolOutput", headRaw);
+							lines.push(`${icon}${idPart} ${typeBadge} ${headLabel} ${durationText}`);
 							for (let i = 1; i < visibleLabelLines.length; i++) {
 								lines.push(`  ${uiTheme.fg("toolOutput", visibleLabelLines[i]!)}`);
 							}
 
-							const preview = job.errorText?.trim() || job.resultText?.trim();
+							const preview = flattenStructuredPreview(
+								stripTaskResultEnvelope(job.errorText?.trim() || job.resultText?.trim() || ""),
+							);
 							if (preview) {
 								const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
 								const previewLines = getPreviewLines(preview, maxLines, PREVIEW_LINE_WIDTH, Ellipsis.Unicode);

package/src/tools/learn.ts

@@ -0,0 +1,144 @@
+import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
+import { z } from "zod/v4";
+import { sanitizeSkillName, writeManagedSkill } from "../autolearn/managed-skills";
+import { isNameClaimedByAuthoredSkill } from "../extensibility/skills";
+import { localBackend } from "../memory-backend/local-backend";
+import learnDescription from "../prompts/tools/learn.md" with { type: "text" };
+import type { ToolSession } from ".";
+
+const learnSchema = z.object({
+	memory: z.string().describe("the durable, self-contained lesson to remember (what, when, why)"),
+	context: z.string().describe("optional source context for the lesson").optional(),
+	skill: z
+		.object({
+			action: z.enum(["create", "update"]),
+			name: z.string().describe("kebab-case skill name"),
+			description: z.string().describe("one-line description of when to use the skill"),
+			body: z.string().describe("the SKILL.md body in markdown (no frontmatter)"),
+		})
+		.describe("also create or enhance a managed skill in the same call")
+		.optional(),
+});
+
+export type LearnParams = z.infer<typeof learnSchema>;
+
+/**
+ * Orchestrating "learn" tool: persists a lesson to long-term memory and,
+ * given a `skill` payload, mints/enhances a managed skill via the shared
+ * `writeManagedSkill` primitive. Gated behind `autolearn.enabled` plus a live
+ * memory backend — `hindsight`/`mnemopi` (remote/SQLite) or `local` (the
+ * file-based rollout backend, where lessons append to `learned.md`).
+ */
+export class LearnTool implements AgentTool<typeof learnSchema> {
+	readonly name = "learn";
+	readonly approval = (args: unknown) =>
+		(args as Partial<LearnParams>).skill || this.session.settings.get("memory.backend") === "local"
+			? "write"
+			: "read";
+	readonly label = "Learn";
+	readonly description = learnDescription;
+	readonly parameters = learnSchema;
+	readonly strict = true;
+	readonly loadMode = "essential" as const;
+	readonly summary = "Capture a reusable lesson to memory (and optionally a managed skill)";
+
+	constructor(private readonly session: ToolSession) {}
+
+	static createIf(session: ToolSession): LearnTool | null {
+		if (!session.settings.get("autolearn.enabled")) return null;
+		const backend = session.settings.get("memory.backend");
+		if (backend !== "hindsight" && backend !== "mnemopi" && backend !== "local") return null;
+		return new LearnTool(session);
+	}
+
+	async execute(_id: string, params: LearnParams): Promise<AgentToolResult> {
+		// 1) Persist or queue the lesson to long-term memory (mirrors MemoryRetainTool).
+		const backend = this.session.settings.get("memory.backend");
+		let memoryMessage = "Lesson stored";
+		if (backend === "mnemopi") {
+			const state = this.session.getMnemopiSessionState?.();
+			if (!state) {
+				throw new Error("Mnemopi backend is not initialised for this session.");
+			}
+			const id = state.rememberScoped(params.memory, {
+				source: "coding-agent-learn",
+				importance: 0.8,
+				metadata: {
+					session_id: state.sessionId,
+					cwd: state.session.sessionManager.getCwd(),
+					context: params.context ?? null,
+					tool: "learn",
+				},
+				scope: "bank",
+				extract: true,
+				extractEntities: true,
+				veracity: "tool",
+				memoryType: "fact",
+			});
+			// rememberScoped returns undefined when the retain failed (closed DB /
+			// disk error); mirror mnemopiBackend.save and fail loudly rather than
+			// reporting (and minting a skill for) a lesson that was silently dropped.
+			if (!id) {
+				throw new Error("Mnemopi did not store the lesson (no memory id returned).");
+			}
+		} else if (backend === "local") {
+			const result = await localBackend.save?.(
+				{ agentDir: this.session.settings.getAgentDir(), cwd: this.session.settings.getCwd() },
+				{ content: params.memory, context: params.context, source: "coding-agent-learn", importance: 0.8 },
+			);
+			if (!result || result.stored === 0) {
+				throw new Error("Lesson was empty after sanitization; nothing stored.");
+			}
+		} else {
+			const state = this.session.getHindsightSessionState?.();
+			if (!state) {
+				throw new Error("Hindsight backend is not initialised for this session.");
+			}
+			state.enqueueRetain(params.memory, params.context);
+			memoryMessage = "Lesson queued for retention";
+		}
+
+		// 2) Optionally mint/enhance a managed skill. A failure here is surfaced
+		// as a partial outcome — the lesson is already stored or queued.
+		if (params.skill) {
+			// A managed skill resolves below any authored skill of the same name, so
+			// minting one under a claimed name writes a file that never surfaces. The
+			// lesson is already stored/queued; refuse the skill rather than report a
+			// false "Created" (mirrors ManageSkillTool).
+			let safeSkillName: string | undefined;
+			try {
+				safeSkillName = sanitizeSkillName(params.skill.name);
+			} catch {
+				safeSkillName = undefined;
+			}
+			if (params.skill.action === "create" && safeSkillName && isNameClaimedByAuthoredSkill(safeSkillName)) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: `${memoryMessage}. Did not create managed skill "${params.skill.name}": an authored skill of that name already exists, and managed skills cannot override authored ones. Choose a different name.`,
+						},
+					],
+					isError: true,
+					details: { skill: null, shadowed: true },
+				};
+			}
+			try {
+				await writeManagedSkill(params.skill);
+			} catch (err) {
+				const reason = err instanceof Error ? err.message : String(err);
+				throw new Error(`${memoryMessage}, but the managed skill could not be written: ${reason}`);
+			}
+			const verb = params.skill.action === "create" ? "Created" : "Updated";
+			return {
+				content: [{ type: "text", text: `${memoryMessage}. ${verb} managed skill "${params.skill.name}".` }],
+				details: { skill: params.skill.name },
+			};
+		}
+
+		return {
+			content: [{ type: "text", text: `${memoryMessage}.` }],
+			details: { skill: null },
+		};
+	}
+}

package/src/tools/manage-skill.ts

@@ -0,0 +1,104 @@
+import * as path from "node:path";
+import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
+import { z } from "zod/v4";
+import {
+	deleteManagedSkill,
+	getManagedSkillsDir,
+	sanitizeSkillName,
+	writeManagedSkill,
+} from "../autolearn/managed-skills";
+import { isNameClaimedByAuthoredSkill } from "../extensibility/skills";
+import manageSkillDescription from "../prompts/tools/manage-skill.md" with { type: "text" };
+import type { ToolSession } from ".";
+
+const manageSkillSchema = z
+	.object({
+		action: z.enum(["create", "update", "delete"]),
+		name: z.string().describe("kebab-case skill name"),
+		description: z
+			.string()
+			.describe("one-line description of when to use the skill (required for create/update)")
+			.optional(),
+		body: z
+			.string()
+			.describe("the SKILL.md body in markdown, no frontmatter (required for create/update)")
+			.optional(),
+	})
+	// Enforce the action/field contract at validation time rather than only in
+	// execute. Kept as a cross-field refine (not a discriminated union) so the
+	// wire schema stays a single root object — strict structured-output mode and
+	// the Anthropic tool-schema builder both require that.
+	.refine(p => p.action === "delete" || (p.description !== undefined && p.body !== undefined), {
+		message: '"create" and "update" require both "description" and "body".',
+		path: ["description"],
+	});
+
+export type ManageSkillParams = z.infer<typeof manageSkillSchema>;
+
+/**
+ * Direct create/update/delete of isolated managed skills. Gated behind
+ * `autolearn.enabled`; backend-independent (the skill side is standalone).
+ */
+export class ManageSkillTool implements AgentTool<typeof manageSkillSchema> {
+	readonly name = "manage_skill";
+	readonly approval = "write" as const;
+	readonly label = "Manage Skill";
+	readonly description = manageSkillDescription;
+	readonly parameters = manageSkillSchema;
+	readonly strict = true;
+	readonly loadMode = "essential" as const;
+	readonly summary = "Create, update, or delete an isolated managed skill";
+
+	// No session state needed: createIf reads settings; writes target the
+	// home-based managed-skills dir directly.
+	static createIf(session: ToolSession): ManageSkillTool | null {
+		if (!session.settings.get("autolearn.enabled")) return null;
+		return new ManageSkillTool();
+	}
+
+	async execute(_id: string, params: ManageSkillParams): Promise<AgentToolResult> {
+		if (params.action === "delete") {
+			await deleteManagedSkill(params.name);
+			return {
+				content: [{ type: "text", text: `Deleted managed skill "${params.name}".` }],
+				details: { action: "delete", name: params.name },
+			};
+		}
+
+		// Defensive narrowing: the schema refine already rejects create/update
+		// without both fields, so this is unreachable for valid input — it only
+		// proves the strings are present to `writeManagedSkill`'s typed contract.
+		if (!params.description || !params.body) {
+			throw new Error(`"${params.action}" requires both "description" and "body".`);
+		}
+		// A managed skill resolves below any authored skill of the same name
+		// (authored always wins in discovery), so creating one under a name an
+		// authored skill already claims writes a file that never surfaces. Refuse
+		// up front rather than report a false "Created". `sanitizeSkillName`
+		// normalizes to the on-disk name the discovery scan compares against.
+		if (params.action === "create" && isNameClaimedByAuthoredSkill(sanitizeSkillName(params.name))) {
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Cannot create managed skill "${params.name}": an authored skill of that name already exists, and managed skills cannot override authored ones. Choose a different name.`,
+					},
+				],
+				isError: true,
+				details: { action: "create", name: params.name, shadowed: true },
+			};
+		}
+		const { path: skillPath } = await writeManagedSkill({
+			action: params.action,
+			name: params.name,
+			description: params.description,
+			body: params.body,
+		});
+		const relativePath = path.relative(getManagedSkillsDir(), skillPath);
+		const verb = params.action === "create" ? "Created" : "Updated";
+		return {
+			content: [{ type: "text", text: `${verb} managed skill "${params.name}" (managed-skills/${relativePath}).` }],
+			details: { action: params.action, name: params.name },
+		};
+	}
+}

package/src/tools/memory-edit.ts

@@ -1,5 +1,5 @@
 import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import memoryEditDescription from "../prompts/tools/memory-edit.md" with { type: "text" };
 import type { ToolSession } from ".";
 
@@ -21,20 +21,20 @@ export class MemoryEditTool implements AgentTool<typeof memoryEditSchema> {
 	readonly parameters = memoryEditSchema;
 	readonly strict = true;
 	readonly loadMode = "discoverable";
-	readonly summary = "Update, forget, or invalidate Prometheus Memory memories";
+	readonly summary = "Update, forget, or invalidate Mnemopi memories";
 
 	constructor(private readonly session: ToolSession) {}
 
 	static createIf(session: ToolSession): MemoryEditTool | null {
 		const backend = session.settings.get("memory.backend");
-		if (backend !== "prometheus-memory") return null;
+		if (backend !== "mnemopi") return null;
 		return new MemoryEditTool(session);
 	}
 
 	async execute(_id: string, params: MemoryEditParams): Promise<AgentToolResult> {
 		const state = this.session.getMnemopiSessionState?.();
 		if (!state) {
-			throw new Error("Prometheus Memory backend is not initialised for this session.");
+			throw new Error("Mnemopi backend is not initialised for this session.");
 		}
 		if (params.op === "update" && params.content === undefined && params.importance === undefined) {
 			throw new Error("memory_edit update requires content or importance.");

package/src/tools/memory-recall.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
 import { logger, untilAborted } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { formatCurrentTime, formatMemories } from "../hindsight/content";
 import recallDescription from "../prompts/tools/recall.md" with { type: "text" };
 import type { ToolSession } from ".";
@@ -25,17 +25,17 @@ export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
 
 	static createIf(session: ToolSession): MemoryRecallTool | null {
 		const backend = session.settings.get("memory.backend");
-		if (backend !== "hindsight" && backend !== "prometheus-memory") return null;
+		if (backend !== "hindsight" && backend !== "mnemopi") return null;
 		return new MemoryRecallTool(session);
 	}
 
 	async execute(_id: string, params: MemoryRecallParams, signal?: AbortSignal): Promise<AgentToolResult> {
 		return untilAborted(signal, async () => {
 			const backend = this.session.settings.get("memory.backend");
-			if (backend === "prometheus-memory") {
+			if (backend === "mnemopi") {
 				const state = this.session.getMnemopiSessionState?.();
 				if (!state) {
-					throw new Error("Prometheus Memory backend is not initialised for this session.");
+					throw new Error("Mnemopi backend is not initialised for this session.");
 				}
 				try {
 					const results = await state.recallResultsScoped(params.query);
@@ -43,6 +43,7 @@ export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
 						return {
 							content: [{ type: "text", text: "No relevant memories found." }],
 							details: {},
+							useless: true,
 						};
 					}
 					const formatted = state.formatScopedRecallWithIds(results);
@@ -56,11 +57,7 @@ export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
 						details: {},
 					};
 				} catch (err) {
-					logger.warn("recall failed", {
-						backend: "prometheus-memory",
-						bank: state.config.bank,
-						error: String(err),
-					});
+					logger.warn("recall failed", { backend: "mnemopi", bank: state.config.bank, error: String(err) });
 					throw err instanceof Error ? err : new Error(String(err));
 				}
 			}
@@ -83,6 +80,7 @@ export class MemoryRecallTool implements AgentTool<typeof memoryRecallSchema> {
 					return {
 						content: [{ type: "text", text: "No relevant memories found." }],
 						details: {},
+						useless: true,
 					};
 				}
 				const formatted = formatMemories(results);

package/src/tools/memory-reflect.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolResult } from "@prometheus-ai/agent-core";
 import { logger, untilAborted } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { ensureBankExists } from "../hindsight/bank";
 import reflectDescription from "../prompts/tools/reflect.md" with { type: "text" };
 import type { ToolSession } from ".";
@@ -26,17 +26,17 @@ export class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema>
 
 	static createIf(session: ToolSession): MemoryReflectTool | null {
 		const backend = session.settings.get("memory.backend");
-		if (backend !== "hindsight" && backend !== "prometheus-memory") return null;
+		if (backend !== "hindsight" && backend !== "mnemopi") return null;
 		return new MemoryReflectTool(session);
 	}
 
 	async execute(_id: string, params: MemoryReflectParams, signal?: AbortSignal): Promise<AgentToolResult> {
 		return untilAborted(signal, async () => {
 			const backend = this.session.settings.get("memory.backend");
-			if (backend === "prometheus-memory") {
+			if (backend === "mnemopi") {
 				const state = this.session.getMnemopiSessionState?.();
 				if (!state) {
-					throw new Error("Prometheus Memory backend is not initialised for this session.");
+					throw new Error("Mnemopi backend is not initialised for this session.");
 				}
 
 				try {
@@ -56,11 +56,7 @@ export class MemoryReflectTool implements AgentTool<typeof memoryReflectSchema>
 						details: {},
 					};
 				} catch (err) {
-					logger.warn("reflect failed", {
-						backend: "prometheus-memory",
-						bank: state.config.bank,
-						error: String(err),
-					});
+					logger.warn("reflect failed", { backend: "mnemopi", bank: state.config.bank, error: String(err) });
 					throw err instanceof Error ? err : new Error(String(err));
 				}
 			}