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

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## [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
+
+- Improved `/status` command output formatting to use consistent column alignment across all sections
+- Updated version update notification to suggest `omp update` instead of manual npm install command
+
 ## [3.1.1337] - 2026-01-03
 ### Added
 

package/docs/extension-loading.md

@@ -775,7 +775,7 @@ Update argument parsing:
   result.noHooks = true;
 ```
 
-Add subcommand handling for `pi install`, `pi remove`, `pi update`.
+Add subcommand handling for `omp install`, `omp remove`, `omp update`.
 
 ### `src/core/hooks/loader.ts`
 
@@ -949,7 +949,7 @@ if (settings.skills?.customDirectories) {
 5. **Phase 5: CLI updates**
    - Add new flags to args.ts
    - Update help text
-   - Add `pi install`, `pi remove`, `pi update` subcommands
+   - Add `omp install`, `omp remove`, `omp update` subcommands
 
 6. **Phase 6: Integration**
    - Update sdk.ts

package/docs/sdk.md

@@ -54,7 +54,7 @@ The main factory function. Creates an `AgentSession` with configurable options.
 
 **Philosophy:** "Omit to discover, provide to override."
 
-- Omit an option → pi discovers/loads from standard locations
+- Omit an option → omp discovers/loads from standard locations
 - Provide an option → your value is used, discovery skipped for that option
 
 ```typescript
@@ -405,7 +405,7 @@ const { session } = await createAgentSession({
 
 **When you don't need factories:**
 
-- If you omit `tools`, pi automatically creates them with the correct `cwd`
+- If you omit `tools`, omp automatically creates them with the correct `cwd`
 - If you use `process.cwd()` as your `cwd`, the pre-built instances work fine
 
 **When you must use factories:**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "3.1.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.1.1337",
-		"@oh-my-pi/pi-ai": "3.1.1337",
-		"@oh-my-pi/pi-tui": "3.1.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();
+	}
 }