@oh-my-pi/pi-coding-agent 13.12.4 → 13.12.6

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [Unreleased]
 
+## [13.12.6] - 2026-03-15
+### Changed
+
+- Updated llama.cpp model discovery to read context window from the `/props` endpoint's `default_generation_settings.n_ctx` field instead of using hardcoded 128000 default
+- Updated llama.cpp model discovery to detect vision capabilities from the `/props` endpoint's `modalities.vision` field instead of defaulting to text-only input
+- Changed llama.cpp `maxTokens` calculation to respect discovered context window limits, capping at 8192 or the server's context window, whichever is smaller
+
+### Fixed
+
+- Fixed llama.cpp auto-discovery to read context window and vision support from the native `/props` endpoint instead of relying on hardcoded defaults
+
+## [13.12.5] - 2026-03-15
+
+### Added
+
+- Automatic discovery of Ollama model context window from model metadata, enabling accurate token limit configuration
+- Added `attribution` option to `PromptOptions` to explicitly control billing/initiator attribution for prompts
+- Added automatic clearing of completed and abandoned todo tasks after ~1 minute
+
+### Changed
+
+- Ollama model registration now uses discovered context window instead of hardcoded 128000 token default
+- Ollama model maxTokens now respects discovered context window constraints
+- Improved session directory migration to handle legacy absolute paths with double-dash format, automatically relocating them to new canonical locations
+- Enhanced session directory encoding to use `-tmp-` prefix for temporary directories instead of legacy double-dash format for better clarity
+- Updated `SessionManager.create()` to require both `cwd` and `sessionDir` parameters for explicit session directory control
+- Improved session directory naming for temporary working directories using `-tmp-` prefix instead of legacy `--` format
+- Made `cwd` and `sessionDir` fields mutable in SessionManager to support session relocation without type casting
+- Changed subagent prompts to explicitly set `attribution: "agent"` for accurate billing attribution
+- Strip already-completed tasks when restoring session from branch history
+
+### Fixed
+
+- Fixed automatic migration of legacy session directories to new `-tmp-` prefixed naming scheme for temp-root sessions
+
 ## [13.12.4] - 2026-03-15
 ### Added
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.12.4",
+	"version": "13.12.6",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.12.4",
-		"@oh-my-pi/pi-agent-core": "13.12.4",
-		"@oh-my-pi/pi-ai": "13.12.4",
-		"@oh-my-pi/pi-natives": "13.12.4",
-		"@oh-my-pi/pi-tui": "13.12.4",
-		"@oh-my-pi/pi-utils": "13.12.4",
+		"@oh-my-pi/omp-stats": "13.12.6",
+		"@oh-my-pi/pi-agent-core": "13.12.6",
+		"@oh-my-pi/pi-ai": "13.12.6",
+		"@oh-my-pi/pi-natives": "13.12.6",
+		"@oh-my-pi/pi-tui": "13.12.6",
+		"@oh-my-pi/pi-utils": "13.12.6",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/commit/agentic/agent.ts

@@ -161,11 +161,17 @@ export async function runCommitAgentSession(input: CommitAgentInput): Promise<Co
 		let retryCount = 0;
 		const needsChangelog = input.requireChangelog && input.changelogTargets.length > 0;
 
-		await session.prompt(prompt, { expandPromptTemplates: false });
+		await session.prompt(prompt, {
+			attribution: "agent",
+			expandPromptTemplates: false,
+		});
 		while (retryCount < MAX_RETRIES && !isProposalComplete(state, needsChangelog)) {
 			retryCount += 1;
 			const reminder = buildReminderMessage(state, needsChangelog, retryCount, MAX_RETRIES);
-			await session.prompt(reminder, { expandPromptTemplates: false });
+			await session.prompt(reminder, {
+				attribution: "agent",
+				expandPromptTemplates: false,
+			});
 		}
 
 		return state;

package/src/config/model-registry.ts

@@ -366,6 +366,17 @@ interface CustomModelsResult {
 	found: boolean;
 }
 
+type OllamaDiscoveredModelMetadata = {
+	reasoning: boolean;
+	input: ("text" | "image")[];
+	contextWindow?: number;
+};
+
+type LlamaCppDiscoveredServerMetadata = {
+	contextWindow?: number;
+	input?: ("text" | "image")[];
+};
+
 /**
  * Resolve an API key config value to an actual key.
  * Checks environment variable first, then treats as literal.
@@ -376,6 +387,59 @@ function resolveApiKeyConfig(keyConfig: string): string | undefined {
 	return keyConfig;
 }
 
+function toPositiveNumberOrUndefined(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+		return value;
+	}
+	if (typeof value === "string" && value.trim()) {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed) && parsed > 0) {
+			return parsed;
+		}
+	}
+	return undefined;
+}
+
+function extractOllamaContextWindow(payload: Record<string, unknown>): number | undefined {
+	const modelInfo = payload.model_info;
+	if (isRecord(modelInfo)) {
+		for (const [key, value] of Object.entries(modelInfo)) {
+			if (key === "context_length" || key.endsWith(".context_length")) {
+				const contextWindow = toPositiveNumberOrUndefined(value);
+				if (contextWindow !== undefined) {
+					return contextWindow;
+				}
+			}
+		}
+	}
+
+	const parameters = payload.parameters;
+	if (typeof parameters !== "string") {
+		return undefined;
+	}
+	const match = parameters.match(/(?:^|\n)\s*num_ctx\s+(\d+)\s*(?:$|\n)/m);
+	return match ? toPositiveNumberOrUndefined(match[1]) : undefined;
+}
+
+function extractLlamaCppContextWindow(payload: Record<string, unknown>): number | undefined {
+	const generationSettings = payload.default_generation_settings;
+	if (isRecord(generationSettings)) {
+		const contextWindow = toPositiveNumberOrUndefined(generationSettings.n_ctx);
+		if (contextWindow !== undefined) {
+			return contextWindow;
+		}
+	}
+	return toPositiveNumberOrUndefined(payload.n_ctx);
+}
+
+function extractLlamaCppInputCapabilities(payload: Record<string, unknown>): ("text" | "image")[] | undefined {
+	const modalities = payload.modalities;
+	if (!isRecord(modalities)) {
+		return undefined;
+	}
+	return modalities.vision === true ? ["text", "image"] : ["text"];
+}
+
 function extractGoogleOAuthToken(value: string | undefined): string | undefined {
 	if (!isAuthenticated(value)) return undefined;
 	try {
@@ -1096,7 +1160,7 @@ export class ModelRegistry {
 		endpoint: string,
 		modelId: string,
 		headers: Record<string, string> | undefined,
-	): Promise<{ reasoning: boolean; input: ("text" | "image")[] } | null> {
+	): Promise<OllamaDiscoveredModelMetadata | null> {
 		const showUrl = `${endpoint}/api/show`;
 		try {
 			const response = await fetch(showUrl, {
@@ -1112,6 +1176,7 @@ export class ModelRegistry {
 			if (!isRecord(payload)) {
 				return null;
 			}
+			const contextWindow = extractOllamaContextWindow(payload);
 			const capabilities = payload.capabilities;
 			if (Array.isArray(capabilities)) {
 				const normalized = new Set(
@@ -1121,15 +1186,21 @@ export class ModelRegistry {
 				return {
 					reasoning: normalized.has("thinking"),
 					input: supportsVision ? ["text", "image"] : ["text"],
+					contextWindow,
 				};
 			}
 			if (!isRecord(capabilities)) {
-				return null;
+				return {
+					reasoning: false,
+					input: ["text"],
+					contextWindow,
+				};
 			}
 			const supportsVision = capabilities.vision === true || capabilities.image === true;
 			return {
 				reasoning: capabilities.thinking === true,
 				input: supportsVision ? ["text", "image"] : ["text"],
+				contextWindow,
 			};
 		} catch {
 			return null;
@@ -1170,14 +1241,40 @@ export class ModelRegistry {
 				reasoning: metadata?.reasoning ?? false,
 				input: metadata?.input ?? ["text"],
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: 128000,
-				maxTokens: 8192,
+				contextWindow: metadata?.contextWindow ?? 128000,
+				maxTokens: Math.min(metadata?.contextWindow ?? Number.POSITIVE_INFINITY, 8192),
 				headers: providerConfig.headers,
 			});
 		});
 		return this.#applyProviderModelOverrides(providerConfig.provider, discovered);
 	}
 
+	async #discoverLlamaCppServerMetadata(
+		baseUrl: string,
+		headers: Record<string, string> | undefined,
+	): Promise<LlamaCppDiscoveredServerMetadata | null> {
+		const propsUrl = `${this.#toLlamaCppNativeBaseUrl(baseUrl)}/props`;
+		try {
+			const response = await fetch(propsUrl, {
+				headers,
+				signal: AbortSignal.timeout(150),
+			});
+			if (!response.ok) {
+				return null;
+			}
+			const payload = (await response.json()) as unknown;
+			if (!isRecord(payload)) {
+				return null;
+			}
+			return {
+				contextWindow: extractLlamaCppContextWindow(payload),
+				input: extractLlamaCppInputCapabilities(payload),
+			};
+		} catch {
+			return null;
+		}
+	}
+
 	async #discoverLlamaCppModels(providerConfig: DiscoveryProviderConfig): Promise<Model<Api>[]> {
 		const baseUrl = this.#normalizeLlamaCppBaseUrl(providerConfig.baseUrl);
 		const modelsUrl = `${baseUrl}/models`;
@@ -1188,10 +1285,13 @@ export class ModelRegistry {
 			headers.Authorization = `Bearer ${apiKey}`;
 		}
 
-		const response = await fetch(modelsUrl, {
-			headers,
-			signal: AbortSignal.timeout(250),
-		});
+		const [response, serverMetadata] = await Promise.all([
+			fetch(modelsUrl, {
+				headers,
+				signal: AbortSignal.timeout(250),
+			}),
+			this.#discoverLlamaCppServerMetadata(baseUrl, headers),
+		]);
 		if (!response.ok) {
 			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
 		}
@@ -1209,10 +1309,10 @@ export class ModelRegistry {
 					provider: providerConfig.provider,
 					baseUrl,
 					reasoning: false,
-					input: ["text"],
+					input: serverMetadata?.input ?? ["text"],
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: 128000,
-					maxTokens: 8192,
+					contextWindow: serverMetadata?.contextWindow ?? 128000,
+					maxTokens: Math.min(serverMetadata?.contextWindow ?? Number.POSITIVE_INFINITY, 8192),
 					headers,
 					compat: {
 						supportsStore: false,
@@ -1284,6 +1384,18 @@ export class ModelRegistry {
 		}
 	}
 
+	#toLlamaCppNativeBaseUrl(baseUrl: string): string {
+		try {
+			const parsed = new URL(baseUrl);
+			const trimmedPath = parsed.pathname.replace(/\/+$/g, "");
+			parsed.pathname = trimmedPath.endsWith("/v1") ? trimmedPath.slice(0, -3) || "/" : trimmedPath || "/";
+			const normalized = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+			return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+		} catch {
+			return baseUrl.endsWith("/v1") ? baseUrl.slice(0, -3) : baseUrl;
+		}
+	}
+
 	#normalizeLmStudioBaseUrl(baseUrl?: string): string {
 		const defaultBaseUrl = "http://127.0.0.1:1234/v1";
 		const raw = baseUrl || defaultBaseUrl;

package/src/config/prompt-templates.ts

@@ -275,6 +275,28 @@ handlebars.registerHelper("hlinefull", (lineNum: unknown, content: unknown): str
 	return `${ref}:${text}`;
 });
 
+const INLINE_ARG_SHELL_PATTERN = /\$(?:ARGUMENTS|@(?:\[\d+(?::\d*)?\])?|\d+)/;
+const INLINE_ARG_TEMPLATE_PATTERN = /\{\{[\s\S]*?(?:\b(?:arguments|ARGUMENTS|args)\b|\barg\s+[^}]+)[\s\S]*?\}\}/;
+
+/**
+ * Keep the check source-level and cheap: if the template text contains any explicit
+ * inline-arg placeholder syntax, do not append the fallback text again.
+ */
+export function templateUsesInlineArgPlaceholders(templateSource: string): boolean {
+	return INLINE_ARG_SHELL_PATTERN.test(templateSource) || INLINE_ARG_TEMPLATE_PATTERN.test(templateSource);
+}
+
+export function appendInlineArgsFallback(
+	rendered: string,
+	argsText: string,
+	usesInlineArgPlaceholders: boolean,
+): string {
+	if (argsText.length === 0 || usesInlineArgPlaceholders) return rendered;
+	if (rendered.length === 0) return argsText;
+
+	return `${rendered}\n\n${argsText}`;
+}
+
 export function renderPromptTemplate(template: string, context: TemplateContext = {}): string {
 	const compiled = handlebars.compile(template, { noEscape: true, strict: false });
 	const rendered = compiled(context ?? {});
@@ -405,8 +427,10 @@ export function expandPromptTemplate(text: string, templates: PromptTemplate[]):
 	if (template) {
 		const args = parseCommandArgs(argsString);
 		const argsText = args.join(" ");
+		const usesInlineArgPlaceholders = templateUsesInlineArgPlaceholders(template.content);
 		const substituted = substituteArgs(template.content, args);
-		return renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
+		const rendered = renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
+		return appendInlineArgsFallback(rendered, argsText, usesInlineArgPlaceholders);
 	}
 
 	return text;

package/src/config/settings-schema.ts

@@ -1292,6 +1292,17 @@ export const SETTINGS_SCHEMA = {
 		default: {} as Record<string, string>,
 	},
 
+	"tasks.todoClearDelay": {
+		type: "number",
+		default: 60,
+		ui: {
+			tab: "tasks",
+			label: "Todo auto-clear delay",
+			description: "How long to wait before removing completed/abandoned tasks from the list",
+			submenu: true,
+		},
+	},
+
 	// Skills
 	"skills.enabled": { type: "boolean", default: true },
 

package/src/extensibility/slash-commands.ts

@@ -1,6 +1,10 @@
 import type { AutocompleteItem } from "@oh-my-pi/pi-tui";
 import { slashCommandCapability } from "../capability/slash-command";
-import { renderPromptTemplate } from "../config/prompt-templates";
+import {
+	appendInlineArgsFallback,
+	renderPromptTemplate,
+	templateUsesInlineArgPlaceholders,
+} from "../config/prompt-templates";
 import type { SlashCommand } from "../discovery";
 import { loadCapability } from "../discovery";
 import {
@@ -217,8 +221,10 @@ export function expandSlashCommand(text: string, fileCommands: FileSlashCommand[
 	if (fileCommand) {
 		const args = parseCommandArgs(argsString);
 		const argsText = args.join(" ");
+		const usesInlineArgPlaceholders = templateUsesInlineArgPlaceholders(fileCommand.content);
 		const substituted = substituteArgs(fileCommand.content, args);
-		return renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
+		const rendered = renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
+		return appendInlineArgsFallback(rendered, argsText, usesInlineArgPlaceholders);
 	}
 
 	return text;

package/src/modes/components/settings-defs.ts

@@ -248,6 +248,17 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "1000", label: "1000 lines" },
 		{ value: "5000", label: "5000 lines" },
 	],
+	// Todo auto-clear delay
+	"tasks.todoClearDelay": [
+		{ value: "0", label: "Instant" },
+		{ value: "60", label: "1 minute", description: "Default" },
+		{ value: "300", label: "5 minutes" },
+		{ value: "900", label: "15 minutes" },
+		{ value: "1800", label: "30 minutes" },
+		{ value: "3600", label: "1 hour" },
+		{ value: "-1", label: "Never" },
+	],
+
 	// Edit fuzzy threshold
 	"edit.fuzzyThreshold": [
 		{ value: "0.85", label: "0.85", description: "Lenient" },

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

@@ -548,6 +548,10 @@ export class EventController {
 				this.ctx.ui.requestRender();
 				break;
 			}
+
+			case "todo_auto_clear":
+				await this.ctx.reloadTodos();
+				break;
 		}
 	}
 

package/src/modes/interactive-mode.ts

@@ -542,7 +542,7 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		const indent = "  ";
 		const hook = theme.tree.hook;
-		const lines = [indent + theme.bold(theme.fg("accent", "Todos"))];
+		const lines = ["", indent + theme.bold(theme.fg("accent", "Todos"))];
 
 		if (!this.todoExpanded) {
 			const activePhase = this.#getActivePhase(phases);

package/src/session/agent-session.ts

@@ -31,6 +31,7 @@ import type {
 	Effort,
 	ImageContent,
 	Message,
+	MessageAttribution,
 	Model,
 	ProviderSessionState,
 	ServiceTier,
@@ -154,7 +155,8 @@ export type AgentSessionEvent =
 	| { type: "auto_retry_start"; attempt: number; maxAttempts: number; delayMs: number; errorMessage: string }
 	| { type: "auto_retry_end"; success: boolean; attempt: number; finalError?: string }
 	| { type: "ttsr_triggered"; rules: Rule[] }
-	| { type: "todo_reminder"; todos: TodoItem[]; attempt: number; maxAttempts: number };
+	| { type: "todo_reminder"; todos: TodoItem[]; attempt: number; maxAttempts: number }
+	| { type: "todo_auto_clear" };
 
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
@@ -224,6 +226,8 @@ export interface PromptOptions {
 	toolChoice?: ToolChoice;
 	/** Send as developer/system message instead of user. Providers that support it use the developer role; others fall back to user. */
 	synthetic?: boolean;
+	/** Explicit billing/initiator attribution for the prompt. Defaults to user prompts as `user` and synthetic prompts as `agent`. */
+	attribution?: MessageAttribution;
 	/** Skip pre-send compaction checks for this prompt (internal use for maintenance flows). */
 	skipCompactionCheck?: boolean;
 }
@@ -361,6 +365,7 @@ export class AgentSession {
 	// Todo completion reminder state
 	#todoReminderCount = 0;
 	#todoPhases: TodoPhase[] = [];
+	#todoClearTimers = new Map<string, Timer>();
 	#nextToolChoiceOverride: ToolChoice | undefined = undefined;
 
 	// Bash execution state
@@ -1534,6 +1539,7 @@ export class AgentSession {
 			logger.warn("Failed to emit session_shutdown event", { error: String(error) });
 		}
 		this.#cancelPostPromptTasks();
+		this.#clearTodoClearTimers();
 		const drained = await this.#asyncJobManager?.dispose({ timeoutMs: 3_000 });
 		const deliveryState = this.#asyncJobManager?.getDeliveryState();
 		if (drained === false && deliveryState) {
@@ -1991,9 +1997,10 @@ export class AgentSession {
 			userContent.push(...options.images);
 		}
 
+		const promptAttribution = options?.attribution ?? (options?.synthetic ? "agent" : "user");
 		const message = options?.synthetic
-			? { role: "developer" as const, content: userContent, attribution: "agent" as const, timestamp: Date.now() }
-			: { role: "user" as const, content: userContent, attribution: "user" as const, timestamp: Date.now() };
+			? { role: "developer" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() }
+			: { role: "user" as const, content: userContent, attribution: promptAttribution, timestamp: Date.now() };
 
 		if (eagerTodoPrelude) {
 			this.#nextToolChoiceOverride = eagerTodoPrelude.toolChoice;
@@ -2538,10 +2545,17 @@ export class AgentSession {
 
 	setTodoPhases(phases: TodoPhase[]): void {
 		this.#todoPhases = this.#cloneTodoPhases(phases);
+		this.#scheduleTodoAutoClear(phases);
 	}
 
 	#syncTodoPhasesFromBranch(): void {
-		this.setTodoPhases(getLatestTodoPhasesFromEntries(this.sessionManager.getBranch()));
+		const phases = getLatestTodoPhasesFromEntries(this.sessionManager.getBranch());
+		// Strip completed/abandoned tasks — they were done in a previous run,
+		// so the auto-clear grace period has already elapsed.
+		for (const phase of phases) {
+			phase.tasks = phase.tasks.filter(t => t.status !== "completed" && t.status !== "abandoned");
+		}
+		this.setTodoPhases(phases.filter(p => p.tasks.length > 0));
 	}
 
 	#cloneTodoPhases(phases: TodoPhase[]): TodoPhase[] {
@@ -2557,6 +2571,68 @@ export class AgentSession {
 		}));
 	}
 
+	/** Schedule auto-removal of completed/abandoned tasks after a delay. */
+	#scheduleTodoAutoClear(phases: TodoPhase[]): void {
+		const delaySec = this.settings.get("tasks.todoClearDelay") ?? 60;
+		if (delaySec < 0) return; // "Never" — no auto-clear
+		const delayMs = delaySec * 1000;
+		const doneTaskIds = new Set<string>();
+		for (const phase of phases) {
+			for (const task of phase.tasks) {
+				if (task.status === "completed" || task.status === "abandoned") {
+					doneTaskIds.add(task.id);
+				}
+			}
+		}
+
+		// Cancel timers for tasks that are no longer done (e.g. status was reverted)
+		for (const [id, timer] of this.#todoClearTimers) {
+			if (!doneTaskIds.has(id)) {
+				clearTimeout(timer);
+				this.#todoClearTimers.delete(id);
+			}
+		}
+
+		// Schedule new timers for newly-done tasks
+		for (const id of doneTaskIds) {
+			if (this.#todoClearTimers.has(id)) continue;
+			if (delayMs === 0) {
+				// Instant — run synchronously on next microtask to batch removals
+				const timer = setTimeout(() => this.#runTodoAutoClear(id), 0);
+				this.#todoClearTimers.set(id, timer);
+			} else {
+				const timer = setTimeout(() => this.#runTodoAutoClear(id), delayMs);
+				this.#todoClearTimers.set(id, timer);
+			}
+		}
+	}
+
+	/** Remove a single completed task and notify the UI. */
+	#runTodoAutoClear(taskId: string): void {
+		this.#todoClearTimers.delete(taskId);
+		let removed = false;
+		for (const phase of this.#todoPhases) {
+			const idx = phase.tasks.findIndex(t => t.id === taskId);
+			if (idx !== -1 && (phase.tasks[idx].status === "completed" || phase.tasks[idx].status === "abandoned")) {
+				phase.tasks.splice(idx, 1);
+				removed = true;
+				break;
+			}
+		}
+		if (!removed) return;
+
+		// Remove empty phases
+		this.#todoPhases = this.#todoPhases.filter(p => p.tasks.length > 0);
+		this.#emit({ type: "todo_auto_clear" });
+	}
+
+	#clearTodoClearTimers(): void {
+		for (const timer of this.#todoClearTimers.values()) {
+			clearTimeout(timer);
+		}
+		this.#todoClearTimers.clear();
+	}
+
 	/**
 	 * Abort current operation and wait for agent to become idle.
 	 */

package/src/session/session-manager.ts

@@ -347,6 +347,44 @@ export function migrateSessionEntries(entries: FileEntry[]): void {
 
 let sessionDirsMigrated = false;
 
+/**
+ * Merge or rename a legacy session directory into its canonical target.
+ * Best effort: callers decide whether migration failures should surface.
+ */
+function migrateSessionDirPath(oldPath: string, newPath: string): void {
+	const existing = fs.statSync(newPath, { throwIfNoEntry: false });
+	if (existing?.isDirectory()) {
+		for (const file of fs.readdirSync(oldPath)) {
+			const src = path.join(oldPath, file);
+			const dst = path.join(newPath, file);
+			if (!fs.existsSync(dst)) {
+				fs.renameSync(src, dst);
+			}
+		}
+		fs.rmSync(oldPath, { recursive: true, force: true });
+		return;
+	}
+	if (existing) {
+		fs.rmSync(newPath, { recursive: true, force: true });
+	}
+	fs.renameSync(oldPath, newPath);
+}
+
+function encodeLegacyAbsoluteSessionDirName(cwd: string): string {
+	const resolvedCwd = path.resolve(cwd);
+	return `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
+
+function pathIsWithin(root: string, candidate: string): boolean {
+	const relative = path.relative(root, candidate);
+	return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function encodeRelativeSessionDirName(prefix: string, root: string, cwd: string): string {
+	const relative = path.relative(root, cwd).replace(/[/\\:]/g, "-");
+	return relative ? `${prefix}-${relative}` : prefix;
+}
+
 /**
  * Migrate old `--<home-encoded>-*--` session dirs to the new `-*` format.
  * Runs once on first access, best-effort.
@@ -378,34 +416,29 @@ function migrateHomeSessionDirs(): void {
 			continue;
 		}
 
-		const newName = `-${remainder}`;
+		const newName = remainder ? `-${remainder}` : "-";
 		const oldPath = path.join(sessionsRoot, entry);
 		const newPath = path.join(sessionsRoot, newName);
 
 		try {
-			const existing = fs.statSync(newPath, { throwIfNoEntry: false });
-			if (existing?.isDirectory()) {
-				// Merge files from old dir into existing new dir
-				for (const file of fs.readdirSync(oldPath)) {
-					const src = path.join(oldPath, file);
-					const dst = path.join(newPath, file);
-					if (!fs.existsSync(dst)) {
-						fs.renameSync(src, dst);
-					}
-				}
-				fs.rmSync(oldPath, { recursive: true, force: true });
-			} else {
-				if (existing) {
-					fs.rmSync(newPath, { recursive: true, force: true });
-				}
-				fs.renameSync(oldPath, newPath);
-			}
+			migrateSessionDirPath(oldPath, newPath);
 		} catch {
 			// Best effort
 		}
 	}
 }
 
+function migrateLegacyAbsoluteSessionDir(cwd: string, sessionDir: string): void {
+	const legacyDir = path.join(getSessionsDir(), encodeLegacyAbsoluteSessionDirName(cwd));
+	if (legacyDir === sessionDir || !fs.existsSync(legacyDir)) return;
+
+	try {
+		migrateSessionDirPath(legacyDir, sessionDir);
+	} catch {
+		// Best effort
+	}
+}
+
 /** Exported for compaction.test.ts */
 export function parseSessionEntries(content: string): FileEntry[] {
 	return parseJsonlLenient<FileEntry>(content);
@@ -603,23 +636,31 @@ export function buildSessionContext(
 /**
  * Encode a cwd into a safe directory name for session storage.
  * Home-relative paths use single-dash format: `/Users/x/Projects/pi` → `-Projects-pi`
- * Absolute paths use double-dash format: `/tmp/foo` → `--tmp-foo--`
+ * Temp-root paths use `-tmp-` prefixes: `/tmp/foo` → `-tmp-foo`
+ * Other absolute paths keep the legacy double-dash format for compatibility.
  */
 function encodeSessionDirName(cwd: string): string {
-	const home = os.homedir();
-	if (cwd === home || cwd.startsWith(`${home}/`) || cwd.startsWith(`${home}\\`)) {
-		const relative = cwd.slice(home.length).replace(/^[/\\]/, "");
-		return `-${relative.replace(/[/\\:]/g, "-")}`;
+	const resolvedCwd = path.resolve(cwd);
+	const home = path.resolve(os.homedir());
+	if (pathIsWithin(home, resolvedCwd)) {
+		return encodeRelativeSessionDirName("-", home, resolvedCwd);
+	}
+	const tempRoot = path.resolve(os.tmpdir());
+	if (pathIsWithin(tempRoot, resolvedCwd)) {
+		return encodeRelativeSessionDirName("-tmp", tempRoot, resolvedCwd);
 	}
-	return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+	return encodeLegacyAbsoluteSessionDirName(resolvedCwd);
 }
+
 /**
  * Compute the default session directory for a cwd.
  * Encodes cwd into a safe directory name under ~/.omp/agent/sessions/.
  */
 function getDefaultSessionDir(cwd: string, storage: SessionStorage): string {
+	const resolvedCwd = path.resolve(cwd);
 	migrateHomeSessionDirs();
-	const sessionDir = path.join(getSessionsDir(), encodeSessionDirName(cwd));
+	const sessionDir = path.join(getSessionsDir(), encodeSessionDirName(resolvedCwd));
+	migrateLegacyAbsoluteSessionDir(resolvedCwd, sessionDir);
 	storage.ensureDirSync(sessionDir);
 	return sessionDir;
 }
@@ -1307,7 +1348,7 @@ export class SessionManager {
 	#fileEntries: FileEntry[] = [];
 	#byId: Map<string, SessionEntry> = new Map();
 	#labelsById: Map<string, string> = new Map();
-	#leafId = null as string | null;
+	#leafId: string | null = null;
 	#usageStatistics = {
 		input: 0,
 		output: 0,
@@ -1316,7 +1357,7 @@ export class SessionManager {
 		premiumRequests: 0,
 		cost: 0,
 	} satisfies UsageStatistics;
-	#persistWriter = undefined as NdjsonFileWriter | undefined;
+	#persistWriter: NdjsonFileWriter | undefined;
 	#persistWriterPath: string | undefined;
 	#persistChain: Promise<void> = Promise.resolve();
 	#persistError: Error | undefined;
@@ -1326,8 +1367,8 @@ export class SessionManager {
 	readonly #blobStore: BlobStore;
 
 	private constructor(
-		private readonly cwd: string,
-		private readonly sessionDir: string,
+		private cwd: string,
+		private sessionDir: string,
 		private readonly persist: boolean,
 		private readonly storage: SessionStorage,
 	) {
@@ -1429,7 +1470,7 @@ export class SessionManager {
 		this.#sessionName = newHeader.title;
 
 		// Replace the header in fileEntries
-		const entries = this.#fileEntries.filter(e => e.type !== "session") as SessionEntry[];
+		const entries = this.#fileEntries.filter((e): e is SessionEntry => e.type !== "session");
 		this.#fileEntries = [newHeader, ...entries];
 
 		// Write the new session file
@@ -1506,9 +1547,9 @@ export class SessionManager {
 			this.#sessionFile = newSessionFile;
 		}
 
-		// Update cwd and sessionDir (controlled mutation of readonly fields)
-		(this as unknown as { cwd: string }).cwd = resolvedCwd;
-		(this as unknown as { sessionDir: string }).sessionDir = newSessionDir;
+		// Update cwd and sessionDir after the move succeeds.
+		this.cwd = resolvedCwd;
+		this.sessionDir = newSessionDir;
 
 		// Update the session header in fileEntries
 		const header = this.#fileEntries.find(e => e.type === "session") as SessionHeader | undefined;

package/src/task/executor.ts

@@ -1078,7 +1078,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				}
 			});
 
-			await session.prompt(task);
+			await session.prompt(task, { attribution: "agent" });
 			await session.waitForIdle();
 
 			const reminderToolChoice = buildNamedToolChoice("submit_result", session.model);
@@ -1092,7 +1092,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						maxRetries: MAX_SUBMIT_RESULT_RETRIES,
 					});
 
-					await session.prompt(reminder, reminderToolChoice ? { toolChoice: reminderToolChoice } : undefined);
+					await session.prompt(reminder, {
+						attribution: "agent",
+						...(reminderToolChoice ? { toolChoice: reminderToolChoice } : {}),
+					});
 					await session.waitForIdle();
 				} catch (err) {
 					logger.error("Subagent prompt failed", {