@widnyana/design-thinking 0.0.6 → 0.0.20

package/README.md

@@ -43,11 +43,15 @@ pi install npm:@widnyana/design-thinking
 omp install npm:@widnyana/design-thinking
 
 # pinned version
-pi install npm:@widnyana/design-thinking@0.0.1
+pi install npm:@widnyana/design-thinking@0.0.19
 
 # from a local checkout of this repo
 pi install /absolute/path/to/pi-packages/design-thinking
 
+# via the omp marketplace
+omp plugin marketplace add widnyana/eyay-toolkits
+omp plugin install design-thinking@eyay-toolkits
+
 # try without installing
 pi -e npm:@widnyana/design-thinking
 pi -e ./pi-packages/design-thinking
@@ -61,7 +65,8 @@ pi -e ./pi-packages/design-thinking
 |---|---|
 | `/dt` | Toggle Design Thinking mode. While on, plans and reviews render as Design Graphs. Persists across restarts. |
 | `/dt on\|off\|status` | Set or query the mode explicitly. |
-| `/dt approve\|deny` | Arm/revoke file edits for the next agent run — run `approve` after a presented graph to let the implementation run edit, `deny` to re-lock. |
+| Review dialog | When a run ends with a presented Design Graph — or the agent asks for approval in prose — a dialog opens automatically (arrow keys + Enter or mouse), **never mid-run**: **Approve** arms the gate (file edits, shells, code execution) **and** sends the go-ahead so implementation starts immediately, **Refine** asks for feedback and sends it back to the agent (the dialog re-opens after the updated graph), **Deny** keeps everything blocked until a new Design Graph is presented (a Deny latches — it won't re-prompt on every run end). Headless/no-UI sessions fall back to manual `/dt approve\|deny`. While unapproved, `write`, `edit`, `bash`, and code-execution tools are blocked outright — read-only exploration keeps `read`/`grep`/`glob`, plus read-only MCP lookups (qmd, codegraph explore). |
+| LSP reminder | Always-on, independent of `/dt`: while the harness has an `lsp` tool (omp with LSP enabled — default), every run gets a short `LSP FIRST` block — use the language server for definitions/references/renames/diagnostics, never hand-grep or hand-edit renames; if the project has no configured server, the agent tells you once per session how to enable one. Without an `lsp` tool, you get one notification per session **with a UI** (omp: enable it or add a server; pi: pi has no LSP integration) — headless/no-UI sessions get none. |
 | `/dt <prompt>` | Turn the mode **on** (never off), then run `<prompt>` under it — graph and clarifying questions first, implementation after your go-ahead. |
 | `/cg <module \| task>` | Generate a call graph: extract the graph existing code implements, or sketch one for a task. |
 | `/cg-plan <task>` | Design before code — full Design Graph, then implement to match it. |

package/extensions/design-thinking.ts

@@ -10,14 +10,43 @@
  * system prompt so design/plan/review answers render as Design Graphs in
  * Graph Protocol form. Full specs live in the package's references/ directory,
  * loaded on demand — not inlined here, to keep the injected prompt small.
+ * Separately, an ALWAYS-ON LSP reminder composes into every run's system
+ * prompt while the harness exposes an `lsp` tool (mode-independent); without
+ * one, the user is told once per session how to enable it.
  *
  * Commands:
  *   /dt            toggle Design Thinking mode
  *   /dt on|off     set explicitly
- *   /dt status     show current state
- *   /dt approve|deny  arm/revoke file edits for the next agent run
- *   /dt <prompt>   turn mode ON (never off), then run <prompt> as a user
- *                  message — graph + clarifying questions before implementation
+ *   /dt approve|deny  manual arm/revoke fallback (headless / no-UI sessions)
+ *   After a gated run presents a Design Graph, a review dialog opens
+ *   automatically: Approve (arm + implement), Refine (send feedback), or
+ *   Deny (keep file edits blocked). /dt <prompt> turns the mode ON (never
+ *   off) and runs the prompt — graph + clarifying questions before code.
+ *
+ * Approval gate design (one state machine, one owner):
+ *   - The gate is `{ mode: "off" | "on", approval: "none" | "armed" }`. Every
+ *     change goes through a transition function; handlers never touch the
+ *     fields directly.
+ *   - Approval is scoped to ONE human turn. It survives the many runs of
+ *     implementing an approved design, and is re-locked (relock()) when a new
+ *     user instruction arrives — a genuine `input` event, not the extension's
+ *     own go-ahead / refine messages. The next instruction is a refinement:
+ *     the agent updates and re-presents the graph, then the dialog re-opens.
+ *   - At most one review dialog exists. Each offer carries an epoch; a dialog
+ *     decision is applied only if its epoch is still current AND the gate is
+ *     still on AND still unapproved. Stale decisions are discarded, not
+ *     applied.
+ *   - The dialog opens at run end when the agent presented a Design Graph
+ *     (VERDICT + section headers) OR ended the turn asking for approval in
+ *     prose — the human always gets a button, never a prose-only ask.
+ *   - Dialogs are opened with an extension-owned AbortSignal: omp binds
+ *     handler-opened dialogs to the handler's 30s abort scope, and a floating
+ *     promise does not escape that binding. If the dialog is still dismissed
+ *     (runtime kill, or the agent's own dialog displacing it), the offer is
+ *     retracted and a fresh one opens at the next run end. No reopen loops,
+ *     no timing heuristics.
+ *   - An explicit Deny latches until a NEW graph is presented: deny means
+ *     stop asking.
  *
  * Stack-agnostic: no language detection, no auto-enable. Adapt the vocabulary
  * to whatever stack the project uses; never the discipline.
@@ -62,13 +91,20 @@ Pipeline: shapes → graph(A) → cardinality → E(⟳retry ↯escape ☠die)
 🔒 parse at boundaries → ⛈ orthogonal behavior → scope → test-R → verdict.
 
 Rules:
-- ANY turn that will end in code or file edits (feature, change, fix,
+- ANY turn that will end in code or file changes (feature, change, fix,
   refactor — the model does NOT get to reclassify the request): render the
   Design Graph in Graph Protocol form and any clarifying questions FIRST;
-  ZERO file edits until the user approves the design. Reading/exploring code
-  first is fine; the FIRST edit is not allowed before the graph. Once the
-  user runs /dt approve, edits are armed for the NEXT run: implement the
-  approved design without re-presenting the graph.
+  ZERO mutations until the user approves the design — no file edits, no
+  shell commands, no code execution. Reading/exploring code first is fine,
+  via read-only tools only (read/grep/glob; read-only MCP devices such as
+  qmd and codegraph exploration also pass). If any tool call is blocked by
+  the gate, STOP: do NOT route the change around it via bash, eval, scripts,
+  or subagents — present or update the graph and end the turn. End the turn
+  after the graph with NO prose approval request — no "approve and I'll…", no
+  "let me know", no go-ahead questions. A review dialog opens automatically
+  when the run ends — never mid-run: approve (implement the presented design
+  without re-presenting the graph), refine (present an updated graph), or
+  deny (stay blocked).
 - Design, plan, and review answers must render a Design Graph — fixed
   sections: PROBLEM, SHAPES, GRAPH, CARDINALITY, BOUNDARIES, BEHAVIOR, SCOPE,
   TEST LAYERS, VERDICT.
@@ -81,46 +117,257 @@ Full specs — read these when a section needs detail:
 - ${REF_DIR}/protocol.md      (Graph Protocol: notation spec + worked example)
 - ${REF_DIR}/method.md        (the §1–§10 method, generalized)
 - ${REF_DIR}/design-graph.md  (the artifact spec + completeness checklist)
-Skills load BY NAME into the agent (/skill:<name>); the files above are named
-by stem, NOT by skill name. Exact mapping:
-  /skill:graph-protocol → protocol.md   /skill:design-method → method.md
-  /skill:design-graph → design-graph.md
-  The extension blocks write/edit tools mechanically until the user runs
-  /dt approve — it arms the NEXT run, cleared when that run ends. Re-approve
-  per implementation round. Present the graph first.
+  The extension blocks file edits, shells (bash/powershell), and code
+  execution (eval) mechanically until the user approves — a review dialog
+  opens when a graph-presenting run ends. Approval covers
+  ONE human turn: it stays armed across the many runs it takes to implement
+  the approved design, and drops the moment the user sends a new instruction.
+  Treat that next instruction as a refinement of the current design: UPDATE
+  the existing Design Graph to fold it in and re-present it (do not start a
+  blank graph unless the goal itself changed), then end the turn and wait for
+  the dialog. /dt deny or mode off also re-lock.
+  NEVER ask the user to run /dt approve, /dt deny, or any approval command:
+  the dialog is automatic, and mentioning commands just confuses the flow.
 NEVER read references/<skill-name>.md — no such files exist.
 `.trim();
 
-// pi's file-edit tools — the mechanical gate's scope ("file edits"). Bash
-// stays open for read-only exploration. apply_patch/multiedit are Claude Code
-// tool names that never fire in pi; keep this list to real pi mutators.
+// pi + omp mutation tools — the mechanical gate's scope. While unapproved,
+// these are blocked outright: file edits (write, edit), shells (bash, and
+// powershell on Windows), and omp's code-execution kernel (eval). Names a
+// harness lacks never fire — a no-op there (powershell on unix, eval on pi).
+// Bash is NOT pattern-gated: a deny-list of shell mutators is porous by
+// construction (redirects, package managers, interpreters — `go mod init` is
+// the proof), and the design turn should execute nothing anyway. Read-only
+// exploration keeps its dedicated tools (read/grep/find/ls/glob); read-only
+// MCP devices routed through write on omp pass too (see READONLY_MCP_PATH).
 const MUTATING_TOOLS: Record<string, true> = {
 	write: true,
 	edit: true,
+	bash: true,
+	powershell: true,
+	eval: true,
+};
+// omp executes MCP tools through the `write` tool as `xd://mcp__<tool>`
+// device paths; the blanket write block would eat them. Pure knowledge
+// lookups are carved out in the tool_call handler: qmd (retrieve/search)
+// and codegraph's read-only actions. Everything else stays blocked — file
+// writes and execution devices (ast_edit, lsp, debug, browser,
+// chrome_devtools, codegraph init/index/sync/unlock); unknown codegraph
+// actions and unparsable device args default to blocked.
+const READONLY_MCP_PATH =
+	/^xd:\/\/mcp__(?:[\w-]+__)?(?:qmd_(?:get|multi_get|query|status|search)|codegraph_explore)$/;
+
+const READONLY_CODEGRAPH_ACTIONS: Record<string, true> = {
+	explore: true,
+	node: true,
+	search: true,
+	files: true,
+	status: true,
+	callers: true,
+	callees: true,
+	impact: true,
+	affected: true,
+	help: true,
 };
 
 interface DtState {
 	enabled: boolean;
 }
 
+
+
 const GATE_REASON =
-	"Design Thinking mode is ON: present the Design Graph (Graph Protocol) and wait for user approval before file edits. The user arms the NEXT run with /dt approve; the approval clears when that run ends.";
+	"Design Thinking mode is ON: file edits, shell commands, and code execution are blocked until the user approves the presented design. Do NOT attempt this change through any other channel — no bash or shell commands, no eval/scripts, no subagent delegation. Explore with read-only tools (read/grep/glob), present (or update and re-present) the Design Graph (Graph Protocol), then END YOUR TURN with NO prose approval request — an approval dialog opens for the user automatically when the run ends. NEVER ask the user to run /dt approve, /dt deny, or any command; NEVER re-attempt the blocked action this turn.";
+
+const REVIEW_OPTIONS = [
+	"Approve — implement now",
+	"Refine — ask the agent for changes",
+	"Deny — keep file edits blocked",
+] as const;
+
+const GO_AHEAD_MESSAGE =
+	"Approved — implement the presented design now. (Design Thinking gate is armed; go straight to implementation, no graph re-presentation.)";
+
+/** Always-on LSP discipline block — mode-INDEPENDENT: it composes into every
+ *  run's system prompt while a language server exists, whether or not /dt is
+ *  on. */
+const LSP_REMINDER = `
+LSP FIRST — a language server is available in this session.
+- definition, type_definition, implementation, references, hover, symbols,
+  rename, rename_file, code_actions, diagnostics: use the \`lsp\` tool.
+- NEVER hand-grep for definitions/references or hand-edit cross-file renames
+  when \`lsp\` answers the same question — it follows shadowing and re-exports
+  that text search misses.
+- Imports and quick-fixes: list \`code_actions\`, apply one.
+- If \`lsp\` reports no configured servers for this project, tell the user ONCE
+  this session how to enable one (project lsp.json or server install), then
+  continue without repeating it.
+`.trim();
+
+const LSP_SUGGESTION_OMP =
+	"LSP Reminder: no `lsp` tool in this session — LSP is disabled. Enable it in settings, or add a server for this project (lsp.json; auto-detect needs a root marker plus the server binary on PATH). Until then, code intelligence falls back to text search.";
+
+const LSP_SUGGESTION_PI =
+	"LSP Reminder: pi has no LSP integration — code intelligence falls back to text search. omp provides a built-in `lsp` tool.";
+
+// Graph Protocol section headers. A real Design Graph renders the fixed set;
+// VERDICT is mandatory. Requiring VERDICT + ≥3 others avoids tripping on a bare
+// mention of the word "verdict" in prose, and still fires on a graph rendered
+// without that exact literal elsewhere.
+const SECTION_HEADER =
+	/^[ \t]*#{0,4}[ \t>*-]*(PROBLEM|SHAPES|GRAPH|CARDINALITY|BOUNDARIES|BEHAVIOR|SCOPE|TEST LAYERS|VERDICT)\b/gm;
+
+/** The agent is asking the human for a go-ahead in prose — narrow on purpose so
+ *  an ordinary closing sentence does not trip it. */
+const APPROVAL_ASK =
+	/\b(approve|go[- ]?ahead|await(?:ing)? (?:your )?(?:approval|go)|shall i (?:implement|proceed|write|build|start)|should i (?:implement|proceed|write|build|start)|want me to (?:implement|write|build|start|proceed)|ready to implement)\b/i;
+
+/** Flatten an AgentMessage's content to plain text (string or content parts). */
+function messageText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.map((part) =>
+			part && typeof part === "object" && typeof (part as { text?: unknown }).text === "string"
+				? (part as { text: string }).text
+				: "",
+		)
+		.join("\n");
+}
+
+/** Does an assistant message render a Design Graph (Graph Protocol)? */
+function presentsGraph(message: { role: string; content?: unknown }): boolean {
+	if (message.role !== "assistant") return false;
+	const seen = new Set<string>();
+	for (const m of messageText(message.content).matchAll(SECTION_HEADER)) seen.add(m[1]);
+	return seen.has("VERDICT") && seen.size >= 4;
+}
+
+/** Did the agent end its turn asking the human to approve, in prose? */
+function asksApproval(message: { role: string; content?: unknown }): boolean {
+	return message.role === "assistant" && APPROVAL_ASK.test(messageText(message.content));
+}
+
+interface Offer {
+	epoch: number;
+	abort: AbortController;
+}
 
 export default function designThinkingExtension(pi: ExtensionAPI) {
-	let enabled = false;
-	// Armed by /dt approve for the NEXT agent run. Cleared when that run ends
-	// (agent_end), by /dt deny, or when the mode turns off. Not persisted.
-	let editsApproved = false;
+	// ── Gate state — the ONLY mutable state; change it via the transitions
+	// below, never inline in a handler. ─────────────────────────────────────
+	let mode: "off" | "on" = "off";
+	// "armed" lets mutating tools through. Approval is NOT consumed by runs:
+	// implementing an approved design spans many runs, and re-arming per run
+	// only produced approval loops. It is re-locked by relock() when a new user
+	// instruction arrives, when a NEW Design Graph is presented, by /dt deny, or
+	// when the mode turns off.
+	let approval: "none" | "armed" = "none";
+	// A Design Graph was presented in the CURRENT design cycle. Reset by
+	// relock() — i.e. when a new user instruction arrives. Approval is scoped to
+	// one human turn: it survives the many runs of implementing an approved
+	// design, and drops the moment the user speaks again (a new goal, or a
+	// refinement of the current one → re-graph, re-approve).
+	let cycleGraphSeen = false;
+	// Set by an explicit deny (dialog or /dt deny). Latches until a NEW graph
+	// is presented — deny means stop asking.
+	let graphDenied = false;
+	// Dialog offers. Monotonic epoch; a decision applies only when its epoch
+	// matches the live offer and the gate still allows arming.
+	let nextEpoch = 1;
+	let offer: Offer | undefined;
+	// How many messages of the session have already been scanned for VERDICT.
+	let scannedMessages = 0;
+
+	// ── LSP reminder state — always-on, independent of dt mode ───────────────
+	// Probed once per session; the suggestion fires at most once per session
+	// (reset on session_start). Probing uses pi.getAllTools(), present on both
+	// pi 0.84.3 and omp; omp is detected via its pi.logger surface (absent on
+	// pi) only to pick the suggestion text.
+	let lspProbed = false;
+	let lspCapable = false;
+	let lspSuggested = false;
+
+	function isOmp(): boolean {
+		return typeof (pi as ExtensionAPI & { logger?: unknown }).logger === "object";
+	}
+
+	function probeLsp(): void {
+		lspProbed = true;
+		try {
+			const tools: Array<{ name?: string }> =
+				(pi as ExtensionAPI & { getAllTools?: () => unknown[] }).getAllTools?.() ?? [];
+			lspCapable = tools.some((t) => t?.name === "lsp");
+		} catch {
+			lspCapable = false;
+		}
+	}
+
+	function maybeSuggestLsp(ctx: ExtensionContext): void {
+		if (lspSuggested || lspCapable || !ctx.hasUI) return;
+		lspSuggested = true;
+		ctx.ui.notify(isOmp() ? LSP_SUGGESTION_OMP : LSP_SUGGESTION_PI, "info");
+	}
+
+	// omp-only pi.logger surface; absent on pi 0.84.3.
+	const logger = (pi as ExtensionAPI & { logger?: { warn?: (msg: string) => void } }).logger;
+
+	// ── Transitions ─────────────────────────────────────────────────────────
+	function setMode(on: boolean): void {
+		mode = on ? "on" : "off";
+		if (!on) {
+			approval = "none";
+			cycleGraphSeen = false;
+			graphDenied = false;
+			retractOffer();
+		}
+	}
+
+	/** Arm the gate. Fails when the mode is off or an approval is already in
+	 *  effect — the caller decides how to surface that. */
+	function arm(): boolean {
+		if (mode !== "on" || approval !== "none") return false;
+		approval = "armed";
+		retractOffer();
+		return true;
+	}
+
+	/** Explicit revoke (/dt deny). Latches graph review until a new graph. */
+	function revoke(): void {
+		approval = "none";
+		graphDenied = true;
+		retractOffer();
+	}
 
+	/** A new user instruction opens a fresh design decision: re-lock the gate so
+	 *  the agent must present (or update and re-present) the graph and get a new
+	 *  approval before editing. Not called for the extension's own go-ahead /
+	 *  refine messages. */
+	function relock(): void {
+		if (mode !== "on") return;
+		approval = "none";
+		cycleGraphSeen = false;
+		graphDenied = false;
+		retractOffer();
+	}
+
+	function retractOffer(): void {
+		offer?.abort.abort();
+		offer = undefined;
+	}
+
+	/** May a dialog decision from `epoch` still be applied? */
+	function decisionApplies(epoch: number): boolean {
+		return offer?.epoch === epoch && mode === "on" && approval === "none";
+	}
+
+	// ── Session plumbing ────────────────────────────────────────────────────
 	function applyStatus(ctx: ExtensionContext) {
-		ctx.ui.setStatus(
-			"design-thinking",
-			enabled ? "design-thinking: on" : undefined,
-		);
+		ctx.ui.setStatus("design-thinking", mode === "on" ? "design-thinking: on" : undefined);
 	}
 
 	function persist() {
-		pi.appendEntry<DtState>(STATE_TYPE, { enabled });
+		pi.appendEntry<DtState>(STATE_TYPE, { enabled: mode === "on" });
 	}
 
 	function restore(ctx: ExtensionContext) {
@@ -134,13 +381,15 @@ export default function designThinkingExtension(pi: ExtensionAPI) {
 				}
 			}
 		}
-		if (restored !== undefined) {
-			enabled = restored;
-		}
+		if (restored !== undefined) setMode(restored);
 	}
 
-	// Restore toggle state when a session starts, loads, or reloads.
 	pi.on("session_start", async (_event, ctx) => {
+		// A new session gets one fresh LSP probe and suggestion.
+		lspProbed = false;
+		lspSuggested = false;
+		probeLsp();
+		maybeSuggestLsp(ctx);
 		restore(ctx);
 		applyStatus(ctx);
 	});
@@ -149,53 +398,64 @@ export default function designThinkingExtension(pi: ExtensionAPI) {
 		ctx.ui.setStatus("design-thinking", undefined);
 	});
 
-	// /dt — the Design Thinking tool. Toggles mode; on|off|status set/query;
-	// approve|deny arm/revoke file edits; anything else runs as a prompt with mode on.
+	// ── /dt command ─────────────────────────────────────────────────────────
 	pi.registerCommand("dt", {
-		description: "Design Thinking mode: /dt toggles, on|off|status set/query, approve arms the next run for file edits, deny revokes; anything else runs as a prompt with mode on",
+		description: "Design Thinking mode: /dt toggles, on|off|status set/query, approve asks then implements, deny re-locks; anything else runs as a prompt with mode on",
 		handler: async (args, ctx) => {
 			const arg = (args ?? "").trim();
 			const lower = arg.toLowerCase();
 
 			if (lower === "status") {
-				ctx.ui.notify(`Design Thinking mode: ${enabled ? "on" : "off"}${editsApproved ? " (file edits armed for the next run)" : ""}`, "info");
+				ctx.ui.notify(`Design Thinking mode: ${mode === "on" ? "on" : "off"}${approval === "armed" ? " (gate armed)" : ""}`, "info");
 				return;
 			}
 
 			if (lower === "approve") {
-				if (!enabled) {
+				if (mode !== "on") {
 					ctx.ui.notify("Design Thinking is OFF — nothing to approve. Run /dt on first.", "info");
 					return;
 				}
-				editsApproved = true;
-				ctx.ui.notify("Design Thinking: file edits armed (current or next run) — it may implement the approved design without re-presenting the graph", "info");
+				// Direct arm: the interactive approve/refine/deny dialog opens
+				// automatically after a gated run ends; this command is the
+				// headless/scripting path, so no nested dialog here.
+				if (!arm()) {
+					ctx.ui.notify("Design Thinking: gate is already armed", "info");
+					return;
+				}
+				ctx.ui.notify("Design Thinking: gate armed — implementing the approved design without re-presenting the graph", "info");
+				// Arming alone leaves the session idle: the agent never learns approval
+				// happened and the user sees "nothing happened". Send the go-ahead so
+				// the armed run starts now (steer if mid-run).
+				await pi.sendUserMessage(GO_AHEAD_MESSAGE, { deliverAs: "steer" });
 				return;
 			}
 			if (lower === "deny") {
-				if (!editsApproved) {
-					ctx.ui.notify("Design Thinking: no approval in effect — file edits are already blocked", "info");
+				if (approval !== "armed") {
+					ctx.ui.notify("Design Thinking: no approval in effect — mutations are already blocked", "info");
 					return;
 				}
-				editsApproved = false;
-				ctx.ui.notify("Design Thinking: file edits blocked again", "info");
+				revoke();
+				ctx.ui.notify("Design Thinking: mutations blocked again", "info");
 				return;
 			}
-
 			// "on"/"off" set explicitly; anything else is a prompt to run in this
 			// mode and always turns the mode ON (never toggles it off); bare /dt toggles.
 			const prompt = /^(on|off|status)$/.test(lower) ? "" : arg;
-			enabled = lower === "on" || prompt ? true : lower === "off" ? false : !enabled;
-			if (!enabled) editsApproved = false;
+			const on = lower === "on" || prompt ? true : lower === "off" ? false : mode === "off";
+			setMode(on);
 			persist();
 			applyStatus(ctx);
 			ctx.ui.notify(
-				enabled
+				on
 					? "Design Thinking ON — plans and reviews will render as Design Graphs (Graph Protocol)"
 					: "Design Thinking OFF",
 				"info",
 			);
 
 			if (prompt) {
+				// A prompt via /dt is a new goal: re-lock so the graph comes first
+				// (the input handler skips this — sendUserMessage is source "extension").
+				relock();
 				// deliverAs "steer": sends immediately when idle, queues mid-stream.
 				await pi.sendUserMessage(
 					`${prompt}\n\n(Design Thinking is ON: before implementing, present the Design Graph (Graph Protocol) and any clarifying questions, then wait for my go-ahead.)`,
@@ -205,26 +465,153 @@ export default function designThinkingExtension(pi: ExtensionAPI) {
 		},
 	});
 
-	// While active, append the distilled block to the system prompt every run.
-	pi.on("before_agent_start", async (event) => {
-		if (!enabled) return undefined;
-		return {
-			systemPrompt: event.systemPrompt + "\n\n" + DISTILLED + "\n",
-		};
+	// ── Run hooks ───────────────────────────────────────────────────────────
+	// A genuine user instruction re-locks the gate: the previous approval covered
+	// the previous turn's work only. Our own go-ahead / refine messages arrive as
+	// source "extension" and must NOT re-lock.
+	pi.on("input", async (event) => {
+		if (mode !== "on") return undefined;
+		if (event.source === "extension") return undefined;
+		relock();
+		return undefined;
 	});
 
-	// An approved run consumes the approval: clear it when the run ends so
-	// later runs are gated again until the user re-approves with /dt approve.
-	pi.on("agent_end", async () => {
-		editsApproved = false;
+	// Compose the system prompt: the distilled block is dt-mode-scoped, the
+	// LSP reminder is always-on. Either may be absent.
+	pi.on("before_agent_start", async (event) => {
+		if (!lspProbed) probeLsp();
+		const parts = [event.systemPrompt];
+		if (mode === "on") parts.push(DISTILLED + "\n");
+		if (lspCapable) parts.push(LSP_REMINDER + "\n");
+		if (parts.length === 1) return undefined;
+		return { systemPrompt: parts.join("\n\n") };
 	});
 
-	// Hard gate: while enabled, file-edit tools are blocked until the user
-	// arms the next run with /dt approve. Prompt-level rules alone proved
-	// insufficient — this is the mechanical backstop.
 	pi.on("tool_call", async (event) => {
-		if (!enabled || editsApproved) return undefined;
+		if (mode !== "on") return undefined;
 		if (!MUTATING_TOOLS[event.toolName]) return undefined;
+		if (approval === "armed") return undefined;
+		// omp routes MCP calls through `write` (xd://mcp__… device paths); let
+		// read-only devices through. qmd devices are pure reads; codegraph
+		// only for its read-only actions — init/index/sync/unlock and
+		// unparsable args stay blocked.
+		if (event.toolName === "write") {
+			const input = event.input as { path?: unknown; content?: unknown } | undefined;
+			const path = input?.path;
+			if (typeof path === "string" && READONLY_MCP_PATH.test(path)) {
+				const isCodegraph = path.includes("codegraph_explore");
+				let action = "explore"; // codegraph's default action is a read
+				if (isCodegraph) {
+					try {
+						action = (JSON.parse(String(input?.content ?? "{}")) as { action?: string })
+							.action ?? "explore";
+					} catch {
+						action = "init"; // unparsable device args → treat as mutating
+					}
+				}
+				if (!isCodegraph || READONLY_CODEGRAPH_ACTIONS[action]) return undefined;
+			}
+		}
+		// Block only — NEVER open the review dialog here. Mid-run, the agent is
+		// still streaming, and a UI-up-while-the-agent-acts is the failure this
+		// mode exists to prevent. A blocked mutation returns the stop-and-do-not-
+		// route-around reason; agent_end offers the dialog (a graph seen earlier
+		// this cycle re-offers there too), so the UI appears only after the run
+		// ends and the agent has stopped.
 		return { block: true, reason: GATE_REASON };
 	});
+
+	// Run-end housekeeping: offer the review dialog when the agent presented a
+	// graph this cycle, or ended the turn asking for approval in prose (so the
+	// human always gets a button, never a prose-only ask). While an approval
+	// holds, edits stay open and no dialog is offered.
+	pi.on("agent_end", async (event, ctx) => {
+		// Keep the scan cursor in sync even while off, so re-enabling does not
+		// rescan or mis-slice history.
+		const messages = event.messages;
+		if (mode !== "on") {
+			scannedMessages = messages.length;
+			return;
+		}
+
+		// Incremental scan — only messages since the last run end. A long
+		// session never re-scans old history.
+		const fresh = messages.slice(Math.min(scannedMessages, messages.length));
+		scannedMessages = messages.length;
+		if (fresh.some(presentsGraph)) {
+			cycleGraphSeen = true;
+			graphDenied = false;
+			approval = "none"; // a presented graph always means: awaiting approval
+		}
+
+		if (approval === "armed") return;
+		if (graphDenied) return;
+		if (offer) return; // a dialog is already live
+		// Open the dialog on a presented graph, or a prose approval ask.
+		if (!cycleGraphSeen && !fresh.some(asksApproval)) return;
+		if (!ctx.hasUI) {
+			ctx.ui.notify("Design Thinking: review the presented design, then run /dt approve or /dt deny", "info");
+			return;
+		}
+		offerReview(ctx);
+	});
+
+	// ── Review dialog ───────────────────────────────────────────────────────
+	// One dialog per offer. Extension-owned AbortSignal: omp dismisses
+	// handler-opened dialogs when the handler's 30s budget expires, and a
+	// detached promise does not escape that binding — the signal replaces it.
+	// If the dialog is dismissed anyway (runtime kill, or the agent's own
+	// dialog displacing it), the offer is retracted; the next run end makes a
+	// fresh offer. A dismissed dialog is NOT a deny.
+	function offerReview(ctx: ExtensionContext): void {
+		const epoch = nextEpoch++;
+		const abort = new AbortController();
+		offer = { epoch, abort };
+
+		void (async () => {
+			const choice = await ctx.ui.select("Review the presented design", [...REVIEW_OPTIONS], {
+				signal: abort.signal,
+			});
+			if (!decisionApplies(epoch)) return; // superseded; discard silently
+
+			if (choice === undefined) {
+				// Dismissed, not decided. File edits stay blocked; a fresh offer
+				// opens at the next run end.
+				retractOffer();
+				return;
+			}
+			if (choice.startsWith("Deny")) {
+				graphDenied = true;
+				retractOffer();
+				ctx.ui.notify("Design Thinking: mutations blocked — nothing approved", "info");
+				return;
+			}
+			if (choice.startsWith("Approve")) {
+				if (!arm()) return; // gate changed while the human was deciding
+				ctx.ui.notify("Design Thinking: gate armed — implementing the approved design", "info");
+				await pi.sendUserMessage(GO_AHEAD_MESSAGE, { deliverAs: "steer" });
+				return;
+			}
+			// Refine: collect feedback and send it back; the dialog re-opens
+			// after the refined plan is presented.
+			const feedback = await ctx.ui.input(
+				"What should change in the design?",
+				"e.g. too complex — drop the cache layer",
+				{ signal: abort.signal },
+			);
+			if (!decisionApplies(epoch)) return;
+			if (feedback === undefined || !feedback.trim()) {
+				retractOffer();
+				return;
+			}
+			retractOffer();
+			await pi.sendUserMessage(
+				`Refine the presented design (do not implement yet): ${feedback.trim()}\n\n(Design Thinking: update the Design Graph (Graph Protocol) per this feedback and present it again. Mutations stay blocked.)`,
+				{ deliverAs: "steer" },
+			);
+		})().catch((err: unknown) => {
+			if (offer?.epoch === epoch) retractOffer();
+			logger?.warn?.(`design-thinking: review dialog failed: ${String(err)}`);
+		});
+	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@widnyana/design-thinking",
-  "version": "0.0.6",
+  "version": "0.0.20",
   "type": "module",
   "description": "Design Thinking · Design Graph · Graph Protocol — a stack-agnostic design methodology for pi. Turns every plan, review, and refactor into an annotated call graph. Method originally by r17x; generalized to a pi package by widnyana.",
   "author": {
@@ -47,7 +47,7 @@
     "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.3",
+    "@earendil-works/pi-coding-agent": "1.0.4",
     "@types/node": "^22.10.0",
     "typescript": "^5.7.0"
   }

package/prompts/cg-map.md

@@ -36,6 +36,5 @@ mapping table followed by a small worked mini-graph in Graph Protocol format.
 - This mapping is a companion artifact: once produced, refer to it in later
   `/cg-plan` and `/cg-review` runs in the same stack.
 
-Full specs load as skills in the `design-thinking` pi package:
-`/skill:graph-protocol` (notation), `/skill:design-method` (the method),
-`/skill:design-graph` (artifact).
+Full specs live in this package's `references/` directory: `protocol.md`
+(notation), `method.md` (the method), `design-graph.md` (artifact).

package/prompts/cg-plan.md

@@ -60,6 +60,5 @@ VERDICT:     the target structure the implementation must satisfy
 - The VERDICT section states the structural invariants the code must satisfy so
   the graph can later be re-checked in review (`/cg-review`).
 
-Full specs load as skills in the `design-thinking` pi package:
-`/skill:graph-protocol` (notation), `/skill:design-method` (the method),
-`/skill:design-graph` (artifact).
+Full specs live in this package's `references/` directory: `protocol.md`
+(notation), `method.md` (the method), `design-graph.md` (artifact).

package/prompts/cg-review.md

@@ -64,6 +64,5 @@ VERDICT:     <matches | mismatches listed by § number>
   otherwise review against the checklist alone.
 - Severity: mark findings that will cause runtime failures vs structural debt.
 
-Full specs load as skills in the `design-thinking` pi package:
-`/skill:graph-protocol` (notation), `/skill:design-method` (the method),
-`/skill:design-graph` (artifact).
+Full specs live in this package's `references/` directory: `protocol.md`
+(notation), `method.md` (the method), `design-graph.md` (artifact).

package/prompts/cg.md

@@ -45,6 +45,5 @@ VERDICT:     code matches graph? happy path free of error handling? E fully enum
 - If you find nodes that violate the method (tangled happy path, unscoped
   resources, hidden dependencies), list them under VERDICT, grouped by § number.
 
-If the full spec is needed, load the skills shipped in the `design-thinking`
-pi package: `/skill:graph-protocol` (notation) and `/skill:design-method`
-(the method).
+If the full spec is needed, read it from this package's `references/`
+directory: `protocol.md` (notation) and `method.md` (the method).

package/skills/design-graph/SKILL.md

@@ -6,6 +6,7 @@ description: >
   cardinality, E, R. Use when drawing a graph before writing code or
   reconstructing and diffing one against existing code. Includes the
   completeness checklist.
+disable-model-invocation: true
 ---
 
 # Design Graph — The Artifact

package/skills/design-method/SKILL.md

@@ -5,6 +5,7 @@ description: >
   cardinality → break points (E: ⟳ ↯ ☠) → requirements (R) → boundaries →
   behavior layers → scope → test layers → verdict. Stack-agnostic. Use when
   planning, designing, or refactoring any feature or system.
+disable-model-invocation: true
 ---
 
 # Design Thinking — The Method

package/skills/graph-protocol/SKILL.md

@@ -6,6 +6,7 @@ description: >
   VERDICT) and fixed markers (⟳retry ↯escape ☠die 🔒boundary (1)(N)(T) ⛈layer
   @scope). Use when writing, reviewing, or checking any Design Graph so
   notation is mechanically checkable and identical across languages.
+disable-model-invocation: true
 ---
 
 # Graph Protocol