@oh-my-pi/pi-coding-agent 15.0.1 → 15.0.2

package/src/modes/rpc/host-uris.ts

@@ -0,0 +1,235 @@
+import { Snowflake } from "@oh-my-pi/pi-utils";
+import { InternalUrlRouter } from "../../internal-urls";
+import type {
+	InternalResource,
+	InternalUrl,
+	ProtocolHandler,
+	ResolveContext,
+	WriteContext,
+} from "../../internal-urls/types";
+import type {
+	RpcHostUriCancelRequest,
+	RpcHostUriRequest,
+	RpcHostUriResult,
+	RpcHostUriSchemeDefinition,
+} from "./rpc-types";
+
+type RpcHostUriOutput = (frame: RpcHostUriRequest | RpcHostUriCancelRequest) => void;
+
+type PendingUriRequest = {
+	operation: "read" | "write";
+	url: string;
+	resolve: (frame: RpcHostUriResult) => void;
+	reject: (error: Error) => void;
+};
+
+/** Type guard for inbound `host_uri_result` frames coming from the host. */
+export function isRpcHostUriResult(value: unknown): value is RpcHostUriResult {
+	if (!value || typeof value !== "object") return false;
+	const frame = value as { type?: unknown; id?: unknown };
+	return frame.type === "host_uri_result" && typeof frame.id === "string";
+}
+
+/**
+ * One handler instance per host-registered scheme. Delegates reads and (when
+ * the scheme was registered as writable) writes to the bridge, which serializes
+ * them over the RPC transport.
+ */
+class RpcHostUriProtocolHandler implements ProtocolHandler {
+	readonly scheme: string;
+	readonly immutable: boolean;
+	readonly write?: (url: InternalUrl, content: string, context?: WriteContext) => Promise<void>;
+	readonly #bridge: RpcHostUriBridge;
+
+	constructor(definition: RpcHostUriSchemeDefinition, bridge: RpcHostUriBridge) {
+		this.scheme = definition.scheme;
+		this.immutable = definition.immutable === true;
+		this.#bridge = bridge;
+		if (definition.writable === true) {
+			this.write = (url, content, context) => this.#bridge.requestWrite(this.scheme, url, content, context);
+		}
+	}
+
+	resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		return this.#bridge.requestRead(this.scheme, url, context);
+	}
+}
+
+/**
+ * Bidirectional bridge that lets the RPC host own a set of URI schemes.
+ *
+ * The host registers schemes via `set_host_uri_schemes`; the bridge installs
+ * a `RpcHostUriProtocolHandler` per scheme into the process-global
+ * {@link InternalUrlRouter}. Reads land on the read tool through the existing
+ * router; writes are intercepted by the write tool and dispatched through
+ * `requestWrite`.
+ */
+export class RpcHostUriBridge {
+	#output: RpcHostUriOutput;
+	#router: InternalUrlRouter;
+	#definitions = new Map<string, RpcHostUriSchemeDefinition>();
+	#pending = new Map<string, PendingUriRequest>();
+
+	constructor(output: RpcHostUriOutput, router: InternalUrlRouter = InternalUrlRouter.instance()) {
+		this.#output = output;
+		this.#router = router;
+	}
+
+	getSchemes(): string[] {
+		return Array.from(this.#definitions.keys());
+	}
+
+	/**
+	 * Replace the registered set of host URI schemes. Previously registered
+	 * schemes that no longer appear in the new set are unregistered from the
+	 * router; surviving and new schemes get fresh handler instances.
+	 */
+	setSchemes(schemes: RpcHostUriSchemeDefinition[]): string[] {
+		const normalized = new Map<string, RpcHostUriSchemeDefinition>();
+		for (const raw of schemes) {
+			const scheme = typeof raw?.scheme === "string" ? raw.scheme.trim().toLowerCase() : "";
+			if (!scheme) {
+				throw new Error("Host URI scheme must be a non-empty string");
+			}
+			if (!/^[a-z][a-z0-9+.-]*$/.test(scheme)) {
+				throw new Error(`Host URI scheme contains invalid characters: ${raw.scheme}`);
+			}
+			normalized.set(scheme, {
+				scheme,
+				description: typeof raw.description === "string" ? raw.description : undefined,
+				writable: raw.writable === true,
+				immutable: raw.immutable === true,
+			});
+		}
+
+		for (const previous of this.#definitions.keys()) {
+			if (!normalized.has(previous)) {
+				this.#router.unregister(previous);
+			}
+		}
+		for (const definition of normalized.values()) {
+			this.#router.register(new RpcHostUriProtocolHandler(definition, this));
+		}
+		this.#definitions = normalized;
+		return Array.from(normalized.keys());
+	}
+
+	/**
+	 * Unregister every host scheme from the router and reject any in-flight
+	 * requests. Called on RPC shutdown to keep the global router clean for
+	 * subsequent sessions in the same process (used by tests).
+	 */
+	clear(message: string = "Host URI bridge shut down"): void {
+		for (const scheme of this.#definitions.keys()) {
+			this.#router.unregister(scheme);
+		}
+		this.#definitions.clear();
+		this.rejectAllPending(message);
+	}
+
+	/** Resolve a pending request by id; called by `rpc-mode` on inbound results. */
+	handleResult(frame: RpcHostUriResult): boolean {
+		const pending = this.#pending.get(frame.id);
+		if (!pending) return false;
+		this.#pending.delete(frame.id);
+		pending.resolve(frame);
+		return true;
+	}
+
+	rejectAllPending(message: string): void {
+		const error = new Error(message);
+		const pending = Array.from(this.#pending.values());
+		this.#pending.clear();
+		for (const entry of pending) {
+			entry.reject(error);
+		}
+	}
+
+	async requestRead(scheme: string, url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		const result = await this.#dispatch("read", url.href, undefined, context?.signal);
+		if (result.isError) {
+			throw new Error(result.error || result.content || `Host URI read failed for ${url.href}`);
+		}
+		const content = result.content ?? "";
+		const contentType = result.contentType ?? "text/plain";
+		const definition = this.#definitions.get(scheme);
+		return {
+			url: url.href,
+			content,
+			contentType,
+			size: Buffer.byteLength(content, "utf-8"),
+			notes: result.notes && result.notes.length > 0 ? [...result.notes] : undefined,
+			immutable: result.immutable ?? definition?.immutable === true,
+		};
+	}
+
+	async requestWrite(_scheme: string, url: InternalUrl, content: string, context?: WriteContext): Promise<void> {
+		const result = await this.#dispatch("write", url.href, content, context?.signal);
+		if (result.isError) {
+			throw new Error(result.error || result.content || `Host URI write failed for ${url.href}`);
+		}
+	}
+
+	#dispatch(
+		operation: "read" | "write",
+		url: string,
+		content: string | undefined,
+		signal: AbortSignal | undefined,
+	): Promise<RpcHostUriResult> {
+		if (signal?.aborted) {
+			return Promise.reject(new Error(`Host URI ${operation} for ${url} was aborted`));
+		}
+
+		const id = Snowflake.next() as string;
+		const { promise, resolve, reject } = Promise.withResolvers<RpcHostUriResult>();
+		let settled = false;
+
+		const cleanup = () => {
+			signal?.removeEventListener("abort", onAbort);
+			this.#pending.delete(id);
+		};
+
+		const onAbort = () => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			this.#output({
+				type: "host_uri_cancel",
+				id: Snowflake.next() as string,
+				targetId: id,
+			});
+			reject(new Error(`Host URI ${operation} for ${url} was aborted`));
+		};
+
+		signal?.addEventListener("abort", onAbort, { once: true });
+		this.#pending.set(id, {
+			operation,
+			url,
+			resolve: frame => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				resolve(frame);
+			},
+			reject: err => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(err);
+			},
+		});
+
+		const frame: RpcHostUriRequest = {
+			type: "host_uri_request",
+			id,
+			operation,
+			url,
+		};
+		if (operation === "write") {
+			frame.content = content ?? "";
+		}
+		this.#output(frame);
+
+		return promise;
+	}
+}

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

@@ -21,6 +21,7 @@ import { type Theme, theme } from "../../modes/theme/theme";
 import type { AgentSession } from "../../session/agent-session";
 import { initializeExtensions } from "../runtime-init";
 import { isRpcHostToolResult, isRpcHostToolUpdate, RpcHostToolBridge } from "./host-tools";
+import { isRpcHostUriResult, RpcHostUriBridge } from "./host-uris";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
@@ -28,6 +29,8 @@ import type {
 	RpcHostToolCallRequest,
 	RpcHostToolCancelRequest,
 	RpcHostToolDefinition,
+	RpcHostUriCancelRequest,
+	RpcHostUriRequest,
 	RpcResponse,
 	RpcSessionState,
 } from "./rpc-types";
@@ -41,7 +44,14 @@ export type PendingExtensionRequest = {
 };
 
 type RpcOutput = (
-	obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | object,
+	obj:
+		| RpcResponse
+		| RpcExtensionUIRequest
+		| RpcHostToolCallRequest
+		| RpcHostToolCancelRequest
+		| RpcHostUriRequest
+		| RpcHostUriCancelRequest
+		| object,
 ) => void;
 
 function normalizeHostToolDefinitions(tools: RpcHostToolDefinition[]): RpcHostToolDefinition[] {
@@ -188,6 +198,7 @@ export async function runRpcMode(
 
 	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
 	const hostToolBridge = new RpcHostToolBridge(output);
+	const hostUriBridge = new RpcHostUriBridge(output);
 
 	// Shutdown request flag (wrapped in object to allow mutation with const)
 	const shutdownState = { requested: false };
@@ -533,6 +544,15 @@ export async function runRpcMode(
 				return success(id, "set_host_tools", { toolNames: tools.map(tool => tool.name) });
 			}
 
+			case "set_host_uri_schemes": {
+				try {
+					const schemes = hostUriBridge.setSchemes(command.schemes);
+					return success(id, "set_host_uri_schemes", { schemes });
+				} catch (err) {
+					return error(id, "set_host_uri_schemes", err instanceof Error ? err.message : String(err));
+				}
+			}
+
 			// =================================================================
 			// Model
 			// =================================================================
@@ -807,6 +827,11 @@ export async function runRpcMode(
 				continue;
 			}
 
+			if (isRpcHostUriResult(parsed)) {
+				hostUriBridge.handleResult(parsed);
+				continue;
+			}
+
 			// Handle regular commands
 			const command = parsed as RpcCommand;
 			const response = await handleCommand(command);
@@ -821,5 +846,6 @@ export async function runRpcMode(
 
 	// stdin closed — RPC client is gone, exit cleanly
 	hostToolBridge.rejectAllPending("RPC client disconnected before host tool execution completed");
+	hostUriBridge.clear("RPC client disconnected before host URI request completed");
 	process.exit(0);
 }

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

@@ -29,6 +29,7 @@ export type RpcCommand =
 	| { id?: string; type: "get_state" }
 	| { id?: string; type: "set_todos"; phases: TodoPhase[] }
 	| { id?: string; type: "set_host_tools"; tools: RpcHostToolDefinition[] }
+	| { id?: string; type: "set_host_uri_schemes"; schemes: RpcHostUriSchemeDefinition[] }
 
 	// Model
 	| { id?: string; type: "set_model"; provider: string; modelId: string }
@@ -121,6 +122,7 @@ export type RpcResponse =
 	| { id?: string; type: "response"; command: "get_state"; success: true; data: RpcSessionState }
 	| { id?: string; type: "response"; command: "set_todos"; success: true; data: { todoPhases: TodoPhase[] } }
 	| { id?: string; type: "response"; command: "set_host_tools"; success: true; data: { toolNames: string[] } }
+	| { id?: string; type: "response"; command: "set_host_uri_schemes"; success: true; data: { schemes: string[] } }
 
 	// Model
 	| {
@@ -304,6 +306,61 @@ export interface RpcHostToolResult {
 	isError?: boolean;
 }
 
+// ============================================================================
+// Host URI Frames (bidirectional)
+// ============================================================================
+
+export interface RpcHostUriSchemeDefinition {
+	/** URL scheme without trailing `://` (e.g. `db`, `notion`). */
+	scheme: string;
+	/** Optional human-readable description for logs/diagnostics. */
+	description?: string;
+	/** When true, the write tool is allowed to dispatch writes to this scheme. */
+	writable?: boolean;
+	/** When true, downstream callers suppress hashline anchors for resolved content. */
+	immutable?: boolean;
+}
+
+export type RpcHostUriOperation = "read" | "write";
+
+/** Emitted by the RPC server when it needs the host to satisfy a URI operation. */
+export interface RpcHostUriRequest {
+	type: "host_uri_request";
+	id: string;
+	operation: RpcHostUriOperation;
+	url: string;
+	/** Present for write operations. */
+	content?: string;
+}
+
+/** Emitted by the RPC server when a pending URI request should be aborted. */
+export interface RpcHostUriCancelRequest {
+	type: "host_uri_cancel";
+	id: string;
+	targetId: string;
+}
+
+/** Sent by the host to complete a pending URI request. */
+export interface RpcHostUriResult {
+	type: "host_uri_result";
+	id: string;
+	/**
+	 * Required for successful `read` results. Ignored for `write` success.
+	 * Set on errors when a textual explanation accompanies `isError`.
+	 */
+	content?: string;
+	/** Defaults to `text/plain` when omitted. */
+	contentType?: "text/markdown" | "application/json" | "text/plain";
+	/** Optional resolution notes propagated to the read tool. */
+	notes?: string[];
+	/** Overrides the scheme-level `immutable` flag for this single resolution. */
+	immutable?: boolean;
+	/** When true, surface the result content as an error to the caller. */
+	isError?: boolean;
+	/** Optional error message; preferred over `content` for error surfacing. */
+	error?: string;
+}
+
 // ============================================================================
 // Extension UI Commands (stdin)
 // ============================================================================

package/src/modes/runtime-init.ts

@@ -7,6 +7,7 @@
  * caller-supplied hooks.
  */
 import { runExtensionCompact, runExtensionSetModel } from "../extensibility/extensions/compact-handler";
+import { getSessionSlashCommands } from "../extensibility/extensions/get-commands-handler";
 import type { ExtensionError, ExtensionUIContext } from "../extensibility/extensions/types";
 import type { AgentSession } from "../session/agent-session";
 
@@ -59,7 +60,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			getActiveTools: () => session.getActiveToolNames(),
 			getAllTools: () => session.getAllToolNames(),
 			setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
-			getCommands: () => [],
+			getCommands: () => getSessionSlashCommands(session),
 			setModel: model => runExtensionSetModel(session, model),
 			getThinkingLevel: () => session.thinkingLevel,
 			setThinkingLevel: level => session.setThinkingLevel(level),

package/src/modes/theme/defaults/dark-poimandres.json

@@ -133,6 +133,7 @@
       "icon.pause": "‖",
       "icon.loop": "↻",
       "icon.folder": "▸",
+      "icon.scratchFolder": "◌",
       "icon.pi": "π",
       "format.bullet": "◦",
       "md.bullet": "◦"

package/src/modes/theme/defaults/light-poimandres.json

@@ -133,6 +133,7 @@
       "icon.pause": "‖",
       "icon.loop": "↻",
       "icon.folder": "▸",
+      "icon.scratchFolder": "◌",
       "icon.pi": "π",
       "format.bullet": "◦",
       "md.bullet": "◦"

package/src/modes/theme/theme.ts

@@ -95,6 +95,7 @@ export type SymbolKey =
 	| "icon.pause"
 	| "icon.loop"
 	| "icon.folder"
+	| "icon.scratchFolder"
 	| "icon.file"
 	| "icon.git"
 	| "icon.branch"
@@ -258,6 +259,7 @@ const UNICODE_SYMBOLS: SymbolMap = {
 	"icon.pause": "⏸",
 	"icon.loop": "↻",
 	"icon.folder": "📁",
+	"icon.scratchFolder": "🗑",
 	"icon.file": "📄",
 	"icon.git": "⎇",
 	"icon.branch": "⑂",
@@ -476,6 +478,8 @@ const NERD_SYMBOLS: SymbolMap = {
 	"icon.loop": "\uf021",
 	// pick:  | alt:  
 	"icon.folder": "\uf115",
+	// pick:  | alt:
+	"icon.scratchFolder": "\uf014",
 	// pick:  | alt:  
 	"icon.file": "\uf15b",
 	// pick:  | alt:  ⎇
@@ -678,6 +682,7 @@ const ASCII_SYMBOLS: SymbolMap = {
 	"icon.pause": "||",
 	"icon.loop": "loop",
 	"icon.folder": "[D]",
+	"icon.scratchFolder": "[T]",
 	"icon.file": "[F]",
 	"icon.git": "git:",
 	"icon.branch": "@",
@@ -1457,6 +1462,7 @@ export class Theme {
 			pause: this.#symbols["icon.pause"],
 			loop: this.#symbols["icon.loop"],
 			folder: this.#symbols["icon.folder"],
+			scratchFolder: this.#symbols["icon.scratchFolder"],
 			file: this.#symbols["icon.file"],
 			git: this.#symbols["icon.git"],
 			branch: this.#symbols["icon.branch"],

package/src/prompts/tools/github.md

@@ -6,10 +6,10 @@ Pick the operation via `op`. Each op uses a subset of the parameters:
 - `pr_create` — Create a pull request. Either provide `title` (and optional `body`) or set `fill: true` to auto-fill from commits. Optional `base` (target, defaults to repo default), `head` (source, defaults to current branch), `draft`, `repo`, `reviewer[]`, `assignee[]`, `label[]`. Returns the new PR URL plus a summary.
 - `pr_checkout` — Check one or more pull requests out into dedicated git worktrees. Optional `pr` (number, URL, branch, or array of any of those — pass an array to batch-check-out multiple PRs in one call), `repo`, `force` (reset existing local branch).
 - `pr_push` — Push a checked-out PR branch back to its source branch. Requires the branch to have been checked out via `op: pr_checkout` (carries push metadata). Optional `branch`; defaults to the current checked-out git branch. Optional `forceWithLease`.
-- `search_issues` — Search issues using normal GitHub issue search syntax. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`, `dateField`.
-- `search_prs` — Search pull requests using normal GitHub PR search syntax. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`, `dateField`.
-- `search_code` — Search code with GitHub code search syntax. Required `query`. Optional `repo`, `limit`. Returns matching paths with surrounding fragments. Date filtering (`since`/`until`) is **not** supported by GitHub code search.
-- `search_commits` — Search commits across GitHub. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`. `dateField` is ignored — always uses `committer-date`.
+- `search_issues` — Search issues using normal GitHub issue search syntax. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`, `dateField`. Defaults `repo` to the current checkout's `owner/repo` when omitted; pass an explicit `repo:`/`org:`/`user:` qualifier in `query` to search outside it.
+- `search_prs` — Search pull requests using normal GitHub PR search syntax. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`, `dateField`. Defaults `repo` to the current checkout's `owner/repo` when omitted; pass an explicit `repo:`/`org:`/`user:` qualifier in `query` to search outside it.
+- `search_code` — Search code with GitHub code search syntax. Required `query`. Optional `repo`, `limit`. Returns matching paths with surrounding fragments. Defaults `repo` to the current checkout's `owner/repo` when omitted; pass an explicit `repo:`/`org:`/`user:` qualifier in `query` to search outside it. Date filtering (`since`/`until`) is **not** supported by GitHub code search.
+- `search_commits` — Search commits across GitHub. Optional `query` (required unless `since`/`until` is set), `repo`, `limit`, `since`, `until`. `dateField` is ignored — always uses `committer-date`. Defaults `repo` to the current checkout's `owner/repo` when omitted; pass an explicit `repo:`/`org:`/`user:` qualifier in `query` to search outside it.
 - `search_repos` — Search repositories across GitHub. Optional `query` (required unless `since`/`until` is set), `limit`, `since`, `until`, `dateField` (use query qualifiers like `org:`, `language:` instead of `repo`).
 - Date filter format for `since` / `until`: relative duration `<n><unit>` (`m`/`h`/`d`/`w`/`mo`/`y`, e.g. `3d`, `12h`, `2w`), an ISO date `YYYY-MM-DD`, or an ISO datetime. Translated to a single GitHub-search qualifier (`created:≥…`, `created:≤…`, or `created:since..until`). `dateField: "updated"` maps to `updated:` for issues/prs and `pushed:` for repos. When you only want a date filter and no keywords, omit `query` entirely.
 - `run_watch` — Watch a GitHub Actions workflow run. Optional `run` (id or URL). Omitting `run` watches all workflow runs for the current HEAD commit; `branch` falls back to the current branch. Optional `tail` (log lines per failed job). Streams snapshots, fast-fails on the first detected job failure (with a brief grace period to capture concurrent failures), then fetches tailed logs for the failed jobs. The full failed-job logs are saved as a session artifact for on-demand reads.

package/src/prompts/tools/hashline.md

@@ -66,36 +66,35 @@ When braces bound your edit, you SHOULD prefer these shapes:
 </common-failures>
 
 <case file="mod.ts">
-{{hline 1 "const DEF = \"guest\";"}}
-{{hline 2 "export function label(name) {"}}
+{{hline 1 "const TITLE = \"Mr\";"}}
+{{hline 2 "export function greet(name) {"}}
 {{hline 3 "\treturn ["}}
-{{hline 4 "\t\tname?.trim() || DEF,"}}
-{{hline 5 "\t\t\" • \","}}
-{{hline 6 "\t].join(\"\");"}}
+{{hline 4 "\t\tTITLE,"}}
+{{hline 5 "\t\tname?.trim() || \"guest\","}}
+{{hline 6 "\t].join(\" \");"}}
 {{hline 7 "}"}}
 </case>
 
 <examples>
 # Replace one line (the payload must re-emit the original indentation)
 @@ mod.ts
-= {{hrefr 4}}..{{hrefr 4}}
-{{hsep}}		name?.trim().toUpperCase() || DEF,
+= {{hrefr 1}}..{{hrefr 1}}
+{{hsep}}const TITLE = "Mrs";
 
 # Replace a full multiline statement (widen to a self-contained boundary)
 @@ mod.ts
 = {{hrefr 3}}..{{hrefr 6}}
 {{hsep}}	return [
-{{hsep}}		name?.trim() || DEF,
-{{hsep}}		"·",
-{{hsep}}		" • ",
-{{hsep}}	].join("");
+{{hsep}}		"Mrs",
+{{hsep}}		name?.trim() || "guest",
+{{hsep}}	].join(" ");
 
 # Insert AFTER/BEFORE a line
 @@ mod.ts
-+ {{hrefr 3}}
-{{hsep}}		"·",
++ {{hrefr 4}}
+{{hsep}}		"Dr",
 < {{hrefr 5}}
-{{hsep}}		"·",
+{{hsep}}		"Dr",
 
 # Append to file
 @@ mod.ts
@@ -112,13 +111,12 @@ When braces bound your edit, you SHOULD prefer these shapes:
 </examples>
 
 <anti-pattern>
-# WRONG — replaces 3 lines just to add one.
+# WRONG — replaces 2 lines just to add one.
 @@ mod.ts
-= {{hrefr 1}}..{{hrefr 3}}
-{{hsep}}const DEF = "guest";
+= {{hrefr 1}}..{{hrefr 2}}
+{{hsep}}const TITLE = "Mr";
 {{hsep}}const DEBUG = false;
-{{hsep}}export function label(name) {
-{{hsep}}	return [
+{{hsep}}export function greet(name) {
 # RIGHT — same effect, one-line insert
 @@ mod.ts
 + {{hrefr 1}}
@@ -127,17 +125,15 @@ When braces bound your edit, you SHOULD prefer these shapes:
 # WRONG — replace from the middle of a larger statement (error-prone)
 @@ mod.ts
 = {{hrefr 4}}..{{hrefr 5}}
-{{hsep}}		name?.trim() || DEF,
-{{hsep}}		"·",
-{{hsep}}		" • ",
+{{hsep}}		"Dr",
+{{hsep}}		name?.trim() || "guest",
 # RIGHT — widen to the full statement
 @@ mod.ts
 = {{hrefr 3}}..{{hrefr 6}}
 {{hsep}}	return [
-{{hsep}}		name?.trim() || DEF,
-{{hsep}}		"·",
-{{hsep}}		" • ",
-{{hsep}}	].join("");
+{{hsep}}		"Dr",
+{{hsep}}		name?.trim() || "guest",
+{{hsep}}	].join(" ");
 </anti-pattern>
 
 <critical>