gentle-pi 3.1.0 → 3.1.1

package/assets/orchestrator-memory.md

@@ -14,7 +14,7 @@ On resume, use `mem_context`, then project/feature-scoped `mem_search`, and `mem
 
 Before implementation or resume, the parent reads both the actual file and full observation, reconciles them, and passes the locator and relevant context; workers read the document before edits. Small work without a document still receives its authorized scope and checks.
 
-The existing `todo` tool is an optional session/UI projection, not a third authority. Rebuild it from reconciled feature progress when useful; its replay or completed-list clearing must not delete or replace the durable file or Engram copy. Small/read-only work does not acquire an ODD artifact merely because the UI displays tasks.
+The existing `todo` tool is the required session/UI projection for substantial ODD, not a third authority. After reconciling and writing the durable file and Engram copy, create or rebuild the visible `todo` list from the same feature tasks before the first source write; after every task transition and material plan change, update both durable copies and the visible projection in the same turn; its replay or completed-list clearing must not delete or replace the durable file or Engram copy. If the projection is unavailable, record that limitation without pretending it is synchronized. Small/read-only work does not acquire an ODD artifact or todo list merely because the UI can display tasks.
 
 ### SDD phases
 

package/assets/sdd-orchestrator-workflow.md

@@ -71,7 +71,7 @@ Do not guess the active change. If change selection is ambiguous, ask the user a
 
 ## Lazy SDD Preflight
 
-Do not ask SDD setup questions on session start. The first time the user initiates an SDD process in a Pi session, run the SDD preflight once and keep those choices for the rest of that session. Runtime trigger detection is intentionally deterministic: slash SDD flows and `/gentle-sdd-init` run preflight automatically; for natural-language requests, the parent/orchestrator decides semantically whether SDD is needed and must run/reuse `/gentle:sdd-preflight` before continuing.
+Do not ask SDD setup questions on session start. The first time the user initiates an SDD process in a Pi session, run the SDD preflight once and keep those choices for the rest of that session. Runtime input detection is intentionally syntax-only: slash SDD flows and `/gentle-sdd-init` run preflight automatically; ordinary natural-language text never triggers preflight by itself. For natural-language requests, the parent/orchestrator decides semantically whether the user explicitly selected SDD. Only after that selection, when the parent is about to dispatch the first SDD operation or agent, the execution gate runs or reuses `/gentle:sdd-preflight` before allowing SDD work to start. Merely mentioning, asking about, explaining, comparing, auditing, or referencing SDD — including questions ("what is SDD?"), negatives ("don't use SDD for this"), conditionals ("could we use SDD?"), bug reports about SDD itself, and passing references — stays in the normal read-only flow without preflight, the init guard, or any SDD phase. When a message is ambiguous between discussing SDD and requesting it, ask one clarification and remain read-only until answered.
 
 **Hard gate:** `openspec/config.yaml`, existing SDD changes, installed `.pi`/global SDD assets, or a todo named "preflight" are not session preflight. They are project context only. Do not mark SDD preflight complete, start `sdd-init`, launch SDD subagents/chains, or move to explore/proposal/spec/design/tasks until this session has an injected `## SDD Session Preflight` block or an equivalent resolution from the canonical authority order below.
 

package/extensions/gentle-ai.ts

@@ -1388,8 +1388,8 @@ Organic Driven Development (ODD) is the predefined workflow of this orchestrator
 2. **Explore.** Explore existing code and requirements first, proportionately to the request, before proposing or writing anything.
 3. **Resolve uncertainty.** Recommend optional research only for a named uncertainty; ask one focused user question only for a real unresolved product decision, then stop and wait; use at most one scoped read-only assumption challenge for a high-consequence unproven premise.
 4. **Classify.** The work is substantial when exploration yields two or more meaningful implementation steps, or progress worth recovering after an interruption. Small, understood work stays small and creates no durable task artifacts.
-5. **Track before the first write.** For substantial authorized implementation, create \`odd/tasks/<feature-name>.md\` and its Engram mirror \`odd/<feature-name>/tasks\` automatically, before the first source write, without asking permission for tasks or storage. Tell the user in one line which feature document was created and how many tasks it holds.
-6. **Implement task by task.** Route each task through the orchestrator's Work Routing Ladder, with the configured TDD mode and applicable checks. Check an item off only after its outcome and checks were observed; update the file and the mirror after each task.
+5. **Track before the first write.** For substantial authorized implementation, create \`odd/tasks/<feature-name>.md\` and its Engram mirror \`odd/<feature-name>/tasks\` automatically, then create or rebuild the visible \`todo\` list from the reconciled feature tasks, all before the first source write and without asking permission for tasks or storage. Tell the user in one line which feature document was created and how many tasks it holds.
+6. **Implement task by task.** Route each task through the orchestrator's Work Routing Ladder, with the configured TDD mode and applicable checks. Check an item off only after its outcome and checks were observed; update the file, mirror, and visible \`todo\` projection after every task transition and material plan change.
 7. **Close.** Report the verified outcome, every failed, skipped, or pending check, and the next step. Native review applies only at the deliverable boundary and only under the user-owned RDD switch.
 Resume an interrupted feature with \`mem_context\`, then project- and feature-scoped \`mem_search\`, then \`mem_get_observation\` for the full document, then the task file itself; reconcile before continuing the next unfinished task. Detail for steps 3–7: \`orchestrator-delegation.md\` and \`orchestrator-memory.md\`.
 

package/extensions/pi-pretty.ts

@@ -61,7 +61,19 @@ export default async function gentlePiPrettyExtension(
 			};
 		},
 	});
-	const result = await extension(delegated, deps);
+	// pi-pretty's hidden-thinking API is global. Its best-effort private per-row
+	// patch can miss the host's actual component class and then animate every
+	// historical Thinking row. Gentle Shell chooses the robust presentation:
+	// keep collapsed labels static while preserving the separate working frame.
+	const previousThinkingIndicator = process.env.PRETTY_THINKING_INDICATOR;
+	process.env.PRETTY_THINKING_INDICATOR = "off";
+	let result: unknown;
+	try {
+		result = await extension(delegated, deps);
+	} finally {
+		if (previousThinkingIndicator === undefined) delete process.env.PRETTY_THINKING_INDICATOR;
+		else process.env.PRETTY_THINKING_INDICATOR = previousThinkingIndicator;
+	}
 	// GentlePromptEditor already carries the live working state in its frame.
 	// Hide Pi's separate loader row to avoid repeating Thinking above the input;
 	// transcript thinking blocks remain untouched as historical reasoning markers.

package/lib/sdd-preflight.ts

@@ -835,26 +835,12 @@ export function installPackageAssets(
 	}, lockOptions);
 }
 
-function hasAffirmativeSddIntent(text: string): boolean {
-	// Natural-language routing must not depend on a closed list of complete
-	// phrases. An SDD mention becomes an invocation only with an imperative,
-	// request, or first-person intent marker; a neutral statement such as
-	// "I use SDD sometimes" remains ordinary conversation.
-	if (!/\bsdd\b/i.test(text)) return false;
-	return /(?:\b(?:please|por\s+favor)\b|\b(?:want|need|would\s+like|let'?s|quiero|queremos|necesito|quisiera|me\s+gustar[ií]a|vamos|vayamos|hagamos|usemos)\b|^(?:use|run|start|build|create|implement|handle|make|usa|usá|corre|corré|arranca|arrancá|inicia|iniciá|empeza|empezá|hacelo|hazlo|hacerlo)\b)/i.test(text);
-}
-
+// Input interception is intentionally syntax-only. Natural-language SDD intent
+// belongs to the parent/orchestrator; dispatch and before_agent_start gates run
+// or reuse preflight when an SDD action is actually attempted. This keeps mere
+// mentions side-effect free without trying to encode language in a regex.
 export function isSddPreflightTrigger(text: string): boolean {
-	const trimmed = text.trim();
-	if (/^\/(?:gentle-)?sdd(?:[-:][^\s]*)?(?:\s|$)/i.test(trimmed)) return true;
-	if (/[?？]\s*$/.test(trimmed)) return false;
-	if (
-		/(?:\b(?:don't|do\s+not|never)\b|\bnot\s+(?:want|need|plan(?:ning)?|intend|use|using)\b)[^.!?\n]{0,80}\bsdd\b/i.test(trimmed) ||
-		/\b(?:sin\s+usar|no\s+(?:quiero|queremos|necesito|necesitamos|quisiera|quisiéramos|vamos\s+a|pienso|planeo|usar))\b[^.!?\n]{0,80}\bsdd\b/i.test(trimmed)
-	) {
-		return false;
-	}
-	return hasAffirmativeSddIntent(trimmed);
+	return /^\/(?:gentle-)?sdd(?:[-:][^\s]*)?(?:\s|$)/i.test(text.trim());
 }
 
 export function sddPreflightSessionKey(ctx: ExtensionContext): string {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gentle-pi",
-	"version": "3.1.0",
+	"version": "3.1.1",
 	"description": "Turn Pi into el Gentleman: a senior-architect development harness with SDD/OpenSpec, subagents, strict TDD evidence, review guardrails, and skill discovery.",
 	"license": "MIT",
 	"type": "module",

package/tests/gentle-theme.test.ts

@@ -219,6 +219,8 @@ test("bundled Gentleman-Cute Pi theme defines complete brand and restrained colo
 	assertResolvedThemeColor(theme, "error", "#FF718F");
 	assertResolvedThemeColor(theme, "muted", "#A78E9B");
 	assertResolvedThemeColor(theme, "dim", "#76616B");
+	assert.equal(colors.thinkingText, "softRose");
+	assertResolvedThemeColor(theme, "thinkingText", "#D7A0B8");
 	assertResolvedThemeColor(theme, "toolPendingBg", "#100A0F");
 	assertResolvedThemeColor(theme, "toolSuccessBg", "#151316");
 	assertResolvedThemeColor(theme, "toolErrorBg", "#261019");

package/tests/odd-routing-contract.test.ts

@@ -81,7 +81,11 @@ test("organic progress preserves both complete feature copies and reconciles act
 		"mem_get_observation",
 		"read the actual task file",
 		"not a third authority",
+		"create or rebuild the visible `todo` list",
+		"before the first source write",
+		"after every task transition and material plan change",
 	]);
+	assert.doesNotMatch(memory, /`todo` tool is an optional session\/UI projection/);
 });
 
 test("assumption challenge and task checks do not activate or duplicate native review", () => {
@@ -170,6 +174,7 @@ test("ODD protocol is always-on in the rendered system prompt and runs by defaul
 		"4. **Classify.**",
 		"two or more meaningful implementation steps",
 		"5. **Track before the first write.**",
+		"create or rebuild the visible `todo` list from the reconciled feature tasks",
 		"Tell the user in one line which feature document was created and how many tasks it holds",
 		"6. **Implement task by task.**",
 		"7. **Close.**",

package/tests/package-manifest.test.ts

@@ -1574,9 +1574,9 @@ test("pi-pretty wrapper uses cached ESM loading for compiled and pnpm symlink in
 	assert.match(wrapper, /quietToolsEnabled/);
 });
 
-test("v3.1.0 release package and runtime stop before publication", () => {
+test("Gentle Shell v3.1.1 package and runtime stop before publication", () => {
 	const packageJson = readPackageJson();
-	assert.equal(packageJson.version, "3.1.0", "the release manifest must remain explicitly pinned to v3.1.0");
+	assert.equal(packageJson.version, "3.1.1", "the release manifest must remain explicitly pinned to v3.1.1");
 	assert.equal(
 		packageJson.scripts?.test,
 		"node --experimental-strip-types --test tests/*.test.ts && pnpm run check:provider-contract && pnpm run test:harness",

package/tests/pi-pretty.test.ts

@@ -18,13 +18,18 @@ test("bundled pretty cannot replace or restore an editor owned by the host", asy
 		setWorkingVisible(value: boolean) { visible = value; },
 		theme: { fg: (role: string, text: string) => `<${role}>${text}</${role}>`, bold: (text: string) => text },
 	} };
+	const previousThinkingIndicator = process.env.PRETTY_THINKING_INDICATOR;
+	let thinkingIndicatorDuringActivation: string | undefined;
 	await pretty(pi, undefined, async (api: any) => {
+		thinkingIndicatorDuringActivation = process.env.PRETTY_THINKING_INDICATOR;
 		api.on("session_start", (_event: unknown, context: any) => {
 			context.ui.setEditorComponent(() => "pretty");
 			context.ui.setWorkingIndicator({ frames: ["foreign"] });
 		});
 		api.on("session_shutdown", (_event: unknown, context: any) => context.ui.setEditorComponent(undefined));
 	}, {});
+	assert.equal(thinkingIndicatorDuringActivation, "off", "Gentle Shell disables pi-pretty's global Thinking shimmer");
+	assert.equal(process.env.PRETTY_THINKING_INDICATOR, previousThinkingIndicator, "activation must restore the caller's environment");
 	for (const handler of handlers.get("session_start") ?? []) await handler({}, ctx);
 	assert.equal(editor, owner);
 	assert.equal(visible, false, "the prompt frame owns the live working state without a duplicate loader row");

package/tests/runtime-harness.mjs

@@ -1250,24 +1250,26 @@ async function run() {
 			await inputHook({ text: "vamos con sdd", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
-		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
-		assert.equal(existsSync(join(lazySddCwd, ".pi", "chains", "sdd-full.chain.md")), false);
-		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
-		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-status.md")), true);
-		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), false);
-		assert.equal(existsSync(join(globalAgentHome, "gentle-ai", "support", "sdd-status-contract.md")), true);
-		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
-		assert.equal(ctx.ui.selections.length, 1, "first interactive SDD trigger confirms session suggestions");
-		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: explicit session choice/);
 		assert.deepEqual(
 			await inputHook({ text: "please use sdd for this change", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
-		assert.equal(ctx.ui.selections.length, 1, "natural SDD triggers reuse confirmed session choices");
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "agents", "sdd-apply.md")), false);
+		assert.equal(existsSync(join(lazySddCwd, ".pi", "chains", "sdd-full.chain.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), false);
+		assert.equal(ctx.ui.selections.length, 0, "natural-language SDD text has no input-hook side effect");
+
 		assert.deepEqual(
 			await inputHook({ text: "/sdd", source: "interactive" }, ctx),
 			{ action: "continue" },
 		);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-apply.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-status.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "agents", "sdd-sync.md")), false);
+		assert.equal(existsSync(join(globalAgentHome, "gentle-ai", "support", "sdd-status-contract.md")), true);
+		assert.equal(existsSync(join(globalAgentHome, "chains", "sdd-full.chain.md")), true);
+		assert.equal(ctx.ui.selections.length, 1, "first slash SDD trigger confirms session suggestions");
+		assert.match(ctx.ui.notifications.at(-1).message, /Preference source: explicit session choice/);
 		assert.deepEqual(
 			await inputHook({ text: "/sdd plan", source: "interactive" }, ctx),
 			{ action: "continue" },

package/tests/sdd-managed-runtime-settlement.test.ts

@@ -75,9 +75,9 @@ test("remediation actor preserves separately authorized memory artifact tools",
 
 test("R1 confirms exact canonical paths and commands; data, denial and symlinks grant nothing", async t => {
 	const { confirmRemediationScope, remediationToolAllowed } = await import("../extensions/gentle-agents.ts");
-	const { mkdtempSync, writeFileSync, symlinkSync, rmSync } = await import("node:fs");
+	const { mkdtempSync, realpathSync, writeFileSync, symlinkSync, rmSync } = await import("node:fs");
 	const { tmpdir } = await import("node:os"); const { join } = await import("node:path");
-	const cwd = mkdtempSync(join(tmpdir(), "remediation-scope-")); t.after(() => rmSync(cwd, { recursive: true, force: true }));
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "remediation-scope-"))); t.after(() => rmSync(cwd, { recursive: true, force: true }));
 	const target = join(cwd, "allowed.ts"); writeFileSync(target, "original"); symlinkSync(target, join(cwd, "alias.ts"));
 	const candidate = { ...plan, cwd, editPaths: [target] }, native = { mode: "repo-local", workspaceRoot: cwd, allowedEditRoots: [cwd] };
 	let shown = "", confirmations = 0;

package/tests/sdd-preflight-rpc-input.test.ts

@@ -8,17 +8,12 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 import { isSddPreflightTrigger, sddPreflightDiskPath } from "../lib/sdd-preflight.ts";
 
-// gentle-pi#1001: the natural-language SDD `input` hook called the parent-only
-// preflight resolver for every matching prompt, RPC children included.
-// `ensureSddPreflight` rejects RPC by design, the hook caught that rejection and
-// answered `handled`, and Pi's `AgentSession.prompt()` accepts handled input and
-// returns before `before_agent_start` and the model loop. A delegated child
-// therefore ACKed a prompt it never ran: no agent_start, zero turns, zero tool
-// calls, and a stall that only surfaced as the runner's inactivity timeout.
-//
-// An RPC child consumes the parent-rendered preflight block transported in its
-// task context. It must never originate preflight, and the interceptor must
-// never consume a delegated prompt on its behalf.
+// The `input` hook is syntax-only: slash SDD commands may originate preflight
+// in an interactive parent, while ordinary natural-language text always reaches
+// the model. Natural-language SDD selection belongs to the parent/orchestrator;
+// dispatch and before_agent_start gates enforce preflight at the action boundary.
+// RPC children consume the parent-rendered preflight block transported in task
+// context and never originate preflight.
 
 type InputResult = { action: "continue" | "handled" };
 type InputHandler = (event: { text?: unknown }, ctx: ExtensionContext) => Promise<InputResult>;
@@ -52,13 +47,11 @@ function ctx(overrides: Record<string, unknown>): ExtensionContext {
 	} as unknown as ExtensionContext;
 }
 
-test("the delegated task text reaches the preflight interceptor", () => {
-	// Guards the premise of the tests below: if the classifier stops matching
-	// this text they would pass for the wrong reason.
-	assert.equal(isSddPreflightTrigger(DELEGATED_SDD_TASK), true);
+test("natural-language SDD task text bypasses the input preflight interceptor", () => {
+	assert.equal(isSddPreflightTrigger(DELEGATED_SDD_TASK), false);
 });
 
-test("an RPC child's matching prompt is not consumed by the preflight interceptor", async () => {
+test("an RPC child's natural-language SDD prompt is not consumed by the input hook", async () => {
 	const input = inputHook();
 	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-rpc-input-"));
 	const notifications: string[] = [];
@@ -95,27 +88,34 @@ test("an RPC child's ordinary prompt still continues", async () => {
 	}
 });
 
-test("an interactive parent still resolves preflight for a matching prompt", async () => {
+test("an interactive parent's natural-language SDD request has no input-hook side effect", async () => {
 	const input = inputHook();
-	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-parent-input-"));
+	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-parent-natural-input-"));
+	try {
+		const result = await input(
+			{ text: DELEGATED_SDD_TASK },
+			ctx({ cwd, hasUI: false, sessionManager: { getSessionId: () => "sdd-preflight-natural-parent" } }),
+		);
+		assert.deepEqual(result, { action: "continue" });
+		assert.equal(existsSync(sddPreflightDiskPath(cwd)), false, "text alone must not persist preflight");
+	} finally {
+		await rm(cwd, { recursive: true, force: true });
+	}
+});
+
+test("an interactive parent still resolves preflight for an explicit slash SDD command", async () => {
+	const input = inputHook();
+	const cwd = await mkdtemp(join(tmpdir(), "gentle-pi-parent-slash-input-"));
 	const agentHome = await mkdtemp(join(tmpdir(), "gentle-pi-parent-agent-home-"));
 	const previousAgentHome = process.env.GENTLE_PI_AGENT_HOME;
 	process.env.GENTLE_PI_AGENT_HOME = agentHome;
 	try {
 		const result = await input(
-			{ text: DELEGATED_SDD_TASK },
-			ctx({
-				cwd,
-				hasUI: false,
-				sessionManager: { getSessionId: () => "sdd-preflight-interactive-parent" },
-			}),
+			{ text: "/sdd-new feature" },
+			ctx({ cwd, hasUI: false, sessionManager: { getSessionId: () => "sdd-preflight-slash-parent" } }),
 		);
 		assert.deepEqual(result, { action: "continue" });
-		assert.equal(
-			existsSync(sddPreflightDiskPath(cwd)),
-			true,
-			"the parent remains the only actor that resolves and persists preflight",
-		);
+		assert.equal(existsSync(sddPreflightDiskPath(cwd)), true, "slash SDD commands still resolve preflight");
 	} finally {
 		if (previousAgentHome === undefined) delete process.env.GENTLE_PI_AGENT_HOME;
 		else process.env.GENTLE_PI_AGENT_HOME = previousAgentHome;

package/tests/sdd-preflight.test.ts

@@ -507,20 +507,25 @@ test("only a structurally valid parent-rendered preflight block can reach an SDD
 	assert.equal(isParentConfirmedSddPreflightContext("## SDD Session Preflight\ncaller-authored defaults"), false);
 });
 
-test("affirmative natural-language SDD requests trigger preflight without matching a finite phrase list", () => {
+test("natural-language SDD text never triggers input preflight", () => {
+	// Natural-language intent belongs to the parent/orchestrator. The input hook
+	// is syntax-only; execution gates enforce preflight when an SDD action is
+	// actually attempted.
 	for (const text of [
 		"quiero hacer un proyecto con SDD",
 		"I want to build this with SDD",
 		"por favor usemos SDD para este cambio",
-	]) {
-		assert.equal(isSddPreflightTrigger(text), true, text);
-	}
-	for (const text of [
+		"do SDD for this change",
+		"haz SDD para este cambio",
+		"continue the SDD change",
 		"Should we use SDD?",
 		"no quiero usar SDD por ahora",
-		"no necesito usar SDD",
-		"I don't want to use SDD",
 		"I use SDD sometimes",
+		"necesito reportar un bug del preflight de SDD",
+		"I need to report a bug in the SDD preflight",
+		"quiero comparar SDD con ODD",
+		"I want to review the SDD proposal",
+		"necesito una explicación de SDD",
 	]) {
 		assert.equal(isSddPreflightTrigger(text), false, text);
 	}

package/tests/windows-hidden-processes.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { createRequire, syncBuiltinESMExports } from "node:module";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
@@ -102,7 +102,7 @@ async function captureOwnedRoutes(t: TestContext): Promise<{ captures: Capture[]
 	const cp = childProcess();
 	const original = { execFileSync: cp.execFileSync, execFile: cp.execFile, spawnSync: cp.spawnSync };
 	const captures: Capture[] = [];
-	const cwd = mkdtempSync(join(tmpdir(), "gentle-pi-windows-hidden-workspace-"));
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-windows-hidden-workspace-")));
 	t.after(() => rmSync(cwd, { recursive: true, force: true }));
 	mkdirSync(join(cwd, ".git"), { recursive: true });
 	const fakeSync = ((command: string, args: readonly string[], options: Options = {}) => {

package/themes/Gentleman-Cute.json

@@ -40,7 +40,7 @@
     "muted": "muted",
     "dim": "dim",
     "text": "text",
-    "thinkingText": "muted",
+    "thinkingText": "softRose",
     "selectedBg": "selection",
     "scrollbarThumb": "border",
     "searchMatchBg": "deepPink",