threadwell 0.0.0 → 0.0.2

package/examples/extensions/plan-mode/utils.ts

@@ -0,0 +1,168 @@
+/**
+ * Pure utility functions for plan mode.
+ * Extracted for testability.
+ */
+
+// Destructive commands blocked in plan mode
+const DESTRUCTIVE_PATTERNS = [
+	/\brm\b/i,
+	/\brmdir\b/i,
+	/\bmv\b/i,
+	/\bcp\b/i,
+	/\bmkdir\b/i,
+	/\btouch\b/i,
+	/\bchmod\b/i,
+	/\bchown\b/i,
+	/\bchgrp\b/i,
+	/\bln\b/i,
+	/\btee\b/i,
+	/\btruncate\b/i,
+	/\bdd\b/i,
+	/\bshred\b/i,
+	/(^|[^<])>(?!>)/,
+	/>>/,
+	/\bnpm\s+(install|uninstall|update|ci|link|publish)/i,
+	/\byarn\s+(add|remove|install|publish)/i,
+	/\bpnpm\s+(add|remove|install|publish)/i,
+	/\bpip\s+(install|uninstall)/i,
+	/\bapt(-get)?\s+(install|remove|purge|update|upgrade)/i,
+	/\bbrew\s+(install|uninstall|upgrade)/i,
+	/\bgit\s+(add|commit|push|pull|merge|rebase|reset|checkout|branch\s+-[dD]|stash|cherry-pick|revert|tag|init|clone)/i,
+	/\bsudo\b/i,
+	/\bsu\b/i,
+	/\bkill\b/i,
+	/\bpkill\b/i,
+	/\bkillall\b/i,
+	/\breboot\b/i,
+	/\bshutdown\b/i,
+	/\bsystemctl\s+(start|stop|restart|enable|disable)/i,
+	/\bservice\s+\S+\s+(start|stop|restart)/i,
+	/\b(vim?|nano|emacs|code|subl)\b/i,
+];
+
+// Safe read-only commands allowed in plan mode
+const SAFE_PATTERNS = [
+	/^\s*cat\b/,
+	/^\s*head\b/,
+	/^\s*tail\b/,
+	/^\s*less\b/,
+	/^\s*more\b/,
+	/^\s*grep\b/,
+	/^\s*find\b/,
+	/^\s*ls\b/,
+	/^\s*pwd\b/,
+	/^\s*echo\b/,
+	/^\s*printf\b/,
+	/^\s*wc\b/,
+	/^\s*sort\b/,
+	/^\s*uniq\b/,
+	/^\s*diff\b/,
+	/^\s*file\b/,
+	/^\s*stat\b/,
+	/^\s*du\b/,
+	/^\s*df\b/,
+	/^\s*tree\b/,
+	/^\s*which\b/,
+	/^\s*whereis\b/,
+	/^\s*type\b/,
+	/^\s*env\b/,
+	/^\s*printenv\b/,
+	/^\s*uname\b/,
+	/^\s*whoami\b/,
+	/^\s*id\b/,
+	/^\s*date\b/,
+	/^\s*cal\b/,
+	/^\s*uptime\b/,
+	/^\s*ps\b/,
+	/^\s*top\b/,
+	/^\s*htop\b/,
+	/^\s*free\b/,
+	/^\s*git\s+(status|log|diff|show|branch|remote|config\s+--get)/i,
+	/^\s*git\s+ls-/i,
+	/^\s*npm\s+(list|ls|view|info|search|outdated|audit)/i,
+	/^\s*yarn\s+(list|info|why|audit)/i,
+	/^\s*node\s+--version/i,
+	/^\s*python\s+--version/i,
+	/^\s*curl\s/i,
+	/^\s*wget\s+-O\s*-/i,
+	/^\s*jq\b/,
+	/^\s*sed\s+-n/i,
+	/^\s*awk\b/,
+	/^\s*rg\b/,
+	/^\s*fd\b/,
+	/^\s*bat\b/,
+	/^\s*eza\b/,
+];
+
+export function isSafeCommand(command: string): boolean {
+	const isDestructive = DESTRUCTIVE_PATTERNS.some((p) => p.test(command));
+	const isSafe = SAFE_PATTERNS.some((p) => p.test(command));
+	return !isDestructive && isSafe;
+}
+
+export interface TodoItem {
+	step: number;
+	text: string;
+	completed: boolean;
+}
+
+export function cleanStepText(text: string): string {
+	let cleaned = text
+		.replace(/\*{1,2}([^*]+)\*{1,2}/g, "$1") // Remove bold/italic
+		.replace(/`([^`]+)`/g, "$1") // Remove code
+		.replace(
+			/^(Use|Run|Execute|Create|Write|Read|Check|Verify|Update|Modify|Add|Remove|Delete|Install)\s+(the\s+)?/i,
+			"",
+		)
+		.replace(/\s+/g, " ")
+		.trim();
+
+	if (cleaned.length > 0) {
+		cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+	}
+	if (cleaned.length > 50) {
+		cleaned = `${cleaned.slice(0, 47)}...`;
+	}
+	return cleaned;
+}
+
+export function extractTodoItems(message: string): TodoItem[] {
+	const items: TodoItem[] = [];
+	const headerMatch = message.match(/\*{0,2}Plan:\*{0,2}\s*\n/i);
+	if (!headerMatch) return items;
+
+	const planSection = message.slice(message.indexOf(headerMatch[0]) + headerMatch[0].length);
+	const numberedPattern = /^\s*(\d+)[.)]\s+\*{0,2}([^*\n]+)/gm;
+
+	for (const match of planSection.matchAll(numberedPattern)) {
+		const text = match[2]
+			.trim()
+			.replace(/\*{1,2}$/, "")
+			.trim();
+		if (text.length > 5 && !text.startsWith("`") && !text.startsWith("/") && !text.startsWith("-")) {
+			const cleaned = cleanStepText(text);
+			if (cleaned.length > 3) {
+				items.push({ step: items.length + 1, text: cleaned, completed: false });
+			}
+		}
+	}
+	return items;
+}
+
+export function extractDoneSteps(message: string): number[] {
+	const steps: number[] = [];
+	for (const match of message.matchAll(/\[DONE:(\d+)\]/gi)) {
+		const step = Number(match[1]);
+		if (Number.isFinite(step)) steps.push(step);
+	}
+	return steps;
+}
+
+export function markCompletedSteps(text: string, items: TodoItem[]): number {
+	const doneSteps = extractDoneSteps(text);
+	for (const step of doneSteps) {
+		const item = items.find((t) => t.step === step);
+		if (item) item.completed = true;
+	}
+	return doneSteps.length;
+}

package/examples/extensions/preset.ts

@@ -0,0 +1,436 @@
+/**
+ * Preset Extension
+ *
+ * Allows defining named presets that configure model, thinking level, tools,
+ * and system prompt instructions. Presets are defined in JSON config files
+ * and can be activated via CLI flag, /preset command, or Ctrl+Shift+U to cycle.
+ *
+ * Config files (merged, project takes precedence):
+ * - ~/.threadwell/agent/presets.json (global)
+ * - <cwd>/.threadwell/presets.json (project-local)
+ *
+ * Example presets.json:
+ * ```json
+ * {
+ *   "plan": {
+ *     "provider": "openai-codex",
+ *     "model": "gpt-5.2-codex",
+ *     "thinkingLevel": "high",
+ *     "tools": ["read", "grep", "find", "ls"],
+ *     "instructions": "You are in PLANNING MODE. Your job is to deeply understand the problem and create a detailed implementation plan.\n\nRules:\n- DO NOT make any changes. You cannot edit or write files.\n- Read files IN FULL (no offset/limit) to get complete context. Partial reads miss critical details.\n- Explore thoroughly: grep for related code, find similar patterns, understand the architecture.\n- Ask clarifying questions if requirements are ambiguous. Do not assume.\n- Identify risks, edge cases, and dependencies before proposing solutions.\n\nOutput:\n- Create a structured plan with numbered steps.\n- For each step: what to change, why, and potential risks.\n- List files that will be modified.\n- Note any tests that should be added or updated.\n\nWhen done, ask the user if they want you to:\n1. Write the plan to a markdown file (e.g., PLAN.md)\n2. Create a GitHub issue with the plan\n3. Proceed to implementation (they should switch to 'implement' preset)"
+ *   },
+ *   "implement": {
+ *     "provider": "anthropic",
+ *     "model": "claude-sonnet-4-5",
+ *     "thinkingLevel": "high",
+ *     "tools": ["read", "bash", "edit", "write"],
+ *     "instructions": "You are in IMPLEMENTATION MODE. Your job is to make focused, correct changes.\n\nRules:\n- Keep scope tight. Do exactly what was asked, no more.\n- Read files before editing to understand current state.\n- Make surgical edits. Prefer edit over write for existing files.\n- Explain your reasoning briefly before each change.\n- Run tests or type checks after changes if the project has them (npm test, npm run check, etc.).\n- If you encounter unexpected complexity, STOP and explain the issue rather than hacking around it.\n\nIf no plan exists:\n- Ask clarifying questions before starting.\n- Propose what you'll do and get confirmation for non-trivial changes.\n\nAfter completing changes:\n- Summarize what was done.\n- Note any follow-up work or tests that should be added."
+ *   }
+ * }
+ * ```
+ *
+ * Usage:
+ * - `threadwell --preset plan` - start with plan preset
+ * - `/preset` - show selector to switch presets mid-session
+ * - `/preset implement` - switch to implement preset directly
+ * - `Ctrl+Shift+U` - cycle through presets
+ *
+ * CLI flags always override preset values.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Api, Model } from "@threadwell/ai";
+import { Container, Key, type SelectItem, SelectList, Text } from "@threadwell/tui";
+import type { ExtensionAPI, ExtensionContext } from "threadwell";
+import { DynamicBorder, getAgentDir } from "threadwell";
+
+// Preset configuration
+interface Preset {
+	/** Provider name (e.g., "anthropic", "openai") */
+	provider?: string;
+	/** Model ID (e.g., "claude-sonnet-4-5") */
+	model?: string;
+	/** Thinking level */
+	thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+	/** Tools to enable (replaces default set) */
+	tools?: string[];
+	/** Instructions to append to system prompt */
+	instructions?: string;
+}
+
+interface PresetsConfig {
+	[name: string]: Preset;
+}
+
+/**
+ * Load presets from config files.
+ * Project-local presets override global presets with the same name.
+ */
+function loadPresets(cwd: string): PresetsConfig {
+	const globalPath = join(getAgentDir(), "presets.json");
+	const projectPath = join(cwd, ".threadwell", "presets.json");
+
+	let globalPresets: PresetsConfig = {};
+	let projectPresets: PresetsConfig = {};
+
+	// Load global presets
+	if (existsSync(globalPath)) {
+		try {
+			const content = readFileSync(globalPath, "utf-8");
+			globalPresets = JSON.parse(content);
+		} catch (err) {
+			console.error(`Failed to load global presets from ${globalPath}: ${err}`);
+		}
+	}
+
+	// Load project presets
+	if (existsSync(projectPath)) {
+		try {
+			const content = readFileSync(projectPath, "utf-8");
+			projectPresets = JSON.parse(content);
+		} catch (err) {
+			console.error(`Failed to load project presets from ${projectPath}: ${err}`);
+		}
+	}
+
+	// Merge (project overrides global)
+	return { ...globalPresets, ...projectPresets };
+}
+
+interface OriginalState {
+	model: Model<Api> | undefined;
+	thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+	tools: string[];
+}
+
+export default function presetExtension(threadwell: ExtensionAPI) {
+	let presets: PresetsConfig = {};
+	let activePresetName: string | undefined;
+	let activePreset: Preset | undefined;
+	let originalState: OriginalState | undefined;
+
+	// Register --preset CLI flag
+	threadwell.registerFlag("preset", {
+		description: "Preset configuration to use",
+		type: "string",
+	});
+
+	/**
+	 * Apply a preset configuration.
+	 */
+	async function applyPreset(name: string, preset: Preset, ctx: ExtensionContext): Promise<boolean> {
+		// Snapshot state before the first preset is applied (i.e. only when transitioning from no-preset)
+		if (activePresetName === undefined) {
+			originalState = {
+				model: ctx.model,
+				thinkingLevel: threadwell.getThinkingLevel(),
+				tools: threadwell.getActiveTools(),
+			};
+		}
+
+		// Apply model if specified
+		if (preset.provider && preset.model) {
+			const model = ctx.modelRegistry.find(preset.provider, preset.model);
+			if (model) {
+				const success = await threadwell.setModel(model);
+				if (!success) {
+					ctx.ui.notify(`Preset "${name}": No API key for ${preset.provider}/${preset.model}`, "warning");
+				}
+			} else {
+				ctx.ui.notify(`Preset "${name}": Model ${preset.provider}/${preset.model} not found`, "warning");
+			}
+		}
+
+		// Apply thinking level if specified
+		if (preset.thinkingLevel) {
+			threadwell.setThinkingLevel(preset.thinkingLevel);
+		}
+
+		// Apply tools if specified
+		if (preset.tools && preset.tools.length > 0) {
+			const allToolNames = threadwell.getAllTools().map((t) => t.name);
+			const validTools = preset.tools.filter((t) => allToolNames.includes(t));
+			const invalidTools = preset.tools.filter((t) => !allToolNames.includes(t));
+
+			if (invalidTools.length > 0) {
+				ctx.ui.notify(`Preset "${name}": Unknown tools: ${invalidTools.join(", ")}`, "warning");
+			}
+
+			if (validTools.length > 0) {
+				threadwell.setActiveTools(validTools);
+			}
+		}
+
+		// Store active preset for system prompt injection
+		activePresetName = name;
+		activePreset = preset;
+
+		return true;
+	}
+
+	/**
+	 * Build description string for a preset.
+	 */
+	function buildPresetDescription(preset: Preset): string {
+		const parts: string[] = [];
+
+		if (preset.provider && preset.model) {
+			parts.push(`${preset.provider}/${preset.model}`);
+		}
+		if (preset.thinkingLevel) {
+			parts.push(`thinking:${preset.thinkingLevel}`);
+		}
+		if (preset.tools) {
+			parts.push(`tools:${preset.tools.join(",")}`);
+		}
+		if (preset.instructions) {
+			const truncated =
+				preset.instructions.length > 30 ? `${preset.instructions.slice(0, 27)}...` : preset.instructions;
+			parts.push(`"${truncated}"`);
+		}
+
+		return parts.join(" | ");
+	}
+
+	/**
+	 * Show preset selector UI using custom SelectList component.
+	 */
+	async function showPresetSelector(ctx: ExtensionContext): Promise<void> {
+		const presetNames = Object.keys(presets);
+
+		if (presetNames.length === 0) {
+			ctx.ui.notify(
+				"No presets defined. Add presets to ~/.threadwell/agent/presets.json or .threadwell/presets.json",
+				"warning",
+			);
+			return;
+		}
+
+		// Build select items with descriptions
+		const items: SelectItem[] = presetNames.map((name) => {
+			const preset = presets[name];
+			const isActive = name === activePresetName;
+			return {
+				value: name,
+				label: isActive ? `${name} (active)` : name,
+				description: buildPresetDescription(preset),
+			};
+		});
+
+		// Add "None" option to clear preset
+		items.push({
+			value: "(none)",
+			label: "(none)",
+			description: "Clear active preset, restore defaults",
+		});
+
+		const result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+			const container = new Container();
+			container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
+
+			// Header
+			container.addChild(new Text(theme.fg("accent", theme.bold("Select Preset"))));
+
+			// SelectList with themed styling
+			const selectList = new SelectList(items, Math.min(items.length, 10), {
+				selectedPrefix: (text) => theme.fg("accent", text),
+				selectedText: (text) => theme.fg("accent", text),
+				description: (text) => theme.fg("muted", text),
+				scrollInfo: (text) => theme.fg("dim", text),
+				noMatch: (text) => theme.fg("warning", text),
+			});
+
+			selectList.onSelect = (item) => done(item.value);
+			selectList.onCancel = () => done(null);
+
+			container.addChild(selectList);
+
+			// Footer hint
+			container.addChild(new Text(theme.fg("dim", "↑↓ navigate • enter select • esc cancel")));
+
+			container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
+
+			return {
+				render(width: number) {
+					return container.render(width);
+				},
+				invalidate() {
+					container.invalidate();
+				},
+				handleInput(data: string) {
+					selectList.handleInput(data);
+					tui.requestRender();
+				},
+			};
+		});
+
+		if (!result) return;
+
+		if (result === "(none)") {
+			// Clear preset and restore original state
+			activePresetName = undefined;
+			activePreset = undefined;
+			if (originalState) {
+				if (originalState.model) {
+					await threadwell.setModel(originalState.model);
+				}
+				threadwell.setThinkingLevel(originalState.thinkingLevel);
+				threadwell.setActiveTools(originalState.tools);
+			} else {
+				threadwell.setActiveTools(["read", "bash", "edit", "write"]);
+			}
+			ctx.ui.notify("Preset cleared, defaults restored", "info");
+			updateStatus(ctx);
+			return;
+		}
+
+		const preset = presets[result];
+		if (preset) {
+			await applyPreset(result, preset, ctx);
+			ctx.ui.notify(`Preset "${result}" activated`, "info");
+			updateStatus(ctx);
+		}
+	}
+
+	/**
+	 * Update status indicator.
+	 */
+	function updateStatus(ctx: ExtensionContext) {
+		if (activePresetName) {
+			ctx.ui.setStatus("preset", ctx.ui.theme.fg("accent", `preset:${activePresetName}`));
+		} else {
+			ctx.ui.setStatus("preset", undefined);
+		}
+	}
+
+	function getPresetOrder(): string[] {
+		return Object.keys(presets).sort();
+	}
+
+	async function cyclePreset(ctx: ExtensionContext): Promise<void> {
+		const presetNames = getPresetOrder();
+		if (presetNames.length === 0) {
+			ctx.ui.notify(
+				"No presets defined. Add presets to ~/.threadwell/agent/presets.json or .threadwell/presets.json",
+				"warning",
+			);
+			return;
+		}
+
+		const cycleList = ["(none)", ...presetNames];
+		const currentName = activePresetName ?? "(none)";
+		const currentIndex = cycleList.indexOf(currentName);
+		const nextIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % cycleList.length;
+		const nextName = cycleList[nextIndex];
+
+		if (nextName === "(none)") {
+			activePresetName = undefined;
+			activePreset = undefined;
+			if (originalState) {
+				if (originalState.model) {
+					await threadwell.setModel(originalState.model);
+				}
+				threadwell.setThinkingLevel(originalState.thinkingLevel);
+				threadwell.setActiveTools(originalState.tools);
+			} else {
+				threadwell.setActiveTools(["read", "bash", "edit", "write"]);
+			}
+			ctx.ui.notify("Preset cleared, defaults restored", "info");
+			updateStatus(ctx);
+			return;
+		}
+
+		const preset = presets[nextName];
+		if (!preset) return;
+
+		await applyPreset(nextName, preset, ctx);
+		ctx.ui.notify(`Preset "${nextName}" activated`, "info");
+		updateStatus(ctx);
+	}
+
+	threadwell.registerShortcut(Key.ctrlShift("u"), {
+		description: "Cycle presets",
+		handler: async (ctx) => {
+			await cyclePreset(ctx);
+		},
+	});
+
+	// Register /preset command
+	threadwell.registerCommand("preset", {
+		description: "Switch preset configuration",
+		handler: async (args, ctx) => {
+			// If preset name provided, apply directly
+			if (args?.trim()) {
+				const name = args.trim();
+				const preset = presets[name];
+
+				if (!preset) {
+					const available = Object.keys(presets).join(", ") || "(none defined)";
+					ctx.ui.notify(`Unknown preset "${name}". Available: ${available}`, "error");
+					return;
+				}
+
+				await applyPreset(name, preset, ctx);
+				ctx.ui.notify(`Preset "${name}" activated`, "info");
+				updateStatus(ctx);
+				return;
+			}
+
+			// Otherwise show selector
+			await showPresetSelector(ctx);
+		},
+	});
+
+	// Inject preset instructions into system prompt
+	threadwell.on("before_agent_start", async (event) => {
+		if (activePreset?.instructions) {
+			return {
+				systemPrompt: `${event.systemPrompt}\n\n${activePreset.instructions}`,
+			};
+		}
+	});
+
+	// Initialize on session start
+	threadwell.on("session_start", async (_event, ctx) => {
+		// Load presets from config files
+		presets = loadPresets(ctx.cwd);
+
+		// Check for --preset flag
+		const presetFlag = threadwell.getFlag("preset");
+		if (typeof presetFlag === "string" && presetFlag) {
+			const preset = presets[presetFlag];
+			if (preset) {
+				await applyPreset(presetFlag, preset, ctx);
+				ctx.ui.notify(`Preset "${presetFlag}" activated`, "info");
+			} else {
+				const available = Object.keys(presets).join(", ") || "(none defined)";
+				ctx.ui.notify(`Unknown preset "${presetFlag}". Available: ${available}`, "warning");
+			}
+		}
+
+		// Restore preset from session state
+		const entries = ctx.sessionManager.getEntries();
+		const presetEntry = entries
+			.filter((e: { type: string; customType?: string }) => e.type === "custom" && e.customType === "preset-state")
+			.pop() as { data?: { name: string } } | undefined;
+
+		if (presetEntry?.data?.name && !presetFlag) {
+			const preset = presets[presetEntry.data.name];
+			if (preset) {
+				activePresetName = presetEntry.data.name;
+				activePreset = preset;
+				// Don't re-apply model/tools on restore, just keep the name for instructions
+			}
+		}
+
+		updateStatus(ctx);
+	});
+
+	// Persist preset state
+	threadwell.on("turn_start", async () => {
+		if (activePresetName) {
+			threadwell.appendEntry("preset-state", { name: activePresetName });
+		}
+	});
+}

package/examples/extensions/prompt-customizer.ts

@@ -0,0 +1,97 @@
+/**
+ * Prompt Customizer Extension
+ *
+ * Demonstrates using systemPromptOptions to make informed, context-aware
+ * modifications to the system prompt without re-discovering resources.
+ *
+ * This extension adds tool-specific guidance based on what tools and skills
+ * are currently active, respecting whatever the user has configured.
+ *
+ * Usage:
+ * 1. Copy this file to ~/.threadwell/agent/extensions/ or your project's .threadwell/extensions/
+ * 2. Use the extension — it automatically adapts to your active tools and skills
+ */
+
+import type { BuildSystemPromptOptions, ExtensionAPI } from "threadwell";
+
+/**
+ * Adds tool-specific guidance that adapts to the active tool set.
+ * Instead of appending one-size-fits-all instructions, this reads what's
+ * actually loaded and tailors the guidance accordingly.
+ */
+function addToolGuidance(options: BuildSystemPromptOptions, basePrompt: string): string {
+	const hasTool = (name: string) => options.selectedTools?.includes(name) ?? false;
+
+	const parts: string[] = [];
+
+	if (hasTool("read")) {
+		parts.push(
+			"• Use the `read` tool for file contents (supports text and images).",
+			"  - For large files, use `offset` and `limit` to read in chunks.",
+		);
+	}
+
+	if (hasTool("bash")) {
+		parts.push("• Execute commands with the `bash` tool. Use it for file operations like `ls`, `find`, `grep`.");
+	}
+
+	if (hasTool("edit")) {
+		parts.push(
+			"• Use the `edit` tool for precise text replacements in files. Match exact content including whitespace.",
+		);
+	}
+
+	if (hasTool("write")) {
+		parts.push("• Use the `write` tool to create new files or overwrite existing ones completely.");
+	}
+
+	if (options.skills && options.skills.length > 0) {
+		const skillNames = options.skills.map((s) => s.name).join(", ");
+		parts.push(`\nAvailable skills: ${skillNames}`, "Use skill documentation for best practices on specific tools.");
+	}
+
+	if (parts.length === 0) {
+		return basePrompt;
+	}
+
+	return `${basePrompt}
+
+## Tool Guidance
+
+${parts.join("\n")}
+`;
+}
+
+/**
+ * Merges extension instructions with user-provided append prompts.
+ * This respects whatever the user configured via --append-system-prompt
+ * flags or files, rather than duplicating that work.
+ */
+function mergeWithUserAppend(options: BuildSystemPromptOptions): string {
+	const userAppend = options.appendSystemPrompt;
+	const extensionSpecific = `
+## Extension-Added Context
+
+This prompt includes tool guidance and skill information loaded dynamically.
+If you have additional requirements, configure them via --append-system-prompt or project context files.
+`;
+
+	if (userAppend) {
+		return `${userAppend}\n\n${extensionSpecific}`;
+	}
+
+	return extensionSpecific;
+}
+
+export default function promptCustomizer(threadwell: ExtensionAPI) {
+	threadwell.on("before_agent_start", async (event) => {
+		const { systemPrompt, systemPromptOptions } = event;
+
+		const customPrompt = addToolGuidance(systemPromptOptions, systemPrompt);
+		const appendSection = mergeWithUserAppend(systemPromptOptions);
+
+		return {
+			systemPrompt: `${customPrompt}${appendSection}`,
+		};
+	});
+}