@estebanforge/pi-ask-antigravity 1.2.11 → 1.2.12

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.2.12] - 2026-10-10
+
+### Added
+
+- Peer prompts now carry a `[TIME BUDGET]` notice matching the resolved timeout (default 10 minutes), placed before the plan-mode guard banners so the safety constraints stay the last text the model reads. `timeoutMinutes` values that cannot arm a real timer (non-positive, non-finite, above the 35791-minute ceiling) are rejected with a clear error instead of arming an instant-kill watchdog.
+
+### Fixed
+
+- Project-scope config files resolve under `.pi/` again (`<project>/.pi/ask-*.json`): the shared-layer refactor passed the workspace root where the shared primitive expects the directory containing the file, so project configs would have been read from and written to the workspace root. Restores pre-refactor behavior.
+- The live stdout accumulator applies the original 1MB valve again (past 1MB, keep the last 100k) — the shared-layer refactor had left it uncapped.
+
+### Changed
+
+- **Internal dedup onto `pi-ask-shared` (behavior-preserving).** Config load/save composes the shared layered-config primitives (same homedir-based global path, same project-shadow routing, same atomic write); the spawn lifecycle (detached process group, SIGTERM→SIGKILL grace, watchdog, abort, settle-on-close) runs through the shared `runProcess`; the `agy models` line grammar, tiered alias resolution, plan-mode guard prompts, argv builder, and the SQLite conversation-id discovery technique moved to the shared peer adapter (`peers/antigravity.ts`). No user-facing behavior change: plan runs still never receive the skip-permissions flag (env-injected copies still stripped), conversation binding still disambiguates concurrent runs via the /proc FD scan, and the full test suite passes unchanged.
+
 ## [1.2.11] - 2026-10-07
 
 ### Added

package/README.md

@@ -113,7 +113,7 @@ Interactive picker for the default model and default thinking. If the project co
 | `mode` | no | `plan` (review-shaped; not enforced, see the modes table) or `accept-edits` (agy applies edits, default). |
 | `digest` | no | Prefix the prompt with `(Use compact digests, not full file contents.)`. Defaults on for `plan`, off for `accept-edits`. |
 | `conversationId` | no | Omit for a one-shot (agy starts fresh). Pass the id from a prior call's result (`details.conversationId`) to resume that agy conversation with full context. See [Two modes](#two-modes-one-shot-vs-continued-conversation). |
-| `timeoutMinutes` | no | Hard cap on the run. Default 10. |
+| `timeoutMinutes` | no | Hard cap on the agy run in minutes. Default 10. Above 0, at most 35791 (fractional minutes allowed). The prompt carries a matching `[TIME BUDGET]` notice; rejected values return a tool error without spawning. |
 
 ## Environment
 

package/extensions/index.ts

@@ -28,7 +28,7 @@
  *       so values containing spaces are not supported).
  */
 
-import { spawn } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -48,21 +48,45 @@ import { Type } from "typebox";
 import {
 	BackgroundRunRegistry,
 	backgroundFlagText,
+	buildAgyArgs,
+	buildFinalPrompt,
+	buildTimeBudgetNotice,
+	MAX_TIMEOUT_MINUTES,
+	compareVersionsDesc,
+	CONVERSATIONS_DIR,
+	CONV_ID_RE,
+	configPaths,
 	createStopHandler,
 	createWakeSender,
+	DEFAULT_LINE_BUF_MAX_CHARS,
+	filterHiddenModels,
+	levelToTier,
+	loadLayeredRaw,
+	mergeCatalog,
+	newConversationId,
+	parseModelLine,
+	resolveAgyModel,
+	RunSpawnError,
+	runProcess,
+	saveLayeredConfig,
+	snapshotConversations,
 	summarizePrompt,
+	tryReadJson,
+	type Mode,
+	type ModelEntry,
+	type ResolvedModel,
+	type SaveResult,
+	type ThinkingTier,
 } from "@estebanforge/pi-ask-shared";
 
 // --- Constants -------------------------------------------------------------
 
 const DEFAULT_TIMEOUT_MIN = 10;
-const GRACE_AFTER_TIMEOUT_MS = 5000;
 const STATUS_INTERVAL_MS = 1000;
 const STATUS_TAIL_CHARS = 160;
 const DISCOVERY_TIMEOUT_MS = 8_000;
 const DISCOVERY_POLL_ATTEMPTS = 5;
 const DISCOVERY_POLL_MS = 100;
-const GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "ask-antigravity.json");
 
 // renderCall / renderResult preview limits (match pi-claude-bridge).
 const PREVIEW_MAX_CHARS = 1000;
@@ -74,34 +98,11 @@ const DEFAULT_THINKING = "medium";
 // non-interactive -p mode (accept-edits auto-approves edits, NOT commands).
 const DEFAULT_SKIP_PERMISSIONS = true;
 
-// Per-family fallback tier when none is specified and no config default.
-// Flash defaults to medium (per spec); Pro only ships Low/High, so "latest
-// and greatest" = high.
-const FAMILY_DEFAULT_TIER: Record<Family, ThinkingTier> = {
-	flash: "medium",
-	pro: "high",
-	other: "medium",
-};
-
-const TIER_RANK: Record<ThinkingTier, number> = { low: 0, medium: 1, high: 2 };
-
-/** pi thinking-level vocabulary -> agy tier, for the thinking/effort tool
- *  params. Unknown values fall to low (agy always thinks something). */
-function levelToTier(level: string): ThinkingTier {
-	switch (level) {
-		case "minimal":
-		case "low":
-			return "low";
-		case "medium":
-			return "medium";
-		case "high":
-		case "xhigh":
-		case "max":
-			return "high";
-		default:
-			return "low";
-	}
-}
+// Per-family fallback tier, the pi->agy tier clamp (levelToTier), the static
+// alias overlay, and the line grammar now live in the shared peer adapter
+// (pi-ask-shared peers/antigravity.ts) alongside the argv builder and the
+// conversation-discovery technique, so pi-antigravity-bridge and pi-unblock
+// reuse the exact same resolution contract.
 
 // Mode = which agy tool-loop policy to apply. Distinct from the alias layer.
 //   "plan"         → --mode plan     (review-shaped; NOT a security boundary:
@@ -114,62 +115,6 @@ function levelToTier(level: string): ThinkingTier {
 // Note: agy's --sandbox flag is an orthogonal shell-containment setting
 // (not an "edit preview" mode), so it is not exposed here. Users who need
 // it can pass it via the AGY_EXTRA_ARGS env var.
-type Mode = "plan" | "accept-edits";
-
-// Static alias overlay for non-Gemini models agy may or may not surface in
-// `agy models` depending on plan. When the live catalog contains an entry
-// whose full string equals the overlay target, the live entry wins. When it
-// does not (older agy, missing model, plan gate), the overlay entry resolves
-// the alias so the user can still type "sonnet" and get a working answer.
-//   "sonnet"   -> claude-sonnet-5-5 (tiered low/medium/high like Gemini)
-//   "opus"     -> claude-opus-5-5 (tiered low/medium/high like Gemini)
-const STATIC_ALIAS_OVERLAY: ReadonlyArray<ModelEntry> = [
-	{ full: "claude-sonnet-5-5-low", family: "other", version: null, tier: "low" },
-	{ full: "claude-sonnet-5-5-medium", family: "other", version: null, tier: "medium" },
-	{ full: "claude-sonnet-5-5-high", family: "other", version: null, tier: "high" },
-	{ full: "claude-opus-5-5-low", family: "other", version: null, tier: "low" },
-	{ full: "claude-opus-5-5-medium", family: "other", version: null, tier: "medium" },
-	{ full: "claude-opus-5-5-high", family: "other", version: null, tier: "high" },
-];
-
-// Short alias → overlay full string. Used by resolveModel to recognize
-// friendly short names ("sonnet") that the family-parser (flash/pro) does
-// not match. The overlay entries are also merged into the live catalog for
-// exact-string passthrough, so this map only needs to cover the short names.
-const STATIC_SHORT_ALIAS: ReadonlyMap<string, string> = new Map([
-	["sonnet", "claude-sonnet-5-5"],
-	["opus", "claude-opus-5-5"],
-]);
-
-/** Families dropped outright even while `agy models` still lists them: the
- *  fixed-thinking single slug loses to the cheaper effort-tiered options and
- *  its removal upstream is already announced, so we stop offering it now. */
-const HIDDEN_FAMILY_RE = /^gpt-oss-/;
-
-/** Drop families we refuse to offer. Exported pure so tests exercise the
- *  same filter the live parse runs; discoverModels applies it per load. */
-export function filterHiddenModels(entries: ModelEntry[]): ModelEntry[] {
-	return entries.filter((e) => !HIDDEN_FAMILY_RE.test(e.full));
-}
-
-/** Merge the live catalog with the static alias overlay. Live entries win on
- *  case-insensitive full-string equality so an updated `agy models` listing
- *  always takes precedence over the hardcoded fallback. */
-export function mergeCatalog(live: ModelEntry[]): ModelEntry[] {
-	const seen = new Set(live.map((e) => e.full.toLowerCase()));
-	const merged = [...live];
-	for (const entry of STATIC_ALIAS_OVERLAY) {
-		if (!seen.has(entry.full.toLowerCase())) merged.push(entry);
-	}
-	return merged;
-}
-
-// agy conversation ids are UUID DB-stems (e.g. "9e6fdc2f-f9f9-4096-95fc-7852528b50cc").
-// Reject anything that isn't, so a leading-dash value can't misbind on agy's
-// arg parser as the token after --conversation. First char must be
-// alphanumeric (rejects leading-dash flag injection); hyphens allowed in the
-// body because real UUIDs contain them.
-const CONV_ID_RE = /^[A-Za-z0-9][A-Za-z0-9-]{0,127}$/;
 
 const AGY_DESCRIPTION = `Delegate a self-contained sub-task to Google Antigravity. agy is the CLI for Gemini, so this tool is reached under three equivalent names the user may use interchangeably: **gemini**, **antigravity**, and **agy**. When the user says "ask gemini", "ask antigravity", "ask agy", or otherwise refers to any of these, call THIS tool. agy runs its OWN tool loop: it can read, write, edit, and execute inside the workspace, then returns its final answer. Use for a second opinion from a different model family, Gemini-specific reasoning, or isolated sub-tasks you do not need to drive step-by-step. Provide a complete, self-contained task description; agy will not see this conversation.
 
@@ -191,24 +136,9 @@ THINKING LEVEL (params: thinking, effort - SYNONYMS for one knob):
 
 // --- Types -----------------------------------------------------------------
 
-type ThinkingTier = "low" | "medium" | "high";
 type Family = "flash" | "pro" | "other";
 
-export interface ModelEntry {
-	full: string; // exact agy slug, e.g. "gemini-3.6-flash-medium"
-	family: Family;
-	version: string | null; // "3.6"
-	tier: ThinkingTier | null;
-}
-
-/** Argv-facing model resolution: the exact --model slug plus an optional
- *  --effort tier. Gemini bases split the tier out (the base slug alone is
- *  invalid without --effort); fixed-thinking families keep agy's exact slug
- *  and carry no effort. */
-export interface ResolvedModel {
-	model: string;
-	effort?: ThinkingTier;
-}
+// --- Config ----------------------------------------------------------------
 
 interface Config {
 	defaultModel: string;
@@ -218,41 +148,18 @@ interface Config {
 	skipPermissions: boolean;
 }
 
-// --- Version helpers -------------------------------------------------------
-
-/** Descending numeric version compare. "3.10" > "3.9" (lexical sort would
- *  wrongly rank "3.9" higher because '9' > '1'). */
-function compareVersionsDesc(a: string, b: string): number {
-	const pa = a.split(".").map(Number);
-	const pb = b.split(".").map(Number);
-	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-		const da = pa[i] ?? 0;
-		const db = pb[i] ?? 0;
-		if (da !== db) return db - da; // descending
-	}
-	return 0;
-}
-
-// --- Config ----------------------------------------------------------------
-
-function projectConfigPath(): string {
-	return path.join(process.cwd(), ".pi", "ask-antigravity.json");
-}
-
-function tryReadJson(filePath: string): Record<string, unknown> {
-	if (!fs.existsSync(filePath)) return {};
-	try {
-		const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-		return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {};
-	} catch {
-		return {};
-	}
+/** Layered config paths: global is ~/.pi/agent (homedir, NOT getAgentDir —
+ *  today's shipped resolution for this extension); project is <cwd>/.pi. */
+function configPathsFor() {
+	return configPaths({
+		globalDir: path.join(os.homedir(), ".pi", "agent"),
+		projectDir: path.join(process.cwd(), ".pi"),
+		fileName: "ask-antigravity.json",
+	});
 }
 
 function loadConfig(): Config {
-	const global = tryReadJson(GLOBAL_CONFIG_PATH);
-	const project = tryReadJson(projectConfigPath());
-	const merged = { ...global, ...project };
+	const { merged } = loadLayeredRaw(configPathsFor());
 
 	const thinkingRaw = String(merged.defaultThinking ?? DEFAULT_THINKING).toLowerCase();
 	const thinking: ThinkingTier =
@@ -271,89 +178,19 @@ function loadConfig(): Config {
 	};
 }
 
-interface SaveResult {
-	path: string;
-	/** Keys whose effect is shadowed by a project config (info only). */
-	routedToProject: boolean;
-}
-
-/** Persist a config patch. If the project config already defines any patched
- *  key, write to the PROJECT file so the change actually takes effect
- *  (project shadows global on load); otherwise write to global.
- *  Atomic: temp file + rename, with temp cleanup on failure. */
+/** Persist a config patch via the shared all-or-nothing router: if any
+ *  patched key is already project-defined, the whole patch goes to the
+ *  project file (it shadows global on load). Atomic write inside. */
 function saveConfig(patch: Partial<Config>): SaveResult {
-	const projectRaw = tryReadJson(projectConfigPath());
-	const projectShadows = Object.keys(patch).some((k) => k in projectRaw);
-	const targetPath = projectShadows ? projectConfigPath() : GLOBAL_CONFIG_PATH;
-
-	const existing = tryReadJson(targetPath);
-	const next = { ...existing, ...patch };
-	const dir = path.dirname(targetPath);
-	fs.mkdirSync(dir, { recursive: true });
-
-	const tmp = `${targetPath}.${process.pid}.tmp`;
-	try {
-		fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + "\n", { mode: 0o600 });
-		fs.renameSync(tmp, targetPath);
-	} catch (err) {
-		try {
-			fs.unlinkSync(tmp);
-		} catch {}
-		throw err;
-	}
-	return { path: targetPath, routedToProject: projectShadows };
+	return saveLayeredConfig(configPathsFor(), patch as Record<string, unknown>);
 }
 
-// --- Prompt assembly -------------------------------------------------------
-
-/** Appended to every headless plan-mode prompt. `agy -p` cannot answer
- *  permission prompts: in plan mode a run_command attempt is soft-denied and
- *  the turn ends AT the denial (exit 0, empty stdout, notice only on stderr -
- *  the empty-output branch in execute). Probed 2026-09-28 on agy 1.2.12:
- *  allow rules ARE consulted (a verbatim allow-listed `git log` runs), but
- *  --sandbox does NOT relax the command gate, so the only input every user
- *  is guaranteed is the prompt itself. The guard steers the model to answer
- *  from that material. accept-edits runs keep their tools and never get it. */
-export const PLAN_HEADLESS_GUARD = [
-	"",
-	"--- Headless session constraints ---",
-	"- Do not run shell commands. Command execution is denied in this session, and any attempt ends the session immediately with no answer.",
-	"- Work only from the material provided in this prompt.",
-	"- If information you need is missing, state exactly what is missing in your answer instead of trying to fetch it.",
-].join("\n");
-
-/** Guard for plan runs backed by the restricted reviewer agent. Difference
- *  to PLAN_HEADLESS_GUARD: read commands are the intended analysis path
- *  here, so the guard forbids FILE MUTATION - by tool or by shell - and
- *  keeps the answer-from-material discipline. The agent is a damper, not
- *  enforcement (upstream #1181); a headless command attempt can still be
- *  auto-denied, which ends the run, so the guard steers toward view_file
- *  and staged material first. */
-export const AGENT_REVIEW_GUARD = [
-	"",
-	"--- Review constraints ---",
-	"- Read-only review. Do not create, modify, or delete any files, including through shell commands (no redirects, tee, rm, mv, git commit).",
-	"- Prefer the staged material and view_file for reading. If you run a read-only command (git log, git diff, rg, ls) and it comes back denied, the run ends without an answer: state what you could not check instead of retrying commands.",
-	"- Work from the material provided in this prompt; if information you need is missing, state exactly what is missing in your answer.",
-].join("\n");
-
-/** Assemble the prompt sent to agy: digest marker first (existing behavior),
- *  then the caller's prompt, then the plan-mode guard last - the position
- *  the model reads with the most recency. No user-config mutation: this is
- *  the only plan-mode lever the tool itself owns. */
-export function buildFinalPrompt(
-	prompt: string,
-	mode: Mode,
-	digest: boolean,
-	/** True when the restricted reviewer agent is staged: its empty edit
-	 *  toolset is a damper (the CLI does not enforce review-only, upstream
-	 *  #1181), so the prompt may ALLOW read-only commands. */
-	agentDamper = false,
-): string {
-	let out = digest ? `(Use compact digests, not full file contents.)\n${prompt}` : prompt;
-	if (mode === "plan") out += agentDamper ? AGENT_REVIEW_GUARD : PLAN_HEADLESS_GUARD;
-	return out;
-}
+// --- Prompt assembly: shared peer adapter ----------------------------------
+// The plan-mode guards (PLAN_HEADLESS_GUARD / AGENT_REVIEW_GUARD) and the
+// prompt assembler (buildFinalPrompt) live in pi-ask-shared
+// (peers/antigravity.ts) so the bridge's ask-tool and pi-unblock consults
+// inherit the identical guard discipline.
+export { AGENT_REVIEW_GUARD, PLAN_HEADLESS_GUARD } from "@estebanforge/pi-ask-shared";
 
 // --- Plan-mode reviewer agent ----------------------------------------------
 
@@ -451,204 +288,10 @@ function pidAlive(pid: number): boolean {
 	}
 }
 
-// --- Model parsing + alias resolution --------------------------------------
-
-/** Parse one `agy models` line into a structured entry. */
-export function parseModelLine(line: string): ModelEntry | null {
-	// agy prints TWO columns: "<slug>  <display label>". --model takes only the
-	// slug (col 1), so split it off; the label is display-only. A bare-slug line
-	// (no whitespace) splits to itself.
-	const full = line.trim().split(/\s+/)[0] ?? "";
-	if (!full) return null;
-
-	const lower = full.toLowerCase();
-	const family: Family = lower.includes("flash")
-		? "flash"
-		: lower.includes("pro")
-			? "pro"
-			: "other";
-
-	const versionMatch = lower.match(/(\d+\.\d+)/);
-	const version = versionMatch ? versionMatch[1] : null;
-
-	const tierMatch = lower.match(/-(low|medium|high)$/);
-	const tier = tierMatch ? (tierMatch[1] as ThinkingTier) : null;
-
-	return { full, family, version, tier };
-}
-
-/** Pick the available tier closest in rank to the preferred one. Distance
- *  ties (e.g. Low/High around Medium) break toward the higher tier so
- *  "latest and greatest" wins when a family lacks the requested tier. */
-function nearestTier(available: ThinkingTier[], preferred: ThinkingTier): ThinkingTier {
-	if (available.includes(preferred)) return preferred;
-	const sorted = [...available].sort((a, b) => {
-		const da = Math.abs(TIER_RANK[a] - TIER_RANK[preferred]);
-		const db = Math.abs(TIER_RANK[b] - TIER_RANK[preferred]);
-		return da !== db ? da - db : TIER_RANK[b] - TIER_RANK[a];
-	});
-	return sorted[0] ?? preferred;
-}
-
-/** Build the argv-facing resolution from a picked catalog entry. Gemini and
- *  Claude bases (slugs starting "gemini-"/"claude-") accept a separate
- *  --effort, so split the tier suffix out of the slug: the base alone
- *  (claude-sonnet-5-5) is what --model wants, and the tier goes to --effort
- *  (agy rejects a bare base: "requires --effort"). Only unverified families
- *  keep agy's exact slug whole, so an unknown suffix can never trigger an
- *  unsupported --effort. */
-function toResolved(full: string, tier: ThinkingTier | null): ResolvedModel {
-	if (tier && /^(gemini|claude)-/.test(full.toLowerCase())) {
-		return { model: full.replace(/-(low|medium|high)$/, ""), effort: tier };
-	}
-	return { model: full };
-}
-
-/** Resolve a tiered base id - a short-alias target ("claude-sonnet-5-5") or a
- *  bare base slug the provider itself advertises - to the catalog variant
- *  nearest the requested tier. A bare base alone is invalid upstream
- *  ("requires --effort"), so the pick always rides the split in toResolved;
- *  with no variants in the catalog, the overlay/exact entry or the raw base
- *  passes through unchanged. */
-function resolveTieredBase(
-	base: string,
-	entries: ModelEntry[],
-	defaultThinking: ThinkingTier,
-	preferredTier: ThinkingTier | undefined,
-): ResolvedModel {
-	const needle = base.toLowerCase();
-	const variants = entries.filter((e) => e.full.toLowerCase().startsWith(`${needle}-`));
-	if (variants.length > 0) {
-		const tiers = variants.map((e) => e.tier).filter((t): t is ThinkingTier => t !== null);
-		const preferred =
-			preferredTier ??
-			(tiers.includes(defaultThinking) ? defaultThinking : FAMILY_DEFAULT_TIER.other);
-		const chosen = nearestTier(tiers, preferred);
-		const picked = variants.find((e) => e.tier === chosen) ?? variants[0];
-		return toResolved(picked.full, picked.tier);
-	}
-	const fromCatalog = entries.find((e) => e.full.toLowerCase() === needle);
-	return toResolved(fromCatalog?.full ?? base, fromCatalog?.tier ?? null);
-}
-
-/**
- * Resolve a friendly alias / partial name to an argv-facing {model, effort?}.
- * Returns null only when the family is unrecognized; the caller then passes
- * the raw input straight to agy.
- */
-export function resolveModel(
-	input: string,
-	entries: ModelEntry[],
-	defaultThinking: ThinkingTier,
-	/** Explicit thinking param (thinking/effort). Beats a tier embedded in
-	 *  the alias ("flash high") and the configured default; clamped to the
-	 *  family's real tiers, ignored for fixed-thinking families. */
-	preferredTier?: ThinkingTier,
-): ResolvedModel | null {
-	const lower = input.toLowerCase().trim();
-
-	// 1. Exact full-string match (case-insensitive).
-	const exact = entries.find((e) => e.full.toLowerCase() === lower);
-	if (exact) return toResolved(exact.full, exact.tier);
-
-	// 1b. Static short alias ("sonnet" / "opus"). Checked
-	//     before the family parser because none of these names contain
-	//     "flash" or "pro" and would otherwise return null below. The
-	//     resolved full string is then re-validated against the catalog
-	//     in step 1's second pass on the next call, so renaming the
-	//     overlay entry in code still wins on exact-string match.
-	//     The case-insensitive lookup matches mergeCatalog's dedup logic
-	//     so the "live entries win" guarantee holds even when agy lists
-	//     the model under different casing than the overlay.
-	if (STATIC_SHORT_ALIAS.has(lower)) {
-		return resolveTieredBase(
-			STATIC_SHORT_ALIAS.get(lower) as string,
-			entries,
-			defaultThinking,
-			preferredTier,
-		);
-	}
-
-	// 2. Parse the alias.
-	let family: Family | null = lower.includes("flash")
-		? "flash"
-		: lower.includes("pro")
-			? "pro"
-			: null;
-	const versionMatch = lower.match(/(\d+\.\d+)/);
-	const version = versionMatch ? versionMatch[1] : null;
-	const tierMatch = lower.match(/\b(low|medium|high)\b/);
-	const tier = tierMatch ? (tierMatch[1] as ThinkingTier) : null;
-
-	// "gemini" alone, "default", or empty -> default family (flash).
-	if (!family && (/gemini/.test(lower) || lower === "" || lower === "default")) {
-		family = "flash";
-	}
-	if (!family) {
-		// A bare base slug the provider itself advertises ("claude-sonnet-5-5",
-		// the id behind the antigravity/ entry in pi's picker) is invalid
-		// upstream without an effort: resolve it to the nearest tier variant
-		// exactly like the short aliases.
-		if (
-			entries.some((e) => e.full.toLowerCase().startsWith(`${lower}-`)) ||
-			entries.some((e) => e.full.toLowerCase() === lower)
-		) {
-			return resolveTieredBase(lower, entries, defaultThinking, preferredTier);
-		}
-		return null; // unknown family -> let agy handle it
-	}
-
-	// 3. Filter by family.
-	let candidates = entries.filter((e) => e.family === family);
-	if (candidates.length === 0) return null;
-
-	// 4. Pin version if specified; otherwise pick the HIGHEST version
-	//    (numeric compare, not lexical — see compareVersionsDesc).
-	if (version) {
-		const versioned = candidates.filter((e) => e.version === version);
-		if (versioned.length > 0) candidates = versioned;
-	} else {
-		// Prefer Google's official `gemini-*-latest` aliases (entries with no
-		// parseable version in their name, e.g. "Gemini Flash Latest") when
-		// the user did NOT pin a specific version. The alias is the
-		// versionless pointer Google intends for "the current release" and
-		// hot-swaps on every release, while versioned entries like
-		// "Gemini 3.6 Flash (Medium)" stay available via explicit pinning
-		// (e.g. "3.6 flash medium"). Falls back to the highest versioned
-		// entry if no alias is present in the catalog.
-		const aliases = candidates.filter((e) => e.version === null);
-		if (aliases.length > 0) {
-			candidates = aliases;
-		} else {
-			const versions = candidates
-				.map((e) => e.version)
-				.filter((v): v is string => v !== null)
-				.sort(compareVersionsDesc);
-			if (versions.length > 0) {
-				const top = versions[0];
-				const latest = candidates.filter((e) => e.version === top);
-				if (latest.length > 0) candidates = latest;
-			}
-		}
-	}
-
-	// 5. Pick tier: explicit > config default (if the family offers it) >
-	//    family default. Pro has no Medium, so "pro" + default medium falls
-	//    back to the Pro family default (High), not nearest-Medium.
-	const familyTiers = new Set(
-		candidates.map((e) => e.tier).filter((t): t is ThinkingTier => t !== null),
-	);
-	if (familyTiers.size === 0) return toResolved(candidates[0].full, null); // no tiers on any entry
-
-	const preferred =
-		preferredTier ??
-		tier ??
-		(familyTiers.has(defaultThinking) ? defaultThinking : FAMILY_DEFAULT_TIER[family]);
-	const chosenTier = nearestTier([...familyTiers], preferred);
-	const picked = candidates.find((e) => e.tier === chosenTier) ?? candidates[0];
-	return toResolved(picked.full, picked.tier);
-}
-
+// --- Model parsing + alias resolution: shared peer adapter ---------------
+// parseModelLine, the tier ladder, and resolveModel (family/version/tier
+// resolution incl. the static sonnet/opus overlay) live in pi-ask-shared
+// (peers/antigravity.ts); discoverModels below feeds them the live catalog.
 // --- agy process helpers ---------------------------------------------------
 
 function resolveAgy(): string {
@@ -750,150 +393,10 @@ function extraArgs(): string[] {
 	return raw ? raw.split(/\s+/).filter((s) => s.length > 0) : [];
 }
 
-// --- Conversation discovery (the one technique borrowed from antigravity-acp) --
-// agy -p does NOT print the conversation id, so for a fresh prompt we snapshot
-// the conversations dir before spawn and pick the single new .db after. For a
-// continued call we pass --conversation <id> and agy reuses it (no new file).
-
-const CONVERSATIONS_DIR =
-	process.env.AGY_CONVERSATIONS_DIR ||
-	path.join(os.homedir(), ".gemini", "antigravity-cli", "conversations");
-
-/** Snapshot the set of conversation ids (*.db stems) currently on disk. */
-function snapshotConversations(dir: string): Set<string> {
-	const out = new Set<string>();
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(dir);
-	} catch {
-		return out;
-	}
-	for (const f of entries) {
-		if (f.endsWith(".db")) out.add(f.slice(0, -3));
-	}
-	return out;
-}
-
-/** Resolve which of the `candidates` DB ids is held open by the process tree
- *  rooted at `rootPid`. Used to disambiguate concurrent agy runs. Returns the
- *  single matching id, or null when none/several are open or /proc is
- *  unavailable. Ported from pi-antigravity-bridge src/discovery.ts; keep in
- *  sync. */
-type OpenDbResolver = (
-	rootPid: number,
-	dir: string,
-	candidates: Set<string>,
-) => string | null;
-
-function readProcStat(pid: number): { pid: number; ppid: number } | null {
-	let raw: string;
-	try {
-		raw = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
-	} catch {
-		return null;
-	}
-	const closeParen = raw.lastIndexOf(")");
-	if (closeParen < 0) return null;
-	const fields = raw.slice(closeParen + 2).trim().split(/\s+/);
-	const ppid = Number(fields[1]);
-	if (!Number.isFinite(ppid)) return null;
-	return { pid, ppid };
-}
-
-function collectDescendants(rootPid: number): Set<number> {
-	const out = new Set<number>([rootPid]);
-	let entries: string[];
-	try {
-		entries = fs.readdirSync("/proc");
-	} catch {
-		return out;
-	}
-	const ppidOf = new Map<number, number>();
-	for (const e of entries) {
-		if (!/^\d+$/.test(e)) continue;
-		const s = readProcStat(Number(e));
-		if (s) ppidOf.set(s.pid, s.ppid);
-	}
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const [pid, ppid] of ppidOf) {
-			if (out.has(pid)) continue;
-			if (out.has(ppid)) {
-				out.add(pid);
-				changed = true;
-			}
-		}
-	}
-	return out;
-}
-
-function safeRealpath(p: string): string | null {
-	try {
-		return fs.realpathSync(p);
-	} catch {
-		return null;
-	}
-}
-
-const procTreeOpenDbResolver: OpenDbResolver = (rootPid, dir, candidates) => {
-	if (candidates.size <= 1) return null;
-	if (process.platform !== "linux") return null;
-	const dirResolved = safeRealpath(dir);
-	const tree = collectDescendants(rootPid);
-	const found = new Set<string>();
-	for (const pid of tree) {
-		let fds: string[];
-		try {
-			fds = fs.readdirSync(`/proc/${pid}/fd`);
-		} catch {
-			continue;
-		}
-		for (const fd of fds) {
-			let target: string;
-			try {
-				target = fs.readlinkSync(`/proc/${pid}/fd/${fd}`);
-			} catch {
-				continue;
-		}
-			const base = path.basename(target);
-			if (!base.endsWith(".db")) continue;
-			if (dirResolved && safeRealpath(path.dirname(target)) !== dirResolved) continue;
-			const id = base.slice(0, -3);
-			if (candidates.has(id)) found.add(id);
-		}
-	}
-	if (found.size === 1) return [...found][0] ?? null;
-	return null;
-};
-
-interface BindOptions {
-	pid?: number;
-	resolveOpenDb?: OpenDbResolver;
-}
-
-/** Find the conversation id created since `before`. Returns null when none
- *  appeared, or when several appeared and we cannot tie one to our process.
- *  Pass `opts.pid` (the spawned agy) to enable concurrent-run disambiguation
- *  via the process-tree FD scan. */
-function newConversationId(
-	dir: string,
-	before: Set<string>,
-	opts: BindOptions = {},
-): string | null {
-	const created = [...snapshotConversations(dir)].filter((id) => !before.has(id));
-	if (created.length === 0) return null;
-	if (created.length === 1) return created[0] ?? null;
-	// Ambiguous: try to authoritatively identify ours via the spawned
-	// process's open files. Fail safe to null when we can't pick exactly one.
-	if (opts.pid !== undefined) {
-		const resolve = opts.resolveOpenDb ?? procTreeOpenDbResolver;
-		const hit = resolve(opts.pid, dir, new Set(created));
-		if (hit && created.includes(hit)) return hit;
-	}
-	return null;
-}
-
+// --- Conversation discovery: shared peer adapter ---------------------------
+// The .db snapshot / new-id pick / /proc FD disambiguation technique lives
+// in pi-ask-shared (peers/antigravity.ts): snapshotConversations +
+// newConversationId. CONVERSATIONS_DIR (env-overridable) is exported there.
 // --- Full-context export (opt-in includeContext) --------------------------
 // NOTE: duplicated per pi-ask-* package (each is self-contained). Duck-typed
 // over role/content to tolerate AgentMessage's union + custom message types.
@@ -1004,8 +507,9 @@ interface ProcessRunOptions {
 	signal?: AbortSignal;
 	/** Blocking only: throttled progress partials. */
 	onPartial?: (text: string) => void;
-	/** Background only: hands over the tree-kill switch as soon as the child exists. */
-	onSpawn?: (kill: () => void) => void;
+	/** Background only: hands over the tree-kill switch plus the live child
+	 *  handle (pid for the FD-disambiguation poll) as soon as the child exists. */
+	onSpawn?: (kill: () => void, proc: ChildProcess) => void;
 }
 
 interface ProcessRunOutcome {
@@ -1041,128 +545,51 @@ async function runAgyProcess(opts: ProcessRunOptions): Promise<ProcessRunOutcome
 		: null;
 
 	try {
-		// Bind the conversation id DURING the run (agy is alive then) so the
-		// pid-based /proc FD resolver can disambiguate when a concurrent agy
-		// also drops a new .db. Awaited after the run; the post-exit loop
-		// below is the fallback for runs that exit before the poll binds.
+		// Concurrent bind poll: while agy is ALIVE, the pid-based /proc FD
+		// resolver can disambiguate when a concurrent agy also drops a new
+		// .db. runProcess hands us the kill switch plus the spawned process
+		// through onSpawn; the pid is only useful while the tree lives, and
+		// the post-exit scan below is the fallback once it is gone.
 		let bindDuringRun: Promise<void> = Promise.resolve();
-		const outcome = await new Promise<{
-			exitCode: number;
-			aborted: boolean;
-			timedOut: boolean;
-		}>((resolveP, rejectP) => {
-			// detached: true so we can signal the whole process group.
-			// agy spawns its own exec subprocesses in -p mode; a direct
-			// kill would orphan those grandchildren.
-			const proc = spawn(binary, args, {
-				cwd: workdir,
-				stdio: ["ignore", "pipe", "pipe"],
-				shell: false,
-				detached: true,
-			});
-
-			// Decode at the stream level so multibyte UTF-8 split across
-			// pipe chunks doesn't corrupt (Gemini output is non-ASCII).
-			proc.stdout?.setEncoding("utf8");
-			proc.stderr?.setEncoding("utf8");
 
-			proc.stdout?.on("data", (d: string) => {
-				out += d;
-				// Safety valve for pathological output; keeps the tail.
-				if (out.length > STDOUT_BUF_MAX_CHARS) out = out.slice(-100_000);
-			});
-			proc.stderr?.on("data", (d: string) => {
-				// Cap: stderr feeds notes and wake messages, not forensics.
-				if (details.stderr.length < 64_000) details.stderr += d;
-			});
-
-			// Concurrent bind: poll for the new id while agy is alive. The FD
-			// resolver needs a live process tree, so this stops (and the
-			// post-exit fallback below takes over) once agy has exited.
-			if (!isContinuation && snapshot && proc.pid) {
-				bindDuringRun = (async () => {
-					for (let attempt = 0; attempt < DISCOVERY_POLL_ATTEMPTS; attempt++) {
-						if (details.conversationId) return;
-						if (proc.exitCode !== null) return; // agy gone: scan useless now
-						const found = newConversationId(CONVERSATIONS_DIR, snapshot, {
-							pid: proc.pid,
-						});
-						if (found) {
-							details.conversationId = found;
-							return;
+		const outcome = await runProcess({
+			binary,
+			args,
+			cwd: workdir,
+			timeoutMs: timeoutMin * 60_000,
+			signal,
+			// Raw chunks stream live so the status tail matches the old
+			// during-run accumulation. The 1MB valve lives in runProcess for
+			// stdoutRaw; this accumulator applies the original's own valve
+			// (past 1MB, keep the last 100k) so a pathological stream cannot
+			// balloon memory through the live tail.
+			onChunk: (chunk) => {
+				out += chunk;
+				if (out.length > DEFAULT_LINE_BUF_MAX_CHARS) out = out.slice(-100_000);
+			},
+			onSpawn: (kill, proc) => {
+				// Hand the kill switch to the background registry first, then
+				// start the bind poll against the live pid.
+				onSpawn?.(kill, proc);
+				if (!isContinuation && snapshot && proc.pid) {
+					bindDuringRun = (async () => {
+						for (let attempt = 0; attempt < DISCOVERY_POLL_ATTEMPTS; attempt++) {
+							if (details.conversationId) return;
+							if (proc.exitCode !== null) return; // agy gone: scan useless now
+							const found = newConversationId(CONVERSATIONS_DIR, snapshot, {
+								pid: proc.pid,
+							});
+							if (found) {
+								details.conversationId = found;
+								return;
+							}
+							await sleep(DISCOVERY_POLL_MS);
 						}
-						await sleep(DISCOVERY_POLL_MS);
-					}
-				})().catch(() => {
-					/* best-effort: a bind error must never fail an otherwise-OK turn */
-				});
-			}
-
-			let sigkillTimer: ReturnType<typeof setTimeout> | undefined;
-			let watchdog: ReturnType<typeof setTimeout> | undefined;
-			let settled = false;
-			let timedOut = false;
-
-			// Kill the whole process group; SIGTERM first, then SIGKILL
-			// after a grace period if it hasn't exited.
-			const killTree = () => {
-				try {
-					if (proc.pid) process.kill(-proc.pid, "SIGTERM");
-				} catch {}
-				// Only arm the SIGKILL timer once.
-				if (!sigkillTimer) {
-					sigkillTimer = setTimeout(() => {
-						try {
-							if (proc.pid) process.kill(-proc.pid, "SIGKILL");
-						} catch {}
-					}, GRACE_AFTER_TIMEOUT_MS);
+					})().catch(() => {
+						/* best-effort: a bind error must never fail an otherwise-OK turn */
+					});
 				}
-			};
-
-			// Hand the kill switch to the background registry before any terminal event can fire.
-			onSpawn?.(killTree);
-
-			const cleanup = () => {
-				if (watchdog) clearTimeout(watchdog);
-				if (sigkillTimer) clearTimeout(sigkillTimer);
-				if (signal) signal.removeEventListener("abort", onAbort);
-			};
-
-			const onAbort = () => killTree();
-
-			// Enforce the timeout cap ourselves (not just via
-			// --print-timeout, which agy could ignore or not support).
-			watchdog = setTimeout(() => {
-				timedOut = true;
-				killTree();
-			}, timeoutMin * 60_000);
-
-			if (signal) {
-				if (signal.aborted) killTree();
-				else signal.addEventListener("abort", onAbort, { once: true });
-			}
-
-			const finish = (code: number | null) => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				// Distinguish an aborted run from a normal close: if the
-				// abort signal fired, treat as cancelled regardless of
-				// exit code (killTree produces a non-zero code, but be
-				// explicit and order-independent). Likewise surface a
-				// timeout distinctly from a genuine non-zero exit.
-				resolveP({
-					exitCode: code ?? 0,
-					aborted: !!signal?.aborted,
-					timedOut,
-				});
-			};
-
-			proc.on("error", () => {
-				cleanup();
-				rejectP(new AgySpawnError("failed to spawn agy"));
-			});
-			proc.on("close", finish);
+			},
 		});
 
 		if (statusInterval) clearInterval(statusInterval);
@@ -1171,6 +598,9 @@ async function runAgyProcess(opts: ProcessRunOptions): Promise<ProcessRunOutcome
 		// has exited, so this rarely blocks).
 		await bindDuringRun;
 
+		// stderr feeds notes and wake messages, not forensics; runProcess
+		// applies the same 64k cap the inline accumulator used to.
+		details.stderr = outcome.stderr;
 		details.exitCode = outcome.exitCode;
 		details.aborted = outcome.aborted;
 		details.timedOut = outcome.timedOut;
@@ -1192,6 +622,10 @@ async function runAgyProcess(opts: ProcessRunOptions): Promise<ProcessRunOutcome
 		}
 
 		return { ...outcome, answerText: out.trim() };
+	} catch (err) {
+		// Preserve the extension's spawn-error contract (fixed message).
+		if (err instanceof RunSpawnError) throw new AgySpawnError("failed to spawn agy");
+		throw err;
 	} finally {
 		if (statusInterval) clearInterval(statusInterval);
 	}
@@ -1331,7 +765,7 @@ export default async function (pi: ExtensionAPI) {
 						`  defaultModel:    ${config.defaultModel}`,
 						`  defaultThinking: ${config.defaultThinking}`,
 						`  permissions:     ${config.skipPermissions ? "auto-approved" : "prompt"}`,
-						`  resolved:        ${resolveModel(config.defaultModel, discovered, config.defaultThinking)?.model ?? "(agy default)"}`,
+						`  resolved:        ${resolveAgyModel(config.defaultModel, discovered, config.defaultThinking)?.model ?? "(agy default)"}`,
 						``,
 						`Edit: ~/.pi/agent/ask-antigravity.json`,
 					].join("\n"),
@@ -1342,7 +776,7 @@ export default async function (pi: ExtensionAPI) {
 
 			// Resolve the display string for the current default model.
 			const currentResolved =
-				resolveModel(config.defaultModel, discovered, config.defaultThinking)?.model ?? config.defaultModel;
+				resolveAgyModel(config.defaultModel, discovered, config.defaultThinking)?.model ?? config.defaultModel;
 
 			const items: SettingItem[] = [
 				{
@@ -1352,7 +786,7 @@ export default async function (pi: ExtensionAPI) {
 						"Friendly alias resolved to the latest matching agy model. 'flash' = latest Flash, 'pro' = latest Pro, 'gemini' = latest Flash.",
 					currentValue: `${config.defaultModel} → ${currentResolved}`,
 					values: MODEL_OPTIONS.map((m) => {
-						const r = resolveModel(m, discovered, config.defaultThinking)?.model ?? m;
+						const r = resolveAgyModel(m, discovered, config.defaultThinking)?.model ?? m;
 						return `${m} → ${r}`;
 					}),
 				},
@@ -1499,7 +933,7 @@ export default async function (pi: ExtensionAPI) {
 			),
 			timeoutMinutes: Type.Optional(
 				Type.Number({
-					description: `Hard cap on the agy run in minutes. Default ${DEFAULT_TIMEOUT_MIN}.`,
+					description: `Hard cap on the agy run in minutes. Default ${DEFAULT_TIMEOUT_MIN}. Fractional minutes allowed; must be above 0 and at most ${MAX_TIMEOUT_MINUTES}. The prompt carries a matching [TIME BUDGET] notice.`,
 				}),
 			),
 			includeContext: Type.Optional(
@@ -1523,8 +957,8 @@ export default async function (pi: ExtensionAPI) {
 			const cfg = loadConfig();
 			const requestedModel = (args.model as string | undefined)?.trim() || cfg.defaultModel;
 			const thinkingArg = (args.thinking as string | undefined) ?? (args.effort as string | undefined);
-			const resolved =
-				resolveModel(
+			const resolved: ResolvedModel =
+				resolveAgyModel(
 					requestedModel,
 					discovered,
 					cfg.defaultThinking,
@@ -1651,8 +1085,8 @@ export default async function (pi: ExtensionAPI) {
 				};
 			}
 			const thinkingArg = (params.thinking as string | undefined) ?? (params.effort as string | undefined);
-			const resolved =
-				resolveModel(
+			const resolved: ResolvedModel =
+				resolveAgyModel(
 					requestedModel,
 					discovered,
 					config.defaultThinking,
@@ -1681,6 +1115,14 @@ export default async function (pi: ExtensionAPI) {
 			}
 
 			const timeoutMin = params.timeoutMinutes ?? DEFAULT_TIMEOUT_MIN;
+			if (!(timeoutMin > 0 && Number.isFinite(timeoutMin) && timeoutMin <= MAX_TIMEOUT_MINUTES)) {
+				// timeoutMinutes: 0 would arm runProcess's watchdog with a 0ms
+				// timeout (Node clamps to 1ms) and kill the peer instantly.
+				return {
+					content: [{ type: "text", text: `timeoutMinutes must be a positive number of minutes up to ${MAX_TIMEOUT_MINUTES} (for example 0.5 for 30 seconds).` }],
+					details: emptyDetails(requestedModel, resolved.model),
+				};
+			}
 
 			// Continuity: if a conversationId is provided AND validates as an agy
 			// id (UUID-ish DB stem, never a leading-dash flag), resume it; otherwise
@@ -1716,8 +1158,13 @@ export default async function (pi: ExtensionAPI) {
 				typeof params.digest === "boolean"
 					? params.digest
 					: mode === "plan";
+			// Budget notice into the prompt BEFORE buildFinalPrompt: the plan-mode
+			// guard banners must stay the final text (last-read recency), so the
+			// notice can't go after them. The builder itself stays notice-free so
+			// callers can't double-wrap.
+			const budget = buildTimeBudgetNotice(timeoutMin * 60_000);
 			const finalPrompt: string = buildFinalPrompt(
-				params.prompt,
+				budget ? `${params.prompt}\n\n${budget}` : params.prompt,
 				mode,
 				useDigest,
 				reviewerAgent !== null,
@@ -1746,40 +1193,20 @@ export default async function (pi: ExtensionAPI) {
 				? `The full pi conversation context (as markdown) is at: ${contextFile}\nRead that file first for context, then do the task below.\n\n---\n\n${finalPrompt}`
 				: finalPrompt;
 
-			const args: string[] = ["--add-dir", cwd];
-			const extraRaw = extraArgs();
-			// Fail-closed on every plan run: AGY_EXTRA_ARGS lands before the mode
-			// flags, so an env-injected skip flag would re-arm exactly what the
-			// never-flag-on-plan rule withholds (upstream #1181: an auto-approved
-			// plan run is write-capable). The reviewer agent is a damper, not a
-			// license for the flag.
-			const extra =
-				mode === "plan"
-					? extraRaw.filter((a) => !a.startsWith("--dangerously-skip-permissions"))
-					: extraRaw;
-			if (extra.length) args.push(...extra);
-			if (resolved.model) args.push("--model", resolved.model);
-			if (resolved.effort) args.push("--effort", resolved.effort);
-			args.push("--mode", mode);
-			if (reviewerAgent) args.push("--agent", reviewerAgent.name);
-			// accept-edits auto-approves file edits but NOT shell commands, so a
-			// run_command would hang on an unanswerable y/n prompt in non-interactive
-			// -p mode. Honor the shared permissions setting (same knob as the bridge).
-			// Plan runs NEVER get the flag: it auto-approves every permission
-			// request, and the CLI does not gate writes under plan mode (upstream
-			// google-antigravity/antigravity-cli#1181, probed 2026-10-07), so an
-			// auto-approved plan run is a write-capable run. The reviewer agent's
-			// toolset is a damper, not a guarantee; the 2026-09-28 "safe with the
-			// restricted toolset" probe predates the #1181 evidence. Without the
-			// flag, command attempts fail visibly (headless auto-deny) instead of
-			// running approved.
-			if (config.skipPermissions && mode !== "plan") {
-				args.push("--dangerously-skip-permissions");
-			}
-			if (isContinuation) args.push("--conversation", rawConvId as string);
-			args.push("--print-timeout", `${timeoutMin}m`);
-			if (contextFile) args.push("--add-dir", askContextDir());
-			args.push("-p", effectivePrompt);
+			// Build argv via the shared peer adapter (see buildAgyArgs there for
+			// the flag-order contract and the fail-closed plan-run rules).
+			const args = buildAgyArgs({
+				cwd,
+				resolved,
+				mode,
+				reviewerAgentName: reviewerAgent?.name ?? null,
+				skipPermissions: config.skipPermissions,
+				conversationId: isContinuation ? (rawConvId as string) : null,
+				timeoutMinutes: timeoutMin,
+				addDirs: contextFile ? [askContextDir()] : [],
+				extraArgs: extraArgs(),
+				prompt: effectivePrompt,
+			});
 
 			const details: AgyDetails = {
 				model: requestedModel,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@estebanforge/pi-ask-antigravity",
-  "version": "1.2.11",
+  "version": "1.2.12",
   "description": "Pi tool that delegates a self-contained sub-task to Google Antigravity's agy CLI (the CLI for Gemini). Friendly model aliases (flash/pro/gemini), configurable default model + thinking, and the AskAntigravity delegation tool.",
   "keywords": [
     "pi-package",
@@ -28,7 +28,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@estebanforge/pi-ask-shared": "^0.1.0"
+    "@estebanforge/pi-ask-shared": "^0.1.2"
   },
   "files": [
     "extensions",