pi-do-always 0.10.0 → 0.13.0

package/extensions/pi-do-always/tasks.ts

@@ -37,6 +37,21 @@ export interface DoAlwaysTask {
 	 * Omitted/undefined always shows the task. Evaluated by `evaluateWhen`.
 	 */
 	when?: string | Record<string, unknown>;
+	/**
+	 * Hide the task from the selector and the `list` commands. Hidden tasks
+	 * are not standalone user-visible entries; they can still be resolved by
+	 * name on the command line and are offered as candidates by the commit
+	 * picker. The built-in "Review commits" uses this: it is a pick-after-
+	 * browse option, not an entry point ("Browse commits" is the entry).
+	 */
+	hidden?: boolean;
+	/**
+	 * Exclude the task from the commit picker (the "run on the selected
+	 * commits" list shown after a commit selection). For Plan tasks that
+	 * operate on the working tree or the whole project rather than on a set
+	 * of commits. The task is otherwise unaffected (selector, lists, CLI).
+	 */
+	notForCommits?: boolean;
 	/**
 	 * Extra selection-time guards, evaluated alongside the legacy `requireDirty`
 	 * (see `evaluateGuards`). Each guard blocks the task (with a message, not a
@@ -44,26 +59,43 @@ export interface DoAlwaysTask {
 	 * compatibility; new guards use this array so the set is extensible.
 	 */
 	guards?: Guard[];
+	/**
+	 * A browser to open on selection instead of injecting the prompt directly.
+	 * Currently only "commits": opens the date-grouped commit browser, and the
+	 * selected commits drive the review prompt (see `fillPrompt` in index.ts).
+	 * The built-in "Review commits" task also triggers the browser by name, so
+	 * configs that predate this field keep working.
+	 */
+	browser?: BrowserType;
 }
 
+/** The set of known guard types (used for validation at parse time). */
+export const GUARD_TYPES = [
+	"requireDirty",
+	"requireBranch",
+	"requireRepo",
+	"requireFilePattern",
+] as const;
+
+export type GuardType = (typeof GUARD_TYPES)[number];
+
 /**
  * A selection-time guard that blocks a task when its condition is not met.
  * The task stays visible but selecting it notifies instead of injecting.
  * `requireDirty` needs no `value`; the others require a string `value`.
  */
-interface Guard {
-	type: "requireDirty" | "requireBranch" | "requireRepo" | "requireFilePattern";
+export interface Guard {
+	type: GuardType;
 	value?: string;
 }
 
-/** The set of known guard types (used for validation at parse time). */
-const GUARD_TYPES = [
-	"requireDirty",
-	"requireBranch",
-	"requireRepo",
-	"requireFilePattern",
+/** The set of known browser types (used for validation at parse time). */
+export const BROWSER_TYPES = [
+	"commits",
 ] as const;
 
+export type BrowserType = (typeof BROWSER_TYPES)[number];
+
 /**
  * A config file can be a bare array of tasks, or {"tasks": [...], "shortcut": ...}.
  * `shortcut` is a key id string (e.g. "f4", "ctrl+shift+p"), or null to disable
@@ -142,6 +174,12 @@ export interface TaskContext {
 	stagedFiles: string[];
 	/** Modified-but-unstaged files. */
 	unstagedFiles: string[];
+	/**
+	 * Commits selected in the commit browser, formatted for prompt injection
+	 * (see `formatSelectedCommits`), or "none" when no selection is active.
+	 * Context builds always set "none"; the browser flow overrides it at render.
+	 */
+	selectedCommits: string;
 	/** True when cwd is inside a git working tree (authoritative, not inferred from the branch name). */
 	isGitRepo: boolean;
 }
@@ -164,12 +202,13 @@ export const PROMPT_CONTEXT_KEYS = [
 	"repo",
 	"staged_files",
 	"unstaged_files",
+	"selected_commits",
 ] as const;
 
 /** A fully populated prompt context: one entry per PROMPT_CONTEXT_KEYS. */
 export type PromptContext = Record<(typeof PROMPT_CONTEXT_KEYS)[number], string>;
 
-/** Max number of file paths listed in the `files_changed` string view (the count stays exact). */
+/** Max number of file paths listed in the `files_changed` string view (the count stays exact). Exported for tests. */
 export const MAX_FILES_LISTED = 20;
 
 /**
@@ -191,9 +230,13 @@ export function toPromptContext(ctx: TaskContext): PromptContext {
 		repo: ctx.repo,
 		staged_files: formatFileLines(ctx.stagedFiles),
 		unstaged_files: formatFileLines(ctx.unstagedFiles),
+		selected_commits: ctx.selectedCommits,
 	};
 }
 
+/** Max number of file paths listed in the `staged_files` / `unstaged_files` string views. Exported for tests. */
+export const MAX_FILE_LINES = 50;
+
 /** Comma-joined list, capped at MAX_FILES_LISTED entries; "none" when empty. */
 function formatFileList(files: string[]): string {
 	if (files.length === 0) return "none";
@@ -203,9 +246,31 @@ function formatFileList(files: string[]): string {
 	return files.join(", ");
 }
 
-/** Newline-joined list; "none" when empty. */
+/** Newline-joined list, capped at MAX_FILE_LINES entries; "none" when empty. */
 function formatFileLines(files: string[]): string {
-	return files.length === 0 ? "none" : files.join("\n");
+	if (files.length === 0) return "none";
+	if (files.length > MAX_FILE_LINES) {
+		const shown = files.slice(0, MAX_FILE_LINES);
+		const remaining = files.length - MAX_FILE_LINES;
+		return [...shown, `… (+${remaining} more)`].join("\n");
+	}
+	return files.join("\n");
+}
+
+/**
+ * Extract and normalize a file path from a git status porcelain line (v1).
+ * Handles rename targets (`old -> new`) and unquotes quoted paths (`"file with space"`).
+ */
+function extractPorcelainPath(line: string): string | null {
+	if (line.length < 4) return null;
+	let path = line.slice(3).trim();
+	if (path.includes(" -> ")) {
+		path = path.split(" -> ").pop()!.trim();
+	}
+	if (path.startsWith('"') && path.endsWith('"') && path.length >= 2) {
+		path = path.slice(1, -1).replace(/\\"/g, '"');
+	}
+	return path || null;
 }
 
 /**
@@ -215,19 +280,70 @@ function formatFileLines(files: string[]): string {
  */
 export function parseStatusPorcelain(status: string): string[] {
 	const files: string[] = [];
+	const seen = new Set<string>();
 	for (const line of status.split("\n")) {
-		if (line.length < 4) continue;
-		const path = line.slice(3);
-		if (path && !files.includes(path)) files.push(path);
+		const path = extractPorcelainPath(line);
+		if (path && !seen.has(path)) {
+			seen.add(path);
+			files.push(path);
+		}
 	}
-	files.sort();
+	files.sort((a, b) => a.localeCompare(b));
 	return files;
 }
 
-/** Split raw `git diff --name-only` output into file paths (trimmed, non-empty lines). */
-export function splitFileLines(raw: string | undefined): string[] {
-	if (!raw) return [];
-	return raw.split("\n").map((line) => line.trim()).filter(Boolean);
+/**
+ * Split `git status --porcelain` (v1) output into staged and unstaged file
+ * lists. Lines are "XY <path>" (X = index, Y = worktree; the path starts at
+ * index 3): a space in the X column means the change is unstaged (worktree
+ * only), anything else is staged or untracked. Short lines are skipped and
+ * paths are deduplicated across both lists.
+ */
+export function parseStatusStagedUnstaged(
+	status: string,
+): { staged: string[]; unstaged: string[] } {
+	const staged: string[] = [];
+	const unstaged: string[] = [];
+	const seen = new Set<string>();
+	for (const line of status.split("\n")) {
+		const path = extractPorcelainPath(line);
+		if (!path || seen.has(path)) continue;
+		seen.add(path);
+		if (line[0] === " ") unstaged.push(path);
+		else staged.push(path);
+	}
+	return { staged, unstaged };
+}
+
+/**
+ * Extract the commit subject from a `git log --format=%H %s` line
+ * ("<hash> <subject>"). The subject may contain spaces, so everything after
+ * the first space is the subject. Returns "unknown" when the line is missing
+ * or carries no subject.
+ */
+export function parseCommitSubject(commitLine: string | undefined): string {
+	if (!commitLine) return "unknown";
+	const space = commitLine.indexOf(" ");
+	return space > 0 ? commitLine.slice(space + 1) || "unknown" : "unknown";
+}
+
+/**
+ * Extract one key's value from `git config --get-regexp` output (one
+ * "key value" pair per line). The value may contain spaces (e.g.
+ * user.name "John Doe"), so everything after the first space is the value.
+ * Returns undefined when the key is absent or its value is empty.
+ */
+export function parseConfigRegexpValueForKey(
+	raw: string | undefined,
+	key: string,
+): string | undefined {
+	if (!raw) return undefined;
+	for (const line of raw.split("\n")) {
+		if (!line.startsWith(key + " ")) continue;
+		const value = line.slice(key.length + 1);
+		return value || undefined;
+	}
+	return undefined;
 }
 
 /** Used when neither config file defines any task. */
@@ -237,17 +353,19 @@ export const DEFAULT_TASKS: DoAlwaysTask[] = [
 		category: "Plan",
 		description: "Review the current code changes (Plan)",
 		requireDirty: true,
+		notForCommits: true,
 		prompt:
 			"Review the changes on branch {{branch}} ({{files_changed_count}} changed files: {{files_changed}}). " +
 			"Change summary: {{diff_stat}}. Last commit: {{last_commit}}. " +
 			"Check `git status` and `git diff` to see what changed, then double-check the changes for bugs, " +
 			"edge cases, security issues, and consistency with the rest of the codebase. " +
-			"Do a plan proposal for the fixes if needed. Do a summary of your findings",
+			"Do a plan proposal for the fixes if needed. Do a summary of your findings.",
 	},
 	{
 		name: "Review code",
 		category: "Plan",
 		description: "Review the whole project's code quality (Plan)",
+		notForCommits: true,
 		prompt:
 			"Review this project's code holistically: identify code smells, dead code, duplication, awkward architecture or patterns, maintainability issues, inconsistencies, and missing or unclear documentation. " +
 			"Prioritize by impact, propose a plan for the fixes, and summarize your findings. Do not make any changes yet.",
@@ -315,8 +433,28 @@ export const DEFAULT_TASKS: DoAlwaysTask[] = [
 		name: "Propose features",
 		category: "Plan",
 		description: "Propose new features (Plan)",
+		notForCommits: true,
 		prompt:
-			"Review this project and propose new features that would add value. For each idea, describe the problem it solves, the user benefit, and a rough implementation approach. Prioritize by impact and effort. Do not make any changes yet. Try to evaluate how many lines this will be in term of changes, if this will breaks API, compatibility issue.",
+			"Review this project and propose new features that would add value. For each idea, describe the problem it solves, the user benefit, and a rough implementation approach. Prioritize by impact and effort. Do not make any changes yet. Try to evaluate how many lines this will be in terms of changes, whether this will break APIs, or introduce compatibility issues.",
+	},
+	{
+		name: "Review commits",
+		category: "Plan",
+		description: "Review the selected commits (Plan)",
+		browser: "commits",
+		hidden: true,
+		prompt:
+			"Review the selected commits: {{selected_commits}}. Inspect each with `git show <hash>`, " +
+			"double-check the changes for bugs, edge cases, security issues, and consistency with the rest of the codebase. " +
+			"Summarize your findings per commit and propose a plan for any fixes if needed. Do not make any changes yet.",
+	},
+	{
+		name: "Browse commits",
+		category: "Browse",
+		description: "Browse and select commits, then pick a task to run on them",
+		browser: "commits",
+		when: "git",
+		prompt: "Browse recent commits, select some, then pick a task to run on them.",
 	},
 ];
 
@@ -349,7 +487,7 @@ export function parseConfig(
 	const tasks: DoAlwaysTask[] = [];
 	for (const entry of list) {
 		const t = entry as Partial<DoAlwaysTask> | null;
-		if (t && typeof t.name === "string" && t.name.length > 0 && typeof t.prompt === "string" && t.prompt.length > 0) {
+		if (t && typeof t.name === "string" && t.name.length > 0 && typeof t.prompt === "string" && (t.prompt.length > 0 || t.autoRun === true)) {
 			const task: DoAlwaysTask = {
 				name: t.name,
 				prompt: t.prompt,
@@ -358,6 +496,15 @@ export function parseConfig(
 				if (typeof t.category === "string" && t.category.trim() !== "") task.category = t.category.trim();
 				if (typeof t.autoRun === "boolean") task.autoRun = t.autoRun;
 				if (typeof t.requireDirty === "boolean") task.requireDirty = t.requireDirty;
+				if (typeof t.hidden === "boolean") task.hidden = t.hidden;
+				if (typeof t.notForCommits === "boolean") task.notForCommits = t.notForCommits;
+				if (t.browser !== undefined) {
+					if (typeof t.browser === "string" && BROWSER_TYPES.includes(t.browser as BrowserType)) {
+						task.browser = t.browser as BrowserType;
+					} else {
+						onError(`do-always: ignoring invalid "browser" in ${path} (expected one of: ${BROWSER_TYPES.join(", ")})`);
+					}
+				}
 				if (t.guards !== undefined) {
 					if (Array.isArray(t.guards)) {
 						const guards: Guard[] = [];
@@ -587,8 +734,17 @@ export function evaluateWhen(task: DoAlwaysTask, ctx: TaskContext): boolean {
 	return true;
 }
 
-/** Default order for category headers in the selector. */
-export const DEFAULT_CATEGORY_ORDER = ["Plan", "Do", "Docs", "Ops", "Other"];
+/**
+ * Whether a task is visible in the selector and the lists: not `hidden` and
+ * its `when` condition passes. Single source of truth so the TUI selector and
+ * the `/do-always <n>` numbering can never diverge.
+ */
+export function isTaskVisible(task: DoAlwaysTask, ctx: TaskContext): boolean {
+	return !task.hidden && evaluateWhen(task, ctx);
+}
+
+/** Default order for category headers in the selector. Exported for tests. */
+export const DEFAULT_CATEGORY_ORDER = ["Plan", "Browse", "Do", "Docs", "Ops", "Other"];
 
 /** A category group: a display name and the tasks that belong to it. */
 interface TaskGroup {
@@ -606,6 +762,11 @@ function titleCase(s: string): string {
  * `order` (case-insensitive), then alphabetically; the original order within a
  * group is preserved. The group `name` is the title-cased category. Tasks
  * without a (non-empty) category fall under "Other".
+ *
+ * Not memoized: every caller passes a fresh array (selector open, config
+ * load, list), so an identity-keyed cache would never hit — and would go
+ * stale if a caller ever mutated its array in place. The input is small
+ * (a dozen tasks), so recomputing is cheap.
  */
 export function groupTasksByCategory(
 	tasks: DoAlwaysTask[],
@@ -898,20 +1059,6 @@ export function chainUndo(state: ChainState): { state: ChainState; removed: stri
 	return { state, removed: null };
 }
 
-/**
- * Move a task one position up (-1) or down (1) in the chain. No-op at the
- * ends or when the name is not in the chain.
- */
-export function chainMove(state: ChainState, name: string, dir: -1 | 1): ChainState {
-	const idx = state.items.indexOf(name);
-	const target = idx + dir;
-	if (idx < 0 || target < 0 || target >= state.items.length) return state;
-	const items = [...state.items];
-	items[idx] = items[target];
-	items[target] = name;
-	return { ...state, items };
-}
-
 /**
  * Label for the pinned Run row: a dimmed placeholder for an empty chain,
  * singular for one task, plural with the count otherwise.
@@ -1007,7 +1154,7 @@ function reportTime(d: Date): string {
 	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
 }
 
-/** File name for one chain run's report, e.g. do-always-report-tasks-2025-01-15-1432.md. */
+/** File name for one chain run's report, e.g. do-always-report-tasks-2025-01-15-1432.md. Exported for tests. */
 export function reportFileName(now: Date): string {
 	const p = (n: number) => String(n).padStart(2, "0");
 	return `do-always-report-tasks-${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}.md`;
@@ -1113,3 +1260,234 @@ export function assistantText(
 		.flatMap((part) => (part && part.type === "text" && typeof part.text === "string" ? [part.text] : []))
 		.join("\n");
 }
+
+// ── Chain step summary ───────────────────────────────────────────────────
+//
+// Compact per-step and chain-end summary strings for notifications.
+// These are derived from the existing report data (outcome, timing, file count)
+// and provide immediate, scannable feedback after each chain step.
+
+/** Outcome of one chain step's run (see `sendAndWait`). */
+export type ChainStepOutcome = "completed" | "aborted" | "error" | "failed-to-start";
+
+/**
+ * Generate a compact per-step summary string for notifications.
+ * Examples:
+ *   "✓ Build — 3 files changed — 2m14s"
+ *   "✗ Tests — 45s"
+ *   "⊘ Review changes"
+ *
+ * @param outcome      the step outcome
+ * @param stepName     the task name
+ * @param durationMs   how long the step took (0 if not timed)
+ * @param fileCount    number of changed files after the step (0 if unknown)
+ * @returns the summary string
+ */
+export function stepSummary(
+	outcome: ChainStepOutcome,
+	stepName: string,
+	durationMs: number,
+	fileCount: number,
+): string {
+	const marker = outcomeToMarker(outcome);
+	const parts: string[] = [marker, stepName];
+	if (fileCount > 0) {
+		parts.push(`${fileCount} file${fileCount === 1 ? "" : "s"} changed`);
+	}
+	if (durationMs > 0) {
+		parts.push(formatDuration(durationMs));
+	}
+	// Only add " — " separator when there are parts beyond marker+name.
+	if (parts.length > 2) {
+		return `${marker} ${stepName} — ${parts.slice(2).join(" — ")}`;
+	}
+	return `${marker} ${stepName}`;
+}
+
+/**
+ * Generate a compact chain-end summary string, e.g.
+ * "✅ 4/4 steps completed in 6m42s". Only reachable when every step
+ * completed — the stop paths return early with their own per-step
+ * notification, so `completed` always equals `total` here.
+ */
+export function chainSummary(completed: number, total: number, totalMs: number): string {
+	const time = totalMs > 0 ? formatDuration(totalMs) : "";
+	return `✅ ${completed}/${total} steps completed${time ? ` in ${time}` : ""}`;
+}
+
+/** Format milliseconds to a human-readable duration string. Exported for tests. */
+export function formatDuration(ms: number): string {
+	if (ms < 1000) return `${ms}ms`;
+	const s = Math.floor(ms / 1000);
+	if (s < 60) return `${s}s`;
+	const m = Math.floor(s / 60);
+	const rem = s % 60;
+	return rem > 0 ? `${m}m${rem}s` : `${m}m`;
+}
+
+/** Map a step outcome to its display marker character. */
+function outcomeToMarker(outcome: ChainStepOutcome): string {
+	switch (outcome) {
+		case "completed":
+			return "✓";
+		case "aborted":
+			return "⊘";
+		case "error":
+			return "✗";
+		case "failed-to-start":
+			return "✗";
+		default:
+			// Exhaustive check: the type is a literal union, so this is unreachable.
+			throw new Error(`unexpected outcome: ${outcome as string}`);
+	}
+}
+
+// ── Commit browser types ─────────────────────────────────────────────────
+//
+// Types and constants for the date-grouped commit browser (used by
+// the "Review commits" task in index.ts). Pure data — no Pi dependencies.
+
+/** Maximum commits shown per page in the date-grouped browser. */
+export const COMMIT_BROWSER_MAX = 20;
+
+/** Maximum commits that can be selected for a review chain. */
+export const COMMIT_SELECT_MAX = 20;
+
+/** A single commit as returned by `git log --format`. */
+export interface CommitInfo {
+	/** Full 40-char SHA. */
+	hash: string;
+	/** Short 7-char SHA. */
+	shortHash: string;
+	/** Commit subject line. */
+	subject: string;
+	/** Commit date (YYYY-MM-DD). */
+	date: string;
+	/** Commit author name. */
+	author: string;
+	/** Number of files changed in this commit. */
+	filesChanged: number;
+	/** Insertions in this commit. */
+	insertions: number;
+	/** Deletions in this commit. */
+	deletions: number;
+}
+
+/** A commit selected by the user for review. */
+export interface SelectedCommit extends CommitInfo {
+	/** 1-based position in the user's selection order. */
+	selectionOrder: number;
+}
+
+/** Group of commits sharing the same date. */
+export interface DateGroup {
+	/** Date string (YYYY-MM-DD). */
+	date: string;
+	/** Number of commits in this group. */
+	count: number;
+	/** Commits in this group (newest first). */
+	commits: CommitInfo[];
+}
+
+/**
+ * Parse git log output formatted with:
+ * `COMMIT%x09%H%x09%h%x09%s%x09%ad%x09%an` and optional `--shortstat`.
+ */
+export function parseGitLogOutput(output: string): CommitInfo[] {
+	if (!output) return [];
+	const commits: CommitInfo[] = [];
+	let current: CommitInfo | null = null;
+	for (const rawLine of output.split("\n")) {
+		const line = rawLine.trim();
+		if (line.startsWith("COMMIT\t")) {
+			if (current) commits.push(current);
+			const parts = line.split("\t");
+			if (parts.length >= 6) {
+				const hash = parts[1];
+				const shortHash = parts[2];
+				const date = parts[parts.length - 2];
+				const author = parts[parts.length - 1];
+				const subject = parts.slice(3, parts.length - 2).join("\t") || "(no subject)";
+				current = {
+					hash,
+					shortHash,
+					subject,
+					date,
+					author,
+					filesChanged: 0,
+					insertions: 0,
+					deletions: 0,
+				};
+			} else {
+				current = null;
+			}
+			continue;
+		}
+		if (current && line.includes("changed")) {
+			const mFiles = line.match(/(\d+) file/);
+			const mIns = line.match(/(\d+) insertion/);
+			const mDel = line.match(/(\d+) deletion/);
+			if (mFiles) current.filesChanged = Number(mFiles[1]);
+			if (mIns) current.insertions = Number(mIns[1]);
+			if (mDel) current.deletions = Number(mDel[1]);
+		}
+	}
+	if (current) commits.push(current);
+	return commits;
+}
+
+/** Group commits by date (preserving existing order within and between groups). */
+export function groupCommitsByDate(commits: CommitInfo[]): DateGroup[] {
+	const groups = new Map<string, CommitInfo[]>();
+	for (const c of commits) {
+		if (!groups.has(c.date)) groups.set(c.date, []);
+		groups.get(c.date)!.push(c);
+	}
+	return [...groups.entries()].map(([date, groupCommits]) => ({
+		date,
+		count: groupCommits.length,
+		commits: groupCommits,
+	}));
+}
+
+/**
+ * Format the selected commits as a numbered detail block (hash, subject,
+ * author, date, stats per commit). Injected into task prompts via the
+ * `{{selected_commits}}` placeholder; composed into the full review prompt by
+ * `formatCommitReviewPrompt`.
+ */
+export function formatSelectedCommits(commits: SelectedCommit[]): string {
+	const count = commits.length;
+	return commits
+		.map((c, i) => {
+			const num = count > 1 ? `${i + 1}. ` : "";
+			return (
+				`${num}Commit ${c.shortHash} (${c.hash})\n` +
+				`   Subject: ${c.subject}\n` +
+				`   Author:  ${c.author} on ${c.date}\n` +
+				`   Stats:   ${c.filesChanged} file${c.filesChanged !== 1 ? "s" : ""} changed, +${c.insertions}/-${c.deletions} lines`
+			);
+		})
+		.join("\n\n");
+}
+
+/**
+ * Build the review prompt for the selected commits to send to the agent.
+ */
+export function formatCommitReviewPrompt(commits: SelectedCommit[]): string {
+	const count = commits.length;
+	const commitDetails = formatSelectedCommits(commits);
+
+	const showCmd = count === 1 ? `git show ${commits[0].hash}` : "git show <hash>";
+
+	return (
+		`Review the following git commit${count !== 1 ? "s" : ""}:\n\n` +
+		`${commitDetails}\n\n` +
+		`Please inspect the changes using \`${showCmd}\` (and any related files in the repository). ` +
+		`Double-check the changes for:\n` +
+		`1. Bugs, edge cases, potential regressions, and logic errors.\n` +
+		`2. Code quality, security, and unintended side effects.\n` +
+		`3. Consistency with surrounding project patterns and tests.\n\n` +
+		`Summarize your findings for each commit and propose a plan for any fixes if needed. Do not make changes yet.`
+	);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-do-always",
-	"version": "0.10.0",
+	"version": "0.13.0",
 	"type": "module",
 	"description": "Pi extension: /do-always — pick a common task by number, it fills your prompt",
 	"author": {