Merge pull request #689 from code-yeongyu/feat/shared-rule-activation-tui

code-yeongyu · web-flow · commit 2ed421b0e550 · 2026-08-04T11:51:46.000+09:00
feat(coding-agent): render shared rule activations
diff --git a/packages/coding-agent/src/core/extensions/builtin/changes.md b/packages/coding-agent/src/core/extensions/builtin/changes.md
@@ -1,5 +1,13 @@
 # Builtin extensions changes
 
+## rule-activation: shared project-rules and TTSR notices (2026-08-04)
+
+- Added `rule-activation/` as a presentation-only builtin module with a typed discriminated activation contract, defensive persisted-data parser, custom-entry append/registration helpers, and a compact/expandable Box/Text renderer.
+- Project-rules and TTSR both register the same renderer so either extension still works when loaded alone. Project-rules records successful dynamic tool-path matches; TTSR records committed remediation while preserving its separate persistence entry and hidden model nudge.
+- Why shared code is required: the two engines retain incompatible discovery, matching, deduplication, and remediation semantics, but the TUI needs one stable durable-entry contract instead of engine-specific raw transcript text.
+- Coverage: `test/rules-before-agent-start.test.ts`, `test/ttsr/extension-wiring.test.ts`, and `test/suite/rule-activation-renderer.test.ts`.
+- Expected merge conflict zones: the new `rule-activation/` directory and the small registration/append seams in `rules/index.ts` and `ttsr/index.ts`. Do not fold engine policy into the shared module during conflict resolution.
+
 ## service-tier: enable fast mode for Codex API extension providers (2026-08-03)
 
 - `/fast` now checks the model's `openai-codex-responses` API capability instead
diff --git a/packages/coding-agent/src/core/extensions/builtin/rule-activation/index.ts b/packages/coding-agent/src/core/extensions/builtin/rule-activation/index.ts
@@ -0,0 +1,18 @@
+import type { ExtensionAPI } from "../../types.ts";
+import { renderRuleActivationEntry } from "./renderer.ts";
+import { RULE_ACTIVATION_ENTRY_TYPE, type RuleActivationDetails } from "./types.ts";
+
+export {
+	type ProjectRulesActivationDetails,
+	RULE_ACTIVATION_ENTRY_TYPE,
+	type RuleActivationDetails,
+	type TtsrActivationDetails,
+} from "./types.ts";
+
+export function registerRuleActivationRenderer(pi: ExtensionAPI): void {
+	pi.registerEntryRenderer(RULE_ACTIVATION_ENTRY_TYPE, renderRuleActivationEntry);
+}
+
+export function appendRuleActivation(pi: ExtensionAPI, details: RuleActivationDetails): void {
+	pi.appendEntry(RULE_ACTIVATION_ENTRY_TYPE, details);
+}
diff --git a/packages/coding-agent/src/core/extensions/builtin/rule-activation/renderer.ts b/packages/coding-agent/src/core/extensions/builtin/rule-activation/renderer.ts
@@ -0,0 +1,49 @@
+import { Box, Text } from "@earendil-works/pi-tui";
+import type { EntryRenderer } from "../../types.ts";
+import { parseRuleActivationDetails, type RuleActivationDetails } from "./types.ts";
+
+const BOLD = "\u001b[1m";
+const BOLD_OFF = "\u001b[22m";
+
+export const renderRuleActivationEntry: EntryRenderer<unknown> = (entry, options, theme) => {
+	const details = parseRuleActivationDetails(entry.data);
+	if (details === undefined) return undefined;
+	const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+	box.addChild(new Text(theme.fg("accent", `${BOLD}${titleLine(details)}${BOLD_OFF}`), 0, 0));
+	box.addChild(new Text(theme.fg("dim", summaryLine(details)), 0, 0));
+	if (options.expanded) {
+		box.addChild(new Text(theme.fg("dim", detailLine(details)), 0, 0));
+	}
+	return box;
+};
+
+function titleLine(details: RuleActivationDetails): string {
+	switch (details.kind) {
+		case "project-rules":
+			return `● Project rules · ${details.targetPath}`;
+		case "ttsr":
+			return `⚠ Stream rule · ${details.owner}`;
+	}
+}
+
+function summaryLine(details: RuleActivationDetails): string {
+	switch (details.kind) {
+		case "project-rules": {
+			const noun = details.rules.length === 1 ? "instruction" : "instructions";
+			return `${details.rules.length} ${noun} matched and injected for this tool result.`;
+		}
+		case "ttsr":
+			return details.remediation === "nudge"
+				? "Output interrupted; a corrective nudge was queued."
+				: "Corrupted generation discarded; bounded provider retry started.";
+	}
+}
+
+function detailLine(details: RuleActivationDetails): string {
+	switch (details.kind) {
+		case "project-rules":
+			return details.rules.map((rule) => `rule ${rule}`).join("\n");
+		case "ttsr":
+			return `remediation ${details.remediation} · observed ${details.rules.join(", ")}`;
+	}
+}
diff --git a/packages/coding-agent/src/core/extensions/builtin/rule-activation/types.ts b/packages/coding-agent/src/core/extensions/builtin/rule-activation/types.ts
@@ -0,0 +1,66 @@
+export const RULE_ACTIVATION_ENTRY_TYPE = "rule-activation";
+
+export interface ProjectRulesActivationDetails {
+	readonly kind: "project-rules";
+	readonly targetPath: string;
+	readonly rules: readonly string[];
+}
+
+export interface TtsrActivationDetails {
+	readonly kind: "ttsr";
+	readonly owner: string;
+	readonly rules: readonly string[];
+	readonly remediation: "nudge" | "provider-error";
+}
+
+export type RuleActivationDetails = ProjectRulesActivationDetails | TtsrActivationDetails;
+
+export function parseRuleActivationDetails(value: unknown): RuleActivationDetails | undefined {
+	if (!isObject(value)) return undefined;
+	const kind = Reflect.get(value, "kind");
+	switch (kind) {
+		case "project-rules":
+			return parseProjectRulesActivation(value);
+		case "ttsr":
+			return parseTtsrActivation(value);
+		default:
+			return undefined;
+	}
+}
+
+function parseProjectRulesActivation(value: object): ProjectRulesActivationDetails | undefined {
+	const targetPath = Reflect.get(value, "targetPath");
+	const rules = stringList(Reflect.get(value, "rules"));
+	if (typeof targetPath !== "string" || targetPath.length === 0 || rules === undefined) return undefined;
+	return { kind: "project-rules", targetPath, rules };
+}
+
+function parseTtsrActivation(value: object): TtsrActivationDetails | undefined {
+	const owner = Reflect.get(value, "owner");
+	const rules = stringList(Reflect.get(value, "rules"));
+	const remediation = Reflect.get(value, "remediation");
+	if (
+		typeof owner !== "string" ||
+		owner.length === 0 ||
+		rules === undefined ||
+		(remediation !== "nudge" && remediation !== "provider-error")
+	) {
+		return undefined;
+	}
+	return { kind: "ttsr", owner, rules, remediation };
+}
+
+function stringList(value: unknown): readonly string[] | undefined {
+	if (
+		!Array.isArray(value) ||
+		value.length === 0 ||
+		!value.every((entry) => typeof entry === "string" && entry.length > 0)
+	) {
+		return undefined;
+	}
+	return value;
+}
+
+function isObject(value: unknown): value is object {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
diff --git a/packages/coding-agent/src/core/extensions/builtin/rules/changes.md b/packages/coding-agent/src/core/extensions/builtin/rules/changes.md
@@ -2,6 +2,23 @@
 
 Vendored from [`code-yeongyu/pi-rules`](https://github.com/code-yeongyu/pi-rules) (see `external-versions.json`).
 
+## 2026-08-04 - Shared activation notices for dynamic rules
+
+### What changed and why
+
+- The vendored extension now registers Senpi's shared `rule-activation` entry renderer and appends a typed, display-only activation entry after a newly matched dynamic rule block is added to a tool result.
+- The notice records the tool target and matched rule paths so the TUI can show a compact summary and expandable details instead of presenting the injected instruction block as undifferentiated tool output.
+- Static `before_agent_start` delivery, dynamic fingerprint deduplication, and the exact model-facing instruction block are unchanged.
+
+### Why this cannot stay upstream-only
+
+- Upstream pi-rules owns matching and prompt delivery but does not own Senpi's custom-entry renderer registry or shared TTSR presentation layer. The adapter therefore belongs at the Senpi builtin boundary.
+
+### Coverage and expected conflict zones
+
+- Coverage: `test/rules-before-agent-start.test.ts` verifies unchanged dynamic model delivery plus the typed activation entry; `test/suite/rule-activation-renderer.test.ts` verifies standalone renderer registration and malformed persisted-data handling.
+- Expected conflicts: `index.ts` around renderer registration and the dynamic `tool_result` return path. Preserve the shared activation append after `markDynamicInjected(...)` and before returning augmented tool content.
+
 ## Senpi adaptations vs upstream
 
 - Imports rewritten by `scripts/vendor-transform.mjs`: `@mariozechner/pi-tui` -> `@earendil-works/pi-tui`; `@mariozechner/pi-coding-agent` symbols -> `../../types.ts` (and `Theme` -> `modes/interactive/theme/theme.ts`); relative `.js` import suffixes -> `.ts`.
diff --git a/packages/coding-agent/src/core/extensions/builtin/rules/index.ts b/packages/coding-agent/src/core/extensions/builtin/rules/index.ts
@@ -3,6 +3,7 @@ import { isAbsolute, relative } from "node:path";
 
 import type { ExtensionAPI } from "../../types.ts";
 
+import { appendRuleActivation, registerRuleActivationRenderer } from "../rule-activation/index.ts";
 import { registerSlashCommands } from "./commands.ts";
 import { configFromEnvironment } from "./config.ts";
 import { createEngine } from "./rules/engine.ts";
@@ -41,6 +42,7 @@ export default function piRulesExtension(pi: ExtensionAPI): void {
 		extractToolPaths,
 	});
 	registerSlashCommands(pi, engine);
+	registerRuleActivationRenderer(pi);
 
 	function syncConfigFromFlags(): void {
 		const disabled = pi.getFlag("pi-rules-disabled");
@@ -139,10 +141,16 @@ export default function piRulesExtension(pi: ExtensionAPI): void {
 		}
 
 		const firstPendingTarget = pendingFingerprints[0]?.targetPath ?? firstTargetPath;
-		const block = engine.formatDynamic(rules, displayPath(ctx.cwd, firstPendingTarget));
+		const targetPath = displayPath(ctx.cwd, firstPendingTarget);
+		const block = engine.formatDynamic(rules, targetPath);
 		for (const rule of rules) {
 			engine.markDynamicInjected(firstTargetPath, rule);
 		}
+		appendRuleActivation(pi, {
+			kind: "project-rules",
+			targetPath,
+			rules: rules.map((rule) => rule.relativePath),
+		});
 
 		return { content: [...event.content, { type: "text", text: block }] };
 	});
diff --git a/packages/coding-agent/src/core/extensions/builtin/ttsr/changes.md b/packages/coding-agent/src/core/extensions/builtin/ttsr/changes.md
@@ -1,5 +1,23 @@
 # TTSR Fork Tracker
 
+## 2026-08-04 - Shared visible activation records
+
+### What changed and why
+
+- TTSR now registers Senpi's shared `rule-activation` entry renderer and appends a typed visible activation record whenever remediation is committed.
+- The new record reports the detector owner, observed rule ids, and whether the remediation used a hidden nudge or bounded provider-error retry.
+- The existing `ttsr-injection` persistence entry, hidden corrective `custom_message`, abort/truncation flow, provider retry, repeat gating, and session restoration are unchanged.
+
+### Why an extension-local change is required
+
+- TTSR remains the sole owner of the point where a detection becomes committed remediation. A generic TUI layer cannot infer that state safely from stream deltas or from the hidden nudge without coupling itself to the coordinator.
+- The shared module owns only typed presentation; TTSR still owns detection, interruption, transcript mutation, and retry policy.
+
+### Coverage and expected conflict zones
+
+- Coverage: `test/ttsr/extension-wiring.test.ts` verifies both remediation modes retain their existing records/messages and add the typed activation entry; `test/suite/rule-activation-renderer.test.ts` verifies standalone renderer registration and expanded TTSR details.
+- Expected conflicts: `index.ts` around extension registration and `recordInjection(...)`. Preserve both the original persistence append and the additional shared activation append.
+
 ## 2026-07-31 - Interrupt fabricated unavailable-tool calls
 
 ### What changed and why
diff --git a/packages/coding-agent/src/core/extensions/builtin/ttsr/index.ts b/packages/coding-agent/src/core/extensions/builtin/ttsr/index.ts
@@ -1,6 +1,7 @@
 import { getKeybindings } from "@earendil-works/pi-tui";
 
 import type { ExtensionAPI, ExtensionContext, MessageUpdateEvent } from "../../types.ts";
+import { appendRuleActivation, registerRuleActivationRenderer } from "../rule-activation/index.ts";
 import { BUILTIN_TTSR_RULES } from "./builtin-rules.ts";
 import { registerTtsrCommands, type TtsrPublicState } from "./commands.ts";
 import { claimAbort, createGenerationState, markUserCancelled } from "./coordinator.ts";
@@ -53,6 +54,7 @@ function parseDisabledRules(raw: boolean | string | undefined): string[] {
 }
 
 export default function ttsrExtension(pi: ExtensionAPI): void {
+	registerRuleActivationRenderer(pi);
 	pi.registerFlag("ttsr-disabled", {
 		type: "boolean",
 		default: false,
@@ -82,13 +84,19 @@ export default function ttsrExtension(pi: ExtensionAPI): void {
 		}
 	}
 
-	function recordInjection(owner: string, observed: readonly string[], retryMode: string): void {
+	function recordInjection(owner: string, observed: readonly string[], retryMode: "nudge" | "provider-error"): void {
 		pi.appendEntry(TTSR_INJECTION_CUSTOM_TYPE, {
 			rules: observed,
 			owner,
 			remediation: retryMode,
 			at: Date.now(),
 		});
+		appendRuleActivation(pi, {
+			kind: "ttsr",
+			owner,
+			rules: observed,
+			remediation: retryMode,
+		});
 	}
 
 	function notify(ctx: ExtensionContext, owner: string): void {
diff --git a/packages/coding-agent/test/rules-before-agent-start.test.ts b/packages/coding-agent/test/rules-before-agent-start.test.ts
@@ -27,20 +27,31 @@ import { createModelRegistry } from "./model-runtime-test-utils.ts";
 
 const BASE_SYSTEM_PROMPT = "BASE SYSTEM PROMPT (rebuilt by the host on every user prompt)";
 const STATIC_BLOCK_HEADING = "## Project Instructions";
+const RULE_ACTIVATION_ENTRY_TYPE = "rule-activation";
+
+interface AppendedEntry {
+	readonly customType: string;
+	readonly data: unknown;
+}
 
 describe("rules builtin - before_agent_start delivery", () => {
 	let projectDir: string;
 	let canaryRulePath: string;
 	let canaryRuleContents: string;
 	let canaryToken: string;
+	let dynamicRuleToken: string;
+	let targetPath: string;
+	let appendedEntries: AppendedEntry[];
 	let sessionManager: SessionManager;
 	let modelRegistry: ModelRegistry;
 
 	const extensionActions: ExtensionActions = {
 		registerLazyToolActivator: () => {},
 		sendMessage: () => {},
 		sendUserMessage: () => {},
-		appendEntry: () => {},
+		appendEntry: (customType, data) => {
+			appendedEntries.push({ customType, data });
+		},
 		setSessionName: () => {},
 		getSessionName: () => undefined,
 		setLabel: () => {},
@@ -123,7 +134,17 @@ describe("rules builtin - before_agent_start delivery", () => {
 		canaryRuleContents = `---\nalwaysApply: true\n---\n\n# Canary rule\n\n${canaryToken}\n`;
 		canaryRulePath = join(projectDir, ".omo", "rules", "canary.md");
 		writeFileSync(canaryRulePath, canaryRuleContents, "utf-8");
+		dynamicRuleToken = `RULES-DYNAMIC-CANARY-${randomUUID()}`;
+		writeFileSync(
+			join(projectDir, ".omo", "rules", "typescript.md"),
+			`---\nglobs: src/**/*.ts\n---\n\n# TypeScript rule\n\n${dynamicRuleToken}\n`,
+			"utf-8",
+		);
+		targetPath = join(projectDir, "src", "lib", "proxy", "strategy.ts");
+		mkdirSync(join(projectDir, "src", "lib", "proxy"), { recursive: true });
+		writeFileSync(targetPath, "export const strategy = true;\n", "utf-8");
 
+		appendedEntries = [];
 		sessionManager = SessionManager.inMemory();
 		modelRegistry = await createModelRegistry(AuthStorage.create(join(projectDir, "auth.json")));
 	});
@@ -212,4 +233,39 @@ describe("rules builtin - before_agent_start delivery", () => {
 			"a rule already present as a native context file must not be injected again",
 		).not.toContain(canaryToken);
 	});
+
+	it("#given a path-scoped rule #when a matching read tool result arrives #then the model block and display-only activation entry are both emitted", async () => {
+		const runner = await createRunner();
+		const prompt = await runner.emitBeforeAgentStart(
+			"Read the target TypeScript file",
+			undefined,
+			BASE_SYSTEM_PROMPT,
+			{
+				cwd: projectDir,
+			},
+		);
+		expect(prompt?.systemPrompt ?? "").not.toContain(dynamicRuleToken);
+
+		const toolResult = await runner.emitToolResult({
+			type: "tool_result",
+			toolName: "read",
+			toolCallId: "call-read-strategy",
+			input: { path: "src/lib/proxy/strategy.ts" },
+			content: [{ type: "text", text: "export const strategy = true;" }],
+			details: undefined,
+			isError: false,
+		});
+
+		expect(textOf(toolResult?.content)).toContain(dynamicRuleToken);
+		expect(appendedEntries).toContainEqual(
+			expect.objectContaining({
+				customType: RULE_ACTIVATION_ENTRY_TYPE,
+				data: expect.objectContaining({
+					kind: "project-rules",
+					targetPath: "src/lib/proxy/strategy.ts",
+					rules: expect.arrayContaining([".omo/rules/typescript.md"]),
+				}),
+			}),
+		);
+	});
 });
diff --git a/packages/coding-agent/test/suite/rule-activation-renderer.test.ts b/packages/coding-agent/test/suite/rule-activation-renderer.test.ts
diff --git a/packages/coding-agent/test/suite/ttsr-activation-assertions.ts b/packages/coding-agent/test/suite/ttsr-activation-assertions.ts
diff --git a/packages/coding-agent/test/suite/ttsr-extension.test.ts b/packages/coding-agent/test/suite/ttsr-extension.test.ts
diff --git a/packages/coding-agent/test/ttsr/extension-wiring.test.ts b/packages/coding-agent/test/ttsr/extension-wiring.test.ts
