one-code-extension 0.4.1 → 0.6.0

package/extensions/branding/index.ts

@@ -14,6 +14,9 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
+import { ARGUMENT_HINT_CHANNEL, type ArgumentHint, type CommandHint, frontmatterCommandHint, hintForInput, PI_BUILTIN_HINTS } from "../lib/argument-hints.ts";
+import { parseFrontmatterLoosely } from "../lib/frontmatter.ts";
+import { promptTemplateFiles } from "../lib/skill-scan.ts";
 import { modeCycleKey } from "../lib/keys.ts";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
@@ -21,6 +24,8 @@ import { basename, dirname, join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getAgentDir, SettingsManager, VERSION as PI_VERSION } from "@earendil-works/pi-coding-agent";
 import { piVersionWarning } from "../lib/pi-version.ts";
+import { handleCompactionKeep } from "./compaction-keep.ts";
+import { handleReplacedBuiltins } from "./replaced-builtins.ts";
 import { extensionVersion } from "../lib/package-version.ts";
 import {
 	formatModel,
@@ -38,9 +43,11 @@ import {
 	shouldDefaultHideThinking,
 	type StartupSection,
 } from "./startup.ts";
-import { linesComponent, safeThemePaint, truncateLine } from "../lib/tui-render.ts";
+import { linesComponent, safeThemeInverse, safeThemePaint, truncateLine } from "../lib/tui-render.ts";
+import { AGENT_VIEW_CHANNEL, type AgentViewAnnouncement, type AgentViewTarget } from "../lib/agent-view.ts";
 import { markAssistantMarkdown } from "./assistant-marker.ts";
 import { PROMPT_PADDING, PromptEditor } from "./prompt-editor.ts";
+import { sanitizeTitle } from "../lib/terminal-text.ts";
 
 export { truncateLine };
 
@@ -138,6 +145,19 @@ export function sectionSummary(sections: StartupSection[], paint: (color: string
 		.join(paint("muted", " · "));
 }
 
+/** The mode line's words for each permission mode, so the banner never says "default" beside "manual mode on". */
+const MODE_WORDS: Record<string, string> = {
+	default: "manual",
+	acceptEdits: "accept edits",
+	bypassPermissions: "bypass permissions",
+	dontAsk: "don't ask",
+};
+
+/** The banner's mode field: the permission display with the mode named as the mode line names it. */
+export function bannerModeLabel(display: string): string {
+	return MODE_WORDS[display] ?? display;
+}
+
 /**
  * Banner layout: the wordmark block, then a one-space-indented text column
  * (tagline + version, context, hints, sections). Kept pure so the layout is
@@ -213,7 +233,11 @@ interface BrandingEditorUI {
  * a pi-tui render change ever makes the marker misplace (cosmetic only — typing
  * is never affected; see prompt-marker.ts).
  */
-function installPromptMarker(ctx: { hasUI: boolean; mode: string; ui: BrandingEditorUI }): void {
+function installPromptMarker(
+	ctx: { hasUI: boolean; mode: string; ui: BrandingEditorUI; isIdle(): boolean; hasPendingMessages(): boolean },
+	argumentHints: ReadonlyMap<string, CommandHint>,
+	agentView: { target?: AgentViewTarget },
+): void {
 	if (process.env.CC_NO_INPUT_MARKER === "1") return;
 	if (!ctx.hasUI || ctx.mode !== "tui") return;
 	const ui = ctx.ui;
@@ -223,7 +247,26 @@ function installPromptMarker(ctx: { hasUI: boolean; mode: string; ui: BrandingEd
 		// Bold makes the chevron read heavier than the input text beside it.
 		return `\x1b[1m${safeThemePaint(ui.theme)("accent", PROMPT_GLYPH)}\x1b[0m${" ".repeat(PROMPT_PADDING - 1)}`;
 	};
-	ui.setEditorComponent((tui: unknown, theme: unknown, keybindings: unknown) => new PromptEditor(tui as never, theme as never, keybindings as never, renderMarker));
+	const renderHint = (text: string) => {
+		// While an agent is viewed the empty editor addresses it (lib/agent-view.ts).
+		const placeholder = text === "" && agentView.target ? agentView.target.placeholder : hintForInput(text, argumentHints);
+		return placeholder === undefined ? undefined : safeThemePaint(ui.theme)("dim", placeholder);
+	};
+	const badge = () => agentView.target?.badge;
+	const paintBadge = (label: string) => safeThemeInverse(ui.theme)(safeThemePaint(ui.theme)("accent", ` ${label} `));
+	// The editor can outlive this context across a session replacement; a stale
+	// context throws, and ↑ must still reach the editor then.
+	const queued = () => {
+		try {
+			return !ctx.isIdle() && ctx.hasPendingMessages();
+		} catch {
+			return false;
+		}
+	};
+	ui.setEditorComponent(
+		(tui: unknown, theme: unknown, keybindings: unknown) =>
+			new PromptEditor(tui as never, theme as never, keybindings as never, renderMarker, renderHint, badge, paintBadge, queued),
+	);
 }
 
 /**
@@ -268,6 +311,25 @@ function applyOutputPadDefault(): void {
 }
 
 export default function brandingExtension(pi: ExtensionAPI) {
+	/**
+	 * pi's merged `quietStartup` (global settings with the project's
+	 * `.pi/settings.json` over them), so the banner and pi agree on whether pi
+	 * lists its own startup sections. `pi.getSettings()` is in pi 1.0.1; a pi
+	 * near the 0.84.3 floor without it falls back to the global file alone.
+	 */
+	const effectiveQuietStartup = (agentDir: string): unknown => {
+		try {
+			if (typeof (pi as { getSettings?: unknown }).getSettings === "function") return pi.getSettings().quietStartup;
+		} catch {
+			// The banner must still install: fall back to the global file.
+		}
+		try {
+			return (JSON.parse(readFileSync(join(agentDir, "settings.json"), "utf8")) as { quietStartup?: unknown }).quietStartup;
+		} catch {
+			return undefined;
+		}
+	};
+
 	applyThinkingDefault();
 	applyOutputPadDefault();
 	// Mark each block of assistant prose with Claude Code's "●" bullet. Only
@@ -296,7 +358,9 @@ export default function brandingExtension(pi: ExtensionAPI) {
 	const retitle = (ctx: { hasUI: boolean; cwd: string; ui: { setTitle(title: string): void } }) => {
 		if (!live || !ctx.hasUI) return;
 		const name = pi.getSessionName?.()?.trim();
-		const title = name ? `${NAME} - ${name} - ${basename(ctx.cwd)}` : NAME;
+		// pi writes the title inside its OSC 0 and strips only CR and LF; a BEL or
+		// ESC in the session name (any source) or the directory would end it early.
+		const title = sanitizeTitle(name ? `${NAME} - ${name} - ${basename(ctx.cwd)}` : NAME);
 		if (title === lastTitle) return; // agent_start fires every turn; write only on change
 		lastTitle = title;
 		ctx.ui.setTitle(title);
@@ -307,18 +371,76 @@ export default function brandingExtension(pi: ExtensionAPI) {
 		live = false;
 	});
 
-	pi.on("session_start", (_event, ctx) => {
+	// Commands' argument placeholders (lib/argument-hints.ts), drawn by the prompt editor.
+	// Declared before the CC_NO_BANNER return below: session_start reads it.
+	const argumentHints = new Map<string, CommandHint>(Object.entries(PI_BUILTIN_HINTS).map(([command, hint]) => [command, { hint }]));
+	// The agent the user is viewing, if any: the editor then targets it (lib/agent-view.ts).
+	const agentView: { target?: AgentViewTarget } = {};
+	pi.events.on(AGENT_VIEW_CHANNEL, (data) => {
+		agentView.target = (data as AgentViewAnnouncement | undefined)?.target;
+	});
+	pi.events.on(ARGUMENT_HINT_CHANNEL, (data) => {
+		const { command, ...hint } = data as ArgumentHint;
+		argumentHints.set(command, hint);
+	});
+	// pi's prompt templates and `/skill:` commands carry their file's
+	// `argument-hint` frontmatter. pi lists them only once a turn resolves them,
+	// so the template folders are scanned at session_start (the skill extension
+	// announces `/skill:` hints from its own scan) and pi's list read each turn.
+	// pi runs a built-in or extension command before a command file of the same
+	// name, so such a file's hint is never read.
+	const hintedFiles = new Set<string>();
+	const readFileHints = (files: { name: string; path: string }[], commands = pi.getCommands()) => {
+		const extensionCommands = new Set(commands.filter((c) => c.source === "extension").map((c) => c.name));
+		for (const { name, path } of files) {
+			if (hintedFiles.has(path)) continue;
+			if (Object.hasOwn(PI_BUILTIN_HINTS, name) || extensionCommands.has(name)) continue;
+			try {
+				const hint = frontmatterCommandHint(parseFrontmatterLoosely(readFileSync(path, "utf-8")).frontmatter);
+				if (hint) argumentHints.set(name, hint);
+				hintedFiles.add(path);
+			} catch {
+				// Unreadable (mid-replace, say): no hint now; a later scan retries it.
+			}
+		}
+	};
+	pi.on("before_agent_start", () => {
+		try {
+			const commands = pi.getCommands();
+			readFileHints(
+				commands.filter((c) => c.source !== "extension").map((c) => ({ name: c.name, path: c.sourceInfo.path })),
+				commands,
+			);
+		} catch {
+			// Not bound (a torn-down session): the next turn looks again.
+		}
+	});
+	pi.on("session_start", (event, ctx) => {
 		// pi's own write lands after this handler, so only the deferred write
 		// sticks; a new session may carry a name (resume), so forget the last.
 		lastTitle = undefined;
 		live = true;
 		setTimeout(() => retitle(ctx), 0).unref?.();
 		ctx.ui.setHiddenThinkingLabel(THINKING_LABEL);
-		installPromptMarker(ctx as unknown as { hasUI: boolean; mode: string; ui: BrandingEditorUI });
+		installPromptMarker(ctx as unknown as Parameters<typeof installPromptMarker>[0], argumentHints, agentView);
+		try {
+			readFileHints(promptTemplateFiles(ctx.cwd, os.homedir(), getAgentDir()));
+		} catch {
+			// Commands not bound: nothing was marked read, so the next turn reads pi's list.
+		}
 		// Soft drift guard: warn once at startup when the hosting pi is outside
 		// the range this release was tested against (see lib/pi-version.ts).
 		const versionWarning = piVersionWarning(PI_VERSION);
 		if (versionWarning) ctx.ui.notify(versionWarning, "warning");
+		// pi 0.99 skips its built-in tool search and MCP for ours and warns at
+		// every start, advising the user to remove One Code: offer to turn them
+		// off once, else answer with the notice (replaced-builtins.ts). Only
+		// when pi resolves its built-ins again (startup, /reload), not on a
+		// /new, resume or fork, which re-run this handler too. Not awaited: a
+		// dialog must not hold up startup. The compaction keep-window question
+		// (compaction-keep.ts) follows it, so the two dialogs never overlap.
+		const reason = (event as { reason?: string }).reason ?? "startup";
+		if (reason === "startup" || reason === "reload") void handleReplacedBuiltins(ctx).then(() => handleCompactionKeep(ctx));
 	});
 
 	if (process.env.CC_NO_BANNER === "1") return;
@@ -363,9 +485,11 @@ export default function brandingExtension(pi: ExtensionAPI) {
 		// instead (minus the internal [Extensions] noise).
 		const home = os.homedir();
 		// Resolve pi's live agent dir (honours PI_CODING_AGENT_DIR) so an
-		// isolated one-code app reads its own settings/skills, never ~/.pi.
+		// isolated one-code app reads its own skills, never ~/.pi.
 		const agentDir = getAgentDir();
-		const sections = quietStartupEnabled(join(agentDir, "settings.json"))
+		// Use pi's effective settings, including project overrides, so the two
+		// listings agree on whether quiet startup is enabled.
+		const sections = quietStartupEnabled(effectiveQuietStartup(agentDir))
 			? collectStartupSections(ctx.cwd, home, join(dirname(fileURLToPath(import.meta.url)), "..", "..", "themes"), agentDir)
 			: undefined;
 
@@ -387,7 +511,7 @@ export default function brandingExtension(pi: ExtensionAPI) {
 							version,
 							model: modelLabel ?? "none",
 							cwd: ctx.cwd,
-							mode: permissionModeDisplay(permissionStatus ?? { mode: "default", paused: false }),
+							mode: bannerModeLabel(permissionModeDisplay(permissionStatus ?? { mode: "default", paused: false })),
 							subagents:
 								modelLabel === undefined
 									? "none"

package/extensions/branding/prompt-editor.ts

@@ -3,14 +3,19 @@
  *
  * pi's editor has no prompt marker and no option for one, but `CustomEditor` is
  * the sanctioned base for a replacement (it already wires every app keybinding
- * through handleInput, which we leave untouched). We only reserve a two-column
- * left gutter and paint the marker into it — see prompt-marker.ts for why that
- * is cursor-safe. Registered via `ctx.ui.setEditorComponent`; this file is thin
+ * through handleInput). We reserve a two-column left gutter and paint the
+ * marker into it — see prompt-marker.ts for why that is cursor-safe — draw a
+ * slash command's argument hint after the cursor (lib/argument-hints.ts), and
+ * let ↑ restore queued messages through pi's dequeue action (queued-edit.ts). Registered via `ctx.ui.setEditorComponent`; this file is thin
  * wiring over the pure `applyPromptMarker`.
  */
 
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { applyBorderBadge, fitBadge } from "../lib/agent-view.ts";
+import { applyArgumentHint } from "../lib/argument-hints.ts";
+import { visibleWidth } from "../lib/text-width.ts";
 import { applyPromptMarker } from "./prompt-marker.ts";
+import { upEditsQueue } from "./queued-edit.ts";
 
 /** Width of the left gutter, and therefore the visible width the marker must fill. */
 export const PROMPT_PADDING = 2;
@@ -20,10 +25,45 @@ type EditorArgs = ConstructorParameters<typeof CustomEditor>;
 export class PromptEditor extends CustomEditor {
 	/** Re-read per render so the marker follows live theme changes. */
 	#renderMarker: () => string;
+	/** The painted argument placeholder for the current input, if it is a hinted command. */
+	#renderHint: (text: string) => string | undefined;
+	/** The viewed agent's top-border label (plain text), or undefined on main (lib/agent-view.ts). */
+	#badge: () => string | undefined;
+	/** Paints the fitted badge label as a chip, one space of padding on each side. */
+	#paintBadge: (label: string) => string;
+	/** Whether a message waits in pi's queue mid-turn (queued-edit.ts). */
+	#queued: () => boolean;
+	#keys: EditorArgs[2];
+	/** The width pi wraps the text at, from the last render (pi's own formula). */
+	#layoutWidth = Number.POSITIVE_INFINITY;
 
-	constructor(tui: EditorArgs[0], theme: EditorArgs[1], keybindings: EditorArgs[2], renderMarker: () => string) {
-		super(tui, theme, keybindings, { paddingX: PROMPT_PADDING });
+	constructor(
+		tui: EditorArgs[0],
+		theme: EditorArgs[1],
+		keybindings: EditorArgs[2],
+		renderMarker: () => string,
+		renderHint: (text: string) => string | undefined = () => undefined,
+		badge: () => string | undefined = () => undefined,
+		paintBadge: (label: string) => string = (label) => label,
+		queued: () => boolean = () => false,
+	) {
+		super(tui, theme, keybindings, { paddingX: PROMPT_PADDING, embedWorkingStatus: true });
 		this.#renderMarker = renderMarker;
+		this.#renderHint = renderHint;
+		this.#badge = badge;
+		this.#paintBadge = paintBadge;
+		this.#queued = queued;
+		this.#keys = keybindings;
+	}
+
+	/** ↑ on the first line restores queued messages, as in Claude Code (queued-edit.ts). */
+	handleInput(data: string): void {
+		const dequeue = this.actionHandlers.get("app.message.dequeue");
+		if (dequeue && this.#keys.matches(data, "tui.editor.cursorUp") && upEditsQueue(this, this.#queued(), this.#layoutWidth)) {
+			dequeue();
+			return;
+		}
+		super.handleInput(data);
 	}
 
 	/**
@@ -37,6 +77,13 @@ export class PromptEditor extends CustomEditor {
 	}
 
 	render(width: number): string[] {
-		return applyPromptMarker(super.render(width), PROMPT_PADDING, this.#renderMarker());
+		const paddingX = Math.min(PROMPT_PADDING, Math.max(0, Math.floor((width - 1) / 2)));
+		this.#layoutWidth = Math.max(1, width - paddingX * 2 - (paddingX ? 0 : 1));
+		let lines = applyPromptMarker(super.render(width), PROMPT_PADDING, this.#renderMarker());
+		const hint = this.#renderHint(this.getText());
+		if (hint) lines = applyArgumentHint(lines, hint);
+		const label = this.#badge();
+		const fitted = label ? fitBadge(label, width) : "";
+		return fitted ? applyBorderBadge(lines, this.#paintBadge(fitted), visibleWidth(fitted) + 2, this.borderColor("─")) : lines;
 	}
 }

package/extensions/branding/queued-edit.ts

@@ -0,0 +1,31 @@
+/**
+ * Claude Code's key for editing queued messages: plain ↑. With a message
+ * queued mid-turn, ↑ moves every queued message into the editor instead of
+ * walking history, but only with the cursor on the draft's first line (lower
+ * lines need ↑ to move the cursor) and no autocomplete list open (↑ moves in
+ * the list). pi binds the same restore only to alt+up, which not every
+ * terminal sends: macOS Terminal's terminfo (nsterm) maps option+left and
+ * option+right but no modified up arrow. Pure: `prompt-editor.ts` calls pi's
+ * own dequeue action, so the alt+up binding keeps working alongside.
+ */
+
+import { visibleWidth } from "../lib/text-width.ts";
+
+export interface QueueEditEditor {
+	getCursor(): { line: number; col: number };
+	getLines(): string[];
+	isShowingAutocomplete(): boolean;
+}
+
+/**
+ * Whether a plain ↑ restores the queued messages rather than reaching the
+ * editor. Only on a first line that fits one row of `layoutWidth`: pi's
+ * public API does not say which visual row the cursor is on, so on a wrapped
+ * first line ↑ is left to pi (it moves the cursor) and alt+up restores.
+ */
+export function upEditsQueue(editor: QueueEditEditor, queued: boolean, layoutWidth: number): boolean {
+	if (!queued) return false;
+	if (editor.isShowingAutocomplete()) return false;
+	if (editor.getCursor().line !== 0) return false;
+	return visibleWidth(editor.getLines()[0] ?? "") <= layoutWidth;
+}

package/extensions/branding/replaced-builtins.ts

@@ -0,0 +1,68 @@
+/**
+ * pi 0.99's built-in tool search and MCP, at startup (lib/replaced-builtins.mjs
+ * has the rule; decisions/tools.md "pi's built-in tool search and MCP").
+ *
+ * On the user's own pi, while the user's settings leave a built-in on, One
+ * Code asks once whether to turn them off, explaining why. "Yes" writes the
+ * `-builtin:<name>` entries through pi's own SettingsManager (a locked write
+ * of the `extensions` field only, so pi's in-memory settings keep theirs).
+ * "No" is remembered in `~/.onecode/settings.json` and never asked again;
+ * Escape asks again next start. Without a yes, the one-line notice answers
+ * pi's warning instead. Under the bundled app, which turns them off itself,
+ * a built-in left on is the user's own `+` entry, so only the notice shows.
+ */
+
+import os from "node:os";
+import { type ExtensionContext, getAgentDir, SettingsManager, VERSION as PI_VERSION } from "@earendil-works/pi-coding-agent";
+import { configCommand, installKind, replacedBuiltinsView } from "../doctor/builtins.ts";
+import { tildify } from "../lib/paths.ts";
+import { declined, recordDeclined } from "./declined.ts";
+import { replacedBuiltinsNotice, TURN_OFF_NO, TURN_OFF_YES, turnOffPrompt, withBuiltinsTurnedOff } from "../lib/replaced-builtins.mjs";
+
+/** `~/.onecode/settings.json` key: the user answered "No" to the question. */
+export const DECLINED_KEY = "piBuiltinsTurnOffDeclined";
+
+/** Ask, or show the notice, for the built-ins the settings leave on. Never throws. */
+export async function handleReplacedBuiltins(ctx: ExtensionContext): Promise<void> {
+	try {
+		const cwd = ctx.cwd;
+		const agentDir = getAgentDir();
+		const settings = () => SettingsManager.create(cwd, agentDir);
+		const view = replacedBuiltinsView(PI_VERSION, settings, { agentDir, cwd });
+		if (!view || view.left.length === 0) return;
+		const install = installKind();
+		const command = configCommand(install);
+		const notice = () => {
+			const text = replacedBuiltinsNotice(view.left, command);
+			if (text) ctx.ui.notify(text, "info");
+		};
+		// Only the user's own file is ours to offer: a project's `+builtin` entry stays.
+		const userScoped = view.left.filter((builtin) => builtin.scope === "user");
+		if (install === "app" || !ctx.hasUI || userScoped.length === 0 || declined(DECLINED_KEY)) return notice();
+
+		const shown = tildify(view.paths.user, os.homedir());
+		const choice = await ctx.ui.select(turnOffPrompt(userScoped, shown, command), [TURN_OFF_YES, TURN_OFF_NO]);
+		if (choice === TURN_OFF_YES) {
+			const manager = settings();
+			manager.setExtensionPaths(withBuiltinsTurnedOff(manager.getGlobalSettings().extensions, userScoped.map((builtin) => builtin.name)) as string[]);
+			await manager.flush();
+			const turnedOff = `Turned off pi's built-in ${userScoped.map((builtin) => builtin.name).join(" and ")} in ${shown}.`;
+			// A project's `+builtin` entry still wins over the user's file, so its warning stays.
+			const projectScoped = view.left.filter((builtin) => builtin.scope === "project");
+			const rest =
+				projectScoped.length === 0
+					? "pi's warnings stop from the next start."
+					: `This project's settings keep ${projectScoped.map((builtin) => builtin.name).join(" and ")} on, so pi still warns about ${projectScoped.length > 1 ? "them" : "it"}; run /doctor for that change.`;
+			ctx.ui.notify(`${turnedOff} ${rest}`, "info");
+			return;
+		}
+		if (choice === TURN_OFF_NO) recordDeclined(DECLINED_KEY);
+		notice();
+	} catch (error) {
+		try {
+			ctx.ui.notify(`Could not turn off pi's built-in tool search and MCP: ${(error as Error).message}. Run /doctor for the settings change.`, "warning");
+		} catch {
+			// The session ended while the dialog was open: nothing is left to tell.
+		}
+	}
+}

package/extensions/branding/startup.ts

@@ -2,8 +2,8 @@
  * Compact startup sections for the banner: Context, Skills, Themes.
  *
  * pi's own startup listing has no per-section switch — hiding the noisy
- * [Extensions] block (20 internal module names) means `quietStartup: true`,
- * which hides everything. So when quiet startup is on, the banner shows its
+ * [Extensions] block (20 internal module names) means `quietStartup`, which
+ * hides the whole listing. So when quiet startup is on, the banner shows its
  * own compact versions of the sections that ARE useful. pi's resourceLoader
  * is not exposed to extensions, so these are re-derived the same way our
  * other extensions derive them (claude-compat's skill dirs, pi's git-root
@@ -12,11 +12,14 @@
  * PI_CODING_AGENT_DIR isolation).
  */
 
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { basename, dirname, join, relative } from "node:path";
-import { findGitRoot } from "../lib/git.ts";
+import { existsSync, readdirSync } from "node:fs";
+import { basename, join, relative } from "node:path";
+import os from "node:os";
+import { projectInstructionFiles } from "../lib/claude-context.ts";
+import { projectConfigDir, userConfigDir } from "../lib/config-mode.ts";
+import { BUNDLED_SKILLS_DIR, scanSkills } from "../lib/skill-scan.ts";
 import { defaultDiscoverRoots, discoverPlugins } from "../lib/plugins.ts";
-import { claudeUserDir } from "../lib/paths.ts";
+import { oneCodeStateDir } from "../lib/paths.ts";
 
 export interface StartupSection {
 	label: string;
@@ -25,69 +28,29 @@ export interface StartupSection {
 
 /**
  * The project context files One Code actually gathers, from cwd up to the git
- * root (or just cwd outside a repo), for the startup banner. Mirrors what the
- * blocks send: a directory's CLAUDE.md, or its AGENTS.md when it has no CLAUDE.md
- * (CLAUDE.md > AGENTS.md), plus CLAUDE.local.md and ONECODE.md when present — so
- * AGENTS.md is listed only when it's really in play, not whenever it exists.
+ * root (or just cwd outside a repo), nearest directory first, for the startup
+ * banner. The same discovery and rule the blocks use (lib/claude-context.ts),
+ * so an AGENTS.md is listed only when it is really in play.
  */
-export function contextFileNames(cwd: string): string[] {
-	const stop = findGitRoot(cwd) ?? cwd;
-	const found: string[] = [];
-	let dir = cwd;
-	while (true) {
-		const rel = (name: string) => relative(cwd, join(dir, name)) || name;
-		const present = (name: string) => existsSync(join(dir, name));
-		// CLAUDE.md is primary; AGENTS.md stands in only when there is no CLAUDE.md.
-		if (present("CLAUDE.md")) found.push(rel("CLAUDE.md"));
-		else if (present("AGENTS.md")) found.push(rel("AGENTS.md"));
-		if (present("CLAUDE.local.md")) found.push(rel("CLAUDE.local.md"));
-		for (const name of ["ONECODE.md", "onecode.md", "One Code.md"]) {
-			if (present(name)) {
-				found.push(rel(name));
-				break;
-			}
-		}
-		if (dir === stop) break;
-		const parent = dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-	return found;
+export function contextFileNames(cwd: string, home: string = os.homedir()): string[] {
+	return projectInstructionFiles({ cwd, home, homeOneCodeDir: oneCodeStateDir(process.env, home) }).map((path) => relative(cwd, path) || basename(path));
 }
 
 /**
- * Skills across the same sources our extensions feed to pi: project/user
- * Claude Code dirs, pi's own user dir, and installed plugins. An entry counts
- * when <dir>/<name>/SKILL.md exists — existsSync follows symlinked skill
- * directories, which readdir's isDirectory() would miss.
+ * Skills across the same sources our extensions feed to pi (lib/skill-scan.ts
+ * scanSkills: pi's own user dir, the mode's skill folders, the bundled
+ * catalog, installed plugins), each name once: the set `/skills` lists and
+ * `/doctor` counts.
  */
-export function skillNames(cwd: string, home: string, agentDir: string): string[] {
-	const dirs = [
-		join(cwd, ".claude", "skills"),
-		join(claudeUserDir(home), "skills"),
-		join(agentDir, "skills"),
-	];
-	const names = new Set<string>();
-	for (const dir of dirs) {
-		if (!existsSync(dir)) continue;
-		try {
-			for (const entry of readdirSync(dir)) {
-				if (existsSync(join(dir, entry, "SKILL.md"))) names.add(entry);
-			}
-		} catch {
-			// Unreadable dir: skip, same as pi would.
-		}
-	}
-	for (const skill of discoverPlugins(defaultDiscoverRoots(agentDir, cwd, home)).skills) {
-		names.add(skill.name);
-	}
-	return [...names].sort((a, b) => a.localeCompare(b));
+export function skillNames(cwd: string, home: string, agentDir: string, bundledDir: string = BUNDLED_SKILLS_DIR): string[] {
+	const plugins = discoverPlugins(defaultDiscoverRoots(agentDir, cwd, home)).skills;
+	return [...new Set(scanSkills(cwd, home, agentDir, plugins, bundledDir).map((skill) => skill.name))].sort((a, b) => a.localeCompare(b));
 }
 
-/** Saved workflow names from the Claude Code layout dirs (project shadows user). */
+/** Saved workflow names from the mode's workflow dirs (project shadows user). */
 export function workflowNames(cwd: string, home: string): string[] {
 	const names = new Set<string>();
-	for (const dir of [join(cwd, ".claude", "workflows"), join(claudeUserDir(home), "workflows")]) {
+	for (const dir of [join(projectConfigDir(cwd), "workflows"), join(userConfigDir(home), "workflows")]) {
 		if (!existsSync(dir)) continue;
 		try {
 			for (const entry of readdirSync(dir)) {
@@ -146,20 +109,19 @@ export function shouldDefaultFlushOutputPad(settingsRaw: string | undefined): bo
 	}
 }
 
-/** True when pi's own startup listing is silenced, so ours should render instead. */
-export function quietStartupEnabled(piSettingsPath: string): boolean {
-	try {
-		const settings = JSON.parse(readFileSync(piSettingsPath, "utf8"));
-		return settings?.quietStartup === true;
-	} catch {
-		return false;
-	}
+/**
+ * True when pi's own startup listing is silenced, so ours should render instead:
+ * `quietStartup: true`, or pi 1.0's `"header"`, which keeps pi's header and
+ * still hides the listing. The caller supplies pi's effective, merged value.
+ */
+export function quietStartupEnabled(value: unknown): boolean {
+	return value === true || value === "header";
 }
 
-export function collectStartupSections(cwd: string, home: string, packageThemesDir: string, agentDir: string): StartupSection[] {
+export function collectStartupSections(cwd: string, home: string, packageThemesDir: string, agentDir: string, bundledSkillsDir: string = BUNDLED_SKILLS_DIR): StartupSection[] {
 	const sections: StartupSection[] = [
-		{ label: "context", items: contextFileNames(cwd) },
-		{ label: "skills", items: skillNames(cwd, home, agentDir) },
+		{ label: "context", items: contextFileNames(cwd, home) },
+		{ label: "skills", items: skillNames(cwd, home, agentDir, bundledSkillsDir) },
 		{ label: "workflows", items: workflowNames(cwd, home) },
 		{ label: "themes", items: themeNames(packageThemesDir) },
 	];