@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/extensibility/skills.ts

@@ -1,6 +1,11 @@
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import { getProjectDir } from "@prometheus-ai/utils";
+import {
+	isValidManagedSkillName,
+	MANAGED_SKILLS_PROVIDER_ID,
+	sanitizeManagedDescription,
+} from "../autolearn/managed-skills";
 import { skillCapability } from "../capability/skill";
 import type { SourceMeta } from "../capability/types";
 import type { SkillsSettings } from "../config/settings";
@@ -54,6 +59,26 @@ export function resetActiveSkillsForTests(): void {
 	activeSkills = [];
 }
 
+/**
+ * Whether `name` is already claimed by an active authored (non-managed) skill.
+ *
+ * Managed (auto-learn) skills resolve dead-last in discovery, so an authored
+ * skill of the same name always wins (see `loadSkills`) and a managed skill
+ * written under an authored name is silently dropped — it never surfaces.
+ * `manage_skill` create consults this to refuse the write up front instead of
+ * reporting a false "Created" for a skill that can never appear.
+ */
+export function isNameClaimedByAuthoredSkill(name: string): boolean {
+	return getActiveSkills().some(
+		skill =>
+			skillNameKey(skill.name) === skillNameKey(name) && skill._source?.provider !== MANAGED_SKILLS_PROVIDER_ID,
+	);
+}
+
+function skillNameKey(name: string): string {
+	return name.trim().toLowerCase();
+}
+
 export interface LoadSkillsFromDirOptions {
 	/** Directory to scan for skills */
 	dir: string;
@@ -105,31 +130,45 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 		enableCodexUser = true,
 		enableClaudeUser = true,
 		enableClaudeProject = true,
+		enablePiUser = true,
+		enablePiProject = true,
+		enableAgentsUser = true,
+		enableAgentsProject = true,
 		customDirectories = [],
 		ignoredSkills = [],
 		includeSkills = [],
 		disabledExtensions = [],
 	} = options;
-	const enablePrometheusUser = options.enablePrometheusUser ?? true;
-	const enablePrometheusProject = options.enablePrometheusProject ?? true;
 
 	// Early return if skills are disabled
 	if (!enabled) {
 		return { skills: [], warnings: [] };
 	}
+	// Fall-through gate for third-party CLI providers (claude-plugins, opencode,
+	// gemini, github, ...) that share user intent with the named third-party
+	// source toggles but don't have a dedicated control of their own. Only the
+	// third-party toggles count here: the Prometheus-native providers (`agents`,
+	// `native`) get explicit branches in `isSourceEnabled` below, so folding
+	// them into the fallback would re-enable unrelated third-party CLIs whenever
+	// the user kept the default `.agent[s]/skills` toggles on while turning off
+	// Codex/Claude/Pi (issue #2401 / PR #2405 review).
+	const anyThirdPartySkillToggleEnabled =
+		enableCodexUser || enableClaudeUser || enableClaudeProject || enablePiUser || enablePiProject;
 
-	const anyBuiltInSkillSourceEnabled =
-		enableCodexUser || enableClaudeUser || enableClaudeProject || enablePrometheusUser || enablePrometheusProject;
-	// Helper to check if a source is enabled
 	function isSourceEnabled(source: SourceMeta): boolean {
 		const { provider, level } = source;
+		// Managed skills (auto-learn) are Prometheus-native and discovered unconditionally
+		// — third-party CLI toggles must never silently hide them (cf. #2401). The
+		// master `enabled` flag above still gates them.
+		if (provider === MANAGED_SKILLS_PROVIDER_ID) return true;
 		if (provider === "codex" && level === "user") return enableCodexUser;
 		if (provider === "claude" && level === "user") return enableClaudeUser;
 		if (provider === "claude" && level === "project") return enableClaudeProject;
-		if (provider === "native" && level === "user") return enablePrometheusUser;
-		if (provider === "native" && level === "project") return enablePrometheusProject;
-		// For other providers (agents, claude-plugins, etc.), treat them as built-in skill sources.
-		return anyBuiltInSkillSourceEnabled;
+		if (provider === "native" && level === "user") return enablePiUser;
+		if (provider === "native" && level === "project") return enablePiProject;
+		if (provider === "agents" && level === "user") return enableAgentsUser;
+		if (provider === "agents" && level === "project") return enableAgentsProject;
+		return anyThirdPartySkillToggleEnabled;
 	}
 
 	// Use capability API to load all skills
@@ -162,6 +201,15 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 		if (!matchesIncludePatterns(capSkill.name)) return false;
 		return true;
 	});
+	const enabledAuthoredSkillNames = new Set<string>();
+	for (const capSkill of result.all) {
+		if (capSkill._source.provider === MANAGED_SKILLS_PROVIDER_ID) continue;
+		if (disabledSkillNames.has(capSkill.name)) continue;
+		if (!isSourceEnabled(capSkill._source)) continue;
+		if (matchesIgnorePatterns(capSkill.name)) continue;
+		if (!matchesIncludePatterns(capSkill.name)) continue;
+		enabledAuthoredSkillNames.add(skillNameKey(capSkill.name));
+	}
 
 	// Batch resolve all real paths in parallel
 	const realPaths = await Promise.all(
@@ -177,6 +225,9 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	// Process skills with resolved paths
 	for (let i = 0; i < filteredSkills.length; i++) {
 		const capSkill = filteredSkills[i];
+		// Managed (auto-learn) skills are resolved dead-last (below) so any
+		// authored skill of the same name — from ANY provider or custom dir — wins.
+		if (capSkill._source.provider === MANAGED_SKILLS_PROVIDER_ID) continue;
 		const resolvedPath = realPaths[i];
 
 		// Skip silently if we've already loaded this exact file (via symlink)
@@ -256,6 +307,7 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	for (let i = 0; i < allCustomSkills.length; i++) {
 		const { skill } = allCustomSkills[i];
 		const resolvedPath = customRealPaths[i];
+		enabledAuthoredSkillNames.add(skillNameKey(skill.name));
 		if (realPathSet.has(resolvedPath)) continue;
 
 		const existing = skillMap.get(skill.name);
@@ -270,6 +322,58 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 		}
 	}
 
+	// Managed (auto-learn) skills resolve dead-last with first-wins. Source from
+	// result.all (pre-dedup): capability-level dedup runs BEFORE isSourceEnabled,
+	// so a managed skill can be shadowed by a higher-priority authored skill that
+	// is itself disabled here — managed must stay visible regardless of toggles.
+	// Validate the on-disk name (a hand-placed managed file could carry an unsafe
+	// frontmatter name) and re-sanitize the description on read. Descriptions and
+	// names both render unescaped into the system prompt.
+	const managedCandidates = result.all.filter(
+		capSkill =>
+			capSkill._source.provider === MANAGED_SKILLS_PROVIDER_ID &&
+			isValidManagedSkillName(capSkill.name) &&
+			!disabledSkillNames.has(capSkill.name) &&
+			!matchesIgnorePatterns(capSkill.name) &&
+			matchesIncludePatterns(capSkill.name),
+	);
+	// Names claimed by any ENABLED authored skill (from the pre-dedup superset).
+	// Managed defers to these even when capability dedup hid an enabled authored
+	// skill behind a disabled higher-priority one, so managed never masks it.
+	const managedRealPaths = await Promise.all(
+		managedCandidates.map(async capSkill => {
+			try {
+				return await fs.realpath(capSkill.path);
+			} catch {
+				return capSkill.path;
+			}
+		}),
+	);
+	for (let i = 0; i < managedCandidates.length; i++) {
+		const capSkill = managedCandidates[i];
+		const resolvedPath = managedRealPaths[i];
+		if (realPathSet.has(resolvedPath)) continue;
+		if (enabledAuthoredSkillNames.has(skillNameKey(capSkill.name))) continue; // an enabled authored skill owns this name
+		// Already claimed — e.g. by a custom-directory skill. LOAD-BEARING: custom
+		// dirs also populate `enabledAuthoredSkillNames` above; this map check is
+		// the final veto that lets an authored skill win over a same-named managed one.
+		// The custom-dir loop (which populates
+		// skillMap, ~30 lines up) MUST run before this block — do not reorder.
+		if (skillMap.has(capSkill.name)) continue;
+		const rawDescription =
+			typeof capSkill.frontmatter?.description === "string" ? capSkill.frontmatter.description : "";
+		skillMap.set(capSkill.name, {
+			name: capSkill.name,
+			description: sanitizeManagedDescription(rawDescription),
+			filePath: capSkill.path,
+			baseDir: capSkill.path.replace(/[\\/]SKILL\.md$/, ""),
+			source: `${capSkill._source.provider}:${capSkill.level}`,
+			hide: capSkill.frontmatter?.hide === true || capSkill.frontmatter?.disableModelInvocation === true,
+			_source: capSkill._source,
+		});
+		realPathSet.add(resolvedPath);
+	}
+
 	const skills = Array.from(skillMap.values());
 	// Deterministic ordering for prompt stability (case-insensitive, then exact name, then path).
 	skills.sort((a, b) => compareSkillOrder(a.name, a.filePath, b.name, b.filePath));

package/src/extensibility/slash-commands.ts

@@ -1,14 +1,8 @@
-import type { AutocompleteItem } from "@prometheus-ai/tui";
 import { parseFrontmatter, prompt } from "@prometheus-ai/utils";
 import { slashCommandCapability } from "../capability/slash-command";
 import { appendInlineArgsFallback, templateUsesInlineArgPlaceholders } from "../config/prompt-templates";
 import type { SlashCommand } from "../discovery";
 import { loadCapability } from "../discovery";
-import {
-	BUILTIN_SLASH_COMMAND_DEFS,
-	type BuiltinSlashCommand,
-	type SubcommandDef,
-} from "../slash-commands/builtin-registry";
 import { EMBEDDED_COMMAND_TEMPLATES } from "../task/commands";
 import { parseCommandArgs, substituteArgs } from "../utils/command-args";
 
@@ -24,97 +18,7 @@ export interface SlashCommandInfo {
 	path?: string;
 }
 
-export type { BuiltinSlashCommand, SubcommandDef } from "../slash-commands/builtin-registry";
-
-/**
- * Build getArgumentCompletions from declarative subcommand definitions.
- * Returns subcommand names filtered by prefix in the dropdown.
- */
-function buildArgumentCompletions(subcommands: SubcommandDef[]): (prefix: string) => AutocompleteItem[] | null {
-	return (argumentPrefix: string) => {
-		if (argumentPrefix.includes(" ")) return null; // past the subcommand
-		const lower = argumentPrefix.toLowerCase();
-		const matches = subcommands
-			.filter(s => s.name.startsWith(lower))
-			.map(s => ({
-				value: `${s.name} `,
-				label: s.name,
-				description: s.description,
-				hint: s.usage,
-			}));
-		return matches.length > 0 ? matches : null;
-	};
-}
-
-/**
- * Build getInlineHint from declarative subcommand definitions.
- * Shows remaining completion + usage as dim ghost text after cursor.
- */
-function buildSubcommandInlineHint(subcommands: SubcommandDef[]): (argumentText: string) => string | null {
-	return (argumentText: string) => {
-		const trimmed = argumentText.trimStart();
-		const spaceIndex = trimmed.indexOf(" ");
-
-		if (spaceIndex === -1) {
-			// Still typing subcommand name — show remaining chars + usage
-			const prefix = trimmed.toLowerCase();
-			if (prefix.length === 0) return null;
-			const match = subcommands.find(s => s.name.startsWith(prefix));
-			if (!match) return null;
-			const remaining = match.name.slice(prefix.length);
-			return remaining + (match.usage ? ` ${match.usage}` : "");
-		}
-
-		// Subcommand typed — show remaining usage params
-		const subName = trimmed.slice(0, spaceIndex).toLowerCase();
-		const afterSub = trimmed.slice(spaceIndex + 1);
-		const sub = subcommands.find(s => s.name === subName);
-		if (!sub?.usage) return null;
-
-		if (afterSub.length > 0) {
-			const usageParts = sub.usage.split(" ");
-			const inputParts = afterSub.trim().split(/\s+/);
-			const remaining = usageParts.slice(inputParts.length);
-			return remaining.length > 0 ? remaining.join(" ") : null;
-		}
-
-		return sub.usage;
-	};
-}
-
-/**
- * Build getInlineHint for commands with a simple static hint string.
- * Shows the hint only when no arguments have been typed yet.
- */
-function buildStaticInlineHint(hint: string): (argumentText: string) => string | null {
-	return (argumentText: string) => (argumentText.trim().length === 0 ? hint : null);
-}
-
-/**
- * Materialized builtin slash commands with completion functions derived from
- * declarative subcommand/hint definitions.
- */
-export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<
-	BuiltinSlashCommand & {
-		getArgumentCompletions?: (prefix: string) => AutocompleteItem[] | null;
-		getInlineHint?: (argumentText: string) => string | null;
-	}
-> = BUILTIN_SLASH_COMMAND_DEFS.map(cmd => {
-	if (cmd.subcommands) {
-		return {
-			...cmd,
-			getArgumentCompletions: buildArgumentCompletions(cmd.subcommands),
-			getInlineHint: buildSubcommandInlineHint(cmd.subcommands),
-		};
-	}
-	if (cmd.inlineHint) {
-		return {
-			...cmd,
-			getInlineHint: buildStaticInlineHint(cmd.inlineHint),
-		};
-	}
-	return cmd;
-});
+export type { BuiltinSlashCommand, SubcommandDef } from "../slash-commands/types";
 
 /**
  * Represents a custom slash command loaded from a file

package/src/goals/guided-setup.ts

@@ -0,0 +1,133 @@
+import { instrumentedCompleteSimple, resolveTelemetry } from "@prometheus-ai/agent-core";
+import type { Tool } from "@prometheus-ai/ai";
+import { prompt } from "@prometheus-ai/utils";
+import { extractTextContent, extractToolCall, parseJsonPayload } from "../commit/utils";
+import guidedGoalInterviewPrompt from "../prompts/goals/guided-goal-interview.md" with { type: "text" };
+import guidedGoalSystemPrompt from "../prompts/goals/guided-goal-system.md" with { type: "text" };
+import type { AgentSession } from "../session/agent-session";
+import { toReasoningEffort } from "../thinking";
+
+const RESPOND_TOOL_NAME = "respond";
+
+const RESPOND_TOOL: Tool = {
+	name: RESPOND_TOOL_NAME,
+	description: "Return the next guided-goal interview step.",
+	parameters: {
+		type: "object",
+		properties: {
+			kind: { type: "string", enum: ["question", "ready"] },
+			question: { type: "string" },
+			objective: { type: "string" },
+		},
+		required: ["kind"],
+		additionalProperties: false,
+	},
+	strict: false,
+};
+
+export interface GuidedGoalMessage {
+	role: "user" | "assistant";
+	content: string;
+}
+
+export type GuidedGoalTurnResult =
+	| { kind: "question"; question: string; objective?: string }
+	| { kind: "ready"; objective: string };
+
+export interface GuidedGoalTurnOptions {
+	messages: readonly GuidedGoalMessage[];
+	signal?: AbortSignal;
+}
+
+function parseGuidedGoalPayload(value: unknown): GuidedGoalTurnResult {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		throw new Error("guided goal returned an invalid response");
+	}
+	const payload = value as Record<string, unknown>;
+	if (payload.kind === "question" && typeof payload.question === "string" && payload.question.trim()) {
+		const question = payload.question.trim();
+		if (typeof payload.objective === "string" && payload.objective.trim()) {
+			return { kind: "question", question, objective: payload.objective.trim() };
+		}
+		return { kind: "question", question };
+	}
+	if (payload.kind === "ready" && typeof payload.objective === "string" && payload.objective.trim()) {
+		return { kind: "ready", objective: payload.objective.trim() };
+	}
+	throw new Error("guided goal returned an invalid response");
+}
+
+function parseToolArguments(value: unknown): unknown {
+	return typeof value === "string" ? parseJsonPayload(value) : value;
+}
+
+export async function runGuidedGoalTurn(
+	session: AgentSession,
+	options: GuidedGoalTurnOptions,
+): Promise<GuidedGoalTurnResult> {
+	const plan = session.resolveRoleModelWithThinking("plan");
+	const resolved = plan.model ? plan : session.resolveRoleModelWithThinking("slow");
+	if (!resolved.model) {
+		throw new Error("No plan or slow model is available for /guided-goal.");
+	}
+
+	const apiKey = await session.modelRegistry.getApiKey(resolved.model, session.sessionId);
+	if (!apiKey) {
+		throw new Error(`No API key for ${resolved.model.provider}/${resolved.model.id}`);
+	}
+
+	const userPrompt = prompt.render(guidedGoalInterviewPrompt, {
+		messages: options.messages.map(message => ({ label: message.role.toUpperCase(), content: message.content })),
+	});
+	// Secret obfuscation: route the user-authored transcript through the session obfuscator the
+	// same way normal turns do, so an API key / secret typed into the rough goal or an answer is
+	// never sent verbatim to the plan/slow provider. Deobfuscated again below before display/use.
+	const obfuscator = session.obfuscator;
+	const promptText = obfuscator?.hasSecrets() ? obfuscator.obfuscate(userPrompt) : userPrompt;
+	const response = await instrumentedCompleteSimple(
+		resolved.model,
+		{
+			systemPrompt: [prompt.render(guidedGoalSystemPrompt)],
+			messages: [{ role: "user", content: [{ type: "text", text: promptText }], timestamp: Date.now() }],
+			tools: [RESPOND_TOOL],
+		},
+		{
+			apiKey: session.modelRegistry.resolver(resolved.model, session.sessionId),
+			signal: options.signal,
+			reasoning: toReasoningEffort(resolved.thinkingLevel),
+			toolChoice: { type: "tool", name: RESPOND_TOOL_NAME },
+		},
+		{ telemetry: resolveTelemetry(session.agent.telemetry, session.sessionId), oneshotKind: "guided_goal_setup" },
+	);
+
+	if (response.stopReason === "error") {
+		throw new Error(response.errorMessage ?? "guided goal request failed");
+	}
+	if (response.stopReason === "aborted") {
+		throw new Error("guided goal request aborted");
+	}
+
+	const call = extractToolCall(response, RESPOND_TOOL_NAME);
+	let result: GuidedGoalTurnResult;
+	if (call) {
+		result = parseGuidedGoalPayload(parseToolArguments(call.arguments));
+	} else {
+		const text = extractTextContent(response);
+		if (!text) {
+			throw new Error("guided goal returned an invalid response");
+		}
+		result = parseGuidedGoalPayload(parseJsonPayload(text));
+	}
+
+	// Reverse the obfuscation: restore any secret placeholders the model echoed back before the
+	// question/objective is shown or the goal is started.
+	if (!obfuscator?.hasSecrets()) return result;
+	if (result.kind === "question") {
+		return {
+			kind: "question",
+			question: obfuscator.deobfuscate(result.question),
+			objective: result.objective !== undefined ? obfuscator.deobfuscate(result.objective) : undefined,
+		};
+	}
+	return { kind: "ready", objective: obfuscator.deobfuscate(result.objective) };
+}

package/src/goals/state.ts

@@ -1,4 +1,4 @@
-import type { UsageStatistics } from "../session/session-manager";
+import type { UsageStatistics } from "../session/session-entries";
 
 export type GoalStatus = "active" | "paused" | "budget-limited" | "complete" | "dropped";
 

package/src/goals/tools/goal-tool.ts

@@ -2,15 +2,15 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@prometheus-ai/tui";
 import { Text } from "@prometheus-ai/tui";
 import { formatNumber, prompt } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme, ThemeColor } from "../../modes/theme/theme";
 import goalDescription from "../../prompts/tools/goal.md" with { type: "text" };
 import { formatDuration } from "../../slash-commands/helpers/format";
 import type { ToolSession } from "../../tools";
-import { formatErrorMessage, TRUNCATE_LENGTHS } from "../../tools/render-utils";
+import { formatErrorDetail, TRUNCATE_LENGTHS } from "../../tools/render-utils";
 import { ToolError } from "../../tools/tool-errors";
-import { renderStatusLine, truncateToWidth } from "../../tui";
+import { framedBlock, renderStatusLine, truncateToWidth } from "../../tui";
 import { completionBudgetReport, remainingTokens } from "../runtime";
 import type { Goal, GoalStatus, GoalToolDetails } from "../state";
 
@@ -173,8 +173,7 @@ export const goalToolRenderer = {
 		if (args.op === "create" && args.token_budget !== undefined) {
 			meta.push(`budget ${formatNumber(args.token_budget)}`);
 		}
-		const text = renderStatusLine({ icon: "pending", title: "Goal", description, meta }, uiTheme);
-		return new Text(text, 0, 0);
+		return new Text(renderStatusLine({ icon: "pending", title: "Goal", description, meta }, uiTheme), 0, 0);
 	},
 
 	renderResult(
@@ -190,51 +189,62 @@ export const goalToolRenderer = {
 
 		if (result.isError) {
 			const header = renderStatusLine({ icon: "error", title: "Goal", description }, uiTheme);
-			const body = formatErrorMessage(fallbackText || "Goal tool failed", uiTheme);
-			return new Text([header, body].join("\n"), 0, 0);
+			return framedBlock(uiTheme, width => ({
+				header,
+				sections: [{ lines: formatErrorDetail(fallbackText || "Goal tool failed", uiTheme).split("\n") }],
+				state: "error",
+				borderColor: "error",
+				width,
+			}));
 		}
 
 		const goal = details?.goal ?? null;
 		if (!goal) {
-			const header = renderStatusLine({ icon: "warning", title: "Goal", description }, uiTheme);
-			const body = uiTheme.fg("muted", "No active goal.");
-			return new Text([header, body].join("\n"), 0, 0);
+			return new Text(
+				renderStatusLine({ icon: "warning", title: "Goal", description, meta: ["no active goal"] }, uiTheme),
+				0,
+				0,
+			);
 		}
 
-		const lines: string[] = [];
-		lines.push(
-			renderStatusLine(
-				{
-					icon: "success",
-					title: "Goal",
-					description,
-					badge: { label: goal.status, color: goalBadgeColor(goal.status) },
-				},
-				uiTheme,
-			),
+		const header = renderStatusLine(
+			{
+				iconOverride: uiTheme.styledSymbol("tool.goal", "accent"),
+				title: "Goal",
+				description,
+				badge: { label: goal.status, color: goalBadgeColor(goal.status) },
+			},
+			uiTheme,
 		);
 
+		const lines: string[] = [];
 		const objectiveText = truncateToWidth(goal.objective.trim(), TRUNCATE_LENGTHS.LONG);
-		lines.push(`  ${uiTheme.italic(uiTheme.fg("muted", `"${objectiveText}"`))}`);
+		lines.push(uiTheme.italic(uiTheme.fg("muted", `"${objectiveText}"`)));
 
 		const used = formatNumber(goal.tokensUsed);
 		const tokensLine =
 			goal.tokenBudget !== undefined
 				? `${used} / ${formatNumber(goal.tokenBudget)} tokens (${formatNumber(Math.max(0, goal.tokenBudget - goal.tokensUsed))} left)`
 				: `${used} tokens`;
-		lines.push(`  ${uiTheme.fg("dim", tokensLine)}`);
-
+		const metaParts = [tokensLine];
 		if (goal.timeUsedSeconds > 0) {
-			lines.push(`  ${uiTheme.fg("dim", `${formatDuration(goal.timeUsedSeconds * 1000)} elapsed`)}`);
+			metaParts.push(`${formatDuration(goal.timeUsedSeconds * 1000)} elapsed`);
 		}
+		lines.push(uiTheme.fg("dim", metaParts.join(" · ")));
 
 		const report = details?.completionBudgetReport;
+		const sections: Array<{ label?: string; lines: string[] }> = [{ lines }];
 		if (report) {
-			lines.push("");
-			lines.push(uiTheme.italic(uiTheme.fg("muted", report)));
+			sections.push({ label: "Report", lines: report.split("\n").map(line => uiTheme.fg("muted", line)) });
 		}
 
-		return new Text(lines.join("\n"), 0, 0);
+		return framedBlock(uiTheme, width => ({
+			header,
+			sections,
+			state: "success",
+			borderColor: "borderMuted",
+			width,
+		}));
 	},
 
 	mergeCallAndResult: true,

package/src/hindsight/bank.ts

@@ -22,6 +22,7 @@
 
 import * as path from "node:path";
 import { logger } from "@prometheus-ai/utils";
+import * as git from "../utils/git";
 import type { HindsightApi } from "./client";
 import type { HindsightConfig } from "./config";
 
@@ -53,10 +54,24 @@ function baseBankId(config: HindsightConfig): string {
 	return prefix ? `${prefix}-${base}` : base;
 }
 
-/** Best-effort project label from a working-directory path. */
+/**
+ * Best-effort project label from a working-directory path.
+ *
+ * When `directory` lives inside a git repository we resolve the primary
+ * checkout root (or the shared common dir for bare-repo worktrees) via
+ * {@link git.repo.primaryRootSync} and basename that, so every linked
+ * worktree of one repo shares the same `project:<name>` tag.
+ * Outside a repo (or when resolution fails), fall back to the cwd basename.
+ *
+ * Sync only: this runs on the hot path of `computeBankScope`, which is
+ * exposed as a sync API to callers like `backend.ts` and must stay sync.
+ * `git.repo.primaryRootSync` walks `.git`/`commondir` with sync file reads —
+ * no subprocess — so the cost is one or two `stat`s and a small `readFile`.
+ */
 function projectLabel(directory: string): string {
 	if (!directory) return UNKNOWN_PROJECT;
-	return path.basename(directory) || UNKNOWN_PROJECT;
+	const primary = git.repo.primaryRootSync(directory);
+	return path.basename(primary ?? directory) || UNKNOWN_PROJECT;
 }
 
 /**

package/src/hindsight/client.ts

@@ -10,7 +10,7 @@
 
 import type { HindsightConfig } from "./config";
 
-const USER_AGENT = "prometheus-coding-agent";
+const USER_AGENT = "Prometheus-coding-agent";
 const DEFAULT_USER_AGENT = USER_AGENT;
 
 export type Budget = "low" | "mid" | "high" | string;
@@ -546,7 +546,7 @@ interface BuiltMemoryItem {
 function buildMemoryItem(item: MemoryItemInput): BuiltMemoryItem {
 	const out: BuiltMemoryItem = { content: item.content };
 	if (item.timestamp !== undefined) {
-		out.timestamp = item.timestamp instanceof Date ? item.timestamp.toISOString() : item.timestamp;
+		out.timestamp = item.timestamp instanceof Date ? formatDateWithLocalOffset(item.timestamp) : item.timestamp;
 	}
 	if (item.context !== undefined) out.context = item.context;
 	if (item.metadata !== undefined) out.metadata = item.metadata;
@@ -558,6 +558,31 @@ function buildMemoryItem(item: MemoryItemInput): BuiltMemoryItem {
 	return out;
 }
 
+function formatDateWithLocalOffset(date: Date): string {
+	const offsetMinutes = date.getTimezoneOffset();
+	const offsetSign = offsetMinutes <= 0 ? "+" : "-";
+	const absoluteOffset = Math.abs(offsetMinutes);
+	const offsetHours = Math.floor(absoluteOffset / 60);
+	const offsetRemainderMinutes = absoluteOffset % 60;
+	const milliseconds = date.getMilliseconds();
+	const millisecondsPart = milliseconds === 0 ? "" : `.${pad3(milliseconds)}`;
+	return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}T${pad2(
+		date.getHours(),
+	)}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}${millisecondsPart}${offsetSign}${pad2(
+		offsetHours,
+	)}:${pad2(offsetRemainderMinutes)}`;
+}
+
+function pad2(value: number): string {
+	return value < 10 ? `0${value}` : String(value);
+}
+
+function pad3(value: number): string {
+	if (value < 10) return `00${value}`;
+	if (value < 100) return `0${value}`;
+	return String(value);
+}
+
 function buildQueryString(query: Record<string, unknown>): string {
 	const params = new URLSearchParams();
 	for (const [key, value] of Object.entries(query)) {