@oh-my-pi/pi-coding-agent 13.12.3 → 13.12.5

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## [Unreleased]
 
+## [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
+
+- Exposed `settings` instance in `CustomToolContext` for session-specific configuration access
+
+### Changed
+
+- Improved artifact spill configuration to use session settings with schema defaults as fallback
+- Refactored type annotations for better type safety in tool result handling
+
 ## [13.12.2] - 2026-03-15
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.12.3",
+	"version": "13.12.5",
 	"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.3",
-		"@oh-my-pi/pi-agent-core": "13.12.3",
-		"@oh-my-pi/pi-ai": "13.12.3",
-		"@oh-my-pi/pi-natives": "13.12.3",
-		"@oh-my-pi/pi-tui": "13.12.3",
-		"@oh-my-pi/pi-utils": "13.12.3",
+		"@oh-my-pi/omp-stats": "13.12.5",
+		"@oh-my-pi/pi-agent-core": "13.12.5",
+		"@oh-my-pi/pi-ai": "13.12.5",
+		"@oh-my-pi/pi-natives": "13.12.5",
+		"@oh-my-pi/pi-tui": "13.12.5",
+		"@oh-my-pi/pi-utils": "13.12.5",
 		"@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,12 @@ interface CustomModelsResult {
 	found: boolean;
 }
 
+type OllamaDiscoveredModelMetadata = {
+	reasoning: boolean;
+	input: ("text" | "image")[];
+	contextWindow?: number;
+};
+
 /**
  * Resolve an API key config value to an actual key.
  * Checks environment variable first, then treats as literal.
@@ -376,6 +382,40 @@ 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 extractGoogleOAuthToken(value: string | undefined): string | undefined {
 	if (!isAuthenticated(value)) return undefined;
 	try {
@@ -1096,7 +1136,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 +1152,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 +1162,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,8 +1217,8 @@ 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,
 			});
 		});

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/custom-tools/types.ts

@@ -10,6 +10,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import type { Static, TSchema } from "@sinclair/typebox";
 import type { Rule } from "../../capability/rule";
 import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { HookUIContext } from "../../extensibility/hooks/types";
 import type { Theme } from "../../modes/theme/theme";
@@ -76,6 +77,8 @@ export interface CustomToolContext {
 	hasQueuedMessages(): boolean;
 	/** Abort the current agent operation (fire-and-forget, does not wait) */
 	abort(): void;
+	/** Settings instance for the current session. Prefer over the global singleton. */
+	settings?: Settings;
 }
 
 /** Session event passed to onSession callback */

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/sdk.ts

@@ -79,7 +79,7 @@ import {
 	loadProjectContextFiles as loadContextFilesInternal,
 } from "./system-prompt";
 import { AgentOutputManager } from "./task/output-manager";
-import { resolveThinkingLevelForModel, toReasoningEffort } from "./thinking";
+import { parseThinkingLevel, resolveThinkingLevelForModel, toReasoningEffort } from "./thinking";
 import {
 	BashTool,
 	BUILTIN_TOOLS,
@@ -626,7 +626,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	if (!options.modelRegistry) {
 		modelRegistry.refreshInBackground();
 	}
-	const skillsSettings = settings.getGroup("skills") as SkillsSettings;
+	const skillsSettings = settings.getGroup("skills");
 	const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
 	const discoveredSkillsPromise =
 		options.skills === undefined
@@ -711,7 +711,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// If session has data and includes a thinking entry, restore it
 	if (thinkingLevel === undefined && hasExistingSession && hasThinkingEntry) {
-		thinkingLevel = existingSession.thinkingLevel as ThinkingLevel | undefined;
+		thinkingLevel = parseThinkingLevel(existingSession.thinkingLevel);
 	}
 
 	if (thinkingLevel === undefined && !hasExplicitModel && !hasThinkingEntry && defaultRoleSpec.explicitThinkingLevel) {
@@ -935,7 +935,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				// Always filter Exa - we have native integration
 				filterExa: true,
 				// Filter browser MCP servers when builtin browser tool is active
-				filterBrowser: (settings.get("browser.enabled") as boolean) ?? false,
+				filterBrowser: settings.get("browser.enabled") ?? false,
 				cacheStorage: settings.getStorage(),
 				authStorage,
 			}),
@@ -1005,10 +1005,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		extensionsResult = options.preloadedExtensions;
 	} else {
 		// Merge CLI extension paths with settings extension paths
-		const configuredPaths = [
-			...(options.additionalExtensionPaths ?? []),
-			...((settings.get("extensions") as string[]) ?? []),
-		];
+		const configuredPaths = [...(options.additionalExtensionPaths ?? []), ...(settings.get("extensions") ?? [])];
 		const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
 		extensionsResult = await logger.timeAsync(
 			"discoverAndLoadExtensions",
@@ -1118,11 +1115,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		abort: () => {
 			session.abort();
 		},
+		settings,
 	});
 	const toolContextStore = new ToolContextStore(getSessionContext);
 
 	const registeredTools = extensionRunner?.getAllRegisteredTools() ?? [];
-	let wrappedExtensionTools: AgentTool[];
+	let wrappedExtensionTools: Tool[];
 
 	if (extensionRunner) {
 		// With extension runner: convert CustomTools to ToolDefinitions and wrap all together
@@ -1144,16 +1142,17 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			isIdle: () => !session?.isStreaming,
 			hasQueuedMessages: () => (session?.queuedMessageCount ?? 0) > 0,
 			abort: () => session?.abort(),
+			settings,
 		});
 		wrappedExtensionTools = (options.customTools ?? [])
 			.filter(isCustomTool)
-			.map(tool => CustomToolAdapter.wrap(tool, customToolContext) as AgentTool);
+			.map(tool => CustomToolAdapter.wrap(tool, customToolContext));
 	}
 
 	// All built-in tools are active (conditional tools like git/ask return null from factory if disabled)
-	const toolRegistry = new Map<string, AgentTool>();
+	const toolRegistry = new Map<string, Tool>();
 	for (const tool of builtinTools) {
-		toolRegistry.set(tool.name, tool as AgentTool);
+		toolRegistry.set(tool.name, tool);
 	}
 	for (const tool of wrappedExtensionTools) {
 		toolRegistry.set(tool.name, tool);
@@ -1173,7 +1172,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	} else if (!toolRegistry.has("resolve")) {
 		const resolveTool = await logger.timeAsync("createTools:resolve:session", HIDDEN_TOOLS.resolve, toolSession);
 		if (resolveTool) {
-			toolRegistry.set(resolveTool.name, wrapToolWithMetaNotice(resolveTool) as AgentTool);
+			toolRegistry.set(resolveTool.name, wrapToolWithMetaNotice(resolveTool));
 		}
 	}
 
@@ -1218,7 +1217,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			tools,
 			toolNames,
 			rules: rulebookRules,
-			skillsSettings: settings.getGroup("skills") as SkillsSettings,
+			skillsSettings: settings.getGroup("skills"),
 			appendSystemPrompt: appendPrompt,
 			repeatToolDescriptions,
 			eagerTasks,
@@ -1236,7 +1235,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				tools,
 				toolNames,
 				rules: rulebookRules,
-				skillsSettings: settings.getGroup("skills") as SkillsSettings,
+				skillsSettings: settings.getGroup("skills"),
 				customPrompt: options.systemPrompt,
 				appendSystemPrompt: appendPrompt,
 				repeatToolDescriptions,
@@ -1297,17 +1296,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 					if (hasImages) {
 						const filteredContent = content
 							.map(c => (c.type === "image" ? { type: "text" as const, text: "Image reading is disabled." } : c))
-							.filter(
-								(c, i, arr) =>
-									// Dedupe consecutive "Image reading is disabled." texts
-									!(
-										c.type === "text" &&
-										c.text === "Image reading is disabled." &&
-										i > 0 &&
-										arr[i - 1].type === "text" &&
-										(arr[i - 1] as { type: "text"; text: string }).text === "Image reading is disabled."
-									),
-							);
+							.filter((c, i, arr) => {
+								// Dedupe consecutive "Image reading is disabled." texts
+								if (!(c.type === "text" && c.text === "Image reading is disabled." && i > 0)) return true;
+								const prev = arr[i - 1];
+								return !(prev.type === "text" && prev.text === "Image reading is disabled.");
+							});
 						return { ...msg, content: filteredContent };
 					}
 				}
@@ -1439,7 +1433,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		customCommands: customCommandsResult.commands,
 		skills,
 		skillWarnings,
-		skillsSettings: settings.getGroup("skills") as Required<SkillsSettings>,
+		skillsSettings: settings.getGroup("skills"),
 		modelRegistry,
 		toolRegistry,
 		transformContext,
@@ -1514,7 +1508,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		mcpManager.setOnResourcesChanged((serverName, uri) => {
 			logger.debug("MCP resources changed", { path: `mcp:${serverName}`, uri });
 			if (!settings.get("mcp.notifications")) return;
-			const debounceMs = (settings.get("mcp.notificationDebounceMs") as number) ?? 500;
+			const debounceMs = settings.get("mcp.notificationDebounceMs");
 			const key = `${serverName}:${uri}`;
 			const existing = notificationDebounceTimers.get(key);
 			if (existing) clearTimeout(existing);

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;
@@ -191,7 +193,7 @@ export interface AgentSessionConfig {
 	skillWarnings?: SkillWarning[];
 	/** Custom commands (TypeScript slash commands) */
 	customCommands?: LoadedCustomCommand[];
-	skillsSettings?: Required<SkillsSettings>;
+	skillsSettings?: SkillsSettings;
 	/** Model registry for API key resolution and model discovery */
 	modelRegistry: ModelRegistry;
 	/** Tool registry for LSP and settings */
@@ -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
@@ -383,7 +388,7 @@ export class AgentSession {
 	/** MCP prompt commands (updated dynamically when prompts are loaded) */
 	#mcpPromptCommands: LoadedCustomCommand[] = [];
 
-	#skillsSettings: Required<SkillsSettings> | undefined;
+	#skillsSettings: SkillsSettings | undefined;
 
 	// Model registry for API key resolution
 	#modelRegistry: ModelRegistry;
@@ -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;
@@ -2518,7 +2525,7 @@ export class AgentSession {
 		return undefined;
 	}
 
-	get skillsSettings(): Required<SkillsSettings> | undefined {
+	get skillsSettings(): SkillsSettings | undefined {
 		return this.#skillsSettings;
 	}
 
@@ -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", {

package/src/tools/output-meta.ts

@@ -12,7 +12,7 @@ import type {
 	AgentToolUpdateCallback,
 } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
-import { settings } from "../config/settings";
+import { getDefault, type Settings } from "../config/settings";
 import { formatGroupedDiagnosticMessages } from "../lsp/utils";
 import type { Theme } from "../modes/theme/theme";
 import { type OutputSummary, type TruncationResult, truncateTail } from "../session/streaming-output";
@@ -415,16 +415,17 @@ export function formatStyledTruncationWarning(meta: OutputMeta | undefined, them
  * Append output notice to tool result content if meta is present.
  */
 function appendOutputNotice(
-	content: Array<{ type: string; text?: string }>,
+	content: (TextContent | ImageContent)[],
 	meta: OutputMeta | undefined,
-): Array<{ type: string; text?: string }> {
+): (TextContent | ImageContent)[] {
 	const notice = formatOutputNotice(meta);
 	if (!notice) return content;
 
 	const result = [...content];
 	for (let i = result.length - 1; i >= 0; i--) {
-		if (result[i].type === "text" && result[i].text != null) {
-			result[i] = { ...result[i], text: result[i].text + notice };
+		const item = result[i];
+		if (item.type === "text") {
+			result[i] = { ...item, text: item.text + notice };
 			return result;
 		}
 	}
@@ -439,19 +440,16 @@ const kUnwrappedExecute = Symbol("OutputMeta.UnwrappedExecute");
 // Centralized artifact spill for large tool results
 // =============================================================================
 
-/** Artifact spill threshold — tool output above this size is saved as an artifact. */
-function getArtifactSpillThreshold(): number {
-	return settings.get("tools.artifactSpillThreshold") * 1024;
-}
-
-/** When spilling, keep this many bytes of tail in the result sent to the LLM. */
-function getArtifactTailBytes(): number {
-	return settings.get("tools.artifactTailBytes") * 1024;
-}
-
-/** When spilling, keep at most this many lines of tail. */
-function getArtifactTailLines(): number {
-	return settings.get("tools.artifactTailLines");
+/** Resolved artifact spill config sourced from the session settings (or schema defaults). */
+function getSpillConfig(s: Settings | undefined) {
+	const get = <P extends "tools.artifactSpillThreshold" | "tools.artifactTailBytes" | "tools.artifactTailLines">(
+		path: P,
+	) => s?.get(path) ?? getDefault(path);
+	return {
+		threshold: get("tools.artifactSpillThreshold") * 1024,
+		tailBytes: get("tools.artifactTailBytes") * 1024,
+		tailLines: get("tools.artifactTailLines"),
+	};
 }
 
 /**
@@ -467,9 +465,10 @@ async function spillLargeResultToArtifact(
 ): Promise<AgentToolResult> {
 	const sessionManager = context?.sessionManager;
 	if (!sessionManager) return result;
+	const { threshold, tailBytes, tailLines } = getSpillConfig(context?.settings);
 
 	// Skip if tool already saved an artifact
-	const existingMeta = (result.details as { meta?: OutputMeta } | undefined)?.meta;
+	const existingMeta: OutputMeta | undefined = result.details?.meta;
 	if (existingMeta?.truncation?.artifactId) return result;
 
 	// Measure total text content
@@ -483,7 +482,7 @@ async function spillLargeResultToArtifact(
 
 	const fullText = textParts.length === 1 ? textParts[0] : textParts.join("\n");
 	const totalBytes = Buffer.byteLength(fullText, "utf-8");
-	if (totalBytes <= getArtifactSpillThreshold()) return result;
+	if (totalBytes <= threshold) return result;
 
 	// Save full output as artifact
 	const artifactId = await sessionManager.saveArtifact(fullText, toolName);
@@ -491,8 +490,8 @@ async function spillLargeResultToArtifact(
 
 	// Truncate to tail
 	const truncated = truncateTail(fullText, {
-		maxBytes: getArtifactTailBytes(),
-		maxLines: getArtifactTailLines(),
+		maxBytes: tailBytes,
+		maxLines: tailLines,
 	});
 
 	// Replace text blocks with single tail-truncated block, keep images
@@ -515,7 +514,7 @@ async function spillLargeResultToArtifact(
 		totalBytes: truncated.totalBytes,
 		outputLines,
 		outputBytes,
-		maxBytes: getArtifactTailBytes(),
+		maxBytes: tailBytes,
 		shownRange: { start: shownStart, end: truncated.totalLines },
 		artifactId,
 	};
@@ -547,11 +546,11 @@ async function wrappedExecute(
 		result = await spillLargeResultToArtifact(result, this.name, context);
 
 		// Append notices from meta
-		const meta = (result.details as { meta?: OutputMeta } | undefined)?.meta;
+		const meta: OutputMeta | undefined = result.details?.meta;
 		if (meta) {
 			return {
 				...result,
-				content: appendOutputNotice(result.content, meta) as (TextContent | ImageContent)[],
+				content: appendOutputNotice(result.content, meta),
 			};
 		}
 		return result;