pi-harness-delegate 0.1.0

package/extensions/progress.ts

@@ -0,0 +1,142 @@
+/**
+ * Live progress window for /delegate runs — a framed overlay showing the
+ * activity feed, thinking indicator and text tail while the delegation runs.
+ *
+ * Controls:
+ *   - ESC twice: cancel (first press arms, second confirms within 1.5s)
+ *   - `m`: minimize (hide the window, run continues in the background;
+ *     re-show with /delegate watch)
+ */
+
+import { Key, matchesKey, truncateToWidth, visibleWidth, type Component, type TUI } from '@earendil-works/pi-tui';
+import type { Theme } from '@earendil-works/pi-coding-agent';
+
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPIN_INTERVAL_MS = 100;
+const MAX_VISIBLE_ENTRIES = 12;
+
+export type FeedEntry =
+	| { kind: 'tool'; text: string; ok?: boolean }
+	| { kind: 'thinking'; text: string }
+	| { kind: 'text'; text: string };
+
+export interface ProgressWindowOptions {
+	/** Harness name shown in title. */
+	harness?: string;
+	/** Mode name, shown in the title bar (e.g. "review"). */
+	mode: string;
+	/** Model (or alias) shown in the title bar. */
+	model?: string | null;
+	/** Epoch ms when the run started — drives the live elapsed timer. */
+	startedAt: number;
+	/** Live feed entries (tool calls, thinking, text tail). */
+	getEntries: () => FeedEntry[];
+	/** Show an "unrestricted permissions" warning banner. */
+	dangerous?: boolean;
+	/** Called when the user confirms cancel. */
+	onCancel: () => void;
+	/** Called when the user presses `m` (minimize — keep the run going). */
+	onMinimize: () => void;
+}
+
+export function fmtElapsed(ms: number): string {
+	const total = Math.max(0, Math.floor(ms / 1000));
+	const m = Math.floor(total / 60);
+	const s = total % 60;
+	return m > 0 ? `${m}:${String(s).padStart(2, '0')}` : `0:${String(s).padStart(2, '0')}`;
+}
+
+/** Style one feed entry; the returned string may contain ANSI colors. */
+export function renderEntry(entry: FeedEntry, theme: Theme): string {
+	switch (entry.kind) {
+		case 'tool': {
+			const mark = entry.ok === undefined ? '' : entry.ok ? theme.fg('success', ' ✓') : theme.fg('error', ' ✗');
+			return theme.fg('accent', '▶ ') + theme.fg('muted', entry.text) + mark;
+		}
+		case 'thinking':
+			return theme.fg('dim', entry.text);
+		case 'text':
+			return theme.fg('text', entry.text);
+	}
+}
+
+/** Create the overlay component; disposes the spinner timer. */
+export function progressWindow(tui: TUI, theme: Theme, opts: ProgressWindowOptions): Component & { dispose(): void } {
+	let frame = 0;
+	let armed = false;
+	let armTimer: ReturnType<typeof setTimeout> | null = null;
+	const timer = setInterval(() => {
+		frame++;
+		tui.requestRender();
+	}, SPIN_INTERVAL_MS);
+
+	const disarm = () => {
+		armed = false;
+		if (armTimer) {
+			clearTimeout(armTimer);
+			armTimer = null;
+		}
+	};
+
+	return {
+		render(width: number): string[] {
+			const inner = Math.max(10, width - 4);
+			const padTo = (s: string, w: number) => `${s}${' '.repeat(Math.max(1, w - visibleWidth(s)))}`;
+			const out: string[] = [];
+
+			// title bar: ⠋ <harness> <mode> · <model> · ⏱ elapsed
+			const harness = opts.harness ?? 'delegate';
+			const title = `${SPINNER[frame % SPINNER.length]} ${harness} ${opts.mode}`;
+			const status = [opts.model ?? '', `⏱ ${fmtElapsed(Date.now() - opts.startedAt)}`].filter(Boolean).join(' · ');
+			const titleStr = status ? `${title} · ${status}` : title;
+			const dash = '─'.repeat(Math.max(1, inner - visibleWidth(titleStr) - 2));
+			out.push(theme.fg('accent', `╭─ ${titleStr} ${dash}─╮`));
+
+			// danger banner
+			if (opts.dangerous) {
+				const banner = theme.fg('error', '⚠ danger — unrestricted access');
+				out.push(`│ ${padTo(banner, inner)} │`);
+			}
+
+			// feed
+			for (const entry of opts.getEntries().slice(-MAX_VISIBLE_ENTRIES)) {
+				out.push(`│ ${padTo(truncateToWidth(renderEntry(entry, theme), inner), inner)} │`);
+			}
+
+			// hint row (double-ESC guard + minimize)
+			const hint = armed
+				? theme.fg('warning', 'press esc again to cancel') + theme.fg('dim', ' · m minimize')
+				: theme.fg('dim', 'esc cancel') + theme.fg('dim', ' · m minimize');
+			out.push(`│ ${padTo(hint, inner)} │`);
+
+			out.push(theme.fg('accent', `╰${'─'.repeat(Math.max(1, width - 2))}╯`));
+			return out;
+		},
+		handleInput(data: string): void {
+			if (matchesKey(data, Key.escape)) {
+				if (armed) {
+					disarm();
+					opts.onCancel();
+				} else {
+					armed = true;
+					armTimer = setTimeout(() => {
+						armed = false;
+						armTimer = null;
+						tui.requestRender();
+					}, 1500);
+					tui.requestRender();
+				}
+			} else if (data === 'm') {
+				disarm();
+				opts.onMinimize();
+			}
+		},
+		invalidate(): void {
+			// stateless render — nothing to clear
+		},
+		dispose(): void {
+			clearInterval(timer);
+			disarm();
+		},
+	};
+}

package/extensions/run-claude.ts

@@ -0,0 +1,52 @@
+/** @deprecated use extensions/runner.ts + harnesses/claude.ts directly */
+import type { ActivityEvent, StreamedResult } from './harnesses/types.ts';
+import { claudeHarness } from './harnesses/claude.ts';
+import { runHarness } from './runner.ts';
+
+export interface RunClaudeOptions {
+	prompt: string;
+	cwd: string;
+	permissionMode: string;
+	model?: string;
+	maxBudgetUsd?: number;
+	addDirs?: string[];
+	signal?: AbortSignal;
+	timeoutMs?: number;
+	resumeSessionId?: string;
+	onStream?: (text: string) => void;
+	onActivity?: (ev: ActivityEvent) => void;
+}
+
+export interface ClaudeResult extends StreamedResult {
+	streamedText: string;
+}
+
+export const DEFAULT_TIMEOUT_MS = 600_000;
+
+function mapPerm(mode: string): 'readonly' | 'edit' | 'danger' {
+	if (mode === 'plan') return 'readonly';
+	if (mode === 'bypassPermissions') return 'danger';
+	return 'edit';
+}
+
+export function runClaude(opts: RunClaudeOptions): Promise<ClaudeResult> {
+	const perm = mapPerm(opts.permissionMode);
+	const nativePerm = perm === 'readonly' && opts.permissionMode !== 'plan' ? opts.permissionMode : perm === 'danger' && opts.permissionMode !== 'bypassPermissions' ? opts.permissionMode : undefined;
+	// normalize: if caller passed a non-standard mode, preserve as native
+	const isStandard = opts.permissionMode === 'plan' || opts.permissionMode === 'acceptEdits' || opts.permissionMode === 'bypassPermissions';
+	return runHarness({
+		harness: claudeHarness,
+		prompt: opts.prompt,
+		cwd: opts.cwd,
+		permission: perm,
+		nativePermission: isStandard ? undefined : opts.permissionMode,
+		model: opts.model,
+		maxBudgetUsd: opts.maxBudgetUsd,
+		addDirs: opts.addDirs,
+		signal: opts.signal,
+		timeoutMs: opts.timeoutMs,
+		resumeSessionId: opts.resumeSessionId,
+		onStream: opts.onStream,
+		onActivity: opts.onActivity,
+	}).then((r) => ({ ...r, streamedText: r.streamedText }));
+}

package/extensions/runner.ts

@@ -0,0 +1,120 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import type { Harness, ParseState, StreamedResult } from './harnesses/types.ts';
+
+export interface RunHarnessOptions {
+	harness: Harness;
+	prompt: string;
+	cwd: string;
+	permission: import('./harnesses/types.ts').NormalizedPermission;
+	nativePermission?: string;
+	model?: string;
+	maxBudgetUsd?: number;
+	addDirs?: string[];
+	signal?: AbortSignal;
+	timeoutMs?: number;
+	resumeSessionId?: string;
+	onStream?: (text: string) => void;
+	onActivity?: (ev: import('./harnesses/types.ts').ActivityEvent) => void;
+}
+
+export interface HarnessResult extends StreamedResult {
+	streamedText: string;
+	harness: string;
+}
+
+import { DEFAULT_TIMEOUT_MS } from './harnesses/types.ts';
+
+export function runHarness(opts: RunHarnessOptions): Promise<HarnessResult> {
+	return new Promise((resolve, reject) => {
+		const args = opts.harness.buildArgs({
+			prompt: opts.prompt,
+			cwd: opts.cwd,
+			permission: opts.permission,
+			nativePermission: opts.nativePermission,
+			model: opts.model,
+			maxBudgetUsd: opts.maxBudgetUsd,
+			addDirs: opts.addDirs,
+			resumeSessionId: opts.resumeSessionId,
+		});
+
+		const proc = spawn(opts.harness.binary, args, { cwd: opts.cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+
+		const state: ParseState = { streamedText: '', activities: [], result: null, _harness: {} };
+		let stderr = '';
+		let settled = false;
+		let firstTokenAt: number | null = null;
+		const startAt = Date.now();
+
+		const finish = (r: StreamedResult) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			const ttft = firstTokenAt !== null ? firstTokenAt - startAt : r.ttftMs;
+			resolve({ ...r, ttftMs: ttft, streamedText: state.streamedText, harness: opts.harness.name });
+		};
+		const fail = (err: Error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			reject(err);
+		};
+
+		const rl = createInterface({ input: proc.stdout });
+		rl.on('line', (line) => {
+			const outcome = opts.harness.parseLine(line, state);
+			if (outcome.streamedText) {
+				if (firstTokenAt === null) firstTokenAt = Date.now();
+				state.streamedText += outcome.streamedText;
+				opts.onStream?.(outcome.streamedText);
+			}
+			if (outcome.activities) {
+				for (const a of outcome.activities) {
+					state.activities.push(a);
+					opts.onActivity?.(a);
+				}
+			}
+			if (outcome.result) {
+				// merge streamedText into result if empty
+				if (!outcome.result.result) outcome.result.result = state.streamedText;
+				state.result = outcome.result;
+			}
+		});
+
+		proc.stderr.on('data', (d: Buffer) => (stderr += d.toString()));
+		proc.on('close', (code) => {
+			// Don't synthesize fallback on non-zero exit without explicit result — surface the error
+			if (code !== 0 && !state.result) {
+				fail(new Error(stderr.trim() || `${opts.harness.binary} exited with code ${code}`));
+				return;
+			}
+			const final = opts.harness.extractResult(state);
+			if (final) {
+				if (!final.result) final.result = state.streamedText;
+				finish(final);
+			} else if (code !== 0) {
+				fail(new Error(stderr.trim() || `${opts.harness.binary} exited with code ${code}`));
+			} else {
+				fail(new Error(`${opts.harness.binary} finished without emitting a result`));
+			}
+		});
+		proc.on('error', (err) => {
+			fail(new Error(`failed to start ${opts.harness.binary}: ${err.message}`));
+		});
+
+		const timer = setTimeout(() => {
+			proc.kill('SIGKILL');
+			fail(new Error(`${opts.harness.binary} timed out after ${opts.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`));
+		}, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+		timer.unref?.();
+
+		opts.signal?.addEventListener(
+			'abort',
+			() => {
+				proc.kill('SIGKILL');
+				fail(new Error('cancelled'));
+			},
+			{ once: true },
+		);
+	});
+}

package/extensions/stream-parse.ts

@@ -0,0 +1,29 @@
+/** @deprecated use extensions/harnesses/claude.ts parse directly */
+export type { StreamedUsage, StreamedResult, ActivityEvent, StreamParseOutcome, ParseState, ParseOutcome } from './harnesses/types.ts';
+import type { ParseState, StreamParseOutcome } from './harnesses/types.ts';
+import { parseClaudeLine } from './harnesses/claude.ts';
+
+export function parseStreamLines(lines: Iterable<string>): StreamParseOutcome {
+	const state: ParseState = { streamedText: '', activities: [], result: null };
+	let streamedText = '';
+	const activities: StreamParseOutcome['activities'] = [];
+	let result: StreamParseOutcome['result'] = null;
+	for (const line of lines) {
+		const out = parseClaudeLine(line, state);
+		if (out.streamedText) {
+			streamedText += out.streamedText;
+			state.streamedText += out.streamedText;
+		}
+		if (out.activities) {
+			for (const a of out.activities) {
+				activities.push(a);
+				state.activities.push(a);
+			}
+		}
+		if (out.result) {
+			result = out.result;
+			state.result = out.result;
+		}
+	}
+	return { streamedText, result, activities };
+}

package/extensions/templates.ts

@@ -0,0 +1,166 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { NormalizedPermission } from './harnesses/types.ts';
+
+export type PermissionMode =
+	| 'plan'
+	| 'acceptEdits'
+	| 'bypassPermissions'
+	| 'dontAsk'
+	| 'auto'
+	| 'manual';
+
+const PERMISSION_MODES = new Set<PermissionMode>([
+	'plan',
+	'acceptEdits',
+	'bypassPermissions',
+	'dontAsk',
+	'auto',
+	'manual',
+]);
+
+export interface DelegateTemplate {
+	name: string;
+	description: string;
+	permission: NormalizedPermission;
+	/** Native harness permission string if user used escape hatch. */
+	nativePermission?: string;
+	/** Legacy raw permissionMode for transcript compat. */
+	permissionMode: PermissionMode;
+	model?: string;
+	maxBudgetUsd?: number;
+	skill?: string;
+	defaultTask?: string;
+	defaultScope?: string;
+	prompt: string;
+	harness?: string;
+}
+
+export function normalizePermission(raw: string | undefined, fallbackMode: string | undefined): { permission: NormalizedPermission; nativePermission?: string; permissionMode: PermissionMode } {
+	// Prefer normalized permission
+	if (raw) {
+		const lower = raw.trim().toLowerCase();
+		if (lower === 'readonly' || lower === 'read-only' || lower === 'read_only') return { permission: 'readonly', permissionMode: 'plan' };
+		if (lower === 'edit' || lower === 'acceptEdits' || lower === 'accept-edits') return { permission: 'edit', permissionMode: 'acceptEdits' };
+		if (lower === 'danger' || lower === 'bypassPermissions' || lower === 'danger-full-access' || lower === 'danger_full_access') return { permission: 'danger', permissionMode: 'bypassPermissions' };
+		// Unknown native — treat as native escape hatch
+		return { permission: 'edit', nativePermission: raw.trim(), permissionMode: 'acceptEdits' };
+	}
+	// Legacy permissionMode mapping
+	if (fallbackMode && PERMISSION_MODES.has(fallbackMode as PermissionMode)) {
+		const m = fallbackMode as PermissionMode;
+		if (m === 'plan') return { permission: 'readonly', permissionMode: m };
+		if (m === 'bypassPermissions') return { permission: 'danger', permissionMode: m };
+		return { permission: 'edit', permissionMode: m };
+	}
+	return { permission: 'edit', permissionMode: 'acceptEdits' };
+}
+
+/** Parse a template file: frontmatter (---\nkey: value\n---) + markdown body. */
+export function parseTemplate(text: string): DelegateTemplate | null {
+	const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(text.trimStart());
+	if (!m) return null;
+
+	const meta: Record<string, string> = {};
+	for (const line of m[1].split('\n')) {
+		const i = line.indexOf(':');
+		if (i <= 0) continue;
+		meta[line.slice(0, i).trim()] = line.slice(i + 1).trim();
+	}
+
+	const name = meta.name?.trim();
+	if (!name) return null;
+
+	const permRaw = meta.permission?.trim();
+	const permModeRaw = meta.permissionMode?.trim() ?? meta.sandbox?.trim();
+	const norm = normalizePermission(permRaw, permModeRaw);
+
+	const budget = meta.maxBudgetUsd ? Number(meta.maxBudgetUsd) : NaN;
+
+	return {
+		name,
+		description: meta.description ?? '',
+		permission: norm.permission,
+		nativePermission: norm.nativePermission,
+		permissionMode: norm.permissionMode,
+		model: meta.model || undefined,
+		maxBudgetUsd: Number.isFinite(budget) && budget > 0 ? budget : undefined,
+		skill: meta.skill || undefined,
+		defaultTask: meta.defaultTask || undefined,
+		defaultScope: meta.defaultScope || undefined,
+		prompt: m[2].trim(),
+		harness: meta.harness || undefined,
+	};
+}
+
+function loadDir(dir: string, out: Map<string, DelegateTemplate>): void {
+	if (!existsSync(dir)) return;
+	for (const f of readdirSync(dir)) {
+		if (!f.endsWith('.md')) continue;
+		try {
+			const t = parseTemplate(readFileSync(join(dir, f), 'utf8'));
+			if (t) out.set(t.name, t);
+		} catch {
+			// skip unreadable files
+		}
+	}
+}
+
+export function builtinTemplatesDir(): string {
+	return fileURLToPath(new URL('../templates/', import.meta.url));
+}
+
+export function builtinHarnessTemplatesDir(harness: string): string {
+	return fileURLToPath(new URL(`../templates/${harness}/`, import.meta.url));
+}
+
+export function sharedTemplatesDir(): string {
+	return fileURLToPath(new URL('../templates/shared/', import.meta.url));
+}
+
+export function userTemplatesDir(harness?: string): string {
+	const dir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
+	if (harness) return join(dir, 'delegate', 'templates', harness);
+	return join(dir, 'delegate', 'templates');
+}
+
+export function projectTemplatesDir(cwd: string, harness?: string): string {
+	if (harness) return join(cwd, '.pi', 'delegate', 'templates', harness);
+	return join(cwd, '.pi', 'delegate', 'templates');
+}
+
+/** Legacy dirs for compat */
+function legacyUserTemplatesDir(): string {
+	const dir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), '.pi', 'agent');
+	return join(dir, 'claude-delegate', 'templates');
+}
+function legacyProjectTemplatesDir(cwd: string): string {
+	return join(cwd, '.pi', 'claude-delegate', 'templates');
+}
+
+/** Legacy root < shared < harness builtins < legacyUser < user < user/harness < legacyProject < project < project/harness (later wins). */
+export function loadTemplates(cwd: string, harnessName?: string): Map<string, DelegateTemplate> {
+	const out = new Map<string, DelegateTemplate>();
+	const harness = harnessName ?? 'claude';
+	// legacy root builtins (templates/*.md) lowest — for migration from pi-claude-delegate
+	loadDir(builtinTemplatesDir(), out);
+	// shared canonical bodies
+	loadDir(sharedTemplatesDir(), out);
+	// harness-specific builtins override shared
+	loadDir(builtinHarnessTemplatesDir(harness), out);
+	// user globals: legacy before new so new wins
+	loadDir(legacyUserTemplatesDir(), out);
+	loadDir(userTemplatesDir(), out);
+	loadDir(userTemplatesDir(harness), out);
+	// project locals: legacy before new so new wins
+	loadDir(legacyProjectTemplatesDir(cwd), out);
+	loadDir(projectTemplatesDir(cwd), out);
+	loadDir(projectTemplatesDir(cwd, harness), out);
+	return out;
+}
+
+export function loadAllTemplates(cwd: string): Map<string, DelegateTemplate> {
+	return loadTemplates(cwd);
+}

package/extensions/usage.ts

@@ -0,0 +1,40 @@
+import type { Usage } from '@earendil-works/pi-ai';
+
+export interface HarnessUsage {
+	inputTokens: number;
+	outputTokens: number;
+	cacheCreationInputTokens: number;
+	cacheReadInputTokens: number;
+	totalCostUsd: number;
+}
+
+export type ClaudeUsage = HarnessUsage;
+
+/**
+ * Map harness usage/cost into pi's `Usage` shape so delegated runs appear
+ * in the pi footer token/cost stats and /session totals.
+ */
+export function mapHarnessUsage(u: HarnessUsage): Usage {
+	const input = u.inputTokens + u.cacheCreationInputTokens;
+	const cacheRead = u.cacheReadInputTokens;
+	const output = u.outputTokens;
+	const totalTokens = input + output + cacheRead;
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite: 0,
+		totalTokens,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: u.totalCostUsd,
+		},
+	};
+}
+
+export function mapClaudeUsage(u: ClaudeUsage): Usage {
+	return mapHarnessUsage(u);
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "pi-harness-delegate",
+	"version": "0.1.0",
+	"description": "Delegate work to any harness (Claude Code, Muse, OpenCode, Amp) from the pi coding agent — code reviews, plans, implementation, security audits, docs, or your own custom templates.",
+	"type": "module",
+	"files": [
+		"extensions",
+		"templates",
+		"README.md",
+		"LICENSE"
+	],
+	"keywords": [
+		"pi-package",
+		"pi",
+		"coding-agent",
+		"claude",
+		"codex",
+		"opencode",
+		"amp",
+		"delegate",
+		"subagent",
+		"code-review",
+		"harness"
+	],
+	"license": "MIT",
+	"author": "Jorge Barnaby",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/yorch/pi-harness-delegate.git"
+	},
+	"bugs": {
+		"url": "https://github.com/yorch/pi-harness-delegate/issues"
+	},
+	"scripts": {
+		"typecheck": "tsc --noEmit",
+		"test": "node --experimental-strip-types --test tests/**/*.test.ts"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
+		"typebox": "*"
+	},
+	"devDependencies": {
+		"@earendil-works/pi-ai": "^0.84.1",
+		"@earendil-works/pi-coding-agent": "^0.84.1",
+		"@earendil-works/pi-tui": "^0.84.1",
+		"@types/node": "24.x",
+		"typebox": "^1.3.7",
+		"typescript": "^5.9.0"
+	},
+	"pi": {
+		"extensions": [
+			"./extensions/index.ts"
+		],
+		"image": "https://raw.githubusercontent.com/yorch/pi-harness-delegate/main/docs/assets/claude-delegate-preview.png"
+	}
+}

package/templates/amp/docs.md

@@ -0,0 +1,11 @@
+---
+name: docs
+description: Generate or update documentation. Writes files.
+permission: edit
+model: amp-default
+---
+You are a technical writer delegated by the pi coding agent.
+
+Write clear, accurate documentation matching the project's existing doc style
+(check for README/ADRs/docs conventions first). Cover usage, gotchas, and
+worked examples. Report which files you created or changed.

package/templates/amp/general.md

@@ -0,0 +1,9 @@
+---
+name: general
+description: General delegation — any task. Bounded to file edits unless allowDangerous is set.
+permission: edit
+model: amp-default
+---
+You are a capable engineer delegated by the pi coding agent to handle the
+following task. Work in the current repository. Follow its conventions, run
+available checks, and report what you did and why.

package/templates/amp/implement.md

@@ -0,0 +1,13 @@
+---
+name: implement
+description: Implement a task with file edits (auto-accepted). Runs checks.
+permission: edit
+model: amp-default
+---
+You are a senior engineer delegated by the pi coding agent to implement a
+task.
+
+Implement the task described below. Follow the repo's existing conventions.
+Run the relevant checks when present (tests, typecheck, lint) and fix what
+breaks. Keep changes minimal and focused on the task. Report what you changed
+and the verification you ran.

package/templates/amp/plan.md

@@ -0,0 +1,18 @@
+---
+name: plan
+description: Produce a detailed implementation plan from an intent. Read-only.
+permission: readonly
+model: amp-default
+---
+You are a staff engineer delegated by the pi coding agent to produce a
+detailed implementation plan.
+
+Understand the current codebase first (read the relevant files). Then produce:
+1. Goal and non-goals
+2. Proposed approach, with alternatives considered and why rejected
+3. Step-by-step implementation plan: ordered steps, each naming the files to
+   touch and what changes in them
+4. Risks, edge cases, and testing strategy
+
+Be concrete and reference actual files/functions in the repo. Do not edit
+files — this is a plan.

package/templates/amp/review.md

@@ -0,0 +1,19 @@
+---
+name: review
+description: Code review of a scope (git diff, files, or the whole repo). Read-only.
+permission: readonly
+model: amp-default
+defaultTask: Review the current git diff (staged + unstaged)
+defaultScope: diff
+---
+You are a senior code reviewer delegated by the pi coding agent.
+
+Review the provided scope for:
+- Correctness bugs and edge cases
+- Security issues (injection, auth, secrets, unsafe deserialization)
+- Performance problems
+- Code style and maintainability
+
+Be specific: cite `file:line` for every finding. Classify each finding as
+Critical / Major / Minor / Nit. End with a prioritized list of the top
+actions. Do not edit files — this is a review.