jeopi-cli 16.2.13 → 16.2.14

package/src/lsp/config.ts

@@ -336,7 +336,7 @@ function getConfigSources(cwd: string): ConfigSource[] {
 		sources.push(fileConfigSource(path.join(cwd, filename)));
 	}
 
-	// Project config directories (.omp/, .pi/, .claude/)
+	// Project config directories (.jeopi/, .pi/, .claude/)
 	const projectDirs = getConfigDirPaths("", { user: false, project: true, cwd });
 	for (const dir of projectDirs) {
 		for (const filename of filenames) {
@@ -344,7 +344,7 @@ function getConfigSources(cwd: string): ConfigSource[] {
 		}
 	}
 
-	// User config directories (~/.omp/agent/, ~/.pi/agent/, ~/.claude/)
+	// User config directories (~/.jeopi/agent/, ~/.pi/agent/, ~/.claude/)
 	const userDirs = getConfigDirPaths("", { user: true, project: false });
 	for (const dir of userDirs) {
 		for (const filename of filenames) {
@@ -374,8 +374,8 @@ function getConfigSources(cwd: string): ConfigSource[] {
  *
  * Priority (highest to lowest):
  * 1. Project root: lsp.json/.lsp.json/lsp.yml/.lsp.yml/lsp.yaml/.lsp.yaml
- * 2. Project config dirs: .omp/lsp.*, .pi/lsp.*, .claude/lsp.* (+ hidden variants)
- * 3. User config dirs: ~/.omp/agent/lsp.*, ~/.pi/agent/lsp.*, ~/.claude/lsp.* (+ hidden variants)
+ * 2. Project config dirs: .jeopi/lsp.*, .pi/lsp.*, .claude/lsp.* (+ hidden variants)
+ * 3. User config dirs: ~/.jeopi/agent/lsp.*, ~/.pi/agent/lsp.*, ~/.claude/lsp.* (+ hidden variants)
  * 4. User home root: ~/lsp.*, ~/.lsp.*
  * 5. Auto-detect from project markers + available binaries
  *

package/src/lsp/index.ts

@@ -2060,7 +2060,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 		if (action === "reload" && (isWorkspace || !resolvedFile)) {
 			// `reload *` is the user's explicit request to re-read config from
-			// disk. Drop the per-cwd cache entry so `.omp/lsp.json`, root markers,
+			// disk. Drop the per-cwd cache entry so `.jeopi/lsp.json`, root markers,
 			// and plugin configs added after the first LSP call become visible —
 			// otherwise `getConfig` returns the first observation for the rest of
 			// the process lifetime (#3546).

package/src/main.ts

@@ -747,7 +747,7 @@ export async function createSessionManager(
 
 /** Discover SYSTEM.md file if no CLI system prompt was provided */
 function discoverSystemPromptFile(): string | undefined {
-	// Check project-local first (.omp/SYSTEM.md, .pi/SYSTEM.md legacy)
+	// Check project-local first (.jeopi/SYSTEM.md, .pi/SYSTEM.md legacy)
 	const projectPath = findConfigFile("SYSTEM.md", { user: false });
 	if (projectPath) {
 		return projectPath;

package/src/mcp/config-writer.ts

@@ -1,7 +1,7 @@
 /**
  * MCP Configuration File Writer
  *
- * Utilities for reading/writing .omp/mcp.json files at user or project level.
+ * Utilities for reading/writing .jeopi/mcp.json files at user or project level.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -270,7 +270,7 @@ export interface SetMcpServerEnabledOptions {
 	projectPath: string;
 	/**
 	 * Absolute path to the loaded row's source mcp.json. Provide ONLY for
-	 * formats this codebase owns (native `.omp/mcp.json` and `mcp-json`
+	 * formats this codebase owns (native `.jeopi/mcp.json` and `mcp-json`
 	 * `mcp.json`/`.mcp.json`). Tool-owned configs (opencode.json, claude.json,
 	 * settings.json …) MUST be omitted; we never mutate another tool's file.
 	 */

package/src/memories/index.ts

@@ -17,6 +17,7 @@ import readPathTemplate from "../prompts/memories/read-path.md" with { type: "te
 import stageOneInputTemplate from "../prompts/memories/stage_one_input.md" with { type: "text" };
 import stageOneSystemTemplate from "../prompts/memories/stage_one_system.md" with { type: "text" };
 import type { AgentSession } from "../session/agent-session";
+import { okfTimestamp, parseOkfDocument, renderOkfDocument, stripOkfFrontmatter } from "./okf";
 import {
 	claimStage1Jobs,
 	clearMemoryData as clearMemoryDataInDb,
@@ -186,7 +187,7 @@ async function readMemoryToolDeveloperInstructionsSnapshot(
 
 	let summary = "";
 	try {
-		summary = (await Bun.file(path.join(memoryRoot, "memory_summary.md")).text()).trim();
+		summary = stripOkfFrontmatter(await Bun.file(path.join(memoryRoot, "memory_summary.md")).text()).trim();
 	} catch {
 		// Missing or unreadable summary — injection is best-effort; fall through
 		// so any captured lessons still surface on their own.
@@ -790,10 +791,18 @@ async function syncPhase2Artifacts(memoryRoot: string, outputs: Stage1OutputRow[
 		const stem = formatRolloutFilename(row.threadId, row.rolloutSlug);
 		const filename = `${stem}.md`;
 		keepFiles.add(filename);
-		const body = [`thread_id: ${row.threadId}`, `updated_at: ${row.sourceUpdatedAt}`, "", row.rolloutSummary].join(
-			"\n",
+		const document = renderOkfDocument(
+			{
+				type: "Session Summary",
+				title: `Rollout ${stem}`,
+				description: "Summary of one jeopi session rollout, feeding memory consolidation.",
+				tags: ["jeopi", "memory", "rollout"],
+				timestamp: okfTimestamp(row.sourceUpdatedAt),
+				extra: { thread_id: row.threadId, updated_at: row.sourceUpdatedAt },
+			},
+			row.rolloutSummary,
 		);
-		await Bun.write(path.join(summariesDir, filename), `${body.trim()}\n`);
+		await Bun.write(path.join(summariesDir, filename), document);
 	}
 
 	const currentFiles = await fs.readdir(summariesDir).catch(() => [] as string[]);
@@ -804,7 +813,17 @@ async function syncPhase2Artifacts(memoryRoot: string, outputs: Stage1OutputRow[
 	}
 
 	const rawBody = buildRawMemoriesMarkdown(outputs);
-	await Bun.write(path.join(memoryRoot, "raw_memories.md"), rawBody);
+	const rawDocument = renderOkfDocument(
+		{
+			type: "Raw Memories",
+			title: "jeopi Raw Memories",
+			description: "Per-thread raw memory extracts feeding the consolidation pass.",
+			tags: ["jeopi", "memory", "raw"],
+			timestamp: okfTimestamp(),
+		},
+		rawBody,
+	);
+	await Bun.write(path.join(memoryRoot, "raw_memories.md"), rawDocument);
 }
 
 async function cleanupConsolidatedArtifacts(memoryRoot: string): Promise<void> {
@@ -837,7 +856,18 @@ async function readRolloutSummaries(memoryRoot: string): Promise<string> {
 			.text()
 			.catch(() => "");
 		if (!text.trim()) continue;
-		blocks.push(`--- ${name} ---\n${text.trim()}`);
+		// OKF atoms carry thread identity in frontmatter; rebuild the plain
+		// header the consolidation prompt has always seen. Legacy files (no
+		// frontmatter) already carry that header inline and pass verbatim.
+		const { frontmatter, body } = parseOkfDocument(text);
+		const threadId = typeof frontmatter?.thread_id === "string" ? frontmatter.thread_id : undefined;
+		const updatedAt = typeof frontmatter?.updated_at === "number" ? frontmatter.updated_at : undefined;
+		const content =
+			threadId !== undefined
+				? [`thread_id: ${threadId}`, `updated_at: ${updatedAt ?? ""}`, "", body.trim()].join("\n")
+				: body.trim();
+		if (!content.trim()) continue;
+		blocks.push(`--- ${name} ---\n${content.trim()}`);
 	}
 	if (blocks.length === 0) return "No rollout summaries yet.";
 	return blocks.join("\n\n");
@@ -860,7 +890,7 @@ async function runConsolidationModel(options: {
 	}>;
 }> {
 	const { memoryRoot, model, apiKey } = options;
-	const rawMemories = await Bun.file(path.join(memoryRoot, "raw_memories.md")).text();
+	const rawMemories = stripOkfFrontmatter(await Bun.file(path.join(memoryRoot, "raw_memories.md")).text());
 	const rolloutSummaries = await readRolloutSummaries(memoryRoot);
 	const input = prompt.render(consolidationTemplate, {
 		raw_memories: truncateByApproxTokens(rawMemories, 20_000),
@@ -938,8 +968,35 @@ async function applyConsolidation(
 		}>;
 	},
 ): Promise<void> {
-	await Bun.write(path.join(memoryRoot, "MEMORY.md"), `${consolidated.memoryMd.trim()}\n`);
-	await Bun.write(path.join(memoryRoot, "memory_summary.md"), `${consolidated.memorySummary.trim()}\n`);
+	const timestamp = okfTimestamp();
+	await Bun.write(
+		path.join(memoryRoot, "MEMORY.md"),
+		renderOkfDocument(
+			{
+				type: "Memory",
+				title: "jeopi Consolidated Memory",
+				description: "Long-term consolidated memory jeopi maintains for this project.",
+				tags: ["jeopi", "memory", "consolidated"],
+				timestamp,
+			},
+			// The model occasionally emits its own frontmatter; strip it so the
+			// atom never carries a nested fence.
+			stripOkfFrontmatter(consolidated.memoryMd.trim()),
+		),
+	);
+	await Bun.write(
+		path.join(memoryRoot, "memory_summary.md"),
+		renderOkfDocument(
+			{
+				type: "Memory Summary",
+				title: "jeopi Memory Summary",
+				description: "Prompt-time memory guidance injected at jeopi session start.",
+				tags: ["jeopi", "memory", "summary"],
+				timestamp,
+			},
+			stripOkfFrontmatter(consolidated.memorySummary.trim()),
+		),
+	);
 	const skillsDir = path.join(memoryRoot, "skills");
 	await fs.mkdir(skillsDir, { recursive: true });
 	const keep = new Set<string>();
@@ -1341,23 +1398,37 @@ async function appendLearnedLine(filePath: string, line: string): Promise<void>
 	} catch (err) {
 		if (!isEnoent(err)) throw err;
 	}
+	// The `- ` filter keeps only lesson lines, so a legacy file (no
+	// frontmatter) and an OKF atom (frontmatter re-rendered below) both fold
+	// into the same newest-first list.
 	const prior = existing
 		.split("\n")
 		.map(l => l.trim())
 		.filter(l => l.startsWith("- ") && l !== line);
 	const lessons = [line, ...prior].slice(0, MAX_LEARNED_LESSONS);
-	await Bun.write(filePath, `${lessons.join("\n")}\n`);
+	const document = renderOkfDocument(
+		{
+			type: "Lessons",
+			title: "jeopi Learned Lessons",
+			description: "Lessons captured via the learn tool, newest first.",
+			tags: ["jeopi", "memory", "lessons"],
+			timestamp: okfTimestamp(),
+		},
+		lessons.join("\n"),
+	);
+	await Bun.write(filePath, document);
 }
 
 /**
  * Read `learned.md`, neutralizing each line on read too — a hand-edited or
  * pre-existing file bypasses write-time normalization and the block renders
  * unescaped into the system prompt. Returns "" when absent/unreadable.
+ * OKF frontmatter is stripped so only lesson lines reach the prompt.
  */
 async function readLearnedLessons(memoryRoot: string): Promise<string> {
 	let raw = "";
 	try {
-		raw = (await Bun.file(path.join(memoryRoot, LEARNED_LESSONS_FILE)).text()).trim();
+		raw = stripOkfFrontmatter(await Bun.file(path.join(memoryRoot, LEARNED_LESSONS_FILE)).text()).trim();
 	} catch {
 		return "";
 	}

package/src/memories/okf.ts

@@ -0,0 +1,129 @@
+/**
+ * Open Knowledge Format (OKF v0.1) support for jeopi memory documents.
+ *
+ * OKF (https://github.com/google/open-knowledge-format — the format jeo-skills'
+ * `okf` skill validates and consumes) stores knowledge atoms as
+ * YAML-frontmatter Markdown: required `type` / `title` / `description`,
+ * optional `resource` / `tags` / `timestamp`. jeopi's local memory backend
+ * writes its artifacts (`MEMORY.md`, `memory_summary.md`, `raw_memories.md`,
+ * `rollout_summaries/*.md`, `learned.md`) as OKF atoms so any OKF consumer can
+ * read a jeopi memory root as a knowledge bundle.
+ *
+ * Prompt-injection read paths strip the frontmatter via
+ * {@link stripOkfFrontmatter} so the model-facing text stays unchanged;
+ * legacy files without frontmatter pass through verbatim.
+ */
+import { YAML } from "bun";
+
+/** OKF v0.1 frontmatter fields. Only `type`/`title`/`description` are required. */
+export interface OkfFields {
+	type: string;
+	title: string;
+	description: string;
+	resource?: string;
+	tags?: readonly string[];
+	/** ISO 8601 datetime, e.g. `2026-07-02T10:00:00Z`. */
+	timestamp?: string;
+	/** Producer-specific extension fields (e.g. `thread_id`). */
+	extra?: Record<string, string | number>;
+}
+
+const FENCE = "---";
+
+function yamlScalar(value: string | number): string {
+	if (typeof value === "number") return String(value);
+	return JSON.stringify(value);
+}
+
+/** Render an OKF atom: YAML frontmatter followed by the markdown body. */
+export function renderOkfDocument(fields: OkfFields, body: string): string {
+	const lines: string[] = [FENCE];
+	lines.push(`type: ${yamlScalar(fields.type)}`);
+	lines.push(`title: ${yamlScalar(fields.title)}`);
+	lines.push(`description: ${yamlScalar(fields.description)}`);
+	if (fields.resource) lines.push(`resource: ${yamlScalar(fields.resource)}`);
+	if (fields.tags?.length) lines.push(`tags: [${fields.tags.join(", ")}]`);
+	if (fields.timestamp) lines.push(`timestamp: ${fields.timestamp}`);
+	for (const [key, value] of Object.entries(fields.extra ?? {})) {
+		lines.push(`${key}: ${yamlScalar(value)}`);
+	}
+	lines.push(FENCE, "");
+	const trimmedBody = body.trim();
+	return trimmedBody ? `${lines.join("\n")}\n${trimmedBody}\n` : `${lines.join("\n")}`;
+}
+
+/** Locate the closing fence line of a leading frontmatter block, or -1. */
+function findFrontmatterEnd(lines: string[]): number {
+	if (lines[0]?.trim() !== FENCE) return -1;
+	for (let index = 1; index < lines.length; index++) {
+		if (lines[index].trim() === FENCE) return index;
+	}
+	return -1;
+}
+
+/** Parsed frontmatter (undefined when absent/unparseable) plus the body. */
+export interface OkfDocumentParts {
+	frontmatter: Record<string, unknown> | undefined;
+	body: string;
+}
+
+/**
+ * Split an OKF document into frontmatter and body. Tolerant by design: text
+ * without a leading fence (legacy jeopi memory files, hand-edited files)
+ * returns the whole text as body with `frontmatter: undefined`, and a
+ * malformed YAML block still strips so prompt paths never leak fences.
+ */
+export function parseOkfDocument(text: string): OkfDocumentParts {
+	const lines = text.split("\n");
+	const end = findFrontmatterEnd(lines);
+	if (end === -1) return { frontmatter: undefined, body: text };
+	const body = lines.slice(end + 1).join("\n");
+	let frontmatter: Record<string, unknown> | undefined;
+	try {
+		const parsed = YAML.parse(lines.slice(1, end).join("\n"));
+		if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+			frontmatter = parsed as Record<string, unknown>;
+		}
+	} catch {
+		// Malformed YAML — treat as fenceless body strip.
+	}
+	return { frontmatter, body };
+}
+
+/** Body of an OKF document with any leading frontmatter removed. */
+export function stripOkfFrontmatter(text: string): string {
+	return parseOkfDocument(text).body;
+}
+
+/**
+ * Validate a document against the OKF v0.1 rules the jeo-skills `okf` linter
+ * enforces: a leading `---` fence, a closing fence, and non-empty
+ * `type` / `title` / `description` fields. Returns an empty array when valid.
+ */
+export function validateOkfDocument(text: string): string[] {
+	const errors: string[] = [];
+	const lines = text.split("\n");
+	if (lines[0]?.trim() !== FENCE) {
+		return ["missing leading frontmatter fence (---)"];
+	}
+	const end = findFrontmatterEnd(lines);
+	if (end === -1) {
+		return ["unclosed frontmatter"];
+	}
+	const { frontmatter } = parseOkfDocument(text);
+	if (!frontmatter) {
+		return ["frontmatter is not a YAML mapping"];
+	}
+	for (const field of ["type", "title", "description"] as const) {
+		const value = frontmatter[field];
+		if (typeof value !== "string" || value.trim() === "") {
+			errors.push(`missing required field '${field}'`);
+		}
+	}
+	return errors;
+}
+
+/** Format a unix-seconds timestamp as the ISO 8601 string OKF expects. */
+export function okfTimestamp(unixSeconds: number = Math.floor(Date.now() / 1000)): string {
+	return new Date(unixSeconds * 1000).toISOString().replace(/\.\d{3}Z$/, "Z");
+}

package/src/modes/components/__tests__/assistant-agent-label.test.ts

@@ -0,0 +1,87 @@
+/**
+ * jeo TUI identity contract: a name label on its own line leads assistant
+ * segments with visible prose (jeo-code's `agentLabel()` ported to jeopi).
+ * Tool-call-only blocks stay unlabeled, and an empty `ui.agentLabel` disables
+ * the label entirely.
+ */
+import { afterEach, beforeAll, describe, expect, it } from "bun:test";
+import type { AssistantMessage } from "jeopi-ai";
+import { Settings } from "../../../config/settings";
+import { getThemeByName, setThemeInstance, type Theme } from "../../theme/theme";
+import { AssistantMessageComponent, setAssistantAgentLabel } from "../assistant-message";
+
+const strip = (lines: readonly string[]): string =>
+	lines
+		.join("\n")
+		.replace(/\x1b\]8;[^\x1b\x07]*(?:\x07|\x1b\\)/g, "")
+		.replace(/\x1b\[[0-9;]*m/g, "");
+
+function assistantMessage(content: AssistantMessage["content"]): AssistantMessage {
+	return {
+		role: "assistant",
+		content,
+		stopReason: "stop",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		timestamp: Date.now(),
+	} as AssistantMessage;
+}
+
+describe("assistant agent label (jeo identity)", () => {
+	let uiTheme: Theme;
+
+	beforeAll(async () => {
+		await Settings.init({ inMemory: true });
+		const loaded = await getThemeByName("dark");
+		if (!loaded) throw new Error("theme unavailable");
+		uiTheme = loaded;
+		setThemeInstance(uiTheme);
+	});
+
+	afterEach(() => {
+		setAssistantAgentLabel("jeo");
+	});
+
+	it("leads a reply with the label on its own line", () => {
+		const component = new AssistantMessageComponent(
+			assistantMessage([{ type: "text", text: "The fix is in place." }]),
+		);
+		const lines = strip(component.render(80)).split("\n");
+		const labelLine = lines.findIndex(line => line.trim() === "jeo");
+		const proseLine = lines.findIndex(line => line.includes("The fix is in place."));
+		expect(labelLine).toBeGreaterThanOrEqual(0);
+		expect(proseLine).toBeGreaterThan(labelLine);
+	});
+
+	it("leads a visible thinking block with the label too", () => {
+		const component = new AssistantMessageComponent(
+			assistantMessage([{ type: "thinking", thinking: "Considering the edge cases first." }]),
+			false,
+		);
+		const text = strip(component.render(80));
+		expect(text).toContain("jeo");
+		expect(text).toContain("Considering the edge cases first.");
+	});
+
+	it("leaves tool-call-only blocks unlabeled", () => {
+		const component = new AssistantMessageComponent(
+			assistantMessage([
+				{ type: "toolCall", id: "call-1", name: "read", arguments: { path: "a.ts" } },
+			] as AssistantMessage["content"]),
+		);
+		expect(strip(component.render(80))).not.toContain("jeo");
+	});
+
+	it("an empty label disables the identity line", () => {
+		setAssistantAgentLabel("");
+		const component = new AssistantMessageComponent(assistantMessage([{ type: "text", text: "Done." }]));
+		const lines = strip(component.render(80)).split("\n");
+		expect(lines.some(line => line.trim() === "jeo")).toBe(false);
+		expect(lines.some(line => line.includes("Done."))).toBe(true);
+	});
+});

package/src/modes/components/assistant-message.ts

@@ -163,6 +163,24 @@ export function resetThinkingSpeedTracker(): void {
 	sharedSpeedTracker.reset();
 }
 
+/**
+ * Agent identity label led on its own line before each assistant segment —
+ * jeo-code's TUI identity ported to jeopi: a bold accent `jeo` name leads
+ * thought blocks and replies so the transcript reads as jeo speaking.
+ * Configured from `ui.agentLabel` at session start; "" disables the label.
+ */
+let assistantAgentLabel = "jeo";
+
+/** Set the assistant identity label ("" disables). Called from interactive-mode startup. */
+export function setAssistantAgentLabel(label: string): void {
+	assistantAgentLabel = label.trim();
+}
+
+/** Current assistant identity label ("" when disabled). */
+export function getAssistantAgentLabel(): string {
+	return assistantAgentLabel;
+}
+
 /**
  * Linear-interpolate two `#rrggbb` colors in sRGB space. `t` clamps to [0,1]:
  * `t = 0` → `from`, `t = 1` → `to`. Drives the streaming speed badge, fading
@@ -728,6 +746,15 @@ export class AssistantMessageComponent extends Container {
 					resolveThinkingDisplay(c, this.proseOnlyThinking).visible),
 		);
 
+		// jeo identity: a bold accent name label on its own line leads every
+		// assistant segment with visible prose or a live thinking pulse —
+		// mirrors jeo-code's TUI (`agentLabel()` leading thought blocks and the
+		// final reply). Tool-call-only blocks stay unlabeled; their cards carry
+		// their own identity.
+		if (assistantAgentLabel && (hasVisibleContent || this.#shouldAnimateThinking(message))) {
+			this.#contentContainer.addChild(new Text(theme.fg("accent", theme.bold(assistantAgentLabel)), 1, 0));
+		}
+
 		// Render content in order
 		let thinkingIndex = 0;
 		for (let i = 0; i < message.content.length; i++) {

package/src/modes/components/extensions/extension-dashboard.ts

@@ -266,7 +266,7 @@ export class ExtensionDashboard implements Component {
 		if (!sm) return;
 
 		// MCP toggles route through the canonical denylist in
-		// `~/.omp/agent/mcp.json` so `/mcp list`, the MCP runtime, and this
+		// `~/.jeopi/agent/mcp.json` so `/mcp list`, the MCP runtime, and this
 		// dashboard agree on every server's enabled state (issue #3827).
 		if (extensionId.startsWith("mcp:")) {
 			void this.#toggleMcpExtension(extensionId, enabled, sm);

package/src/modes/controllers/omfg-controller.ts

@@ -32,8 +32,8 @@ interface GenerateCandidateOptions {
 type SaveCandidateResult = { kind: "saved" | "aborted" | "rejected" } | { kind: "amend"; feedback: string };
 
 const MAX_ATTEMPTS = 3;
-const PROJECT_OPTION = "This project (.omp/rules)";
-const GLOBAL_OPTION = "Global — all projects (~/.omp/agent/rules)";
+const PROJECT_OPTION = "This project (.jeopi/rules)";
+const GLOBAL_OPTION = "Global — all projects (~/.jeopi/agent/rules)";
 const AMEND_OPTION = "Amend with feedback…";
 
 export class OmfgController {

package/src/modes/controllers/ssh-command-controller.ts

@@ -281,7 +281,7 @@ export class SSHCommandController {
 
 			// Show user-level hosts
 			if (userHosts.length > 0) {
-				lines.push(theme.fg("accent", "User level") + theme.fg("muted", ` (~/.omp/agent/ssh.json):`));
+				lines.push(theme.fg("accent", "User level") + theme.fg("muted", ` (~/.jeopi/agent/ssh.json):`));
 				for (const name of userHosts) {
 					const config = userConfig.hosts![name];
 					const details = this.#formatHostDetails(config);
@@ -292,7 +292,7 @@ export class SSHCommandController {
 
 			// Show project-level hosts
 			if (projectHosts.length > 0) {
-				lines.push(theme.fg("accent", "Project level") + theme.fg("muted", ` (.omp/ssh.json):`));
+				lines.push(theme.fg("accent", "Project level") + theme.fg("muted", ` (.jeopi/ssh.json):`));
 				for (const name of projectHosts) {
 					const config = projectConfig.hosts![name];
 					const details = this.#formatHostDetails(config);

package/src/modes/interactive-mode.ts

@@ -122,7 +122,7 @@ import { getEditorCommand, openInEditor } from "../utils/external-editor";
 import { getSessionAccentAnsi, getSessionAccentHex } from "../utils/session-color";
 import { messageHasDisplayableThinking } from "../utils/thinking-display";
 import { popTerminalTitle, pushTerminalTitle, setSessionTerminalTitle } from "../utils/title-generator";
-import type { AssistantMessageComponent } from "./components/assistant-message";
+import { type AssistantMessageComponent, setAssistantAgentLabel } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
 import { ChatBlock, type ChatBlockHost } from "./components/chat-block";
 import { CustomEditor } from "./components/custom-editor";
@@ -677,6 +677,8 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		this.hideThinkingBlock = settings.get("hideThinkingBlock");
 		this.proseOnlyThinking = settings.get("proseOnlyThinking");
+		// jeo TUI identity: the accent name label leading assistant segments.
+		setAssistantAgentLabel(settings.get("ui.agentLabel") ?? "jeo");
 
 		const hookCommands: SlashCommand[] = (
 			this.session.extensionRunner?.getRegisteredCommands(BUILTIN_SLASH_COMMAND_RESERVED_NAMES) ?? []

package/src/prompts/agents/jeo.md

@@ -15,33 +15,43 @@ Crystallize the request into a seed before any planning:
 1. Read the relevant code first so questions are grounded in the repo, not generic.
 2. If the request is ambiguous, ask the user (via `ask`, batched — not one at a time) until you can state: **goal**, **constraints**, **out-of-scope**, and **acceptance criteria**. Acceptance criteria MUST be concrete and mechanically checkable (a command, a test, an observable behavior) — "works well" or "is clean" is not a criterion; push back and sharpen it instead of accepting it.
 3. Freeze the seed: write `local://jeo-seed.md` with those four sections. The seed is immutable for the rest of the run — scope changes require a new interview round, never silent drift.
-4. If the request is already concrete, write the seed directly and say so; do not manufacture interview rounds.
+4. If the request is already concrete, write the seed directly and say so; do not manufacture interview rounds. At most two batched `ask` rounds — if ambiguity survives both, record the residual as an explicit assumption in the seed instead of looping.
 
 ## Phase 2 — Plan
 
-Spawn a `plan` agent with the seed (pass `local://jeo-seed.md` in the assignment). The plan MUST name concrete files, sequencing, and per-criterion verification steps.
+Spawn a `plan` agent with the seed (pass `local://jeo-seed.md` in the assignment — by reference, never inlined). The plan MUST name concrete files, sequencing, and per-criterion verification steps. Persist the returned plan to `local://jeo-plan.md` so the critic and executors read it by reference.
 
-## Phase 3 — Critic gate (blocking)
+## Phase 3 — Critic gate (blocking, runtime-enforced)
 
-Spawn a `critic` agent with the seed and the plan. This gate is real:
+Spawn a `critic` agent with the seed and plan paths. This gate is real — and it is enforced by the runtime, not just this prompt: after a non-okay verdict, the `task` tool refuses to spawn non-read-only agents and `write`/`edit` lock the working tree until a fresh critic returns `okay` (or the user sends a new message).
 
-- `okay` → proceed to Phase 4.
-- `iterate` → feed `required_fixes` back into a revised plan, re-submit to a fresh `critic`. Maximum two iterations; if still not `okay`, stop and report the surviving gaps to the user instead of executing anyway.
+- `okay` → the gate opens; proceed to Phase 4.
+- `iterate` → revise the plan against `required_fixes`, then re-submit to a fresh `critic`. Convergence contract: the revised plan addresses **every** required fix explicitly (or names why one is rejected, with evidence); re-submitting an unchanged plan is prohibited. Maximum two iterations — the runtime closes the loop after three consecutive non-okay verdicts; stop and report the surviving gaps to the user instead of executing anyway.
 - `reject` → stop. Report the disqualifying evidence and return to Phase 1 or ask the user.
 
-You NEVER execute a plan whose latest critic verdict is not `okay`.
+You NEVER execute a plan whose latest critic verdict is not `okay` — and the runtime will not let you.
 
 ## Phase 4 — Execute
 
-Decompose the approved plan into bounded tasks and delegate via `task` (parallel where files are independent, serial where they depend). Each assignment carries: its slice of the plan, the seed's constraints, and the acceptance criterion it serves. Each task is a bounded subgoal — verify one before starting the next; when a task fails, extract what the failure proved and feed that fact into the next attempt's assignment instead of retrying unchanged.
+Decompose the approved plan into bounded tasks and delegate via `task` (parallel where files are independent, serial where they depend). Each assignment carries: its slice of the plan, the seed's constraints, and the acceptance criterion it serves. Each task is a bounded subgoal — verify one before starting the next; when a task fails, extract what the failure proved and feed that fact into the next attempt's assignment instead of retrying unchanged. At most two retries per task; a third failure means the subgoal is mis-scoped — split it or report it, never grind.
 
 ## Phase 5 — Verify (artifact gate)
 
-- Run the repo's real checks once as a global signal (typecheck/tests/build as the repo defines them).
+- Run the repo's real checks once as a global signal (typecheck/tests/build as the repo defines them). Once — a green suite is not re-run for reassurance.
 - Then walk the seed's acceptance criteria one by one: for each, cite the exact command or observation that proves it, and the changed files serving it.
 - A criterion with no supporting artifact is NOT met — mark it `unresolved` with what is missing; never imply success.
 - Optionally spawn `architect` on the final diff for a structural verdict when the change is substantial.
 
+## Loop engineering (token discipline)
+
+Every loop in this pipeline is bounded, converging, and honest about what it dropped:
+
+- **Reference, don't repeat.** The seed and plan live in `local://` files; every assignment and critic submission passes paths, never pasted bodies. One copy of the plan exists per run.
+- **Delta-only iteration.** Each critic re-submission carries a short delta note — which required fix changed what — so the critic re-reads the plan file, not a re-narrated history.
+- **Every round must change state.** A loop iteration that incorporates no new fact (a fix applied, a lesson from a failure, a user answer) is a prohibited no-op retry.
+- **Hard bounds.** Interview ≤2 ask rounds; critic ≤2 iterations (runtime stop at 3 strikes); per-task retries ≤2; suite runs once. When a bound is hit, the loop's exit is a report to the user, not a silent continuation.
+- **No silent caps.** If bounding dropped coverage (a criterion unverified, a subgoal unsplit), name it in the report — silent truncation reads as "covered everything" when it didn't.
+
 ## Report
 
-End with: seed summary, plan verdict history, per-criterion status (met + evidence / unresolved + reason), changed files, and open risks.
+End with: seed summary, plan verdict history (every verdict, in order), per-criterion status (met + evidence / unresolved + reason), changed files, and open risks.

package/src/prompts/system/autolearn-guidance.md

@@ -1,7 +1,7 @@
 ## Auto-Learn (experimental)
 
-You can grow a library of reusable **managed skills** with the `manage_skill` tool. Managed skills are `SKILL.md` files kept in an isolated directory (`~/.omp/agent/managed-skills`); they are surfaced to you in future sessions like any other skill.
+You can grow a library of reusable **managed skills** with the `manage_skill` tool. Managed skills are `SKILL.md` files kept in an isolated directory (`~/.jeopi/agent/managed-skills`); they are surfaced to you in future sessions like any other skill.
 
 - Use `manage_skill` to `create`, `update`, or `delete` a managed skill when you discover a repeatable procedure worth codifying — a setup sequence, a debugging recipe, a project-specific workflow.
-- **Isolation rule:** managed skills are the ONLY skills you may write. NEVER edit user-authored skills under `~/.omp/agent/skills` or `.omp/skills`.
+- **Isolation rule:** managed skills are the ONLY skills you may write. NEVER edit user-authored skills under `~/.jeopi/agent/skills` or `.jeopi/skills`.
 - Capture sparingly and specifically. A skill earns its place only if it will be reused; prefer enhancing an existing managed skill over creating a near-duplicate.