@oh-my-pi/pi-coding-agent 3.3.1337 → 3.5.1337

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## [Unreleased]
 
+## [3.5.1337] - 2026-01-03
+
+### Added
+
+- Added session header and footer output in text mode showing version, model, provider, thinking level, and session ID
+- Added Extension Control Center dashboard accessible via `/extensions` command for unified management of all providers and extensions
+- Added ability to enable/disable individual extensions with persistent settings
+- Added three-column dashboard layout with sidebar tree, extension list, and inspector panel
+- Added fuzzy search filtering for extensions in the dashboard
+- Added keyboard navigation with Tab to cycle panes, j/k for navigation, Space to toggle, Enter to expand/collapse
+
+### Changed
+
+- Redesigned Extension Control Center from 3-column layout to tabbed interface with horizontal provider tabs and 2-column grid
+- Replaced sidebar tree navigation with provider tabs using TAB/Shift+TAB cycling
+
+### Fixed
+
+- Fixed title generation flag not resetting when starting a new session
+
+## [3.4.1337] - 2026-01-03
+
+### Added
+
+- Added Time Traveling Stream Rules (TTSR) feature that monitors agent output for pattern matches and injects rule reminders mid-stream
+- Added `ttsr_trigger` frontmatter field for rules to define regex patterns that trigger mid-stream injection
+- Added TTSR settings for enabled state, context mode (keep/discard partial output), and repeat mode (once/after-gap)
+
+### Fixed
+
+- Fixed excessive subprocess spawns by caching git status for 1 second in the footer component
+
 ## [3.3.1337] - 2026-01-03
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "3.3.1337",
+	"version": "3.5.1337",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,9 +39,9 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "3.3.1337",
-		"@oh-my-pi/pi-ai": "3.3.1337",
-		"@oh-my-pi/pi-tui": "3.3.1337",
+		"@oh-my-pi/pi-agent-core": "3.5.1337",
+		"@oh-my-pi/pi-ai": "3.5.1337",
+		"@oh-my-pi/pi-tui": "3.5.1337",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",
 		"chalk": "^5.5.0",

package/src/capability/rule.ts

@@ -15,6 +15,8 @@ export interface RuleFrontmatter {
 	description?: string;
 	globs?: string[];
 	alwaysApply?: boolean;
+	/** Regex pattern that triggers time-traveling rule injection */
+	ttsr_trigger?: string;
 	[key: string]: unknown;
 }
 
@@ -34,6 +36,8 @@ export interface Rule {
 	alwaysApply?: boolean;
 	/** Description (for agent-requested rules) */
 	description?: string;
+	/** Regex pattern that triggers time-traveling rule injection */
+	ttsrTrigger?: string;
 	/** Source metadata */
 	_source: SourceMeta;
 }

package/src/core/agent-session.ts

@@ -16,6 +16,7 @@
 import type { Agent, AgentEvent, AgentMessage, AgentState, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, ImageContent, Message, Model, TextContent } from "@oh-my-pi/pi-ai";
 import { isContextOverflow, modelsAreEqual, supportsXhigh } from "@oh-my-pi/pi-ai";
+import type { Rule } from "../capability/rule";
 import { getAuthPath } from "../config";
 import { type BashResult, executeBash as executeBashCommand } from "./bash-executor";
 import {
@@ -47,6 +48,7 @@ import type { ModelRegistry } from "./model-registry";
 import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, SessionManager } from "./session-manager";
 import type { SettingsManager, SkillsSettings } from "./settings-manager";
 import { expandSlashCommand, type FileSlashCommand, parseCommandArgs } from "./slash-commands";
+import type { TtsrManager } from "./ttsr";
 
 /** Session-specific events that extend the core AgentEvent */
 export type AgentSessionEvent =
@@ -54,7 +56,8 @@ export type AgentSessionEvent =
 	| { type: "auto_compaction_start"; reason: "threshold" | "overflow" }
 	| { type: "auto_compaction_end"; result: CompactionResult | undefined; aborted: boolean; willRetry: boolean }
 	| { type: "auto_retry_start"; attempt: number; maxAttempts: number; delayMs: number; errorMessage: string }
-	| { type: "auto_retry_end"; success: boolean; attempt: number; finalError?: string };
+	| { type: "auto_retry_end"; success: boolean; attempt: number; finalError?: string }
+	| { type: "ttsr_triggered"; rules: Rule[] };
 
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
@@ -80,6 +83,8 @@ export interface AgentSessionConfig {
 	skillsSettings?: Required<SkillsSettings>;
 	/** Model registry for API key resolution and model discovery */
 	modelRegistry: ModelRegistry;
+	/** TTSR manager for time-traveling stream rules */
+	ttsrManager?: TtsrManager;
 }
 
 /** Options for AgentSession.prompt() */
@@ -179,6 +184,11 @@ export class AgentSession {
 	// Model registry for API key resolution
 	private _modelRegistry: ModelRegistry;
 
+	// TTSR manager for time-traveling stream rules
+	private _ttsrManager: TtsrManager | undefined = undefined;
+	private _pendingTtsrInjections: Rule[] = [];
+	private _ttsrAbortPending = false;
+
 	constructor(config: AgentSessionConfig) {
 		this.agent = config.agent;
 		this.sessionManager = config.sessionManager;
@@ -190,6 +200,7 @@ export class AgentSession {
 		this._customCommands = config.customCommands ?? [];
 		this._skillsSettings = config.skillsSettings;
 		this._modelRegistry = config.modelRegistry;
+		this._ttsrManager = config.ttsrManager;
 
 		// Always subscribe to agent events for internal handling
 		// (session persistence, hooks, auto-compaction, retry logic)
@@ -201,6 +212,16 @@ export class AgentSession {
 		return this._modelRegistry;
 	}
 
+	/** TTSR manager for time-traveling stream rules */
+	get ttsrManager(): TtsrManager | undefined {
+		return this._ttsrManager;
+	}
+
+	/** Whether a TTSR abort is pending (stream was aborted to inject rules) */
+	get isTtsrAbortPending(): boolean {
+		return this._ttsrAbortPending;
+	}
+
 	// =========================================================================
 	// Event Subscription
 	// =========================================================================
@@ -239,6 +260,60 @@ export class AgentSession {
 		// Notify all listeners
 		this._emit(event);
 
+		// TTSR: Reset buffer on turn start
+		if (event.type === "turn_start" && this._ttsrManager) {
+			this._ttsrManager.resetBuffer();
+		}
+
+		// TTSR: Increment message count on turn end (for repeat-after-gap tracking)
+		if (event.type === "turn_end" && this._ttsrManager) {
+			this._ttsrManager.incrementMessageCount();
+		}
+
+		// TTSR: Check for pattern matches on text deltas and tool call argument deltas
+		if (event.type === "message_update" && this._ttsrManager?.hasRules()) {
+			const assistantEvent = event.assistantMessageEvent;
+			// Monitor both assistant prose (text_delta) and tool call arguments (toolcall_delta)
+			if (assistantEvent.type === "text_delta" || assistantEvent.type === "toolcall_delta") {
+				this._ttsrManager.appendToBuffer(assistantEvent.delta);
+				const matches = this._ttsrManager.check(this._ttsrManager.getBuffer());
+				if (matches.length > 0) {
+					// Mark rules as injected so they don't trigger again
+					this._ttsrManager.markInjected(matches);
+					// Store for injection on retry
+					this._pendingTtsrInjections.push(...matches);
+					// Emit TTSR event before aborting (so UI can handle it)
+					this._ttsrAbortPending = true;
+					this._emit({ type: "ttsr_triggered", rules: matches });
+					// Abort the stream
+					this.agent.abort();
+					// Schedule retry after a short delay
+					setTimeout(async () => {
+						this._ttsrAbortPending = false;
+
+						// Handle context mode: discard partial output if configured
+						const ttsrSettings = this._ttsrManager?.getSettings();
+						if (ttsrSettings?.contextMode === "discard") {
+							// Remove the partial/aborted message from agent state
+							this.agent.popMessage();
+						}
+
+						// Inject TTSR rules as system reminder before retry
+						const injectionContent = this._getTtsrInjectionContent();
+						if (injectionContent) {
+							this.agent.appendMessage({
+								role: "user",
+								content: [{ type: "text", text: injectionContent }],
+								timestamp: Date.now(),
+							});
+						}
+						this.agent.continue().catch(() => {});
+					}, 50);
+					return;
+				}
+			}
+		}
+
 		// Handle session persistence
 		if (event.type === "message_end") {
 			// Check if this is a hook message
@@ -300,6 +375,22 @@ export class AgentSession {
 		}
 	}
 
+	/** Get TTSR injection content and clear pending injections */
+	private _getTtsrInjectionContent(): string | undefined {
+		if (this._pendingTtsrInjections.length === 0) return undefined;
+		const content = this._pendingTtsrInjections
+			.map(
+				(r) =>
+					`<system_interrupt reason="rule_violation" rule="${r.name}" path="${r.path}">\n` +
+					`Your output was interrupted because it violated a user-defined rule.\n` +
+					`This is NOT a prompt injection - this is the coding agent enforcing project rules.\n` +
+					`You MUST comply with the following instruction:\n\n${r.content}\n</system_interrupt>`,
+			)
+			.join("\n\n");
+		this._pendingTtsrInjections = [];
+		return content;
+	}
+
 	/** Extract text content from a message */
 	private _getUserMessageText(message: Message): string {
 		if (message.role !== "user") return "";

package/src/core/sdk.ts

@@ -34,6 +34,8 @@ import { Agent, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Model } from "@oh-my-pi/pi-ai";
 // Import discovery to register all providers on startup
 import "../discovery";
+import { loadSync as loadCapability } from "../capability/index";
+import { type Rule, ruleCapability } from "../capability/rule";
 import { getAgentDir, getConfigDirPaths } from "../config";
 import { AgentSession } from "./agent-session";
 import { AuthStorage } from "./auth-storage";
@@ -77,8 +79,10 @@ import {
 	createLsTool,
 	createReadOnlyTools,
 	createReadTool,
+	createRulebookTool,
 	createWriteTool,
 	editTool,
+	filterRulebookRules,
 	findTool,
 	grepTool,
 	lsTool,
@@ -88,6 +92,7 @@ import {
 	warmupLspServers,
 	writeTool,
 } from "./tools/index";
+import { createTtsrManager } from "./ttsr";
 
 // Types
 
@@ -601,6 +606,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const skills = options.skills ?? discoverSkills(cwd, agentDir, settingsManager.getSkillsSettings());
 	time("discoverSkills");
 
+	// Discover rules
+	const ttsrManager = createTtsrManager(settingsManager.getTtsrSettings());
+	const rulesResult = loadCapability<Rule>(ruleCapability.id, { cwd });
+	for (const rule of rulesResult.items) {
+		if (rule.ttsrTrigger) {
+			ttsrManager.addRule(rule);
+		}
+	}
+	time("discoverTtsrRules");
+
+	// Filter rules for the rulebook (non-TTSR, non-alwaysApply, with descriptions)
+	const rulebookRules = filterRulebookRules(rulesResult.items);
+	time("filterRulebookRules");
+
 	const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
 	time("discoverContextFiles");
 
@@ -744,6 +763,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	let allToolsArray: Tool[] = [...builtInTools, ...wrappedCustomTools];
 
+	// Add rulebook tool if there are rules with descriptions (always enabled, regardless of --tools)
+	if (rulebookRules.length > 0) {
+		allToolsArray.push(createRulebookTool(rulebookRules));
+	}
+
 	// Filter out hidden tools unless explicitly requested
 	if (options.explicitTools) {
 		const explicitSet = new Set(options.explicitTools);
@@ -768,6 +792,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		cwd,
 		skills,
 		contextFiles,
+		rulebookRules,
 	});
 	time("buildSystemPrompt");
 
@@ -778,6 +803,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			cwd,
 			skills,
 			contextFiles,
+			rulebookRules,
 			customPrompt: options.systemPrompt,
 		});
 	} else {
@@ -847,6 +873,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		customCommands: customCommandsResult.commands,
 		skillsSettings: settingsManager.getSkillsSettings(),
 		modelRegistry,
+		ttsrManager,
 	});
 	time("createAgentSession");
 

package/src/core/session-manager.ts

@@ -107,6 +107,13 @@ export interface LabelEntry extends SessionEntryBase {
 	label: string | undefined;
 }
 
+/** TTSR injection entry - tracks which time-traveling rules have been injected this session. */
+export interface TtsrInjectionEntry extends SessionEntryBase {
+	type: "ttsr_injection";
+	/** Names of rules that were injected */
+	injectedRules: string[];
+}
+
 /**
  * Custom message entry for hooks to inject messages into LLM context.
  * Use customType to identify your hook's entries.
@@ -136,7 +143,8 @@ export type SessionEntry =
 	| BranchSummaryEntry
 	| CustomEntry
 	| CustomMessageEntry
-	| LabelEntry;
+	| LabelEntry
+	| TtsrInjectionEntry;
 
 /** Raw file entry (includes header) */
 export type FileEntry = SessionHeader | SessionEntry;
@@ -154,6 +162,8 @@ export interface SessionContext {
 	thinkingLevel: string;
 	/** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
 	models: Record<string, string>;
+	/** Names of TTSR rules that have been injected this session */
+	injectedTtsrRules: string[];
 }
 
 export interface SessionInfo {
@@ -295,7 +305,7 @@ export function buildSessionContext(
 	let leaf: SessionEntry | undefined;
 	if (leafId === null) {
 		// Explicitly null - return no messages (navigated to before first entry)
-		return { messages: [], thinkingLevel: "off", models: {} };
+		return { messages: [], thinkingLevel: "off", models: {}, injectedTtsrRules: [] };
 	}
 	if (leafId) {
 		leaf = byId.get(leafId);
@@ -306,7 +316,7 @@ export function buildSessionContext(
 	}
 
 	if (!leaf) {
-		return { messages: [], thinkingLevel: "off", models: {} };
+		return { messages: [], thinkingLevel: "off", models: {}, injectedTtsrRules: [] };
 	}
 
 	// Walk from leaf to root, collecting path
@@ -321,6 +331,7 @@ export function buildSessionContext(
 	let thinkingLevel = "off";
 	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
+	const injectedTtsrRulesSet = new Set<string>();
 
 	for (const entry of path) {
 		if (entry.type === "thinking_level_change") {
@@ -336,9 +347,16 @@ export function buildSessionContext(
 			models.default = `${entry.message.provider}/${entry.message.model}`;
 		} else if (entry.type === "compaction") {
 			compaction = entry;
+		} else if (entry.type === "ttsr_injection") {
+			// Collect injected TTSR rule names
+			for (const ruleName of entry.injectedRules) {
+				injectedTtsrRulesSet.add(ruleName);
+			}
 		}
 	}
 
+	const injectedTtsrRules = Array.from(injectedTtsrRulesSet);
+
 	// Build messages and collect corresponding entries
 	// When there's a compaction, we need to:
 	// 1. Emit summary first (entry = compaction)
@@ -389,7 +407,7 @@ export function buildSessionContext(
 		}
 	}
 
-	return { messages, thinkingLevel, models };
+	return { messages, thinkingLevel, models, injectedTtsrRules };
 }
 
 /**
@@ -814,6 +832,44 @@ export class SessionManager {
 		return entry.id;
 	}
 
+	// =========================================================================
+	// TTSR (Time Traveling Stream Rules)
+	// =========================================================================
+
+	/**
+	 * Append a TTSR injection entry recording which rules were injected.
+	 * @param ruleNames Names of rules that were injected
+	 * @returns Entry id
+	 */
+	appendTtsrInjection(ruleNames: string[]): string {
+		const entry: TtsrInjectionEntry = {
+			type: "ttsr_injection",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: new Date().toISOString(),
+			injectedRules: ruleNames,
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+
+	/**
+	 * Get all unique TTSR rule names that have been injected in the current branch.
+	 * Scans from root to current leaf for ttsr_injection entries.
+	 */
+	getInjectedTtsrRules(): string[] {
+		const path = this.getBranch();
+		const ruleNames = new Set<string>();
+		for (const entry of path) {
+			if (entry.type === "ttsr_injection") {
+				for (const name of entry.injectedRules) {
+					ruleNames.add(name);
+				}
+			}
+		}
+		return Array.from(ruleNames);
+	}
+
 	// =========================================================================
 	// Tree Traversal
 	// =========================================================================

package/src/core/settings-manager.ts

@@ -68,6 +68,16 @@ export interface EditSettings {
 	fuzzyMatch?: boolean; // default: true (accept high-confidence fuzzy matches for whitespace/indentation)
 }
 
+export interface TtsrSettings {
+	enabled?: boolean; // default: true
+	/** What to do with partial output when TTSR triggers: "keep" shows interrupted attempt, "discard" removes it */
+	contextMode?: "keep" | "discard"; // default: "discard"
+	/** How TTSR rules repeat: "once" = only trigger once per session, "after-gap" = can repeat after N messages */
+	repeatMode?: "once" | "after-gap"; // default: "once"
+	/** Number of messages before a rule can trigger again (only used when repeatMode is "after-gap") */
+	repeatGap?: number; // default: 10
+}
+
 export interface Settings {
 	lastChangelogVersion?: string;
 	/** Model roles map: { default: "provider/modelId", small: "provider/modelId", ... } */
@@ -93,7 +103,9 @@ export interface Settings {
 	mcp?: MCPSettings;
 	lsp?: LspSettings;
 	edit?: EditSettings;
+	ttsr?: TtsrSettings;
 	disabledProviders?: string[]; // Discovery provider IDs that are disabled
+	disabledExtensions?: string[]; // Individual extension IDs that are disabled (e.g., "skill:commit")
 }
 
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -582,4 +594,93 @@ export class SettingsManager {
 		this.globalSettings.disabledProviders = providerIds;
 		this.save();
 	}
+
+	getDisabledExtensions(): string[] {
+		return [...(this.settings.disabledExtensions ?? [])];
+	}
+
+	setDisabledExtensions(extensionIds: string[]): void {
+		this.globalSettings.disabledExtensions = extensionIds;
+		this.save();
+	}
+
+	isExtensionEnabled(extensionId: string): boolean {
+		return !(this.settings.disabledExtensions ?? []).includes(extensionId);
+	}
+
+	enableExtension(extensionId: string): void {
+		const disabled = this.globalSettings.disabledExtensions ?? [];
+		const index = disabled.indexOf(extensionId);
+		if (index !== -1) {
+			disabled.splice(index, 1);
+			this.globalSettings.disabledExtensions = disabled;
+			this.save();
+		}
+	}
+
+	disableExtension(extensionId: string): void {
+		const disabled = this.globalSettings.disabledExtensions ?? [];
+		if (!disabled.includes(extensionId)) {
+			disabled.push(extensionId);
+			this.globalSettings.disabledExtensions = disabled;
+			this.save();
+		}
+	}
+
+	getTtsrSettings(): TtsrSettings {
+		return this.settings.ttsr ?? {};
+	}
+
+	setTtsrSettings(settings: TtsrSettings): void {
+		this.globalSettings.ttsr = { ...this.globalSettings.ttsr, ...settings };
+		this.save();
+	}
+
+	getTtsrEnabled(): boolean {
+		return this.settings.ttsr?.enabled ?? true;
+	}
+
+	setTtsrEnabled(enabled: boolean): void {
+		if (!this.globalSettings.ttsr) {
+			this.globalSettings.ttsr = {};
+		}
+		this.globalSettings.ttsr.enabled = enabled;
+		this.save();
+	}
+
+	getTtsrContextMode(): "keep" | "discard" {
+		return this.settings.ttsr?.contextMode ?? "discard";
+	}
+
+	setTtsrContextMode(mode: "keep" | "discard"): void {
+		if (!this.globalSettings.ttsr) {
+			this.globalSettings.ttsr = {};
+		}
+		this.globalSettings.ttsr.contextMode = mode;
+		this.save();
+	}
+
+	getTtsrRepeatMode(): "once" | "after-gap" {
+		return this.settings.ttsr?.repeatMode ?? "once";
+	}
+
+	setTtsrRepeatMode(mode: "once" | "after-gap"): void {
+		if (!this.globalSettings.ttsr) {
+			this.globalSettings.ttsr = {};
+		}
+		this.globalSettings.ttsr.repeatMode = mode;
+		this.save();
+	}
+
+	getTtsrRepeatGap(): number {
+		return this.settings.ttsr?.repeatGap ?? 10;
+	}
+
+	setTtsrRepeatGap(gap: number): void {
+		if (!this.globalSettings.ttsr) {
+			this.globalSettings.ttsr = {};
+		}
+		this.globalSettings.ttsr.repeatGap = gap;
+		this.save();
+	}
 }

package/src/core/system-prompt.ts

@@ -5,12 +5,14 @@
 import { existsSync, readFileSync } from "node:fs";
 import chalk from "chalk";
 import { contextFileCapability } from "../capability/context-file";
+import type { Rule } from "../capability/rule";
 import { systemPromptCapability } from "../capability/system-prompt";
 import { getDocsPath, getExamplesPath, getReadmePath } from "../config";
 import { type ContextFile, loadSync, type SystemPrompt as SystemPromptFile } from "../discovery/index";
 import type { SkillsSettings } from "./settings-manager";
 import { formatSkillsForPrompt, loadSkills, type Skill } from "./skills";
 import type { ToolName } from "./tools/index";
+import { formatRulesForPrompt } from "./tools/rulebook";
 
 /**
  * Execute a git command synchronously and return stdout or null on failure.
@@ -238,6 +240,8 @@ export interface BuildSystemPromptOptions {
 	contextFiles?: Array<{ path: string; content: string; depth?: number }>;
 	/** Pre-loaded skills (skips discovery if provided). */
 	skills?: Skill[];
+	/** Pre-loaded rulebook rules (rules with descriptions, excluding TTSR and always-apply). */
+	rulebookRules?: Rule[];
 }
 
 /** Build the system prompt with tools, guidelines, and context */
@@ -250,6 +254,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		cwd,
 		contextFiles: providedContextFiles,
 		skills: providedSkills,
+		rulebookRules,
 	} = options;
 	const resolvedCwd = cwd ?? process.cwd();
 	const resolvedCustomPrompt = resolvePromptInput(customPrompt, "system prompt");
@@ -310,6 +315,11 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 			prompt += formatSkillsForPrompt(skills);
 		}
 
+		// Append rules section (always enabled when rules exist)
+		if (rulebookRules && rulebookRules.length > 0) {
+			prompt += formatRulesForPrompt(rulebookRules);
+		}
+
 		// Add date/time and working directory last
 		prompt += `\nCurrent date and time: ${dateTime}`;
 		prompt += `\nCurrent working directory: ${resolvedCwd}`;
@@ -419,6 +429,11 @@ Documentation:
 		prompt += formatSkillsForPrompt(skills);
 	}
 
+	// Append rules section (always enabled when rules exist)
+	if (rulebookRules && rulebookRules.length > 0) {
+		prompt += formatRulesForPrompt(rulebookRules);
+	}
+
 	// Add date/time and working directory last
 	prompt += `\nCurrent date and time: ${dateTime}`;
 	prompt += `\nCurrent working directory: ${resolvedCwd}`;

package/src/core/title-generator.ts

@@ -4,6 +4,7 @@
 
 import type { Model } from "@oh-my-pi/pi-ai";
 import { completeSimple } from "@oh-my-pi/pi-ai";
+import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";
 import { findSmolModel } from "./model-resolver";
 
@@ -43,21 +44,35 @@ export async function generateSessionTitle(
 	savedSmolModel?: string,
 ): Promise<string | null> {
 	const model = await findTitleModel(registry, savedSmolModel);
-	if (!model) return null;
+	if (!model) {
+		logger.debug("title-generator: no smol model found");
+		return null;
+	}
 
 	const apiKey = await registry.getApiKey(model);
-	if (!apiKey) return null;
+	if (!apiKey) {
+		logger.debug("title-generator: no API key for model", { provider: model.provider, id: model.id });
+		return null;
+	}
 
 	// Truncate message if too long
 	const truncatedMessage =
 		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}...` : firstMessage;
 
+	const request = {
+		model: `${model.provider}/${model.id}`,
+		systemPrompt: TITLE_SYSTEM_PROMPT,
+		userMessage: `<user-message>\n${truncatedMessage}\n</user-message>`,
+		maxTokens: 30,
+	};
+	logger.debug("title-generator: request", request);
+
 	try {
 		const response = await completeSimple(
 			model,
 			{
-				systemPrompt: TITLE_SYSTEM_PROMPT,
-				messages: [{ role: "user", content: truncatedMessage, timestamp: Date.now() }],
+				systemPrompt: request.systemPrompt,
+				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
 			},
 			{
 				apiKey,
@@ -74,13 +89,20 @@ export async function generateSessionTitle(
 		}
 		title = title.trim();
 
-		if (!title || title.length > 60) {
+		logger.debug("title-generator: response", {
+			title,
+			usage: response.usage,
+			stopReason: response.stopReason,
+		});
+
+		if (!title) {
 			return null;
 		}
 
 		// Clean up: remove quotes, trailing punctuation
 		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
-	} catch {
+	} catch (err) {
+		logger.debug("title-generator: error", { error: err instanceof Error ? err.message : String(err) });
 		return null;
 	}
 }