@oh-my-pi/pi-coding-agent 15.5.15 → 15.7.0

package/src/tui/output-block.ts

@@ -15,8 +15,81 @@ export interface OutputBlockOptions {
 	sections?: Array<{ label?: string; lines: string[] }>;
 	width: number;
 	applyBg?: boolean;
+	/** Animate the border with a sweeping dark segment (pending/running state). */
+	animate?: boolean;
 }
 
+const BORDER_SHIMMER_TICK_MS = 50;
+/** Duration of one full clockwise lap around the border, in ms. Fixed so a box
+ * growing (new output line) or resizing only nudges the segment proportionally
+ * instead of teleporting it. */
+const BORDER_LAP_MS = 4000;
+/** Length, in border cells, of the moving segment. */
+const BORDER_SEGMENT_LEN = 8;
+
+/**
+ * Monotonic frame counter for animated borders. Quantized coarse enough to
+ * coalesce multiple render passes inside one frame, fine enough to advance on
+ * every spinner interval so cached blocks re-render while the segment travels.
+ */
+export function borderShimmerTick(): number {
+	return Math.floor(Date.now() / BORDER_SHIMMER_TICK_MS);
+}
+
+/** Ease-in-out so the segment decelerates into and accelerates out of corners. */
+function easeInOutQuad(t: number): number {
+	return t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2;
+}
+
+/**
+ * Perimeter index of the moving segment's head for a box of inner width `W` and
+ * height `H` at time `now`. The lap is split across the four edges in proportion
+ * to their length (so the average speed is uniform) and each edge is eased, for a
+ * deliberate, non-linear glide that slows at every corner. Position is derived
+ * from the wall clock against a fixed lap duration, so a perimeter change (new
+ * row / resize) shifts the head by at most a cell or two — no reset.
+ */
+export function borderSegmentHead(W: number, H: number, now: number): number {
+	const P = 2 * W + 2 * H - 4;
+	if (P <= 0) return 0;
+	// Edge cell counts, clockwise from top-left: top, right, bottom, left.
+	const edgeLens = [W, H - 1, W - 1, H - 2];
+	const t = (((now % BORDER_LAP_MS) + BORDER_LAP_MS) % BORDER_LAP_MS) / BORDER_LAP_MS;
+	let acc = 0;
+	let start = 0;
+	for (let i = 0; i < 4; i++) {
+		const len = edgeLens[i]!;
+		const frac = len / P;
+		if (len > 0 && t < acc + frac) {
+			const lf = (t - acc) / frac;
+			return (start + Math.floor(easeInOutQuad(lf) * len)) % P;
+		}
+		acc += frac;
+		start += len;
+	}
+	return P - 1;
+}
+
+/**
+ * Scale a truecolor foreground escape toward black by `factor`. Returns
+ * undefined for 256-color escapes (no RGB to scale) so callers fall back to a
+ * dimmer theme color.
+ */
+function darkenFgAnsi(ansi: string, factor: number): string | undefined {
+	const m = /38;2;(\d+);(\d+);(\d+)/.exec(ansi);
+	if (!m) return undefined;
+	const r = Math.round(Number(m[1]) * factor);
+	const g = Math.round(Number(m[2]) * factor);
+	const b = Math.round(Number(m[3]) * factor);
+	return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+type BlockRow =
+	| { kind: "bar"; leftChar: string; rightChar: string; label?: string; meta?: string }
+	| { kind: "bottom"; leftChar: string; rightChar: string }
+	| { kind: "content"; inner: string }
+	| { kind: "sixel"; raw: string };
+
 export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[] {
 	const { header, headerMeta, state, sections = [], width, applyBg = true } = options;
 	const h = theme.boxSharp.horizontal;
@@ -46,62 +119,148 @@ export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): st
 		};
 	})();
 
-	const buildBarLine = (leftChar: string, rightChar: string, label?: string, meta?: string): string => {
-		const left = border(`${leftChar}${cap}`);
-		const right = border(rightChar);
-		if (lineWidth <= 0) return left + right;
-		const labelText = [label, meta].filter(Boolean).join(theme.sep.dot);
-		const rawLabel = labelText ? ` ${labelText} ` : " ";
-		const leftWidth = visibleWidth(left);
-		const rightWidth = visibleWidth(right);
-		const maxLabelWidth = Math.max(0, lineWidth - leftWidth - rightWidth);
-		const trimmedLabel = truncateToWidth(rawLabel, maxLabelWidth);
-		const labelWidth = visibleWidth(trimmedLabel);
-		const fillCount = Math.max(0, lineWidth - leftWidth - labelWidth - rightWidth);
-		return `${left}${trimmedLabel}${border(h.repeat(fillCount))}${right}`;
-	};
-
-	const contentPrefix = border(`${v} `);
-	const contentSuffix = border(v);
-	const contentWidth = Math.max(0, lineWidth - visibleWidth(contentPrefix) - visibleWidth(contentSuffix));
-	const lines: string[] = [];
+	const contentWidth = Math.max(0, lineWidth - visibleWidth(`${v} `) - visibleWidth(v));
 
-	lines.push(
-		padToWidth(buildBarLine(theme.boxSharp.topLeft, theme.boxSharp.topRight, header, headerMeta), lineWidth, bgFn),
-	);
+	// ── Layout pass: collect row descriptors so the border perimeter length is
+	// known before the moving segment is positioned. ──
+	const rows: BlockRow[] = [];
+	rows.push({
+		kind: "bar",
+		leftChar: theme.boxSharp.topLeft,
+		rightChar: theme.boxSharp.topRight,
+		label: header,
+		meta: headerMeta,
+	});
 
-	const hasSections = sections.length > 0;
-	const normalizedSections = hasSections ? sections : [{ lines: [] }];
-
-	for (let i = 0; i < normalizedSections.length; i++) {
-		const section = normalizedSections[i];
+	const normalizedSections = sections.length > 0 ? sections : [{ lines: [] as string[] }];
+	for (const section of normalizedSections) {
 		if (section.label) {
-			lines.push(
-				padToWidth(buildBarLine(theme.boxSharp.teeRight, theme.boxSharp.teeLeft, section.label), lineWidth, bgFn),
-			);
+			rows.push({
+				kind: "bar",
+				leftChar: theme.boxSharp.teeRight,
+				rightChar: theme.boxSharp.teeLeft,
+				label: section.label,
+			});
 		}
 		const allLines = section.lines.flatMap(l => l.split("\n"));
 		const sixelLineMask = TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(allLines) : undefined;
 		for (let lineIndex = 0; lineIndex < allLines.length; lineIndex++) {
 			const line = allLines[lineIndex]!;
 			if (sixelLineMask?.[lineIndex]) {
-				lines.push(line);
+				rows.push({ kind: "sixel", raw: line });
 				continue;
 			}
 			const wrappedLines = wrapTextWithAnsi(line.trimEnd(), contentWidth);
 			for (const wrappedLine of wrappedLines) {
 				const innerPadding = padding(Math.max(0, contentWidth - visibleWidth(wrappedLine)));
-				const fullLine = `${contentPrefix}${wrappedLine}${innerPadding}${contentSuffix}`;
-				lines.push(padToWidth(fullLine, lineWidth, bgFn));
+				rows.push({ kind: "content", inner: `${wrappedLine}${innerPadding}` });
 			}
 		}
 	}
 
-	const bottomLeft = border(`${theme.boxSharp.bottomLeft}${cap}`);
-	const bottomRight = border(theme.boxSharp.bottomRight);
-	const bottomFillCount = Math.max(0, lineWidth - visibleWidth(bottomLeft) - visibleWidth(bottomRight));
-	const bottomLine = `${bottomLeft}${border(h.repeat(bottomFillCount))}${bottomRight}`;
-	lines.push(padToWidth(bottomLine, lineWidth, bgFn));
+	rows.push({ kind: "bottom", leftChar: theme.boxSharp.bottomLeft, rightChar: theme.boxSharp.bottomRight });
+
+	const H = rows.length;
+	const W = lineWidth;
+	const animate = (options.animate ?? false) && (state === "running" || state === "pending") && W >= 2 && H >= 2;
+
+	// ── Segment geometry: one dark run travels the outer edge clockwise,
+	// top → right → bottom → left → top. ──
+	const P = animate ? 2 * W + 2 * H - 4 : 0;
+	const segLen = Math.min(BORDER_SEGMENT_LEN, P);
+	const head = animate ? borderSegmentHead(W, H, Date.now()) : 0;
+	const segAnsi = animate ? (darkenFgAnsi(theme.getFgAnsi(borderColor), 0.4) ?? theme.getFgAnsi("borderMuted")) : "";
+	const seg = (text: string) => `${segAnsi}${text}\x1b[39m`;
+
+	// Perimeter index of border cell (row r, col c), clockwise from top-left.
+	const perimIndex = (r: number, c: number): number => {
+		if (r === 0) return c;
+		if (c === W - 1) return W - 1 + r;
+		if (r === H - 1) return W - 1 + (H - 1) + (W - 1 - c);
+		return W - 1 + (H - 1) + (W - 1) + (H - 1 - r);
+	};
+	const isLit = (idx: number): boolean => (((idx - head) % P) + P) % P < segLen;
+	// Color a run of border glyphs starting at (row r, col startCol), grouping
+	// consecutive same-state cells so each run emits a single escape pair.
+	const colorEdge = (glyphs: string, r: number, startCol: number): string => {
+		let out = "";
+		let runLit: boolean | null = null;
+		let buf = "";
+		for (let i = 0; i < glyphs.length; i++) {
+			const lit = isLit(perimIndex(r, startCol + i));
+			if (lit !== runLit) {
+				if (runLit !== null) out += (runLit ? seg : border)(buf);
+				buf = "";
+				runLit = lit;
+			}
+			buf += glyphs[i];
+		}
+		if (runLit !== null) out += (runLit ? seg : border)(buf);
+		return out;
+	};
+
+	const renderBar = (
+		row: { leftChar: string; rightChar: string; label?: string; meta?: string },
+		r: number,
+	): string => {
+		const leftGlyphs = `${row.leftChar}${cap}`;
+		const rightGlyph = row.rightChar;
+		if (lineWidth <= 0) return border(leftGlyphs) + border(rightGlyph);
+		const labelText = [row.label, row.meta].filter(Boolean).join(theme.sep.dot);
+		const rawLabel = labelText ? ` ${labelText} ` : " ";
+		const leftWidth = visibleWidth(leftGlyphs);
+		const rightWidth = visibleWidth(rightGlyph);
+		const maxLabelWidth = Math.max(0, lineWidth - leftWidth - rightWidth);
+		const trimmedLabel = truncateToWidth(rawLabel, maxLabelWidth);
+		const labelWidth = visibleWidth(trimmedLabel);
+		const fillCount = Math.max(0, lineWidth - leftWidth - labelWidth - rightWidth);
+		const fillGlyphs = h.repeat(fillCount);
+		if (!animate) {
+			return `${border(leftGlyphs)}${trimmedLabel}${border(fillGlyphs)}${border(rightGlyph)}`;
+		}
+		if (r === 0 || r === H - 1) {
+			// Top/bottom edge: the whole horizontal run lies on the perimeter.
+			const leftStr = colorEdge(leftGlyphs, r, 0);
+			const fillStr = colorEdge(fillGlyphs, r, leftWidth + labelWidth);
+			const rightStr = colorEdge(rightGlyph, r, lineWidth - rightWidth);
+			return `${leftStr}${trimmedLabel}${fillStr}${rightStr}`;
+		}
+		// Interior separator: only the first/last cell sit on the outer edge.
+		return `${colorEdge(row.leftChar, r, 0)}${border(cap)}${trimmedLabel}${border(fillGlyphs)}${colorEdge(rightGlyph, r, lineWidth - rightWidth)}`;
+	};
+
+	const renderBottom = (row: { leftChar: string; rightChar: string }, r: number): string => {
+		const leftGlyphs = `${row.leftChar}${cap}`;
+		const rightGlyph = row.rightChar;
+		const fillCount = Math.max(0, lineWidth - visibleWidth(leftGlyphs) - visibleWidth(rightGlyph));
+		const fillGlyphs = h.repeat(fillCount);
+		if (!animate) return `${border(leftGlyphs)}${border(fillGlyphs)}${border(rightGlyph)}`;
+		const leftStr = colorEdge(leftGlyphs, r, 0);
+		const fillStr = colorEdge(fillGlyphs, r, visibleWidth(leftGlyphs));
+		const rightStr = colorEdge(rightGlyph, r, lineWidth - visibleWidth(rightGlyph));
+		return `${leftStr}${fillStr}${rightStr}`;
+	};
+
+	const renderContent = (inner: string, r: number): string => {
+		if (!animate) return `${border(`${v} `)}${inner}${border(v)}`;
+		return `${colorEdge(v, r, 0)} ${inner}${colorEdge(v, r, lineWidth - 1)}`;
+	};
+
+	const lines: string[] = [];
+	for (let r = 0; r < H; r++) {
+		const row = rows[r]!;
+		if (row.kind === "sixel") {
+			lines.push(row.raw);
+			continue;
+		}
+		const line =
+			row.kind === "bar"
+				? renderBar(row, r)
+				: row.kind === "bottom"
+					? renderBottom(row, r)
+					: renderContent(row.inner, r);
+		lines.push(padToWidth(line, lineWidth, bgFn));
+	}
 
 	return lines;
 }
@@ -137,6 +296,8 @@ export class CachedOutputBlock {
 		h.optional(options.headerMeta);
 		h.optional(options.state);
 		h.bool(options.applyBg ?? true);
+		h.bool(options.animate ?? false);
+		if (options.animate) h.u32(borderShimmerTick());
 		if (options.sections) {
 			for (const s of options.sections) {
 				h.optional(s.label);

package/src/utils/title-generator.ts

@@ -9,13 +9,16 @@ import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
+import { ONLINE_TINY_TITLE_MODEL_KEY } from "../tiny/models";
+import { formatTitleUserMessage, normalizeGeneratedTitle } from "../tiny/text";
+import { tinyTitleClient } from "../tiny/title-client";
 
 const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 
 const DEFAULT_TERMINAL_TITLE = "π";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
-const MAX_INPUT_CHARS = 2000;
+export const TITLE_LOCAL_FALLBACK_DELAY_MS = 10_000;
 const TITLE_MAX_TOKENS = 30;
 const REASONING_SAFE_MAX_TOKENS = 1024;
 const SET_TITLE_TOOL_NAME = "set_title";
@@ -48,6 +51,78 @@ function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel
 	return undefined;
 }
 
+export async function raceFirstNonNull<T>(
+	primary: Promise<T | null>,
+	startFallback: () => Promise<T | null>,
+	delayMs: number = TITLE_LOCAL_FALLBACK_DELAY_MS,
+	onPrimaryWinAfterFallback?: () => void,
+): Promise<T | null> {
+	const { promise, resolve } = Promise.withResolvers<T | null>();
+	let resolved = false;
+	let primarySettled = false;
+	let fallbackStarted = false;
+	let fallbackSettled = false;
+
+	const resolveOnce = (value: T | null): void => {
+		if (resolved) return;
+		resolved = true;
+		resolve(value);
+	};
+	const maybeResolveNull = (): void => {
+		if (primarySettled && fallbackStarted && fallbackSettled) resolveOnce(null);
+	};
+	const startFallbackOnce = (): void => {
+		if (fallbackStarted || resolved) return;
+		fallbackStarted = true;
+		let fallback: Promise<T | null>;
+		try {
+			fallback = startFallback();
+		} catch {
+			fallbackSettled = true;
+			maybeResolveNull();
+			return;
+		}
+		void fallback.then(
+			value => {
+				fallbackSettled = true;
+				if (value !== null) resolveOnce(value);
+				else maybeResolveNull();
+			},
+			() => {
+				fallbackSettled = true;
+				maybeResolveNull();
+			},
+		);
+	};
+
+	const timer = setTimeout(startFallbackOnce, delayMs);
+	void primary.then(
+		value => {
+			primarySettled = true;
+			clearTimeout(timer);
+			if (value !== null) {
+				if (fallbackStarted) onPrimaryWinAfterFallback?.();
+				resolveOnce(value);
+				return;
+			}
+			startFallbackOnce();
+			maybeResolveNull();
+		},
+		() => {
+			primarySettled = true;
+			clearTimeout(timer);
+			startFallbackOnce();
+			maybeResolveNull();
+		},
+	);
+
+	try {
+		return await promise;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 /**
  * Generate a title for a session based on the first user message.
  *
@@ -68,6 +143,41 @@ export async function generateSessionTitle(
 	sessionId?: string,
 	currentModel?: Model<Api>,
 	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+): Promise<string | null> {
+	const tinyModel = settings.get("providers.tinyModel");
+	if (tinyModel === ONLINE_TINY_TITLE_MODEL_KEY) {
+		return generateTitleOnline(firstMessage, registry, settings, sessionId, currentModel, metadataResolver);
+	}
+
+	const onlineAbortController = new AbortController();
+	const localTitle = tinyTitleClient.generate(tinyModel, firstMessage).then(
+		title => title || null,
+		() => null,
+	);
+	const startOnline = (): Promise<string | null> =>
+		generateTitleOnline(
+			firstMessage,
+			registry,
+			settings,
+			sessionId,
+			currentModel,
+			metadataResolver,
+			onlineAbortController.signal,
+		);
+
+	return raceFirstNonNull(localTitle, startOnline, TITLE_LOCAL_FALLBACK_DELAY_MS, () => {
+		onlineAbortController.abort();
+	});
+}
+
+export async function generateTitleOnline(
+	firstMessage: string,
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+	currentModel?: Model<Api>,
+	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+	signal?: AbortSignal,
 ): Promise<string | null> {
 	const model = getTitleModel(registry, settings, currentModel);
 	if (!model) {
@@ -75,12 +185,7 @@ export async function generateSessionTitle(
 		return null;
 	}
 
-	// Truncate message if too long
-	const truncatedMessage =
-		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}…` : firstMessage;
-	const userMessage = `<user-message>
-${truncatedMessage}
-</user-message>`;
+	const userMessage = formatTitleUserMessage(firstMessage);
 
 	const apiKey = await registry.getApiKey(model, sessionId);
 	if (!apiKey) {
@@ -122,6 +227,7 @@ ${truncatedMessage}
 				disableReasoning: true,
 				toolChoice: { type: "tool", name: SET_TITLE_TOOL_NAME },
 				metadata,
+				signal,
 			},
 		);
 
@@ -134,7 +240,7 @@ ${truncatedMessage}
 			return null;
 		}
 
-		const title = extractGeneratedTitle(response.content);
+		const title = normalizeGeneratedTitle(extractGeneratedTitle(response.content));
 
 		logger.debug("title-generator: response", {
 			model: request.model,
@@ -143,11 +249,7 @@ ${truncatedMessage}
 			stopReason: response.stopReason,
 		});
 
-		if (!title) {
-			return null;
-		}
-
-		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+		return title;
 	} catch (err) {
 		logger.debug("title-generator: error", {
 			model: request.model,

package/dist/types/tools/recipe/index.d.ts

@@ -1,46 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
-import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import type { Theme } from "../../modes/theme/theme";
-import type { ToolSession } from "..";
-import { type BashRenderContext, type BashToolDetails } from "../bash";
-import { type RecipeRenderArgs } from "./render";
-import { type DetectedRunner } from "./runner";
-declare const recipeSchema: z.ZodObject<{
-    op: z.ZodString;
-}, z.core.$strict>;
-type RecipeParams = z.infer<typeof recipeSchema>;
-type RecipeRenderResult = {
-    content: Array<{
-        type: string;
-        text?: string;
-    }>;
-    details?: BashToolDetails;
-    isError?: boolean;
-};
-export declare class RecipeTool implements AgentTool<typeof recipeSchema, BashToolDetails, Theme> {
-    #private;
-    readonly name = "recipe";
-    readonly label = "Run";
-    readonly approval: "exec";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        op: z.ZodString;
-    }, z.core.$strict>;
-    readonly strict = true;
-    readonly concurrency = "exclusive";
-    readonly loadMode = "discoverable";
-    readonly summary = "Execute a saved bash recipe (multi-step shell command preset)";
-    readonly mergeCallAndResult = true;
-    readonly inline = true;
-    readonly renderCall: (args: RecipeRenderArgs, options: RenderResultOptions, uiTheme: Theme) => Component;
-    readonly renderResult: (result: RecipeRenderResult, options: RenderResultOptions & {
-        renderContext?: BashRenderContext;
-    }, uiTheme: Theme, args?: RecipeRenderArgs) => Component;
-    constructor(session: ToolSession, runners: DetectedRunner[]);
-    static createIf(session: ToolSession): Promise<RecipeTool | null>;
-    execute(toolCallId: string, { op }: RecipeParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
-}
-export * from "./runner";
-export { tasksFromCargoMetadata } from "./runners/cargo";

package/dist/types/tools/recipe/render.d.ts

@@ -1,36 +0,0 @@
-import type { DetectedRunner } from "./runner";
-export interface RecipeRenderArgs {
-    op?: string;
-    __partialJson?: string;
-    [key: string]: unknown;
-}
-export declare function createRecipeToolRenderer(runners: DetectedRunner[]): {
-    renderCall(args: RecipeRenderArgs, options: import("../..").RenderResultOptions, uiTheme: import("../..").Theme): import("@oh-my-pi/pi-tui").Component;
-    renderResult(result: {
-        content: {
-            type: string;
-            text?: string;
-        }[];
-        details?: import("..").BashToolDetails;
-        isError?: boolean;
-    }, options: import("../..").RenderResultOptions & {
-        renderContext?: import("..").BashRenderContext;
-    }, uiTheme: import("../..").Theme, args?: RecipeRenderArgs | undefined): import("@oh-my-pi/pi-tui").Component;
-    mergeCallAndResult: boolean;
-    inline: boolean;
-};
-export declare const recipeToolRenderer: {
-    renderCall(args: RecipeRenderArgs, options: import("../..").RenderResultOptions, uiTheme: import("../..").Theme): import("@oh-my-pi/pi-tui").Component;
-    renderResult(result: {
-        content: {
-            type: string;
-            text?: string;
-        }[];
-        details?: import("..").BashToolDetails;
-        isError?: boolean;
-    }, options: import("../..").RenderResultOptions & {
-        renderContext?: import("..").BashRenderContext;
-    }, uiTheme: import("../..").Theme, args?: RecipeRenderArgs | undefined): import("@oh-my-pi/pi-tui").Component;
-    mergeCallAndResult: boolean;
-    inline: boolean;
-};

package/dist/types/tools/recipe/runner.d.ts

@@ -1,60 +0,0 @@
-export interface RunnerTask {
-    name: string;
-    doc?: string;
-    /** Parameter names only; used for the `name foo bar` signature line in the description. */
-    parameters: string[];
-    /** Override for this specific task, e.g. `cargo run --package crate --bin`. */
-    commandPrefix?: string;
-    /** Token passed to the runner command; defaults to `name`. Used when display names are namespaced. */
-    commandName?: string;
-    /** Working directory for the task, relative to the session cwd; absent means the runner's root cwd. */
-    cwd?: string;
-}
-export interface DetectedRunner {
-    id: string;
-    label: string;
-    /** Resolved shell prefix, e.g. "just" or "bun run" or "make". */
-    commandPrefix: string;
-    tasks: RunnerTask[];
-}
-export interface TaskRunner {
-    id: string;
-    label: string;
-    /**
-     * Probe `cwd` for the manifest, the binary, and the task list.
-     * Returns null when this runner does not apply.
-     */
-    detect(cwd: string): Promise<DetectedRunner | null>;
-}
-interface PromptTaskModel {
-    name: string;
-    paramSig?: string;
-    command?: string;
-    doc?: string;
-    cwd?: string;
-}
-interface PromptRunnerModel {
-    id: string;
-    label: string;
-    commandPrefix: string;
-    tasks: PromptTaskModel[];
-    hiddenTaskCount?: number;
-}
-export interface RecipePromptModel {
-    [key: string]: unknown;
-    hasMultipleRunners: boolean;
-    ambiguityExampleRunner?: string;
-    ambiguityExampleTask?: string;
-    runners: PromptRunnerModel[];
-}
-export interface ResolvedTask {
-    command: string;
-    cwd?: string;
-}
-export declare function resolveCommand(op: string, runners: DetectedRunner[]): ResolvedTask;
-export declare function resolveTaskFromOp(op: string | undefined, runners: DetectedRunner[]): ResolvedTask | undefined;
-export declare function commandFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined;
-export declare function cwdFromOp(op: string | undefined, runners: DetectedRunner[]): string | undefined;
-export declare function titleFromOp(op: string | undefined, runners: DetectedRunner[]): string;
-export declare function buildPromptModel(runners: DetectedRunner[]): RecipePromptModel;
-export {};

package/dist/types/tools/recipe/runners/cargo.d.ts

@@ -1,16 +0,0 @@
-import type { RunnerTask, TaskRunner } from "../runner";
-export interface CargoMetadataTarget {
-    kind?: string[];
-    name?: string;
-}
-export interface CargoMetadataPackage {
-    id?: string;
-    name?: string;
-    targets?: CargoMetadataTarget[];
-}
-export interface CargoMetadata {
-    packages?: CargoMetadataPackage[];
-    workspace_members?: string[];
-}
-export declare function tasksFromCargoMetadata(metadata: CargoMetadata): RunnerTask[];
-export declare const cargoRunner: TaskRunner;

package/dist/types/tools/recipe/runners/index.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const RUNNERS: TaskRunner[];

package/dist/types/tools/recipe/runners/just.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const justRunner: TaskRunner;

package/dist/types/tools/recipe/runners/make.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const makeRunner: TaskRunner;

package/dist/types/tools/recipe/runners/pkg.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const pkgRunner: TaskRunner;

package/dist/types/tools/recipe/runners/task.d.ts

@@ -1,2 +0,0 @@
-import type { TaskRunner } from "../runner";
-export declare const taskRunner: TaskRunner;

package/src/prompts/tools/recipe.md

@@ -1,16 +0,0 @@
-Run a recipe / script / target from the project's task runners.
-
-<instruction>
-- `op` is a single string: task name plus any args, e.g. `{op: "test"}` or `{op: "build --release"}`.
-- In monorepos, package and Cargo target tasks are namespaced with `/`, e.g. `{op: "pkg-a/test"}` or `{op: "crate/bin/server"}`.
-{{#if hasMultipleRunners}}- When the same task name exists in more than one runner, prefix with the runner id, e.g. `{op: "{{ambiguityExampleRunner}}:{{ambiguityExampleTask}}"}`. The available runner ids are: {{#each runners}}`{{id}}`{{#unless @last}}, {{/unless}}{{/each}}.
-{{/if}}- Runs in the session's cwd. Output and exit code are returned in the same shape as `bash`.
-</instruction>
-
-{{#each runners}}
-<runner id="{{id}}" label="{{label}}" command="{{commandPrefix}}">
-{{#each tasks}}
-- `{{name}}{{#if paramSig}} {{paramSig}}{{/if}}`{{#if doc}} — {{doc}}{{/if}}{{#if command}} (`{{command}}`{{#if cwd}} in `{{cwd}}`{{/if}}){{/if}}
-{{/each}}
-</runner>
-{{/each}}