@oh-my-pi/pi-coding-agent 14.5.14 → 14.6.1

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 ## [Unreleased]
 
+## [14.6.1] - 2026-05-02
+### Changed
+
+- Updated GitHub call headers to display operation-specific titles and contextual metadata such as repository, branch, issue/PR IDs, and search query snippets for supported operations
+- Changed non-run-watch result rendering to honor terminal width, truncate long lines, and show a `+N more lines` expansion hint when output exceeds the preview limit
+
+### Fixed
+
+- Fixed GitHub tool output fallbacks that previously always showed a GitHub Run Watch heading so they now show the actual operation and clear `no output`/`request failed` status messaging
+
+## [14.6.0] - 2026-05-02
+### Breaking Changes
+
+- Reworked autoresearch storage and protocol. State now lives in `~/.omp/autoresearch/<project>.db` (SQLite) and per-run logs in `~/.omp/autoresearch/<project>/runs/<id>/benchmark.log`. The repo-side artifacts `autoresearch.md`, `autoresearch.sh`, `autoresearch.checks.sh`, `autoresearch.program.md`, `autoresearch.ideas.md`, `autoresearch.jsonl`, `.autoresearch/`, and `autoresearch.config.json` are no longer read or written; they are deleted by `/autoresearch clear`. Any existing data is not migrated.
+- Removed the autoresearch edit guard. `write`/`edit`/`ast_edit` are no longer blocked based on scope. Scope/off-limits are now post-hoc accountability fields on `log_experiment`.
+- Replaced rigid `init_experiment` contract validation with a simpler schema: `name`, `goal`, `primary_metric`, `metric_unit`, `direction`, `secondary_metrics`, `scope_paths`, `off_limits`, `constraints`, `max_iterations`, `new_segment`. Removed `from_autoresearch_md`, `abandon_unlogged_runs`, `force`, and `preferred_command` flags — the harness `./autoresearch.sh` is the canonical workload, edit it and bump segment when you need to change it.
+- `run_experiment` no longer accepts a `command` parameter. The tool always runs `bash autoresearch.sh`. To change the workload, edit the harness and call `init_experiment new_segment: true`. Removed `force`, `checks_timeout_seconds`, and the legacy `autoresearch.checks.sh` auto-execution; run validation through the regular `bash` tool.
+- Replaced `log_experiment` ASI requirements and `force`/`skip_restore` flags with `justification` (post-hoc explanation for scope deviations) and `flag_runs` (mark earlier runs suspect to exclude them from baseline math). ASI is now opaque metadata.
+- `/autoresearch clear` now resets the worktree to the session's recorded baseline commit (when on an `autoresearch/*` branch or with `--reset-tree`), closes the active session, and deletes any leftover legacy autoresearch repo artifacts.
+- `/autoresearch` now refuses on a dirty worktree with an explicit error instead of silently continuing on the current branch. Commit or stash before invoking — the session needs a clean baseline on a dedicated `autoresearch/*` branch.
+- Split `/autoresearch` into a two-phase protocol. Phase 1 (no session) prompts the agent to build the benchmark harness as `./autoresearch.sh` (must exit 0 and print `METRIC <name>=<value>`). Calling `init_experiment` ends Phase 1: it requires `./autoresearch.sh` to exist, auto-commits any pending harness changes on an `autoresearch/*` branch, then records that commit as the baseline. Phase 2 is the existing iteration loop.
+- Autoresearch sessions are now scoped to the git branch they were created on. Switching off the `autoresearch/*` branch hides the dashboard widget, detaches the experiment tools, and skips the autoresearch system prompt; switching back resumes seamlessly. `/autoresearch` on a fresh branch starts a fresh session instead of resurrecting a session bound to a different branch.
+- `log_experiment discard` no longer rewinds prior `keep` commits. On an `autoresearch/*` branch it now resets the worktree to `HEAD` (and `git clean`s untracked) instead of `git reset --hard $baseline_commit`. Discard reverts only the current iteration's uncommitted edits; previously kept improvements stay on the branch. `/autoresearch clear` continues to reset to the recorded baseline commit when explicitly requested.
+- Autoresearch SQLite storage is now created lazily on first `init_experiment`. Running `omp` in a project that never invokes `/autoresearch` no longer creates a per-folder DB.
+
+- Changed `search`, `find`, `ast_grep`, and `ast_edit` to accept `paths: string[]` instead of comma- or whitespace-delimited path strings.
+
+### Added
+
+- Added `update_notes` tool with `body` (replace) and `append_idea` (append a bullet under an `## Ideas` section). Notes are injected into the system prompt every iteration and replace the file-based `autoresearch.md` / `.program.md` / `.ideas.md` ecosystem.
+
+### Changed
+
+- Updated `log_experiment` summary output to include the count of scope deviations detected for a run
+- Used the active session context in autoresearch resume instructions instead of referencing deleted repo-side files
+- Removed `PI_STRICT_EDIT_MODE`; model-specific edit mode fallbacks are no longer disableable by environment flag.
+
+### Fixed
+
+- Atom edit auto-rebase warning now dedupes by `(originalLid, rebasedLine)` pair. Previously, `@Lid` followed by N `+TEXT` lines emitted N identical "Auto-rebased anchor" warnings (one per cloned cursor anchor); now emits exactly one per distinct rebase.
+- Atom/hashline diff preview no longer renders deleted lines with a 2-space hash placeholder (`-20  |old`) that visually mimicked a Lid. Removed lines now use `--` as the placeholder (`-20--|old`), making them unambiguously non-Lid.
+- Atom/hashline diff preview no longer folds size-mismatched `-`/`+` runs into a confusing mix of `*` (paired modification) lines plus surplus `-`/`+` lines. The `*` collapse now applies only to clean 1:1 line replacements (same number of dels and adds); range replaces with N→M (N≠M) render as plain unified-diff `-` then `+` runs.
+- Atom edits now warn when `@Lid` lands on a brace-opening line and the inserted content is at sibling indent (≤ anchor indent) — a foot-gun where the agent meant `^<nextSibling>` but the inserts ended up as the first body element of the `{...}` block.
+- Atom auto-fix warning for adjacent-duplicate cleanup is now formatted as `AUTO-FIX applied — verify the result. Removed ...` instead of the easier-to-miss `Auto-fixed: removed ...`, and explains that `{}/()/[]` balance was the trigger.
+- Fixed multi-target `search`, `ast-grep`, and `ast-edit` path handling by running each resolved target separately under root-level path resolution
+- Fixed pagination and match/replacement summaries for multi-target AST and text searches so totals and affected file counts include all targets
+- Fixed returned file paths for multi-target `search` and `ast-grep` results by normalizing them to the original search scope
+- Fixed `log_experiment keep` silently dropping the iteration's diff on an autoresearch branch. The previous logic filtered out every path that was already dirty when `run_experiment` ran — but in the iteration cycle the agent's edits always land before `run_experiment`, so the entire iteration was filtered away and nothing was committed. On an autoresearch branch, `keep` now treats every currently-dirty path as the iteration's change and commits it.
+
 ## [14.5.14] - 2026-05-01
 ### Changed
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.5.14",
+	"version": "14.6.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.5.14",
-		"@oh-my-pi/pi-agent-core": "14.5.14",
-		"@oh-my-pi/pi-ai": "14.5.14",
-		"@oh-my-pi/pi-natives": "14.5.14",
-		"@oh-my-pi/pi-tui": "14.5.14",
-		"@oh-my-pi/pi-utils": "14.5.14",
+		"@oh-my-pi/omp-stats": "14.6.1",
+		"@oh-my-pi/pi-agent-core": "14.6.1",
+		"@oh-my-pi/pi-ai": "14.6.1",
+		"@oh-my-pi/pi-natives": "14.6.1",
+		"@oh-my-pi/pi-tui": "14.6.1",
+		"@oh-my-pi/pi-utils": "14.6.1",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",

package/src/autoresearch/command-resume.md

@@ -1,6 +1,4 @@
-Resume autoresearch from the attached notes.
-
-@{{autoresearch_md_path}}
+Resume autoresearch on the active session.
 
 {{branch_status_line}}
 {{#if has_resume_context}}
@@ -10,8 +8,7 @@ Additional context from the user:
 {{resume_context}}
 {{/if}}
 
-Use the notes as the source of truth for the current direction, scope, and constraints.
-- inspect recent git history for context
-- inspect `autoresearch.jsonl` if it exists
-- continue the most promising unfinished direction on the current protected branch
-- keep iterating until interrupted or until the configured iteration cap is reached
+- Use the active session context above as the source of truth for goal, scope, constraints, and run history.
+- Inspect recent git history for context.
+- Continue the most promising unfinished direction.
+- Keep iterating until interrupted or until the configured iteration cap is reached.

package/src/autoresearch/git.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "../extensibility/extensions";
 import * as git from "../utils/git";
-import { isAutoresearchLocalStatePath, normalizeAutoresearchPath } from "./helpers";
+import { normalizePathSpec } from "./helpers";
 
 const AUTORESEARCH_BRANCH_PREFIX = "autoresearch/";
 const BRANCH_NAME_MAX_LENGTH = 48;
@@ -11,9 +11,10 @@ export interface EnsureAutoresearchBranchFailure {
 }
 
 export interface EnsureAutoresearchBranchSuccess {
-	branchName: string;
+	branchName: string | null;
 	created: boolean;
 	ok: true;
+	warning?: string;
 }
 
 export type EnsureAutoresearchBranchResult = EnsureAutoresearchBranchFailure | EnsureAutoresearchBranchSuccess;
@@ -23,6 +24,14 @@ export async function getCurrentAutoresearchBranch(_api: ExtensionAPI, workDir:
 	return currentBranch.startsWith(AUTORESEARCH_BRANCH_PREFIX) ? currentBranch : null;
 }
 
+/**
+ * Ensure the working tree is on an `autoresearch/*` branch when possible.
+ *
+ * If the worktree is dirty and we're not already on an autoresearch branch, this returns
+ * `{ ok: true, branchName: null, warning }` rather than failing. The caller surfaces the
+ * warning and continues on the current branch — `keep` will skip auto-commits and `discard`
+ * will revert only run-modified paths instead of resetting to baseline.
+ */
 export async function ensureAutoresearchBranch(
 	api: ExtensionAPI,
 	workDir: string,
@@ -31,57 +40,48 @@ export async function ensureAutoresearchBranch(
 	const repoRoot = await git.repo.root(workDir);
 	if (!repoRoot) {
 		return {
-			error: "Autoresearch requires a git repository so it can isolate experiments and revert failed runs safely.",
-			ok: false,
+			ok: true,
+			branchName: null,
+			created: false,
+			warning:
+				"Not in a git repository — autoresearch will run without branch isolation, baseline reset, or auto-commits.",
 		};
 	}
 
 	let dirtyPathsOutput: string;
 	try {
-		dirtyPathsOutput = await git.status(repoRoot, {
-			porcelainV1: true,
-			untrackedFiles: "all",
-			z: true,
-		});
+		dirtyPathsOutput = await git.status(repoRoot, { porcelainV1: true, untrackedFiles: "all", z: true });
 	} catch (err) {
 		return {
-			error: `Unable to inspect git status before starting autoresearch: ${err instanceof Error ? err.message : String(err)}`,
 			ok: false,
+			error: `Unable to inspect git status before starting autoresearch: ${err instanceof Error ? err.message : String(err)}`,
 		};
 	}
 
 	const workDirPrefix = await readGitWorkDirPrefix(api, workDir);
-	const unsafeDirtyPaths = collectUnsafeDirtyPaths(dirtyPathsOutput, workDirPrefix);
+	const dirtyPaths = collectRelativeDirtyPaths(dirtyPathsOutput, workDirPrefix);
 	const currentBranch = await getCurrentAutoresearchBranch(api, workDir);
 	if (currentBranch) {
-		if (unsafeDirtyPaths.length > 0) {
-			return buildUnsafeDirtyPathsFailure(unsafeDirtyPaths);
-		}
+		return { ok: true, branchName: currentBranch, created: false };
+	}
+	if (dirtyPaths.length > 0) {
+		const preview = formatDirtyPaths(dirtyPaths);
 		return {
-			branchName: currentBranch,
-			created: false,
-			ok: true,
+			ok: false,
+			error: `Worktree is dirty (${preview}). Commit or stash these changes before starting autoresearch — a fresh autoresearch/* branch needs a clean baseline.`,
 		};
 	}
-	if (unsafeDirtyPaths.length > 0) {
-		return buildUnsafeDirtyPathsFailure(unsafeDirtyPaths);
-	}
 
 	const branchName = await allocateBranchName(api, workDir, goal);
 	try {
 		await git.branch.checkoutNew(workDir, branchName);
 	} catch (err) {
 		return {
-			error: `Failed to create autoresearch branch ${branchName}: ${err instanceof Error ? err.message : String(err)}`,
 			ok: false,
+			error: `Failed to create autoresearch branch ${branchName}: ${err instanceof Error ? err.message : String(err)}`,
 		};
 	}
-
-	return {
-		branchName,
-		created: true,
-		ok: true,
-	};
+	return { ok: true, branchName, created: true };
 }
 
 export function parseWorkDirDirtyPaths(statusOutput: string, workDirPrefix: string): string[] {
@@ -96,7 +96,7 @@ export function parseWorkDirDirtyPaths(statusOutput: string, workDirPrefix: stri
 
 export function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPrefix: string): string | null {
 	const normalizedPath = normalizeStatusPath(repoRelativePath);
-	const normalizedPrefix = normalizeAutoresearchPath(workDirPrefix);
+	const normalizedPrefix = normalizePathSpec(workDirPrefix);
 	if (normalizedPrefix === "" || normalizedPrefix === ".") {
 		return normalizedPath;
 	}
@@ -106,7 +106,7 @@ export function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPref
 	if (!normalizedPath.startsWith(`${normalizedPrefix}/`)) {
 		return null;
 	}
-	return normalizeAutoresearchPath(normalizedPath.slice(normalizedPrefix.length + 1));
+	return normalizePathSpec(normalizedPath.slice(normalizedPrefix.length + 1));
 }
 
 async function readGitWorkDirPrefix(api: ExtensionAPI, workDir: string): Promise<string> {
@@ -162,12 +162,12 @@ function parseDirtyPathsLines(statusOutput: string): string[] {
 	return [...unsafePaths];
 }
 
-export function normalizeStatusPath(path: string): string {
-	let normalized = path.trim();
+export function normalizeStatusPath(rawPath: string): string {
+	let normalized = rawPath.trim();
 	if (normalized.startsWith('"') && normalized.endsWith('"')) {
 		normalized = normalized.slice(1, -1);
 	}
-	return normalizeAutoresearchPath(normalized);
+	return normalizePathSpec(normalized);
 }
 
 async function allocateBranchName(api: ExtensionAPI, workDir: string, goal: string | null): Promise<string> {
@@ -209,32 +209,23 @@ function addDirtyPath(paths: Set<string>, rawPath: string): void {
 	paths.add(normalizedPath);
 }
 
-function buildUnsafeDirtyPathsFailure(unsafeDirtyPaths: string[]): EnsureAutoresearchBranchFailure {
-	const preview = unsafeDirtyPaths.slice(0, 5).join(", ");
-	const suffix = unsafeDirtyPaths.length > 5 ? ` (+${unsafeDirtyPaths.length - 5} more)` : "";
-	return {
-		error:
-			"Autoresearch needs a clean git worktree before it can create or reuse an isolated branch. " +
-			`Commit or stash these paths first: ${preview}${suffix}`,
-		ok: false,
-	};
-}
-
 function isRenameOrCopy(statusToken: string): boolean {
 	const trimmed = statusToken.trim();
 	return trimmed.startsWith("R") || trimmed.startsWith("C");
 }
 
-function collectUnsafeDirtyPaths(statusOutput: string, workDirPrefix: string): string[] {
-	const unsafeDirtyPaths: string[] = [];
+function collectRelativeDirtyPaths(statusOutput: string, workDirPrefix: string): string[] {
+	const dirtyPaths: string[] = [];
 	for (const dirtyPath of parseDirtyPaths(statusOutput)) {
 		const relativePath = relativizeGitPathToWorkDir(dirtyPath, workDirPrefix);
-		if (relativePath && isAutoresearchLocalStatePath(relativePath)) {
-			continue;
-		}
-		unsafeDirtyPaths.push(relativePath ?? normalizeStatusPath(dirtyPath));
+		dirtyPaths.push(relativePath ?? normalizeStatusPath(dirtyPath));
 	}
-	return unsafeDirtyPaths;
+	return dirtyPaths;
+}
+
+function formatDirtyPaths(paths: string[]): string {
+	const preview = paths.slice(0, 5).join(", ");
+	return paths.length > 5 ? `${preview} (+${paths.length - 5} more)` : preview;
 }
 
 export interface DirtyPathEntry {
@@ -318,7 +309,6 @@ export function computeRunModifiedPaths(
 	const untracked: string[] = [];
 	for (const entry of parseWorkDirDirtyPathsWithStatus(currentStatusOutput, workDirPrefix)) {
 		if (preRunSet.has(entry.path)) continue;
-		if (isAutoresearchLocalStatePath(entry.path)) continue;
 		if (entry.untracked) {
 			untracked.push(entry.path);
 		} else {