@oh-my-pi/pi-coding-agent 12.9.0 → 12.10.1

package/src/main.ts

@@ -477,6 +477,11 @@ async function buildSessionOptions(
 		settings.override("skills.includeSkills", parsed.skills as string[]);
 	}
 
+	// Rules
+	if (parsed.noRules) {
+		options.rules = [];
+	}
+
 	// Additional extension paths from CLI
 	const cliExtensionPaths = parsed.noExtensions ? [] : [...(parsed.extensions ?? []), ...(parsed.hooks ?? [])];
 	if (cliExtensionPaths.length > 0) {

package/src/memories/index.ts

@@ -168,7 +168,6 @@ export async function buildMemoryToolDeveloperInstructions(
 	if (!truncated.trim()) return undefined;
 
 	return renderPromptTemplate(readPathTemplate, {
-		base_path: memoryRoot,
 		memory_summary: truncated,
 	});
 }
@@ -575,8 +574,7 @@ async function runStage1Job(options: {
 		const budgetTokens = Math.floor(modelMaxTokens * config.rolloutPayloadPercent);
 		const truncatedItems = truncateByApproxTokens(serializedItems, budgetTokens);
 		const inputPrompt = renderPromptTemplate(stageOneInputTemplate, {
-			rollout_path: claim.rolloutPath,
-			cwd: claim.cwd,
+			thread_id: claim.threadId,
 			response_items_json: truncatedItems,
 		});
 
@@ -635,13 +633,9 @@ async function syncPhase2Artifacts(memoryRoot: string, outputs: Stage1OutputRow[
 		const stem = formatRolloutFilename(row.threadId, row.rolloutSlug);
 		const filename = `${stem}.md`;
 		keepFiles.add(filename);
-		const body = [
-			`thread_id: ${row.threadId}`,
-			`updated_at: ${row.sourceUpdatedAt}`,
-			`cwd: ${row.cwd}`,
-			"",
-			row.rolloutSummary,
-		].join("\n");
+		const body = [`thread_id: ${row.threadId}`, `updated_at: ${row.sourceUpdatedAt}`, "", row.rolloutSummary].join(
+			"\n",
+		);
 		await Bun.write(path.join(summariesDir, filename), `${body.trim()}\n`);
 	}
 
@@ -668,7 +662,7 @@ function buildRawMemoriesMarkdown(outputs: Stage1OutputRow[]): string {
 	}
 
 	const blocks = outputs.map(row => {
-		const header = [`## ${row.threadId}`, `updated_at: ${row.sourceUpdatedAt}`, `cwd: ${row.cwd}`, ""].join("\n");
+		const header = [`## ${row.threadId}`, `updated_at: ${row.sourceUpdatedAt}`, ""].join("\n");
 		return `${header}${row.rawMemory.trim()}\n`;
 	});
 	return `# Raw Memories\n\n${blocks.join("\n")}`;
@@ -707,7 +701,6 @@ async function runConsolidationModel(options: { memoryRoot: string; model: Model
 	const rawMemories = await Bun.file(path.join(memoryRoot, "raw_memories.md")).text();
 	const rolloutSummaries = await readRolloutSummaries(memoryRoot);
 	const input = renderPromptTemplate(consolidationTemplate, {
-		memory_root: memoryRoot,
 		raw_memories: truncateByApproxTokens(rawMemories, 20_000),
 		rollout_summaries: truncateByApproxTokens(rolloutSummaries, 12_000),
 	});
@@ -1077,7 +1070,7 @@ function loadMemoryConfig(settings: Settings): MemoryRuntimeConfig {
 	};
 }
 
-function getMemoryRoot(agentDir: string, cwd: string): string {
+export function getMemoryRoot(agentDir: string, cwd: string): string {
 	return path.join(agentDir, "memories", encodeProjectPath(cwd));
 }
 

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

@@ -139,6 +139,12 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "20", label: "20 messages" },
 		{ value: "30", label: "30 messages" },
 	],
+	"ttsr.interruptMode": [
+		{ value: "always", label: "always", description: "Interrupt on prose and tool streams" },
+		{ value: "prose-only", label: "prose-only", description: "Interrupt only on reply/thinking matches" },
+		{ value: "tool-only", label: "tool-only", description: "Interrupt only on tool-call argument matches" },
+		{ value: "never", label: "never", description: "Never interrupt; inject warning after completion" },
+	],
 	// Virtual terminal
 	"bash.virtualTerminal": [
 		{ value: "on", label: "On", description: "PTY-backed interactive execution" },

package/src/modes/rpc/rpc-client.ts

@@ -28,6 +28,8 @@ export interface RpcClientOptions {
 	provider?: string;
 	/** Model ID to use */
 	model?: string;
+	/** Session directory for the agent */
+	sessionDir?: string;
 	/** Additional CLI arguments */
 	args?: string[];
 }
@@ -108,6 +110,9 @@ export class RpcClient {
 		if (this.options.model) {
 			args.push("--model", this.options.model);
 		}
+		if (this.options.sessionDir) {
+			args.push("--session-dir", this.options.sessionDir);
+		}
 		if (this.options.args) {
 			args.push(...this.options.args);
 		}
@@ -153,6 +158,17 @@ export class RpcClient {
 		this.#pendingRequests.clear();
 	}
 
+	/**
+	 * Stop the RPC agent process and clean up resources.
+	 */
+	[Symbol.dispose](): void {
+		try {
+			this.stop();
+		} catch {
+			// Ignore cleanup errors
+		}
+	}
+
 	/**
 	 * Subscribe to agent events.
 	 */

package/src/prompts/memories/consolidation.md

@@ -1,5 +1,5 @@
 You are the memory consolidation agent.
-Memory root: {{memory_root}}
+Memory root: memory://root
 Input corpus (raw memories):
 {{raw_memories}}
 Input corpus (rollout summaries):

package/src/prompts/memories/read_path.md

@@ -1,10 +1,10 @@
 # Memory Guidance
-Memory root: {{base_path}}
+Memory root: memory://root
 Operational rules:
-1) Read `{{base_path}}/memory_summary.md` first.
-2) If needed, inspect `{{base_path}}/MEMORY.md` and `{{base_path}}/skills/*/SKILL.md`.
+1) Read `memory://root/memory_summary.md` first.
+2) If needed, inspect `memory://root/MEMORY.md` and `memory://root/skills/<name>/SKILL.md`.
 3) Decision boundary: trust memory for heuristics/process context; trust current repo files, runtime output, and user instruction for factual state and final decisions.
-4) Citation policy: when memory changes your plan, cite the memory artifact path you used (for example `memories/skills/<name>/SKILL.md`) and pair it with current-repo evidence before acting.
+4) Citation policy: when memory changes your plan, cite the memory artifact path you used (for example `memory://root/skills/<name>/SKILL.md`) and pair it with current-repo evidence before acting.
 5) Conflict workflow: if memory disagrees with repo state or user instruction, prefer repo/user, treat memory as stale, proceed with corrected behavior, then update/regenerate memory artifacts through normal execution.
 6) Escalate confidence only after repository verification; memory alone is never sufficient proof.
 Memory summary:

package/src/prompts/memories/stage_one_input.md

@@ -1,5 +1,4 @@
-rollout_path: {{rollout_path}}
-cwd: {{cwd}}
+thread_id: {{thread_id}}
 
 Persistable response items (JSON):
 {{response_items_json}}

package/src/prompts/tools/bash.md

@@ -4,34 +4,21 @@ Executes bash command in shell session for terminal operations like git, bun, ca
 
 <instruction>
 - Use `cwd` parameter to set working directory instead of `cd dir && ...`
-- Paths with spaces must use double quotes: `cd "/path/with spaces"`
-- For sequential dependent operations, chain with `&&`: `mkdir foo && cd foo && touch bar`
-- For parallel independent operations, make multiple tool calls in one message
 - Use `;` only when later commands should run regardless of earlier failures
+- `skill://` URIs are auto-resolved to filesystem paths before execution
+	- `python skill://my-skill/scripts/init.py` runs the script from the skill directory
+	- `skill://<name>/<relative-path>` resolves within the skill's base directory
+- `agent://`, `artifact://`, `plan://`, `memory://`, and `rule://` URIs are also auto-resolved to filesystem paths before execution
 </instruction>
 
 <output>
-Returns stdout, stderr, exit code from command execution.
-- Output truncated after 50KB or 2000 lines (whichever first); use `head` parameter to limit output
+Returns the output, and an exit code from command execution.
 - If output truncated, full output stored under $ARTIFACTS and referenced as `artifact://<id>` in metadata
-- Exit codes shown on non-zero exit; stderr captured
+- Exit codes shown on non-zero exit
 </output>
 
 <critical>
-Do NOT use Bash for these operations—specialized tools exist:
-- Reading file contents → Read tool
-- Searching file contents → Grep tool
-- Finding files by pattern → Find tool
-- Content-addressed edits → Edit tool
-- Writing new files → Write tool
-</critical>
-
-<avoid>
-Do NOT pipe through `head` or `tail`—use `head` and `tail` parameters instead:
-- `command | head -n 50` → use `head: 50` parameter
-- `command | tail -n 100` → use `tail: 100` parameter
-
-Pipe pattern breaks streaming output and prevents artifact storage.
-
-Do NOT use `2>&1`—stdout and stderr already merged.
-</avoid>
+- Do NOT use Bash for these operations like read, grep, find, edit, write, where specialized tools exist.
+- Do NOT use `2>&1` pattern, stdout and stderr are already merged.
+- Do NOT use `| head -n 50` or `| tail -n 100` pattern, use `head` and `tail` parameters instead.
+</critical>

package/src/prompts/tools/read.md

@@ -21,6 +21,8 @@ Reads files from local filesystem or internal URLs.
   - `skill://<name>` - read SKILL.md for a skill
   - `skill://<name>/<path>` - read relative path within skill directory
   - `rule://<name>` - read rule content
+  - `memory://root` - read memory summary (`memory_summary.md`)
+  - `memory://root/<path>` - read relative path within project memory root
   - `agent://<id>` - read agent output artifact
   - `agent://<id>/<path>` or `agent://<id>?q=<query>` - extract JSON from agent output
 </instruction>

package/src/sdk.ts

@@ -40,13 +40,14 @@ import {
 	AgentProtocolHandler,
 	ArtifactProtocolHandler,
 	InternalUrlRouter,
+	MemoryProtocolHandler,
 	PlanProtocolHandler,
 	RuleProtocolHandler,
 	SkillProtocolHandler,
 } from "./internal-urls";
 import { disposeAllKernelSessions } from "./ipy/executor";
 import { discoverAndLoadMCPTools, type MCPManager, type MCPToolsLoadResult } from "./mcp";
-import { buildMemoryToolDeveloperInstructions, startMemoryStartupTask } from "./memories";
+import { buildMemoryToolDeveloperInstructions, getMemoryRoot, startMemoryStartupTask } from "./memories";
 import { collectEnvSecrets, loadSecrets, obfuscateMessages, SecretObfuscator } from "./secrets";
 import { AgentSession } from "./session/agent-session";
 import { AuthStorage } from "./session/auth-storage";
@@ -133,6 +134,8 @@ export interface CreateAgentSessionOptions {
 	skills?: Skill[];
 	/** Skills to inline into the system prompt instead of listing available skills. */
 	preloadedSkills?: Skill[];
+	/** Rules. Default: discovered from multiple locations */
+	rules?: Rule[];
 	/** Context files (AGENTS.md content). Default: discovered walking up from cwd */
 	contextFiles?: Array<{ path: string; content: string }>;
 	/** Prompt templates. Default: discovered from cwd/.omp/prompts/ + agentDir/prompts/ */
@@ -671,17 +674,26 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// Discover rules
 	const ttsrSettings = settings.getGroup("ttsr");
 	const ttsrManager = new TtsrManager(ttsrSettings);
-	const rulesResult = await loadCapability<Rule>(ruleCapability.id, { cwd });
+	const rulesResult =
+		options.rules !== undefined
+			? { items: options.rules, warnings: undefined }
+			: await loadCapability<Rule>(ruleCapability.id, { cwd });
+	const registeredTtsrRuleNames = new Set<string>();
 	for (const rule of rulesResult.items) {
-		if (rule.ttsrTrigger) {
-			ttsrManager.addRule(rule);
+		if (rule.condition && rule.condition.length > 0) {
+			if (ttsrManager.addRule(rule)) {
+				registeredTtsrRuleNames.add(rule.name);
+			}
 		}
 	}
+	if (existingSession.injectedTtsrRules.length > 0) {
+		ttsrManager.restoreInjected(existingSession.injectedTtsrRules);
+	}
 	time("discoverTtsrRules");
 
 	// Filter rules for the rulebook (non-TTSR, non-alwaysApply, with descriptions)
 	const rulebookRules = rulesResult.items.filter((rule: Rule) => {
-		if (rule.ttsrTrigger) return false;
+		if (registeredTtsrRuleNames.has(rule.name)) return false;
 		if (rule.alwaysApply) return false;
 		if (!rule.description) return false;
 		return true;
@@ -729,7 +741,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		modelRegistry,
 	};
 
-	// Initialize internal URL router for agent:// and skill:// URLs
+	// Initialize internal URL router for internal protocols (agent://, artifact://, plan://, memory://, skill://, rule://)
 	const internalRouter = new InternalUrlRouter();
 	const getArtifactsDir = () => {
 		const sessionFile = sessionManager.getSessionFile();
@@ -743,6 +755,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			cwd,
 		}),
 	);
+	internalRouter.register(
+		new MemoryProtocolHandler({
+			getMemoryRoot: () => getMemoryRoot(agentDir, settings.getCwd()),
+		}),
+	);
 	internalRouter.register(
 		new SkillProtocolHandler({
 			getSkills: () => skills,

package/src/session/agent-session.ts

@@ -14,6 +14,7 @@
  */
 
 import * as fs from "node:fs";
+import * as path from "node:path";
 
 import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type {
@@ -43,7 +44,7 @@ import {
 import type { Settings, SkillsSettings } from "../config/settings";
 import { type BashResult, executeBash as executeBashCommand } from "../exec/bash-executor";
 import { exportSessionToHtml } from "../export/html";
-import type { TtsrManager } from "../export/ttsr";
+import type { TtsrManager, TtsrMatchContext } from "../export/ttsr";
 import type { LoadedCustomCommand } from "../extensibility/custom-commands";
 import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";
 import { CustomToolAdapter } from "../extensibility/custom-tools/wrapper";
@@ -346,6 +347,7 @@ export class AgentSession {
 	#ttsrManager: TtsrManager | undefined = undefined;
 	#pendingTtsrInjections: Rule[] = [];
 	#ttsrAbortPending = false;
+	#ttsrRetryToken = 0;
 
 	#streamingEditAbortTriggered = false;
 	#streamingEditCheckedLineCounts = new Map<string, number>();
@@ -456,46 +458,82 @@ export class AgentSession {
 			this.#ttsrManager.incrementMessageCount();
 		}
 
-		// TTSR: Check for pattern matches on text deltas and tool call argument deltas
+		// TTSR: Check for pattern matches on assistant text/thinking and tool 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());
+			let matchContext: TtsrMatchContext | undefined;
+
+			if (assistantEvent.type === "text_delta") {
+				matchContext = { source: "text" };
+			} else if (assistantEvent.type === "thinking_delta") {
+				matchContext = { source: "thinking" };
+			} else if (assistantEvent.type === "toolcall_delta") {
+				matchContext = this.#getTtsrToolMatchContext(event.message, assistantEvent.contentIndex);
+			}
+
+			if (matchContext && "delta" in assistantEvent) {
+				const matches = this.#ttsrManager.checkDelta(assistantEvent.delta, matchContext);
 				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);
-					// Abort the stream immediately — do not gate on extension callbacks
-					this.#ttsrAbortPending = true;
-					this.agent.abort();
-					// Notify extensions (fire-and-forget, does not block abort)
-					this.#emitSessionEvent({ type: "ttsr_triggered", rules: matches }).catch(() => {});
-					// 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();
-						}
+					// Queue rules for injection; mark as injected only after successful enqueue.
+
+					this.#addPendingTtsrInjections(matches);
+
+					if (this.#shouldInterruptForTtsrMatch(matchContext)) {
+						// Abort the stream immediately — do not gate on extension callbacks
+						this.#ttsrAbortPending = true;
+						this.agent.abort();
+						// Notify extensions (fire-and-forget, does not block abort)
+						this.#emitSessionEvent({ type: "ttsr_triggered", rules: matches }).catch(() => {});
+						// Schedule retry after a short delay
+						const retryToken = ++this.#ttsrRetryToken;
+						const generation = this.#promptGeneration;
+						const targetMessageTimestamp =
+							event.message.role === "assistant" ? event.message.timestamp : undefined;
+						setTimeout(async () => {
+							if (this.#ttsrRetryToken !== retryToken) {
+								return;
+							}
 
-						// 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;
+							const targetAssistantIndex = this.#findTtsrAssistantIndex(targetMessageTimestamp);
+							if (
+								!this.#ttsrAbortPending ||
+								this.#promptGeneration !== generation ||
+								targetAssistantIndex === -1
+							) {
+								this.#ttsrAbortPending = false;
+								this.#pendingTtsrInjections = [];
+								return;
+							}
+							this.#ttsrAbortPending = false;
+							const ttsrSettings = this.#ttsrManager?.getSettings();
+							if (ttsrSettings?.contextMode === "discard") {
+								// Remove the partial/aborted assistant turn from agent state
+								this.agent.replaceMessages(this.agent.state.messages.slice(0, targetAssistantIndex));
+							}
+							// Inject TTSR rules as system reminder before retry
+							const injection = this.#getTtsrInjectionContent();
+							if (injection) {
+								const details = { rules: injection.rules.map(rule => rule.name) };
+								this.agent.appendMessage({
+									role: "custom",
+									customType: "ttsr-injection",
+									content: injection.content,
+									display: false,
+									details,
+									timestamp: Date.now(),
+								});
+								this.sessionManager.appendCustomMessageEntry(
+									"ttsr-injection",
+									injection.content,
+									false,
+									details,
+								);
+								this.#markTtsrInjected(details.rules);
+							}
+							this.agent.continue().catch(() => {});
+						}, 50);
+						return;
+					}
 				}
 			}
 		}
@@ -522,6 +560,9 @@ export class AgentSession {
 					event.message.display,
 					event.message.details,
 				);
+				if (event.message.role === "custom" && event.message.customType === "ttsr-injection") {
+					this.#markTtsrInjected(this.#extractTtsrRuleNames(event.message.details));
+				}
 			} else if (
 				event.message.role === "user" ||
 				event.message.role === "assistant" ||
@@ -536,10 +577,8 @@ export class AgentSession {
 			// Track assistant message for auto-compaction (checked on agent_end)
 			if (event.message.role === "assistant") {
 				this.#lastAssistantMessage = event.message;
-
-				// Reset retry counter immediately on successful assistant response
-				// This prevents accumulation across multiple LLM calls within a turn
 				const assistantMsg = event.message as AssistantMessage;
+				this.#queueDeferredTtsrInjectionIfNeeded(assistantMsg);
 				if (
 					assistantMsg.stopReason !== "error" &&
 					assistantMsg.stopReason !== "aborted" &&
@@ -622,16 +661,185 @@ export class AgentSession {
 		}
 	}
 
-	/** Get TTSR injection content and clear pending injections */
-	#getTtsrInjectionContent(): string | undefined {
+	/** Get TTSR injection payload and clear pending injections. */
+	#getTtsrInjectionContent(): { content: string; rules: Rule[] } | undefined {
 		if (this.#pendingTtsrInjections.length === 0) return undefined;
-		const content = this.#pendingTtsrInjections
+		const rules = this.#pendingTtsrInjections;
+		const content = rules
 			.map(r => renderPromptTemplate(ttsrInterruptTemplate, { name: r.name, path: r.path, content: r.content }))
 			.join("\n\n");
 		this.#pendingTtsrInjections = [];
-		return content;
+		return { content, rules };
+	}
+
+	#addPendingTtsrInjections(rules: Rule[]): void {
+		const seen = new Set(this.#pendingTtsrInjections.map(rule => rule.name));
+		for (const rule of rules) {
+			if (seen.has(rule.name)) continue;
+			this.#pendingTtsrInjections.push(rule);
+			seen.add(rule.name);
+		}
 	}
 
+	#extractTtsrRuleNames(details: unknown): string[] {
+		if (!details || typeof details !== "object" || Array.isArray(details)) {
+			return [];
+		}
+		const rules = (details as { rules?: unknown }).rules;
+		if (!Array.isArray(rules)) {
+			return [];
+		}
+		return rules.filter((ruleName): ruleName is string => typeof ruleName === "string");
+	}
+
+	#markTtsrInjected(ruleNames: string[]): void {
+		const uniqueRuleNames = Array.from(
+			new Set(ruleNames.map(ruleName => ruleName.trim()).filter(ruleName => ruleName.length > 0)),
+		);
+		if (uniqueRuleNames.length === 0) {
+			return;
+		}
+		this.#ttsrManager?.markInjectedByNames(uniqueRuleNames);
+		this.sessionManager.appendTtsrInjection(uniqueRuleNames);
+	}
+
+	#findTtsrAssistantIndex(targetTimestamp: number | undefined): number {
+		const messages = this.agent.state.messages;
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const message = messages[i];
+			if (message.role !== "assistant") {
+				continue;
+			}
+			if (targetTimestamp === undefined || message.timestamp === targetTimestamp) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	#shouldInterruptForTtsrMatch(matchContext: TtsrMatchContext): boolean {
+		const mode = this.#ttsrManager?.getSettings().interruptMode ?? "always";
+		if (mode === "never") {
+			return false;
+		}
+		if (mode === "prose-only") {
+			return matchContext.source === "text" || matchContext.source === "thinking";
+		}
+		if (mode === "tool-only") {
+			return matchContext.source === "tool";
+		}
+		return true;
+	}
+
+	#queueDeferredTtsrInjectionIfNeeded(assistantMsg: AssistantMessage): void {
+		if (this.#ttsrAbortPending || this.#pendingTtsrInjections.length === 0) {
+			return;
+		}
+		if (assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error") {
+			this.#pendingTtsrInjections = [];
+			return;
+		}
+
+		const injection = this.#getTtsrInjectionContent();
+		if (!injection) {
+			return;
+		}
+		this.agent.followUp({
+			role: "custom",
+			customType: "ttsr-injection",
+			content: injection.content,
+			display: false,
+			details: { rules: injection.rules.map(rule => rule.name) },
+			timestamp: Date.now(),
+		});
+		// Mark as injected after this custom message is delivered and persisted (handled in message_end).
+		// followUp() only enqueues; resume on the next tick once streaming settles.
+		setTimeout(() => {
+			if (this.agent.state.isStreaming || !this.agent.hasQueuedMessages()) {
+				return;
+			}
+			this.agent.continue().catch(() => {});
+		}, 0);
+	}
+
+	/** Build TTSR match context for tool call argument deltas. */
+	#getTtsrToolMatchContext(message: AgentMessage, contentIndex: number): TtsrMatchContext {
+		const context: TtsrMatchContext = { source: "tool" };
+		if (message.role !== "assistant") {
+			return context;
+		}
+
+		const content = message.content;
+		if (!Array.isArray(content) || contentIndex < 0 || contentIndex >= content.length) {
+			return context;
+		}
+
+		const block = content[contentIndex];
+		if (!block || typeof block !== "object" || block.type !== "toolCall") {
+			return context;
+		}
+
+		const toolCall = block as ToolCall;
+		context.toolName = toolCall.name;
+		context.streamKey = toolCall.id ? `toolcall:${toolCall.id}` : `tool:${toolCall.name}:${contentIndex}`;
+		context.filePaths = this.#extractTtsrFilePathsFromArgs(toolCall.arguments);
+		return context;
+	}
+
+	/** Extract path-like arguments from tool call payload for TTSR glob matching. */
+	#extractTtsrFilePathsFromArgs(args: unknown): string[] | undefined {
+		if (!args || typeof args !== "object" || Array.isArray(args)) {
+			return undefined;
+		}
+
+		const rawPaths: string[] = [];
+		for (const [key, value] of Object.entries(args)) {
+			const normalizedKey = key.toLowerCase();
+			if (typeof value === "string" && (normalizedKey === "path" || normalizedKey.endsWith("path"))) {
+				rawPaths.push(value);
+				continue;
+			}
+			if (Array.isArray(value) && (normalizedKey === "paths" || normalizedKey.endsWith("paths"))) {
+				for (const candidate of value) {
+					if (typeof candidate === "string") {
+						rawPaths.push(candidate);
+					}
+				}
+			}
+		}
+
+		const normalizedPaths = rawPaths.flatMap(pathValue => this.#normalizeTtsrPathCandidates(pathValue));
+		if (normalizedPaths.length === 0) {
+			return undefined;
+		}
+
+		return Array.from(new Set(normalizedPaths));
+	}
+
+	/** Convert a path argument into stable relative/absolute candidates for glob checks. */
+	#normalizeTtsrPathCandidates(rawPath: string): string[] {
+		const trimmed = rawPath.trim();
+		if (trimmed.length === 0) {
+			return [];
+		}
+
+		const normalizedInput = trimmed.replaceAll("\\", "/");
+		const candidates = new Set<string>([normalizedInput]);
+		if (normalizedInput.startsWith("./")) {
+			candidates.add(normalizedInput.slice(2));
+		}
+
+		const cwd = this.sessionManager.getCwd();
+		const absolutePath = path.isAbsolute(trimmed) ? path.normalize(trimmed) : path.resolve(cwd, trimmed);
+		candidates.add(absolutePath.replaceAll("\\", "/"));
+
+		const relativePath = path.relative(cwd, absolutePath).replaceAll("\\", "/");
+		if (relativePath && relativePath !== "." && !relativePath.startsWith("../") && relativePath !== "..") {
+			candidates.add(relativePath);
+		}
+
+		return Array.from(candidates);
+	}
 	/** Extract text content from a message */
 	#getUserMessageText(message: Message): string {
 		if (message.role !== "user") return "";