@oh-my-pi/pi-coding-agent 14.9.3 → 14.9.7

package/CHANGELOG.md

@@ -1,6 +1,102 @@
 # Changelog
 
 ## [Unreleased]
+### Breaking Changes
+
+- Changed the `eval` tool input format to a single-line `*** Cell <lang>:"<title>" [t:<duration>] [rst]` header per cell, replacing the `*** Begin <LANG>` / `*** End <LANG>` envelope and the standalone `*** Title:` / `*** Timeout:` / `*** Reset` directives. The lark grammar enforces a fixed attribute order; the runtime parser remains lenient (alias keys, bare positional tokens, single-quoted titles).
+
+### Added
+
+- Added support for explicit boolean `rst` values (`rst:true`, `rst:false`, `rst:1`, `rst:0`, `rst:yes`, `rst:no`, `rst:on`, `rst:off`) in `*** Cell` headers
+
+### Changed
+
+- Changed the HTML transcript renderer to parse the new `*** Cell` headers while keeping the older `*** Begin <LANG>` and `===== ... =====` formats renderable for historical sessions.
+- Changed the `eval` tool parser so a stray non-marker line between cells no longer crashes with `null is not an object (evaluating 'BEGIN_RE.exec(lines[i])[1]')`; stray content is consumed without aborting parsing.
+- Changed `*** End` to be an optional, undocumented per-cell terminator (kept in the lark to satisfy GPT-trained models' natural terminator habit during constrained sampling).
+
+### Fixed
+
+- Improved `*** Cell` header parsing to reject invalid `rst` values with a clear `invalid rst value` error
+
+## [14.9.7] - 2026-05-12
+
+### Breaking Changes
+
+- Changed the `timeoutMs` execution option to no longer be enforced during worker-based JS runs, so callers must rely on external cancellation signals for time limits
+- Replaced the Jupyter kernel gateway + WebSocket protocol behind the Python `eval` backend with a subprocess-backed runner that speaks NDJSON over stdin/stdout; removed the `jupyter_kernel_gateway`/`ipykernel` pip dependencies, the `python.sharedGateway` setting, the `omp jupyter` CLI command, and the `PI_PYTHON_GATEWAY_URL` / `PI_PYTHON_GATEWAY_TOKEN` environment variables
+
+### Added
+
+- Added Python `tool.<name>(args)` support to `executePython` sessions so evaluated Python code can invoke session tools through the prelude `tool` proxy
+- Added per-execution Python tool bridge session registration and loopback endpoint wiring so Python tool calls resolve to host tools and return tool results
+- Added status-event forwarding for Python tool bridge calls so `tool` invocations can emit execution status updates
+- Added browser-tab JavaScript execution through the shared runtime so tab runs now expose the standard helper globals (`read`, `write`, `sort`, `uniq`, `counter`, `diff`, `tree`, `env`, `output`, `display`, and `tool`)
+- Added static ESM `import` support to browser-tab JavaScript by rewriting top-level imports and resolving them against the tab session context
+- Added substring fallback matching to `HistoryStorage.search` so infix and short-token queries that FTS5 prefix matching misses are still returned
+- Added a live single-line sync progress display to the stats command showing current/total sessions while syncing
+- Added automatic inline JS evaluation fallback when worker creation failed so script execution still works in environments without worker support
+
+### Changed
+
+- Changed `setup python` to only verify a reachable Python 3 interpreter instead of installing Jupyter dependencies
+- Changed `info` output to remove the obsolete Python Gateway status block now that shared gateway management is no longer available
+- Changed JavaScript execution in `executeJs` to expose the worker\u2019s real `process` object instead of a restricted, frozen subset
+- Changed JavaScript evaluation to run per session in a worker-backed runner with explicit initialization and teardown handling
+- Changed the Python backend to launch one `python -u runner.py` subprocess per kernel; cancellation now sends `SIGINT` which raises a real `KeyboardInterrupt` in user code, and the same subprocess is reused across cells in session mode
+- Changed Python magic handling so `%pip`, `%cd`, `%env`, `%pwd`, `%ls`, `%time`, `%timeit`, `%who`, `%reset`, `%load`, `%run`, `%%bash`, `%%capture`, `%%timeit`, `%%writefile`, and `!shell` work without depending on IPython
+
+### Fixed
+
+- Fixed Python output rendering so `text/markdown` takes precedence over `text/plain` and status bundles are emitted as status updates rather than plain text
+- Fixed query tokenization in `HistoryStorage.search` so punctuation-delimited terms like `git-commit` are aligned with indexing and matched correctly
+- Fixed history search result merging to de-duplicate matches and return full-text matches before substring-only matches while still respecting the requested limit
+- Fixed JS run cancellation so aborting a run now also cancels in-flight tool calls and terminates the active worker session
+- Fixed top-level `const`, `let`, and `class` declarations in evaluated JavaScript to persist across subsequent runs by rewriting top-level declarations
+
+## [14.9.5] - 2026-05-12
+### Breaking Changes
+
+- Removed the `jobs://` internal URL protocol; inspect background jobs via the `job` tool's `list: true` operation instead
+
+### Added
+
+- Added `since` and `until` date-range filters to `search_issues`, `search_prs`, `search_commits`, and `search_repos`, accepting relative durations (`m`/`h`/`d`/`w`/`mo`/`y`), ISO dates, and ISO datetimes
+- Added `dateField` support for date filtering (`created` or `updated`) so search results can be constrained by creation, update, pushed (for repos), or committer date (for commits)
+- Added owner-based scoping to async job registration and queries so background jobs can be registered with an `ownerId` and filtered per agent in `getRunningJobs`, `getRecentJobs`, `getAllJobs`, and `cancelAll`
+- Added agent ownership metadata to async jobs started by `task` and `bash` tools so their lifecycle and cancellation is attributed to the creating agent
+- Added `list: true` operation to the `job` tool, returning an immediate snapshot of every job spawned by the calling agent without waiting (replaces the deleted `jobs://` URL)
+- Added per-agent visibility scoping to the `job` tool so `list`, `poll`, and `cancel` only see and act on jobs owned by the calling agent; cross-agent operations now return `not_found`
+
+### Changed
+
+- Changed `search_issues`, `search_prs`, `search_commits`, and `search_repos` to allow date-only queries where `query` is omitted if `since`/`until` is provided
+- Changed `search_code` to return a validation error when `since`/`until` is supplied because GitHub code search does not support date qualifiers
+- Changed async job manager ownership so subagents inherit the parent session’s global `AsyncJobManager` instead of creating and owning separate instances
+- Changed session lifecycle cleanup so the global async-job manager is disposed only by the owning top-level session
+- Changed subagent session switches and handoff paths to stop global async-job cancellation and cancel only jobs owned by that session
+- Changed `agent://` and `artifact://` URL resolution to search artifact outputs across all active sessions instead of only the current session, allowing parent and subagent sessions to read each other’s generated outputs by ID
+- Changed `memory://` URL resolution to walk all active sessions’ memory roots and return the first matching file, so worktree-based subagents can access their own memory views as well as shared roots
+- Changed internal URL routing to use a shared process-global `InternalUrlRouter` and protocol handlers, so built-in tools resolve `agent://`, `artifact://`, `memory://`, `skill://`, `rule://`, `mcp://`, and `local://` URLs without requiring session-specific router wiring
+- Changed `mcp://` handler to use the globally registered MCP manager so MCP resource links work for agents sharing session context
+
+### Changed
+
+- Changed the `ask.timeout` default from `30` (seconds) to `0` (wait indefinitely). Auto-selecting the recommended option after a fixed delay was surprising users mid-deliberation; the timer is now strictly opt-in. The legacy auto-select behavior is preserved when `ask.timeout` is set to a non-zero value, and the `ask` tool's prompt has been updated so the model expects unlimited reply time by default.
+
+### Fixed
+
+- Added `ModelRegistry.hasConfiguredAuth(model)` to mirror the upstream `@mariozechner/pi-coding-agent` API surface; external plugins and downstream wrappers that pre-flight auth before launching a subagent no longer crash with `this._modelRegistry.hasConfiguredAuth is not a function` on the direct agent-launch path. ([#993](https://github.com/can1357/oh-my-pi/issues/993))
+- Fixed an ESM circular-import TDZ that crashed test suites when modules from the `task/` and `tools/` graphs were evaluated together (e.g. `executor-warnings.test.ts` + `task-simple-mode.test.ts`) by deferring `BUILTIN_TOOLS.task`'s `TaskTool.create` dereference to factory-call time and sourcing `truncateTail` from `session/streaming-output` instead of the `tools/` barrel
+- Treat keyless-by-design providers (llama.cpp, ollama, lm-studio) as authenticated in subagent model resolution; fixes silent fallback to parent remote model when a local model is configured. ([#1008](https://github.com/can1357/oh-my-pi/issues/1008))
+- Fixed subagent disposal and session transitions that previously canceled all running async jobs, preventing inadvertent termination of a parent agent’s background work
+- Fixed multi-entry edits silently rendering a fake success when every entry failed (e.g. all hit the auto-generated guard), by surfacing `isError: true` from the single-path edit orchestrator so the renderer takes the error branch instead of falling through to the streaming-preview fallback that displays the *proposed* diff
+- Fixed the auto-generated streaming guard being gated behind `edit.streamingAbort` (default false), so it now pre-empts streaming edit tool calls targeting auto-generated files regardless of that setting
+- Fixed subagents launched in the same parallel batch not seeing each other in their initial `# IRC Peers` system-prompt block by pre-registering the agent in the global `AgentRegistry` before `rebuildSystemPrompt` runs and attaching the live session afterwards
+- Fixed plugin manifest extensions whose entry points at a directory (e.g. `pi-goal`'s `"pi": { "extensions": [".pi/extensions/pi-goal"] }`) failing to load with `Failed to load extension: Directories cannot be read like files`. The plugin path resolver now resolves directory entries to their `index.{ts,js,mjs,cjs}` file, matching the behavior of native auto-discovery via `resolveExtensionEntries`.
+- Fixed the SSH tool on native Windows by avoiding OpenSSH ControlMaster multiplexing, which Win32-OpenSSH does not support and reports as `getsockname failed` ([#154](https://github.com/can1357/oh-my-pi/issues/154)).
+- Fixed `/export` and `/tree` not showing developer-role messages (including the plan content injected after `/plan` approval) so the HTML export and TUI session tree now render developer messages dimmed with their actual content instead of hiding them entirely ([#753](https://github.com/can1357/oh-my-pi/issues/753))
+- Fixed `Timed out initializing browser tab worker` on prebuilt binaries by rewriting `spawnTabWorker` to import the worker entry with `with { type: "file" }` so Bun's `--compile` bundler statically discovers and embeds `tab-worker-entry.ts` in the single-file binary ([#1011](https://github.com/can1357/oh-my-pi/issues/1011))
 
 ## [14.9.3] - 2026-05-10
 ### Breaking Changes

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.9.3",
+	"version": "14.9.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -47,12 +47,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.9.3",
-		"@oh-my-pi/pi-agent-core": "14.9.3",
-		"@oh-my-pi/pi-ai": "14.9.3",
-		"@oh-my-pi/pi-natives": "14.9.3",
-		"@oh-my-pi/pi-tui": "14.9.3",
-		"@oh-my-pi/pi-utils": "14.9.3",
+		"@oh-my-pi/omp-stats": "14.9.7",
+		"@oh-my-pi/pi-agent-core": "14.9.7",
+		"@oh-my-pi/pi-ai": "14.9.7",
+		"@oh-my-pi/pi-natives": "14.9.7",
+		"@oh-my-pi/pi-tui": "14.9.7",
+		"@oh-my-pi/pi-utils": "14.9.7",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@types/turndown": "5.0.6",

package/src/async/job-manager.ts

@@ -16,6 +16,13 @@ export interface AsyncJob {
 	promise: Promise<void>;
 	resultText?: string;
 	errorText?: string;
+	/**
+	 * Registry id of the agent that registered the job (e.g. "0-Main",
+	 * "3-AuthLoader"). Used by scoped cancel/list APIs so a subagent's teardown
+	 * does not cancel its parent's jobs. Undefined for callers that don't
+	 * supply an id (e.g. legacy tests, SDK consumers without an agent context).
+	 */
+	ownerId?: string;
 }
 
 export interface AsyncJobManagerOptions {
@@ -41,10 +48,38 @@ export interface AsyncJobDeliveryState {
 
 export interface AsyncJobRegisterOptions {
 	id?: string;
+	/** Registry id of the agent that owns this job; used to scope cancelAll. */
+	ownerId?: string;
 	onProgress?: (text: string, details?: Record<string, unknown>) => void | Promise<void>;
 }
 
+/**
+ * Filter applied to job query/cancel APIs. With `ownerId`, results are
+ * restricted to jobs registered by that agent (registry id from
+ * `AgentRegistry`, e.g. "0-Main", "3-AuthLoader").
+ */
+export interface AsyncJobFilter {
+	ownerId?: string;
+}
+
 export class AsyncJobManager {
+	static #instance: AsyncJobManager | undefined;
+
+	/** Process-global instance shared by internal URL protocol handlers and tools. */
+	static instance(): AsyncJobManager | undefined {
+		return AsyncJobManager.#instance;
+	}
+
+	/** Install or clear the process-global instance. */
+	static setInstance(value: AsyncJobManager | undefined): void {
+		AsyncJobManager.#instance = value;
+	}
+
+	/** Reset the process-global instance. Test-only. */
+	static resetForTests(): void {
+		AsyncJobManager.#instance = undefined;
+	}
+
 	readonly #jobs = new Map<string, AsyncJob>();
 	readonly #deliveries: AsyncJobDelivery[] = [];
 	readonly #suppressedDeliveries = new Set<string>();
@@ -56,6 +91,16 @@ export class AsyncJobManager {
 	#deliveryLoop: Promise<void> | undefined;
 	#disposed = false;
 
+	#filterJobs(jobs: Iterable<AsyncJob>, filter?: AsyncJobFilter): AsyncJob[] {
+		const ownerId = filter?.ownerId;
+		if (!ownerId) return Array.from(jobs);
+		const out: AsyncJob[] = [];
+		for (const job of jobs) {
+			if (job.ownerId === ownerId) out.push(job);
+		}
+		return out;
+	}
+
 	constructor(options: AsyncJobManagerOptions) {
 		this.#onJobComplete = options.onJobComplete;
 		this.#maxRunningJobs = Math.max(1, Math.floor(options.maxRunningJobs ?? DEFAULT_MAX_RUNNING_JOBS));
@@ -95,6 +140,7 @@ export class AsyncJobManager {
 			label,
 			abortController,
 			promise: Promise.resolve(),
+			ownerId: options?.ownerId,
 		};
 
 		const reportProgress = async (text: string, details?: Record<string, unknown>): Promise<void> => {
@@ -138,9 +184,15 @@ export class AsyncJobManager {
 		return id;
 	}
 
-	cancel(id: string): boolean {
+	/**
+	 * Cancel a single job by id. When `filter.ownerId` is set and does not
+	 * match the job's owner, the call is treated as not-found (returns false)
+	 * so cross-agent cancellation is rejected at the manager level.
+	 */
+	cancel(id: string, filter?: AsyncJobFilter): boolean {
 		const job = this.#jobs.get(id);
 		if (!job) return false;
+		if (filter?.ownerId && job.ownerId !== filter.ownerId) return false;
 		if (job.status !== "running") return false;
 		job.status = "cancelled";
 		job.abortController.abort();
@@ -152,19 +204,19 @@ export class AsyncJobManager {
 		return this.#jobs.get(id);
 	}
 
-	getRunningJobs(): AsyncJob[] {
-		return Array.from(this.#jobs.values()).filter(job => job.status === "running");
+	getRunningJobs(filter?: AsyncJobFilter): AsyncJob[] {
+		return this.#filterJobs(this.#jobs.values(), filter).filter(job => job.status === "running");
 	}
 
-	getRecentJobs(limit = 10): AsyncJob[] {
-		return Array.from(this.#jobs.values())
+	getRecentJobs(limit = 10, filter?: AsyncJobFilter): AsyncJob[] {
+		return this.#filterJobs(this.#jobs.values(), filter)
 			.filter(job => job.status !== "running")
 			.sort((a, b) => b.startTime - a.startTime)
 			.slice(0, limit);
 	}
 
-	getAllJobs(): AsyncJob[] {
-		return Array.from(this.#jobs.values());
+	getAllJobs(filter?: AsyncJobFilter): AsyncJob[] {
+		return this.#filterJobs(this.#jobs.values(), filter);
 	}
 
 	getDeliveryState(): AsyncJobDeliveryState {
@@ -221,8 +273,13 @@ export class AsyncJobManager {
 		return before - this.#deliveries.length;
 	}
 
-	cancelAll(): void {
-		for (const job of this.getRunningJobs()) {
+	/**
+	 * Cancel running jobs. With `filter.ownerId` set, cancels only jobs the
+	 * matching agent registered; with no filter, cancels every running job
+	 * (used by `dispose()` to nuke the manager's state).
+	 */
+	cancelAll(filter?: AsyncJobFilter): void {
+		for (const job of this.getRunningJobs(filter)) {
 			job.status = "cancelled";
 			job.abortController.abort();
 			this.#scheduleEviction(job.id);

package/src/capability/rule.ts

@@ -209,6 +209,26 @@ export function parseRuleConditionAndScope(frontmatter: RuleFrontmatter): Pick<R
 	};
 }
 
+let activeRules: readonly Rule[] = [];
+
+/**
+ * Process-global snapshot of rules the active session loaded.
+ * Read by internal URL protocol handlers (rule://).
+ */
+export function getActiveRules(): readonly Rule[] {
+	return activeRules;
+}
+
+/** Replace the active rule snapshot. Called once per top-level session. */
+export function setActiveRules(value: readonly Rule[]): void {
+	activeRules = value;
+}
+
+/** Reset the active rule snapshot. Test-only. */
+export function resetActiveRulesForTests(): void {
+	activeRules = [];
+}
+
 export const ruleCapability = defineCapability<Rule>({
 	id: "rules",
 	displayName: "Rules",

package/src/cli/setup-cli.ts

@@ -21,7 +21,6 @@ export interface SetupCommandArgs {
 
 const VALID_COMPONENTS: SetupComponent[] = ["python", "stt"];
 
-const PYTHON_PACKAGES = ["jupyter_kernel_gateway", "ipykernel"];
 const MANAGED_PYTHON_ENV = getPythonEnvDir();
 
 /**
@@ -65,10 +64,6 @@ export function parseSetupArgs(args: string[]): SetupCommandArgs | undefined {
 interface PythonCheckResult {
 	available: boolean;
 	pythonPath?: string;
-	uvPath?: string;
-	pipPath?: string;
-	missingPackages: string[];
-	installedPackages: string[];
 	usingManagedEnv?: boolean;
 	managedEnvPath?: string;
 }
@@ -85,8 +80,6 @@ function managedPythonPath(): string {
 async function checkPythonSetup(): Promise<PythonCheckResult> {
 	const result: PythonCheckResult = {
 		available: false,
-		missingPackages: [],
-		installedPackages: [],
 		managedEnvPath: MANAGED_PYTHON_ENV,
 	};
 
@@ -94,109 +87,24 @@ async function checkPythonSetup(): Promise<PythonCheckResult> {
 	const managedPath = managedPythonPath();
 	const hasManagedEnv = await Bun.file(managedPath).exists();
 
-	result.uvPath = $which("uv") ?? undefined;
-	result.pipPath = $which("pip3") ?? $which("pip") ?? undefined;
-
-	const candidates = [systemPythonPath, hasManagedEnv ? managedPath : undefined].filter(
-		(candidate): candidate is string => !!candidate,
-	);
-	if (candidates.length === 0) {
+	const pythonPath = systemPythonPath ?? (hasManagedEnv ? managedPath : undefined);
+	if (!pythonPath) {
 		return result;
 	}
-
-	result.pythonPath = systemPythonPath ?? managedPath;
-	let bestMatch = {
-		pythonPath: candidates[0],
-		missingPackages: [...PYTHON_PACKAGES],
-		installedPackages: [] as string[],
-		usingManagedEnv: candidates[0] === managedPath,
-	};
-
-	for (const pythonPath of candidates) {
-		const installedPackages: string[] = [];
-		const missingPackages: string[] = [];
-		for (const pkg of PYTHON_PACKAGES) {
-			const moduleName = pkg === "jupyter_kernel_gateway" ? "kernel_gateway" : pkg;
-			const script = `import importlib.util; raise SystemExit(0 if importlib.util.find_spec('${moduleName}') else 1)`;
-			const check = await $`${pythonPath} -c ${script}`.quiet().nothrow();
-			if (check.exitCode === 0) {
-				installedPackages.push(pkg);
-			} else {
-				missingPackages.push(pkg);
-			}
-		}
-
-		if (missingPackages.length < bestMatch.missingPackages.length) {
-			bestMatch = {
-				pythonPath,
-				missingPackages,
-				installedPackages,
-				usingManagedEnv: pythonPath === managedPath,
-			};
-		}
-
-		if (missingPackages.length === 0) {
-			result.available = true;
-			result.pythonPath = pythonPath;
-			result.missingPackages = missingPackages;
-			result.installedPackages = installedPackages;
-			result.usingManagedEnv = pythonPath === managedPath;
-			return result;
-		}
-	}
-
-	result.pythonPath = bestMatch.pythonPath;
-	result.missingPackages = bestMatch.missingPackages;
-	result.installedPackages = bestMatch.installedPackages;
-	result.usingManagedEnv = bestMatch.usingManagedEnv;
+	const probe = await $`${pythonPath} -c "import sys;sys.exit(0)"`.quiet().nothrow();
+	result.pythonPath = pythonPath;
+	result.available = probe.exitCode === 0;
+	result.usingManagedEnv = pythonPath === managedPath;
 	return result;
 }
 
 /**
  * Install Python packages using uv (preferred) or pip.
  */
-async function installPythonPackages(
-	packages: string[],
-	pythonPath: string,
-	uvPath?: string,
-	pipPath?: string,
-): Promise<{ success: boolean; usedManagedEnv: boolean }> {
-	if (uvPath) {
-		console.log(chalk.dim(`Installing via uv: ${packages.join(" ")}`));
-		const result = await $`${uvPath} pip install ${packages}`.nothrow();
-		if (result.exitCode === 0) {
-			return { success: true, usedManagedEnv: false };
-		}
-	}
-
-	if (pipPath) {
-		console.log(chalk.dim(`Installing via pip: ${packages.join(" ")}`));
-		const result = await $`${pipPath} install ${packages}`.nothrow();
-		if (result.exitCode === 0) {
-			return { success: true, usedManagedEnv: false };
-		}
-	}
-
-	console.log(chalk.dim(`Falling back to managed virtual environment: ${MANAGED_PYTHON_ENV}`));
-
-	if (uvPath) {
-		const createEnv = await $`${uvPath} venv ${MANAGED_PYTHON_ENV}`.quiet().nothrow();
-		if (createEnv.exitCode !== 0) {
-			return { success: false, usedManagedEnv: true };
-		}
-		const installInManagedEnv = await $`${uvPath} pip install --python ${MANAGED_PYTHON_ENV} ${packages}`.nothrow();
-		return { success: installInManagedEnv.exitCode === 0, usedManagedEnv: true };
-	}
-
-	const createEnv = await $`${pythonPath} -m venv ${MANAGED_PYTHON_ENV}`.quiet().nothrow();
-	if (createEnv.exitCode !== 0) {
-		return { success: false, usedManagedEnv: true };
-	}
-
-	const managedPython = managedPythonPath();
-	const installInManagedEnv = await $`${managedPython} -m pip install ${packages}`.nothrow();
-	return { success: installInManagedEnv.exitCode === 0, usedManagedEnv: true };
-}
+// Python installation helper removed: the subprocess runner has no Python
+// package dependencies beyond a working interpreter. `omp setup python --check`
+// remains as a probe; users install optional libs (pandas, matplotlib, ...)
+// directly via pip or the in-process `%pip` magic.
 
 /**
  * Run the setup command.
@@ -232,67 +140,13 @@ async function handlePythonSetup(flags: { json?: boolean; check?: boolean }): Pr
 		console.log(chalk.dim(`Using managed environment: ${check.managedEnvPath}`));
 	}
 
-	if (check.uvPath) {
-		console.log(chalk.dim(`uv: ${check.uvPath}`));
-	} else if (check.pipPath) {
-		console.log(chalk.dim(`pip: ${check.pipPath}`));
-	}
-
-	if (check.installedPackages.length > 0) {
-		console.log(chalk.green(`${theme.status.success} Installed: ${check.installedPackages.join(", ")}`));
-	}
-
-	if (check.missingPackages.length === 0) {
+	if (check.available) {
 		console.log(chalk.green(`\n${theme.status.success} Python execution is ready`));
 		return;
 	}
 
-	console.log(chalk.yellow(`${theme.status.warning} Missing: ${check.missingPackages.join(", ")}`));
-
-	if (flags.check) {
-		process.exit(1);
-	}
-
-	if (!check.uvPath && !check.pipPath) {
-		console.error(chalk.red(`\n${theme.status.error} No package manager found`));
-		console.error(chalk.dim("Install uv (recommended) or pip:"));
-		console.error(chalk.dim("  curl -LsSf https://astral.sh/uv/install.sh | sh"));
-		process.exit(1);
-	}
-
-	console.log("");
-	const install = await installPythonPackages(check.missingPackages, check.pythonPath, check.uvPath, check.pipPath);
-
-	if (!install.success) {
-		console.error(chalk.red(`\n${theme.status.error} Installation failed`));
-		console.error(chalk.dim("Try installing manually:"));
-		if (install.usedManagedEnv) {
-			if (check.uvPath) {
-				console.error(chalk.dim(`  uv venv ${MANAGED_PYTHON_ENV}`));
-				console.error(
-					chalk.dim(`  uv pip install --python ${MANAGED_PYTHON_ENV} ${check.missingPackages.join(" ")}`),
-				);
-			} else {
-				console.error(chalk.dim(`  ${check.pythonPath} -m venv ${MANAGED_PYTHON_ENV}`));
-				console.error(chalk.dim(`  ${managedPythonPath()} -m pip install ${check.missingPackages.join(" ")}`));
-			}
-		} else {
-			console.error(chalk.dim(`  ${check.uvPath ? "uv pip" : "pip"} install ${check.missingPackages.join(" ")}`));
-		}
-		process.exit(1);
-	}
-
-	const recheck = await checkPythonSetup();
-	if (recheck.available) {
-		console.log(chalk.green(`\n${theme.status.success} Python execution is ready`));
-		if (recheck.usingManagedEnv) {
-			console.log(chalk.dim(`Managed Python environment: ${recheck.managedEnvPath}`));
-		}
-	} else {
-		console.error(chalk.red(`\n${theme.status.error} Setup incomplete`));
-		console.error(chalk.dim(`Still missing: ${recheck.missingPackages.join(", ")}`));
-		process.exit(1);
-	}
+	console.error(chalk.red(`\n${theme.status.error} Python interpreter reported failure`));
+	process.exit(1);
 }
 
 async function handleSttSetup(flags: { json?: boolean; check?: boolean }): Promise<void> {
@@ -359,9 +213,8 @@ ${chalk.bold("Usage:")}
   ${APP_NAME} setup <component> [options]
 
 ${chalk.bold("Components:")}
-  python    Install Jupyter kernel dependencies for Python code execution
+  python    Verify a Python 3 interpreter is reachable for code execution
   stt       Install speech-to-text dependencies (openai-whisper, recording tools)
-            Packages: ${PYTHON_PACKAGES.join(", ")}
 
 ${chalk.bold("Options:")}
   -c, --check   Check if dependencies are installed without installing

package/src/cli/stats-cli.ts

@@ -8,6 +8,58 @@ import { APP_NAME, formatDuration, formatNumber, formatPercent } from "@oh-my-pi
 import chalk from "chalk";
 import { openPath } from "../utils/open";
 
+/**
+ * Single-line TTY progress bar. On a non-TTY stream we just stay quiet -
+ * the final "Synced ..." summary still prints either way.
+ */
+function createSyncProgressReporter(): {
+	onProgress: (event: { current: number; total: number; sessionFile: string }) => void;
+	finish: () => void;
+} {
+	const stream = process.stderr;
+	const isTty = stream.isTTY === true;
+	let lastWidth = 0;
+	let lastRender = 0;
+	return {
+		onProgress(event) {
+			if (!isTty) return;
+			const now = Date.now();
+			// Throttle to ~30 fps and always force a render for the last file.
+			if (event.current < event.total && now - lastRender < 33) return;
+			lastRender = now;
+			const label = chalk.dim(shortenSessionFile(event.sessionFile));
+			const pct = ((event.current / event.total) * 100).toFixed(0).padStart(3, " ");
+			const counter = chalk.cyan(`[${event.current}/${event.total}]`);
+			const line = `${counter} ${pct}%  ${label}`;
+			const columns = stream.columns ?? 120;
+			const trimmed = truncateToColumns(line, columns - 1);
+			stream.write(`\r${trimmed.padEnd(lastWidth)}`);
+			lastWidth = trimmed.length;
+		},
+		finish() {
+			if (!isTty || lastWidth === 0) return;
+			stream.write(`\r${" ".repeat(lastWidth)}\r`);
+			lastWidth = 0;
+		},
+	};
+}
+
+function shortenSessionFile(p: string): string {
+	const marker = "/sessions/";
+	const idx = p.indexOf(marker);
+	return idx >= 0 ? p.slice(idx + marker.length) : p;
+}
+
+function truncateToColumns(s: string, max: number): string {
+	if (max <= 0) return "";
+	const width = Bun.stringWidth(s, { countAnsiEscapeCodes: false });
+	if (width <= max) return s;
+	// Cheap right-trim with an ellipsis - we don't need ANSI-aware slicing
+	// because the colored prefix is short and the truncated tail is the
+	// dim filename, where dropping bytes is fine.
+	return `${s.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+
 // =============================================================================
 // Types
 // =============================================================================
@@ -74,8 +126,10 @@ export async function runStatsCommand(cmd: StatsCommandArgs): Promise<void> {
 	);
 
 	// Sync session files first
-	console.log("Syncing session files...");
-	const { processed, files } = await syncAllSessions();
+	const progress = createSyncProgressReporter();
+	process.stderr.write("Syncing session files...\n");
+	const { processed, files } = await syncAllSessions({ onProgress: progress.onProgress });
+	progress.finish();
 	const total = await getTotalMessageCount();
 	console.log(`Synced ${processed} new entries from ${files} files (${total} total)\n`);
 

package/src/cli.ts

@@ -55,7 +55,6 @@ const commands: CommandEntry[] = [
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
 	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
 	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
-	{ name: "jupyter", load: () => import("./commands/jupyter").then(m => m.default) },
 	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
 	{ name: "shell", load: () => import("./commands/shell").then(m => m.default) },

package/src/config/model-registry.ts

@@ -2072,6 +2072,19 @@ export class ModelRegistry {
 		return this.#models.filter(model => this.#isModelAvailable(model));
 	}
 
+	/**
+	 * Check whether auth is configured for a model's provider.
+	 *
+	 * Mirrors the upstream `@mariozechner/pi-coding-agent` API surface so that
+	 * external plugins/extensions and downstream wrappers (e.g. subagent launch
+	 * paths that pre-flight auth before model resolution) can probe a model
+	 * without resolving an API key. Returns true for keyless providers as well
+	 * as providers with stored credentials. See issue #993.
+	 */
+	hasConfiguredAuth(model: Model<Api>): boolean {
+		return this.#keylessProviders.has(model.provider) || this.authStorage.hasAuth(model.provider);
+	}
+
 	getDiscoverableProviders(): string[] {
 		const disabledProviders = getDisabledProviderIdsFromSettings();
 		return this.#discoverableProviders

package/src/config/model-resolver.ts

@@ -16,7 +16,7 @@ import chalk from "chalk";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
 import { parseThinkingLevel, resolveThinkingLevelForModel } from "../thinking";
 import { fuzzyMatch } from "../utils/fuzzy";
-import { isAuthenticated, MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
+import { isAuthenticated, kNoAuth, MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
 import type { Settings } from "./settings";
 
 /** Default model IDs for each known provider */
@@ -743,6 +743,12 @@ export function resolveModelOverride(
  * `modelRoles.task` pointing at an unqualified id whose only available
  * provider variant has no configured credentials — see #985).
  *
+ * Keyless-by-design providers (llama.cpp, ollama, lm-studio) advertise the
+ * `kNoAuth` sentinel from `getApiKey` to signal that they do not require
+ * credentials. Those are treated as authenticated here so an explicitly
+ * configured local model is never silently rerouted to the parent's remote
+ * provider (see #1008).
+ *
  * If neither the subagent nor the parent has working auth, returns the
  * primary resolution unchanged so the existing error path still surfaces
  * a meaningful failure downstream.
@@ -764,7 +770,7 @@ export async function resolveModelOverrideWithAuthFallback(
 	}
 
 	const primaryKey = await modelRegistry.getApiKey(primary.model);
-	if (isAuthenticated(primaryKey)) {
+	if (primaryKey === kNoAuth || isAuthenticated(primaryKey)) {
 		return { ...primary, authFallbackUsed: false };
 	}