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

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [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.4.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.4.1337",
+		"@oh-my-pi/pi-ai": "3.4.1337",
+		"@oh-my-pi/pi-tui": "3.4.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";
@@ -88,6 +90,7 @@ import {
 	warmupLspServers,
 	writeTool,
 } from "./tools/index";
+import { createTtsrManager } from "./ttsr";
 
 // Types
 
@@ -601,6 +604,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const skills = options.skills ?? discoverSkills(cwd, agentDir, settingsManager.getSkillsSettings());
 	time("discoverSkills");
 
+	// Discover TTSR 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");
+
 	const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
 	time("discoverContextFiles");
 
@@ -847,6 +860,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,6 +103,7 @@ export interface Settings {
 	mcp?: MCPSettings;
 	lsp?: LspSettings;
 	edit?: EditSettings;
+	ttsr?: TtsrSettings;
 	disabledProviders?: string[]; // Discovery provider IDs that are disabled
 }
 
@@ -582,4 +593,61 @@ export class SettingsManager {
 		this.globalSettings.disabledProviders = providerIds;
 		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/ttsr.ts

@@ -0,0 +1,211 @@
+/**
+ * Time Traveling Stream Rules (TTSR) Manager
+ *
+ * Manages rules that get injected mid-stream when their trigger pattern matches
+ * the agent's output. When a match occurs, the stream is aborted, the rule is
+ * injected as a system reminder, and the request is retried.
+ */
+
+import type { Rule } from "../capability/rule";
+import { logger } from "./logger";
+import type { TtsrSettings } from "./settings-manager";
+
+interface TtsrEntry {
+	rule: Rule;
+	regex: RegExp;
+}
+
+/** Tracks when a rule was last injected (for repeat-after-gap mode) */
+interface InjectionRecord {
+	/** Message count when the rule was last injected */
+	lastInjectedAt: number;
+}
+
+export interface TtsrManager {
+	/** Add a TTSR rule to be monitored */
+	addRule(rule: Rule): void;
+
+	/** Check if any uninjected TTSR matches the stream buffer. Returns matching rules. */
+	check(streamBuffer: string): Rule[];
+
+	/** Mark rules as injected (won't trigger again until conditions allow) */
+	markInjected(rules: Rule[]): void;
+
+	/** Get names of all injected rules (for persistence) */
+	getInjectedRuleNames(): string[];
+
+	/** Restore injected state from a list of rule names */
+	restoreInjected(ruleNames: string[]): void;
+
+	/** Reset stream buffer (called on new turn) */
+	resetBuffer(): void;
+
+	/** Get current stream buffer */
+	getBuffer(): string;
+
+	/** Append to stream buffer */
+	appendToBuffer(text: string): void;
+
+	/** Check if any TTSRs are registered */
+	hasRules(): boolean;
+
+	/** Increment message counter (call after each turn) */
+	incrementMessageCount(): void;
+
+	/** Get current message count */
+	getMessageCount(): number;
+
+	/** Get settings */
+	getSettings(): Required<TtsrSettings>;
+}
+
+const DEFAULT_SETTINGS: Required<TtsrSettings> = {
+	enabled: true,
+	contextMode: "discard",
+	repeatMode: "once",
+	repeatGap: 10,
+};
+
+export function createTtsrManager(settings?: TtsrSettings): TtsrManager {
+	/** Resolved settings with defaults */
+	const resolvedSettings: Required<TtsrSettings> = {
+		...DEFAULT_SETTINGS,
+		...settings,
+	};
+
+	/** Map of rule name -> { rule, compiled regex } */
+	const rules = new Map<string, TtsrEntry>();
+
+	/** Map of rule name -> injection record */
+	const injectionRecords = new Map<string, InjectionRecord>();
+
+	/** Current stream buffer for pattern matching */
+	let buffer = "";
+
+	/** Message counter for tracking gap between injections */
+	let messageCount = 0;
+
+	/** Check if a rule can be triggered based on repeat settings */
+	function canTrigger(ruleName: string): boolean {
+		const record = injectionRecords.get(ruleName);
+		if (!record) {
+			// Never injected, can trigger
+			return true;
+		}
+
+		if (resolvedSettings.repeatMode === "once") {
+			// Once mode: never trigger again after first injection
+			return false;
+		}
+
+		// After-gap mode: check if enough messages have passed
+		const gap = messageCount - record.lastInjectedAt;
+		return gap >= resolvedSettings.repeatGap;
+	}
+
+	return {
+		addRule(rule: Rule): void {
+			// Only add rules that have a TTSR trigger pattern
+			if (!rule.ttsrTrigger) {
+				return;
+			}
+
+			// Skip if already registered
+			if (rules.has(rule.name)) {
+				return;
+			}
+
+			// Compile the regex pattern
+			try {
+				const regex = new RegExp(rule.ttsrTrigger);
+				rules.set(rule.name, { rule, regex });
+				logger.debug("TTSR rule registered", {
+					ruleName: rule.name,
+					pattern: rule.ttsrTrigger,
+				});
+			} catch (err) {
+				logger.warn("TTSR rule has invalid regex pattern, skipping", {
+					ruleName: rule.name,
+					pattern: rule.ttsrTrigger,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+		},
+
+		check(streamBuffer: string): Rule[] {
+			const matches: Rule[] = [];
+
+			for (const [name, entry] of rules) {
+				// Skip rules that can't trigger yet
+				if (!canTrigger(name)) {
+					continue;
+				}
+
+				// Test the buffer against the rule's pattern
+				if (entry.regex.test(streamBuffer)) {
+					matches.push(entry.rule);
+					logger.debug("TTSR pattern matched", {
+						ruleName: name,
+						pattern: entry.rule.ttsrTrigger,
+					});
+				}
+			}
+
+			return matches;
+		},
+
+		markInjected(rulesToMark: Rule[]): void {
+			for (const rule of rulesToMark) {
+				injectionRecords.set(rule.name, { lastInjectedAt: messageCount });
+				logger.debug("TTSR rule marked as injected", {
+					ruleName: rule.name,
+					messageCount,
+					repeatMode: resolvedSettings.repeatMode,
+				});
+			}
+		},
+
+		getInjectedRuleNames(): string[] {
+			return Array.from(injectionRecords.keys());
+		},
+
+		restoreInjected(ruleNames: string[]): void {
+			// When restoring, we don't know the original message count, so use 0
+			// This means in "after-gap" mode, rules can trigger again after the gap
+			for (const name of ruleNames) {
+				injectionRecords.set(name, { lastInjectedAt: 0 });
+			}
+			if (ruleNames.length > 0) {
+				logger.debug("TTSR injected state restored", { ruleNames });
+			}
+		},
+
+		resetBuffer(): void {
+			buffer = "";
+		},
+
+		getBuffer(): string {
+			return buffer;
+		},
+
+		appendToBuffer(text: string): void {
+			buffer += text;
+		},
+
+		hasRules(): boolean {
+			return rules.size > 0;
+		},
+
+		incrementMessageCount(): void {
+			messageCount++;
+		},
+
+		getMessageCount(): number {
+			return messageCount;
+		},
+
+		getSettings(): Required<TtsrSettings> {
+			return resolvedSettings;
+		},
+	};
+}

package/src/discovery/builtin.ts

@@ -310,6 +310,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 					globs: frontmatter.globs as string[] | undefined,
 					alwaysApply: frontmatter.alwaysApply as boolean | undefined,
 					description: frontmatter.description as string | undefined,
+					ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 					_source: source,
 				};
 			},

package/src/discovery/cline.ts

@@ -52,6 +52,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 					globs,
 					alwaysApply: typeof frontmatter.alwaysApply === "boolean" ? frontmatter.alwaysApply : undefined,
 					description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
+					ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 					_source: source,
 				};
 			},
@@ -85,6 +86,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 			globs,
 			alwaysApply: typeof frontmatter.alwaysApply === "boolean" ? frontmatter.alwaysApply : undefined,
 			description: typeof frontmatter.description === "string" ? frontmatter.description : undefined,
+			ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 			_source: source,
 		});
 	}

package/src/discovery/cursor.ts

@@ -163,6 +163,7 @@ function transformMDCRule(
 	// Extract frontmatter fields
 	const description = typeof frontmatter.description === "string" ? frontmatter.description : undefined;
 	const alwaysApply = frontmatter.alwaysApply === true;
+	const ttsrTrigger = typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined;
 
 	// Parse globs (can be array or single string)
 	let globs: string[] | undefined;
@@ -182,6 +183,7 @@ function transformMDCRule(
 		description,
 		alwaysApply,
 		globs,
+		ttsrTrigger,
 		_source: source,
 	};
 }

package/src/discovery/windsurf.ts

@@ -128,6 +128,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 				globs,
 				alwaysApply: frontmatter.alwaysApply as boolean | undefined,
 				description: frontmatter.description as string | undefined,
+				ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 				_source: createSourceMeta(PROVIDER_ID, userPath, "user"),
 			});
 		}
@@ -157,6 +158,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 					globs,
 					alwaysApply: frontmatter.alwaysApply as boolean | undefined,
 					description: frontmatter.description as string | undefined,
+					ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 					_source: source,
 				};
 			},
@@ -187,6 +189,7 @@ function loadRules(ctx: LoadContext): LoadResult<Rule> {
 				globs,
 				alwaysApply: frontmatter.alwaysApply as boolean | undefined,
 				description: frontmatter.description as string | undefined,
+				ttsrTrigger: typeof frontmatter.ttsr_trigger === "string" ? frontmatter.ttsr_trigger : undefined,
 				_source: createSourceMeta(PROVIDER_ID, legacyPath, "project"),
 			});
 		}

package/src/modes/interactive/components/footer.ts

@@ -58,6 +58,10 @@ export class FooterComponent implements Component {
 	private autoCompactEnabled: boolean = true;
 	private hookStatuses: Map<string, string> = new Map();
 
+	// Git status caching (1s TTL to avoid excessive subprocess spawns)
+	private cachedGitStatus: { staged: number; unstaged: number; untracked: number } | null = null;
+	private gitStatusLastFetch = 0;
+
 	constructor(session: AgentSession) {
 		this.session = session;
 	}
@@ -165,8 +169,14 @@ export class FooterComponent implements Component {
 	/**
 	 * Get git status indicators (staged, unstaged, untracked counts).
 	 * Returns null if not in a git repo.
+	 * Cached for 1s to avoid excessive subprocess spawns.
 	 */
 	private getGitStatus(): { staged: number; unstaged: number; untracked: number } | null {
+		const now = Date.now();
+		if (now - this.gitStatusLastFetch < 1000) {
+			return this.cachedGitStatus;
+		}
+
 		try {
 			const output = execSync("git status --porcelain 2>/dev/null", {
 				encoding: "utf8",
@@ -200,8 +210,12 @@ export class FooterComponent implements Component {
 				}
 			}
 
-			return { staged, unstaged, untracked };
+			this.cachedGitStatus = { staged, unstaged, untracked };
+			this.gitStatusLastFetch = now;
+			return this.cachedGitStatus;
 		} catch {
+			this.cachedGitStatus = null;
+			this.gitStatusLastFetch = now;
 			return null;
 		}
 	}

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

@@ -155,6 +155,35 @@ export const SETTINGS_DEFS: SettingDef[] = [
 		get: (sm) => sm.getEditFuzzyMatch(),
 		set: (sm, v) => sm.setEditFuzzyMatch(v),
 	},
+	{
+		id: "ttsrEnabled",
+		tab: "config",
+		type: "boolean",
+		label: "TTSR enabled",
+		description: "Time Traveling Stream Rules: interrupt agent when output matches rule patterns",
+		get: (sm) => sm.getTtsrEnabled(),
+		set: (sm, v) => sm.setTtsrEnabled(v),
+	},
+	{
+		id: "ttsrContextMode",
+		tab: "config",
+		type: "enum",
+		label: "TTSR context mode",
+		description: "What to do with partial output when TTSR triggers",
+		values: ["discard", "keep"],
+		get: (sm) => sm.getTtsrContextMode(),
+		set: (sm, v) => sm.setTtsrContextMode(v as "keep" | "discard"),
+	},
+	{
+		id: "ttsrRepeatMode",
+		tab: "config",
+		type: "enum",
+		label: "TTSR repeat mode",
+		description: "How rules can repeat: once per session or after a message gap",
+		values: ["once", "after-gap"],
+		get: (sm) => sm.getTtsrRepeatMode(),
+		set: (sm, v) => sm.setTtsrRepeatMode(v as "once" | "after-gap"),
+	},
 	{
 		id: "thinkingLevel",
 		tab: "config",

package/src/modes/interactive/components/ttsr-notification.ts

@@ -0,0 +1,82 @@
+import { Box, Container, Spacer, Text } from "@oh-my-pi/pi-tui";
+import type { Rule } from "../../../capability/rule";
+import { theme } from "../theme/theme";
+
+/**
+ * Component that renders a TTSR (Time Traveling Stream Rules) notification.
+ * Shows when a rule violation is detected and the stream is being rewound.
+ */
+export class TtsrNotificationComponent extends Container {
+	private rules: Rule[];
+	private box: Box;
+	private _expanded = false;
+
+	constructor(rules: Rule[]) {
+		super();
+		this.rules = rules;
+
+		this.addChild(new Spacer(1));
+
+		// Use inverse warning color for yellow background effect
+		this.box = new Box(1, 1, (t) => theme.inverse(theme.fg("warning", t)));
+		this.addChild(this.box);
+
+		this.rebuild();
+	}
+
+	setExpanded(expanded: boolean): void {
+		if (this._expanded !== expanded) {
+			this._expanded = expanded;
+			this.rebuild();
+		}
+	}
+
+	isExpanded(): boolean {
+		return this._expanded;
+	}
+
+	private rebuild(): void {
+		this.box.clear();
+
+		// Build header: ⚠ Injecting <bold>rule-name</bold>    ↩
+		const ruleNames = this.rules.map((r) => theme.bold(r.name)).join(", ");
+		const label = this.rules.length === 1 ? "rule" : "rules";
+		const header = `\u26A0 Injecting ${label}: ${ruleNames}`;
+
+		// Create header with rewind icon on the right
+		const rewindIcon = "\u21A9"; // ↩
+
+		this.box.addChild(new Text(`${header}  ${rewindIcon}`, 0, 0));
+
+		// Show description(s) - italic and truncated
+		for (const rule of this.rules) {
+			const desc = rule.description || rule.content;
+			if (desc) {
+				this.box.addChild(new Spacer(1));
+
+				let displayText = desc.trim();
+				if (!this._expanded) {
+					// Truncate to first 2 lines
+					const lines = displayText.split("\n");
+					if (lines.length > 2) {
+						displayText = `${lines.slice(0, 2).join("\n")}...`;
+					}
+				}
+
+				// Use italic for subtle distinction (fg colors conflict with inverse)
+				this.box.addChild(new Text(theme.italic(displayText), 0, 0));
+			}
+		}
+
+		// Show expand hint if collapsed and there's more content
+		if (!this._expanded) {
+			const hasMoreContent = this.rules.some((r) => {
+				const desc = r.description || r.content;
+				return desc && desc.split("\n").length > 2;
+			});
+			if (hasMoreContent) {
+				this.box.addChild(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
+			}
+		}
+	}
+}

package/src/modes/interactive/interactive-mode.ts

@@ -67,6 +67,7 @@ import { SessionSelectorComponent } from "./components/session-selector";
 import { SettingsSelectorComponent } from "./components/settings-selector";
 import { ToolExecutionComponent } from "./components/tool-execution";
 import { TreeSelectorComponent } from "./components/tree-selector";
+import { TtsrNotificationComponent } from "./components/ttsr-notification";
 import { UserMessageComponent } from "./components/user-message";
 import { UserMessageSelectorComponent } from "./components/user-message-selector";
 import { WelcomeComponent } from "./components/welcome";
@@ -1007,18 +1008,28 @@ export class InteractiveMode {
 				if (event.message.role === "user") break;
 				if (this.streamingComponent && event.message.role === "assistant") {
 					this.streamingMessage = event.message;
-					this.streamingComponent.updateContent(this.streamingMessage);
+					// Don't show "Aborted" text for TTSR aborts - we'll show a nicer message
+					if (this.session.isTtsrAbortPending && this.streamingMessage.stopReason === "aborted") {
+						// TTSR abort - suppress the "Aborted" rendering in the component
+						const msgWithoutAbort = { ...this.streamingMessage, stopReason: "stop" as const };
+						this.streamingComponent.updateContent(msgWithoutAbort);
+					} else {
+						this.streamingComponent.updateContent(this.streamingMessage);
+					}
 
 					if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
-						const errorMessage =
-							this.streamingMessage.stopReason === "aborted"
-								? "Operation aborted"
-								: this.streamingMessage.errorMessage || "Error";
-						for (const [, component] of this.pendingTools.entries()) {
-							component.updateResult({
-								content: [{ type: "text", text: errorMessage }],
-								isError: true,
-							});
+						// Skip error handling for TTSR aborts
+						if (!this.session.isTtsrAbortPending) {
+							const errorMessage =
+								this.streamingMessage.stopReason === "aborted"
+									? "Operation aborted"
+									: this.streamingMessage.errorMessage || "Error";
+							for (const [, component] of this.pendingTools.entries()) {
+								component.updateResult({
+									content: [{ type: "text", text: errorMessage }],
+									isError: true,
+								});
+							}
 						}
 						this.pendingTools.clear();
 					} else {
@@ -1188,6 +1199,15 @@ export class InteractiveMode {
 				this.ui.requestRender();
 				break;
 			}
+
+			case "ttsr_triggered": {
+				// Show a fancy notification when TTSR rules are triggered
+				const component = new TtsrNotificationComponent(event.rules);
+				component.setExpanded(this.toolOutputExpanded);
+				this.chatContainer.addChild(component);
+				this.ui.requestRender();
+				break;
+			}
 		}
 	}
 
@@ -2490,9 +2510,7 @@ export class InteractiveMode {
 				const nameRendered = sourceText ? `${theme.bold(nameText)} ${sourceRendered}` : theme.bold(nameText);
 				const pad = Math.max(0, maxNameWidth - visibleWidth(nameWithSourcePlain));
 				const desc = line.desc;
-				const descPart = desc
-					? `  ${theme.fg("dim", desc.slice(0, 50) + (desc.length > 50 ? "..." : ""))}`
-					: "";
+				const descPart = desc ? `  ${theme.fg("dim", desc.slice(0, 50) + (desc.length > 50 ? "..." : ""))}` : "";
 				return `  ${nameRendered}${" ".repeat(pad)}${descPart}`;
 			});
 
@@ -2536,15 +2554,13 @@ export class InteractiveMode {
 				(s) => (s._source ? { provider: s._source.providerName, level: s._source.level } : "unknown"),
 			);
 			if (skillWarnings.length > 0) {
-				sections.push(
-					{
-						kind: "text",
-						text:
-							theme.bold(theme.fg("warning", "Skill Warnings")) +
-							"\n" +
-							skillWarnings.map((w) => theme.fg("warning", `  ${w.skillPath}: ${w.message}`)).join("\n"),
-					},
-				);
+				sections.push({
+					kind: "text",
+					text:
+						theme.bold(theme.fg("warning", "Skill Warnings")) +
+						"\n" +
+						skillWarnings.map((w) => theme.fg("warning", `  ${w.skillPath}: ${w.message}`)).join("\n"),
+				});
 			}
 		}
 
@@ -2633,14 +2649,12 @@ export class InteractiveMode {
 		if (hookRunner) {
 			const hookPaths = hookRunner.getHookPaths();
 			if (hookPaths.length > 0) {
-				sections.push(
-					{
-						kind: "text",
-						text:
-							`${theme.bold(theme.fg("accent", "Hooks"))}\n` +
-							hookPaths.map((p) => `  ${theme.bold(basename(p))} ${theme.fg("dim", "hook")}`).join("\n"),
-					},
-				);
+				sections.push({
+					kind: "text",
+					text:
+						`${theme.bold(theme.fg("accent", "Hooks"))}\n` +
+						hookPaths.map((p) => `  ${theme.bold(basename(p))} ${theme.fg("dim", "hook")}`).join("\n"),
+				});
 			}
 		}
 
@@ -2652,9 +2666,7 @@ export class InteractiveMode {
 			? Math.min(60, Math.max(...allLines.map((line) => visibleWidth(line.nameWithSource))))
 			: 0;
 		const renderedSections = sections
-			.map((section) =>
-				section.kind === "lines" ? renderLineSection(section.section, maxNameWidth) : section.text,
-			)
+			.map((section) => (section.kind === "lines" ? renderLineSection(section.section, maxNameWidth) : section.text))
 			.filter((section) => section.length > 0);
 
 		if (renderedSections.length === 0) {