@diegopetrucci/pi-extensions 0.1.26 → 0.1.28

package/README.md

@@ -11,11 +11,11 @@ A collection of [pi](https://github.com/earendil-works/pi-mono) agent extensions
 - [`minimal-footer`](./extensions/minimal-footer): Replaces pi's built-in footer with a minimal configurable two-line layout: branch/repo on the first line, context/model on the second, optional `DUMB ZONE`, plus OpenAI Codex 5-hour and 7-day usage when available.
 - [`notify`](./extensions/notify): Sends configurable terminal, desktop, bell, and sound notifications when pi finishes and is ready for input.
 - [`openai-fast`](./extensions/openai-fast): Adds `/fast` to enable OpenAI Codex Fast mode for ChatGPT-auth GPT-5.4 and GPT-5.5 by injecting the priority service tier.
-- [`oracle`](./extensions/oracle): Adds an Amp-style read-only oracle tool that auto-selects the strongest reasoning model on the current provider/subscription, covers pi’s built-in providers with hardcoded rankings, sets reasoning to xhigh by default, and shows live status while running.
+- [`oracle`](./extensions/oracle): Adds an Amp-style read-only oracle tool that auto-selects the strongest reasoning model on the current provider/subscription, covers pi’s built-in providers (including Together) with hardcoded rankings, requests xhigh reasoning by default and clamps to model capabilities, and shows live status while running.
 - [`permission-gate`](./extensions/permission-gate): Prompts for confirmation before dangerous bash commands like `rm -rf`, `sudo`, and `chmod 777`.
 - [`quiet-tools`](./extensions/quiet-tools): Renders collapsed built-in tool rows as a one-line invocation plus an expand hint without changing model-visible tool results; toggle temporarily with `/quiet-tools`.
 - [`todo`](./extensions/todo): Adds a branch-aware `todo` tool for the agent and a `/todos` viewer for users.
-- [`triage-comments`](./extensions/triage-comments): Adds `/triage-comments` and a read-only `triage_comments` subagent tool that classifies selected PR review comments with evidence and handling options without implementing changes.
+- [`triage-comments`](./extensions/triage-comments): Adds `/triage-comments` and a read-only `triage_comments` subagent tool that can auto-detect the current branch's PR, filter resolved/outdated inline comments, classify selected review comments with evidence, and suggest handling options without implementing changes.
 
 (For the full list of pi extensions I use, [check out my dotfiles](https://github.com/diegopetrucci/dot/blob/main/.pi/agent/settings.json).)
 

package/extensions/oracle/README.md

@@ -11,7 +11,7 @@ It adds an `oracle` tool that spins up a separate read-only pi subprocess and se
 - creates an isolated read-only subprocess
 - auto-picks the strongest reasoning model on the current provider
 - uses provider-specific hardcoded rankings first, then a heuristic fallback
-- sets reasoning/thinking to `xhigh` by default for reasoning models
+- requests `xhigh` by default for reasoning models, then clamps to the model-supported thinking level
 - defaults to `read,grep,find,ls`
 - can optionally allow non-mutating `bash` inspection
 - shows a live oracle status line and widget while the subprocess is running
@@ -27,7 +27,7 @@ By default, the extension:
 4. tries a provider-specific hardcoded priority list first
 5. falls back to a heuristic that favors stronger tiers like `opus`, `pro`, newer versions, and penalizes `mini`, `flash`, `haiku`, `spark`, etc.
 
-The hardcoded rankings now cover pi's built-in provider set, including OpenAI/Codex, Anthropic, Google variants, GitHub Copilot, Bedrock, Azure OpenAI Responses, Cloudflare, DeepSeek, Fireworks, Groq, Hugging Face, Kimi/Moonshot, MiniMax, Mistral, OpenCode, OpenRouter, Vercel AI Gateway, xAI, ZAI, and Cerebras.
+The hardcoded rankings now cover pi's built-in provider set, including Together; see the provider matrix for the current provider-by-provider top picks.
 
 If no reasoning model exists on the current provider, it falls back to the best available model on that provider.
 
@@ -35,9 +35,9 @@ If no reasoning model exists on the current provider, it falls back to the best
 
 Yes — the extension explicitly sets the oracle reasoning level.
 
-- reasoning models default to `xhigh`
+- reasoning models request `xhigh` by default, then use the Pi-compatible effective thinking level supported by the matched model
 - non-reasoning models default to `off`
-- you can override it with the tool's optional `thinkingLevel` parameter
+- you can override it with the tool's optional `thinkingLevel` parameter; matched models still clamp unsupported overrides and report the effective level
 
 Use `/oracle-model` inside pi to see what it would pick right now.
 

package/extensions/oracle/index.ts

@@ -7,6 +7,7 @@ import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
 type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+type ThinkingLevelMap = Partial<Record<ThinkingLevel, unknown | null>>;
 
 type PiModel = {
 	provider: string;
@@ -15,6 +16,7 @@ type PiModel = {
 	reasoning?: boolean;
 	contextWindow?: number;
 	maxTokens?: number;
+	thinkingLevelMap?: ThinkingLevelMap;
 };
 
 interface UsageStats {
@@ -33,6 +35,8 @@ interface OracleSelection {
 	modelId: string;
 	modelName?: string;
 	thinkingLevel: ThinkingLevel;
+	requestedThinkingLevel?: ThinkingLevel;
+	thinkingLevelClamped?: boolean;
 	autoSelected: boolean;
 	selectionReason: string;
 }
@@ -294,6 +298,20 @@ const PROVIDER_MODEL_PREFERENCES: Record<string, string[]> = {
 		"minimax/minimax-m2.1",
 		"z-ai/glm-5.1",
 	],
+	together: [
+		"deepseek-ai/DeepSeek-V4-Pro",
+		"zai-org/GLM-5.1",
+		"moonshotai/Kimi-K2.6",
+		"Qwen/Qwen3.6-Plus",
+		"MiniMaxAI/MiniMax-M2.7",
+		"Qwen/Qwen3.5-397B-A17B",
+		"Qwen/Qwen3-Coder-Next-FP8",
+		"Qwen/Qwen3-235B-A22B-Instruct-2507-tput",
+		"openai/gpt-oss-120b",
+		"moonshotai/Kimi-K2.5",
+		"deepseek-ai/DeepSeek-V3-1",
+		"MiniMaxAI/MiniMax-M2.5",
+	],
 	"vercel-ai-gateway": [
 		"anthropic/claude-opus-4.7",
 		"anthropic/claude-opus-4.6",
@@ -393,7 +411,7 @@ const OracleParams = Type.Object({
 	thinkingLevel: Type.Optional(
 		StringEnum(THINKING_LEVELS, {
 			description:
-				"Optional reasoning level override for the oracle subprocess. Default: xhigh for reasoning models, off for non-reasoning models.",
+				"Optional reasoning level override for the oracle subprocess. Defaults request xhigh for reasoning models and off for non-reasoning models, then clamp to matched model capabilities.",
 		}),
 	),
 	cwd: Type.Optional(Type.String({ description: "Optional working directory for the oracle subprocess." })),
@@ -530,9 +548,48 @@ function withThinking(modelRef: string, thinkingLevel: ThinkingLevel): string {
 	return `${modelRef}:${thinkingLevel}`;
 }
 
-function resolveThinkingLevel(model: PiModel | undefined, override: ThinkingLevel | undefined): ThinkingLevel {
-	if (override) return override;
-	return model?.reasoning ? DEFAULT_THINKING_LEVEL : "off";
+// Keep these local so the extension stays compatible with older pi peer installs that do not export clamp helpers.
+function isThinkingLevelSupported(model: PiModel, level: ThinkingLevel): boolean {
+	if (!model.reasoning) return level === "off";
+
+	const map = model.thinkingLevelMap;
+	if (level === "xhigh") {
+		return !!map && Object.prototype.hasOwnProperty.call(map, "xhigh") && map.xhigh != null;
+	}
+	return map?.[level] !== null;
+}
+
+function clampThinkingLevel(model: PiModel, requested: ThinkingLevel): ThinkingLevel {
+	if (isThinkingLevelSupported(model, requested)) return requested;
+
+	const requestedIndex = THINKING_LEVELS.indexOf(requested);
+	for (let index = requestedIndex + 1; index < THINKING_LEVELS.length; index++) {
+		const level = THINKING_LEVELS[index];
+		if (isThinkingLevelSupported(model, level)) return level;
+	}
+	for (let index = requestedIndex - 1; index >= 0; index--) {
+		const level = THINKING_LEVELS[index];
+		if (isThinkingLevelSupported(model, level)) return level;
+	}
+
+	return "off";
+}
+
+function resolveThinkingLevel(
+	model: PiModel | undefined,
+	override: ThinkingLevel | undefined,
+): { requested: ThinkingLevel; effective: ThinkingLevel; clamped: boolean } {
+	const requested = override ?? (model?.reasoning ? DEFAULT_THINKING_LEVEL : "off");
+	const effective = model ? clampThinkingLevel(model, requested) : requested;
+	return { requested, effective, clamped: effective !== requested };
+}
+
+function appendThinkingLevelClampReason(
+	reason: string,
+	resolution: { requested: ThinkingLevel; effective: ThinkingLevel; clamped: boolean },
+): string {
+	if (!resolution.clamped) return reason;
+	return `${reason} Requested thinking level ${resolution.requested} was clamped to ${resolution.effective} based on the matched model's capabilities.`;
 }
 
 async function findAvailableModel(
@@ -599,9 +656,11 @@ async function selectOracleModel(
 
 	const preferred = selectPreferredModel(candidates, providerForPreferences);
 	const winner = preferred ?? [...candidates].sort((a, b) => rankModel(b) - rankModel(a))[0];
-	const selectionReason = preferred
-		? `Selected ${winner.id} via the hardcoded preference list for ${winner.provider}.`
-		: reason;
+	const thinking = resolveThinkingLevel(winner, thinkingLevelOverride);
+	const selectionReason = appendThinkingLevelClampReason(
+		preferred ? `Selected ${winner.id} via the hardcoded preference list for ${winner.provider}.` : reason,
+		thinking,
+	);
 
 	return {
 		ok: true,
@@ -610,7 +669,8 @@ async function selectOracleModel(
 			provider: winner.provider,
 			modelId: winner.id,
 			modelName: winner.name,
-			thinkingLevel: resolveThinkingLevel(winner, thinkingLevelOverride),
+			thinkingLevel: thinking.effective,
+			...(thinking.clamped ? { requestedThinkingLevel: thinking.requested, thinkingLevelClamped: true } : {}),
 			autoSelected: true,
 			selectionReason,
 		},
@@ -867,7 +927,7 @@ export default function oracleExtension(pi: ExtensionAPI) {
 			"Use this tool sparingly when you want a second opinion, deeper analysis, code review, debugging help, or a higher-reasoning pass.",
 			"Do not use it for routine low-value work; it is slower than the main agent.",
 			"The oracle is read-only by default. Set includeBash only when shell-based inspection is genuinely useful.",
-			"The oracle sets thinking to xhigh by default for reasoning models, unless the tool call explicitly overrides thinkingLevel.",
+			"The oracle requests xhigh by default for reasoning models; defaults and explicit thinkingLevel overrides are clamped to the effective model-supported level when the model is matched.",
 		],
 		parameters: OracleParams,
 
@@ -888,16 +948,21 @@ export default function oracleExtension(pi: ExtensionAPI) {
 					const provider =
 						matched?.provider ?? (modelRef.includes("/") ? modelRef.split("/")[0] : ctx.model?.provider ?? "unknown");
 					const modelId = matched?.id ?? (modelRef.includes("/") ? modelRef.split("/").slice(1).join("/") : modelRef);
+					const thinking = resolveThinkingLevel(matched, params.thinkingLevel);
+					const selectionReason = matched
+						? appendThinkingLevelClampReason("Used the explicit model override provided in the tool call.", thinking)
+						: "Used the explicit model override provided in the tool call. The model was not matched against the authenticated model list, so the reasoning level fallback was applied.";
 					selection = {
 						modelRef: matched ? `${matched.provider}/${matched.id}` : modelRef,
 						provider,
 						modelId,
 						modelName: matched?.name,
-						thinkingLevel: resolveThinkingLevel(matched, params.thinkingLevel),
+						thinkingLevel: thinking.effective,
+						...(matched && thinking.clamped
+							? { requestedThinkingLevel: thinking.requested, thinkingLevelClamped: true }
+							: {}),
 						autoSelected: false,
-						selectionReason: matched
-							? "Used the explicit model override provided in the tool call."
-							: "Used the explicit model override provided in the tool call. The model was not matched against the authenticated model list, so the reasoning level fallback was applied.",
+						selectionReason,
 					};
 				} else {
 					const selectionResult = await selectOracleModel(ctx, params.thinkingLevel);

package/extensions/oracle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-oracle",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "An Amp-style oracle extension for pi that consults the strongest reasoning model on your current provider.",
   "keywords": ["pi-package", "pi", "oracle", "reasoning", "subagent"],
   "license": "MIT",

package/extensions/triage-comments/README.md

@@ -37,6 +37,7 @@ The extension registers `/triage-comments` as an interactive intake flow.
 ```text
 /triage-comments
 /triage-comments paste
+/triage-comments pr
 /triage-comments pr 123
 /triage-comments pr https://github.com/owner/repo/pull/123
 /triage-comments 123
@@ -44,8 +45,10 @@ The extension registers `/triage-comments` as an interactive intake flow.
 
 - With no arguments, The Last Harness asks whether to paste feedback or fetch PR comments.
 - `paste` opens an editor for multiline reviewer feedback, then sends one selected feedback item to the main agent.
-- `pr <PR URL or number>` fetches PR review comments, PR issue comments, and review bodies with `gh`, displays them as numbered items with stable IDs, and asks whether to investigate all displayed comments or an explicit subset such as `1,3-5`.
-- If more than 50 comments are fetched, you must choose a subset of at most 50 comments.
+- `pr` with no explicit target first tries to detect an existing PR for the current named non-`main` git branch using read-only `git` and `gh pr view` calls. If the branch is `main`, detached, outside a git repository, `gh` is unavailable or unauthenticated, or no PR is found, it falls back to the PR URL/number prompt.
+- `pr <PR URL or number>` and a bare PR URL/number fetch that explicit PR directly, display PR review comments, PR issue comments, and review bodies with `gh` as numbered items with stable IDs, and ask whether to investigate all displayed comments or an explicit subset such as `1,3-5`.
+- Before displaying fetched PR comments, PR mode asks whether to show all comments or hide resolved inline review comments, outdated inline review comments, or both. This filter applies only to inline review comments because GitHub exposes resolved/outdated state at the review-thread level; PR issue comments and review bodies always remain visible, and inline comments without thread metadata remain visible.
+- If more than 50 comments are displayed after filtering, you must choose a subset of at most 50 comments.
 - The command sends a normal user message instructing the main agent to call `triage_comments` with the selected payload. It does not directly edit files or post GitHub replies.
 
 The slash command requires interactive UI mode for the editor, PR comment display, and all/subset confirmation. In non-UI modes it prints usage instead of running the intake flow.
@@ -57,9 +60,9 @@ PR mode requires:
 - running inside a git checkout;
 - GitHub CLI `gh` installed and on `PATH`;
 - `gh auth login` completed for the target host/repository, including private repositories;
-- a PR number that `gh pr view` can resolve from the current checkout, or a full GitHub PR URL.
+- a PR number that `gh pr view` can resolve from the current checkout, a full GitHub PR URL, or a current non-`main` branch with an existing PR that `gh pr view` can resolve.
 
-The command uses read-only `gh` calls to fetch PR metadata, review comments, issue comments, and review bodies. It does not post comments, submit reviews, checkout branches, or mutate GitHub.
+The command uses read-only `git`/`gh` calls to detect the current branch PR when no target is supplied, then read-only `gh` calls to fetch PR metadata, review comments, PR issue comments, review bodies, and best-effort review-thread resolved/outdated metadata. It does not post comments, submit reviews, checkout branches, or mutate GitHub.
 
 ## `triage_comments` tool behavior
 
@@ -131,5 +134,6 @@ Do not implement changes from this triage automatically; ask the parent/user whi
 - At most 50 comments can be triaged in one tool call.
 - The subagent has an 8-turn and 8-minute budget.
 - PR mode depends on the GitHub API data available to `gh`; authentication, permissions, host configuration, and API availability can affect what is fetched.
+- Resolved/outdated filtering is best effort and only applies to inline review comments. If GitHub does not return review-thread metadata for an inline comment, `/triage-comments` keeps it visible and labels the thread state as unavailable.
 - The tool validates against the current local checkout. If the checkout does not match the PR head/base or supplied diff context, the result may be `needs clarification` or call out stale/missing evidence.
 - Paste mode treats the editor contents as one feedback item; use PR mode or direct tool calls for multiple separately numbered comments.

package/extensions/triage-comments/index.ts

@@ -20,9 +20,34 @@ const MAX_RUN_MS = 8 * 60 * 1000;
 const DEFAULT_BASH_TIMEOUT_SECONDS = 30;
 const COLLAPSED_PREVIEW_LINES = 18;
 const GH_COMMAND_TIMEOUT_MS = 30_000;
+const GH_PR_METADATA_FIELDS = 'number,title,url,headRefName,headRefOid,baseRefName,baseRefOid';
+const GH_REVIEW_THREADS_GRAPHQL_QUERY = `
+query TriageCommentsReviewThreads($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100, after: $after) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          id
+          isResolved
+          isOutdated
+          comments(first: 100) {
+            nodes {
+              id
+              databaseId
+            }
+          }
+        }
+      }
+    }
+  }
+}`;
 const COMMENT_DISPLAY_BODY_LIMIT = 1200;
 const TRIAGE_COMMAND_USAGE =
-	"Usage: /triage-comments [paste | pr <PR URL or number>]\nInteractive UI mode lets you paste feedback or fetch PR comments, then confirm all comments or choose a subset such as 1,3-5.";
+	"Usage: /triage-comments [paste | pr [<PR URL or number>] | <PR URL or number>]\nInteractive UI mode lets you paste feedback or fetch PR comments, optionally hide resolved/outdated inline review comments, then confirm all displayed comments or choose a subset such as 1,3-5. PR mode without a target first tries to detect an open PR for the current non-main branch.";
 const IMPLEMENTATION_NOTE =
 	"Do not implement changes from this triage automatically; ask the parent/user which option to take before implementation.";
 
@@ -185,6 +210,10 @@ function asFiniteNumber(value: unknown): number | undefined {
 	return undefined;
 }
 
+function asBoolean(value: unknown): boolean | undefined {
+	return typeof value === "boolean" ? value : undefined;
+}
+
 function normalizeComment(raw: unknown, index: number): NormalizedComment | undefined {
 	if (typeof raw === "string") {
 		const body = raw.trim();
@@ -855,6 +884,34 @@ type PullRequestContext = {
 	baseSha?: string;
 };
 
+type ReviewThreadState = {
+	threadId?: string;
+	isResolved?: boolean;
+	isOutdated?: boolean;
+	metadataAvailable: boolean;
+};
+
+type ReviewThreadStateLookup = {
+	byDatabaseId: Map<number, ReviewThreadState>;
+	byNodeId: Map<string, ReviewThreadState>;
+};
+
+type InlineCommentFilter = {
+	hideResolved: boolean;
+	hideOutdated: boolean;
+	label: string;
+};
+
+type AppliedInlineCommentFilter = {
+	filter: InlineCommentFilter;
+	originalCount: number;
+	displayedCount: number;
+	hiddenInlineCount: number;
+	hiddenResolvedInlineCount: number;
+	hiddenOutdatedInlineCount: number;
+	keptInlineWithoutThreadMetadataCount: number;
+};
+
 type CommandComment = {
 	id: string;
 	body: string;
@@ -866,6 +923,7 @@ type CommandComment = {
 	author?: string;
 	url?: string;
 	createdAt?: string;
+	reviewThread?: ReviewThreadState;
 	metadata: Record<string, unknown>;
 	sourceLabel: string;
 	displayNumber?: number;
@@ -1097,7 +1155,107 @@ function reviewHtmlUrl(record: Record<string, unknown>): string | undefined {
 	return asTrimmedString(record.html_url ?? record.htmlUrl ?? html?.href);
 }
 
-function normalizeReviewComment(raw: unknown, pr: PullRequestContext, sortIndex: number): CommandComment | undefined {
+function createReviewThreadStateLookup(): ReviewThreadStateLookup {
+	return { byDatabaseId: new Map(), byNodeId: new Map() };
+}
+
+function reviewThreadStateForComment(raw: unknown, lookup: ReviewThreadStateLookup): ReviewThreadState {
+	const record = asRecord(raw);
+	const databaseId = asFiniteNumber(record?.id);
+	const nodeId = asTrimmedString(record?.node_id ?? record?.nodeId);
+	return (
+		(databaseId !== undefined ? lookup.byDatabaseId.get(databaseId) : undefined) ??
+		(nodeId ? lookup.byNodeId.get(nodeId) : undefined) ??
+		{ metadataAvailable: false }
+	);
+}
+
+async function fetchReviewThreadStateLookup(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	pr: PullRequestContext,
+): Promise<ReviewThreadStateLookup> {
+	const [owner, repo] = pr.repository.split('/');
+	if (!owner || !repo) throw new Error(`Could not build GitHub GraphQL variables from repository ${pr.repository}.`);
+
+	const lookup = createReviewThreadStateLookup();
+	let after: string | undefined;
+
+	while (true) {
+		const args = ['api'];
+		if (pr.host) args.push('--hostname', pr.host);
+		args.push(
+			'graphql',
+			'-f',
+			`owner=${owner}`,
+			'-f',
+			`name=${repo}`,
+			'-F',
+			`number=${pr.number}`,
+			'-f',
+			`query=${GH_REVIEW_THREADS_GRAPHQL_QUERY}`,
+		);
+		if (after) args.push('-f', `after=${after}`);
+
+		const label = 'Fetching review thread resolved/outdated metadata with gh';
+		const stdout = await execChecked(pi, ctx, 'gh', args, label);
+		const raw = parseJsonOutput(stdout, label);
+		const data = asRecord(raw)?.data;
+		const repository = asRecord(asRecord(data)?.repository);
+		const pullRequest = asRecord(repository?.pullRequest);
+		const reviewThreads = asRecord(pullRequest?.reviewThreads);
+		if (!reviewThreads) throw new Error('GitHub GraphQL response did not include reviewThreads.');
+
+		const nodes = Array.isArray(reviewThreads.nodes) ? reviewThreads.nodes : [];
+		for (const rawThread of nodes) {
+			const thread = asRecord(rawThread);
+			if (!thread) continue;
+			const state: ReviewThreadState = {
+				threadId: asTrimmedString(thread.id),
+				isResolved: asBoolean(thread.isResolved),
+				isOutdated: asBoolean(thread.isOutdated),
+				metadataAvailable: true,
+			};
+			const comments = asRecord(thread.comments);
+			const commentNodes = Array.isArray(comments?.nodes) ? comments.nodes : [];
+			for (const rawComment of commentNodes) {
+				const comment = asRecord(rawComment);
+				if (!comment) continue;
+				const databaseId = asFiniteNumber(comment.databaseId);
+				const nodeId = asTrimmedString(comment.id);
+				if (databaseId !== undefined) lookup.byDatabaseId.set(databaseId, state);
+				if (nodeId) lookup.byNodeId.set(nodeId, state);
+			}
+		}
+
+		const pageInfo = asRecord(reviewThreads.pageInfo);
+		if (!asBoolean(pageInfo?.hasNextPage)) break;
+		const endCursor = asTrimmedString(pageInfo?.endCursor);
+		if (!endCursor) break;
+		after = endCursor;
+	}
+
+	return lookup;
+}
+
+async function fetchReviewThreadStateLookupBestEffort(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	pr: PullRequestContext,
+): Promise<ReviewThreadStateLookup> {
+	try {
+		return await fetchReviewThreadStateLookup(pi, ctx, pr);
+	} catch (error) {
+		notifyCommand(
+			ctx,
+			`Could not fetch inline review-thread resolved/outdated metadata; inline review comments without thread metadata will stay visible. ${formatErrorMessage(error)}`,
+			'warning',
+		);
+		return createReviewThreadStateLookup();
+	}
+}
+
+function normalizeReviewComment(raw: unknown, pr: PullRequestContext, sortIndex: number, reviewThread: ReviewThreadState): CommandComment | undefined {
 	const record = asRecord(raw);
 	if (!record) return undefined;
 	const body = asTrimmedString(record.body);
@@ -1123,6 +1281,7 @@ function normalizeReviewComment(raw: unknown, pr: PullRequestContext, sortIndex:
 		author: githubLogin(record.user),
 		url: asTrimmedString(record.html_url ?? record.htmlUrl),
 		createdAt,
+		reviewThread,
 		metadata: compactRecord({
 			source: 'pull_request_review_comment',
 			repository: pr.repository,
@@ -1130,6 +1289,12 @@ function normalizeReviewComment(raw: unknown, pr: PullRequestContext, sortIndex:
 			host: pr.host,
 			databaseId,
 			nodeId,
+			reviewThread: compactRecord({
+				threadId: reviewThread.threadId,
+				isResolved: reviewThread.isResolved,
+				isOutdated: reviewThread.isOutdated,
+				metadataAvailable: reviewThread.metadataAvailable,
+			}),
 			pullRequestReviewId: asFiniteNumber(record.pull_request_review_id ?? record.pullRequestReviewId),
 			commitId: asTrimmedString(record.commit_id ?? record.commitId),
 			originalCommitId: asTrimmedString(record.original_commit_id ?? record.originalCommitId),
@@ -1234,35 +1399,64 @@ function assignDisplayNumbers(comments: CommandComment[]): CommandComment[] {
 	}));
 }
 
-async function fetchPrCommentsForTriage(
+function prContextFallbackTarget(raw: unknown, explicitTarget?: string): string {
+	const record = asRecord(raw);
+	const number = asFiniteNumber(record?.number);
+	return explicitTarget ?? asTrimmedString(record?.url) ?? (number ? String(number) : '');
+}
+
+async function fetchPullRequestMetadata(
 	pi: ExtensionAPI,
 	ctx: ExtensionCommandContext,
-	target: string,
-): Promise<{ pr: PullRequestContext; comments: CommandComment[] }> {
-	const normalizedTarget = normalizePrTarget(target);
-	if (!normalizedTarget) {
-		throw new Error('PR input must be a PR number (for example, 123 or #123) or a GitHub pull request URL.');
-	}
+	label: string,
+	target?: string,
+): Promise<PullRequestContext> {
+	const args = ['pr', 'view'];
+	if (target) args.push(target);
+	args.push('--json', GH_PR_METADATA_FIELDS);
 
-	await assertGitRepo(pi, ctx);
-	await assertGhReady(pi, ctx);
+	const stdout = await execChecked(pi, ctx, 'gh', args, label);
+	const raw = parseJsonOutput(stdout, label);
+	return normalizePullRequestContext(raw, prContextFallbackTarget(raw, target));
+}
 
-	const prStdout = await execChecked(
-		pi,
-		ctx,
-		'gh',
-		['pr', 'view', normalizedTarget, '--json', 'number,title,url,headRefName,headRefOid,baseRefName,baseRefOid'],
-		'Fetching PR metadata with gh',
-	);
-	const pr = normalizePullRequestContext(parseJsonOutput(prStdout, 'Fetching PR metadata with gh'), normalizedTarget);
+async function detectCurrentBranchPullRequest(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+): Promise<PullRequestContext | undefined> {
+	try {
+		const branch = await pi.exec('git', ['branch', '--show-current'], {
+			cwd: ctx.cwd,
+			signal: ctx.signal,
+			timeout: GH_COMMAND_TIMEOUT_MS,
+		});
+		if (branch.killed || branch.code !== 0) return undefined;
+
+		const branchName = branch.stdout.trim();
+		if (!branchName || branchName === 'main') return undefined;
+
+		return await fetchPullRequestMetadata(pi, ctx, 'Detecting current branch PR with gh');
+	} catch {
+		return undefined;
+	}
+}
+
+async function fetchCommentsForPullRequest(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	pr: PullRequestContext,
+): Promise<CommandComment[]> {
 	const reviewComments = await ghApiArray(pi, ctx, pr, `pulls/${pr.number}/comments?per_page=100`, 'review comments');
+	const reviewThreadLookup = reviewComments.length > 0
+		? await fetchReviewThreadStateLookupBestEffort(pi, ctx, pr)
+		: createReviewThreadStateLookup();
 	const issueComments = await ghApiArray(pi, ctx, pr, `issues/${pr.number}/comments?per_page=100`, 'issue comments');
 	const reviews = await ghApiArray(pi, ctx, pr, `pulls/${pr.number}/reviews?per_page=100`, 'review bodies');
 
 	let sortIndex = 0;
 	const comments: CommandComment[] = [];
 	for (const raw of reviewComments) {
-		const comment = normalizeReviewComment(raw, pr, ++sortIndex);
+		const comment = normalizeReviewComment(raw, pr, ++sortIndex, reviewThreadStateForComment(raw, reviewThreadLookup));
 		if (comment) comments.push(comment);
 	}
 	for (const raw of issueComments) {
@@ -1274,7 +1468,25 @@ async function fetchPrCommentsForTriage(
 		if (comment) comments.push(comment);
 	}
 
-	return { pr, comments: assignDisplayNumbers(comments.sort(compareCommandComments)) };
+	return assignDisplayNumbers(comments.sort(compareCommandComments));
+}
+
+async function fetchPrCommentsForTriage(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	target: string,
+): Promise<{ pr: PullRequestContext; comments: CommandComment[] }> {
+	const normalizedTarget = normalizePrTarget(target);
+	if (!normalizedTarget) {
+		throw new Error('PR input must be a PR number (for example, 123 or #123) or a GitHub pull request URL.');
+	}
+
+	await assertGitRepo(pi, ctx);
+	await assertGhReady(pi, ctx);
+
+	const pr = await fetchPullRequestMetadata(pi, ctx, 'Fetching PR metadata with gh', normalizedTarget);
+	const comments = await fetchCommentsForPullRequest(pi, ctx, pr);
+	return { pr, comments };
 }
 
 function truncateForDisplay(text: string, max: number): string {
@@ -1294,21 +1506,139 @@ function formatCommentLocation(comment: CommandComment): string {
 	return lineRange ? `${comment.path}:${lineRange}` : comment.path;
 }
 
-function formatFetchedCommentsForSelection(pr: PullRequestContext, comments: CommandComment[]): string {
+function isInlineReviewComment(comment: CommandComment): boolean {
+	return asTrimmedString(comment.metadata.source) === 'pull_request_review_comment';
+}
+
+function formatReviewThreadState(comment: CommandComment): string | undefined {
+	if (!isInlineReviewComment(comment)) return undefined;
+	const reviewThread = comment.reviewThread;
+	if (!reviewThread?.metadataAvailable) return 'thread: resolved/outdated state unavailable (kept visible)';
+	const resolved = reviewThread.isResolved === true
+		? 'resolved'
+		: reviewThread.isResolved === false
+			? 'unresolved'
+			: 'resolved state unavailable';
+	const outdated = reviewThread.isOutdated === true
+		? 'outdated'
+		: reviewThread.isOutdated === false
+			? 'current'
+			: 'outdated state unavailable';
+	return `thread: ${resolved}, ${outdated}`;
+}
+
+function formatInlineFilterNotice(summary: AppliedInlineCommentFilter): string {
+	const scope = 'Only inline review comments can be filtered; PR issue comments, review bodies, and inline comments without thread metadata remain visible.';
+	if (!summary.filter.hideResolved && !summary.filter.hideOutdated) {
+		return `Filter: showing all fetched comments. ${scope}`;
+	}
+	const hiddenParts = [
+		summary.hiddenResolvedInlineCount > 0 ? `${summary.hiddenResolvedInlineCount} resolved` : undefined,
+		summary.hiddenOutdatedInlineCount > 0 ? `${summary.hiddenOutdatedInlineCount} outdated` : undefined,
+	]
+		.filter(Boolean)
+		.join(', ');
+	const hiddenDetail = hiddenParts ? ` (${hiddenParts})` : '';
+	return `Filter: ${summary.filter.label}. Hidden ${summary.hiddenInlineCount} inline review comment(s)${hiddenDetail}; displaying ${summary.displayedCount} of ${summary.originalCount} fetched comment(s). ${scope}`;
+}
+
+function formatInlineFilterContext(summary: AppliedInlineCommentFilter): string {
+	return `${formatInlineFilterNotice(summary)} Inline comments kept without thread metadata: ${summary.keptInlineWithoutThreadMetadataCount}.`;
+}
+
+function formatFetchedCommentsForSelection(pr: PullRequestContext, comments: CommandComment[], filterSummary?: AppliedInlineCommentFilter): string {
 	const title = pr.title ? ` — ${pr.title}` : '';
 	const limitNotice = comments.length > MAX_COMMENTS
 		? `\n\ntriage_comments can investigate at most ${MAX_COMMENTS} comments per run, so choose a subset.`
 		: '\n\nChoose whether to investigate all displayed comments or select a subset.';
-	const header = `Fetched ${comments.length} numbered comment(s) from ${pr.repository}#${pr.number}${title}.${limitNotice}`;
+	const fetchedCount = filterSummary?.originalCount ?? comments.length;
+	const displayedCount = comments.length;
+	const countSummary = filterSummary
+		? `Fetched ${fetchedCount} comment(s) from ${pr.repository}#${pr.number}${title}; displaying ${displayedCount} numbered comment(s) after filtering.`
+		: `Fetched ${displayedCount} numbered comment(s) from ${pr.repository}#${pr.number}${title}.`;
+	const filterNotice = filterSummary ? `\n\n${formatInlineFilterNotice(filterSummary)}` : '';
+	const header = `${countSummary}${filterNotice}${limitNotice}`;
 	const body = comments.map((comment) => {
 		const author = comment.author ? ` by @${comment.author}` : '';
 		const url = comment.url ? `\n   url: ${comment.url}` : '';
+		const threadState = formatReviewThreadState(comment);
+		const threadLine = threadState ? `\n   ${threadState}` : '';
 		const preview = indentLines(truncateForDisplay(comment.body, COMMENT_DISPLAY_BODY_LIMIT), '   ');
-		return `${comment.displayNumber ?? '?'}. ${comment.sourceLabel}${author} — ${formatCommentLocation(comment)}\n   id: ${comment.id}${url}\n${preview}`;
+		return `${comment.displayNumber ?? '?'}. ${comment.sourceLabel}${author} — ${formatCommentLocation(comment)}\n   id: ${comment.id}${url}${threadLine}\n${preview}`;
 	});
 	return [header, ...body].join('\n\n');
 }
 
+async function promptForInlineCommentFilter(ctx: ExtensionCommandContext): Promise<InlineCommentFilter | undefined> {
+	const prompt = [
+		'/triage-comments: filter inline review comments before display',
+		'GitHub exposes resolved/outdated state only for inline review threads. PR issue comments and review bodies will stay visible, and inline comments without thread metadata will stay visible.',
+	].join('\n\n');
+	const showAll = 'Show all fetched comments';
+	const hideResolved = 'Hide resolved inline review comments';
+	const hideOutdated = 'Hide outdated inline review comments';
+	const hideBoth = 'Hide resolved and outdated inline review comments';
+	const cancel = 'Cancel';
+	const decision = await ctx.ui.select(prompt, [showAll, hideResolved, hideOutdated, hideBoth, cancel]);
+	if (!decision || decision === cancel) return undefined;
+	if (decision === hideResolved) return { hideResolved: true, hideOutdated: false, label: 'hiding resolved inline review comments' };
+	if (decision === hideOutdated) return { hideResolved: false, hideOutdated: true, label: 'hiding outdated inline review comments' };
+	if (decision === hideBoth) return { hideResolved: true, hideOutdated: true, label: 'hiding resolved or outdated inline review comments' };
+	return { hideResolved: false, hideOutdated: false, label: 'showing all fetched comments' };
+}
+
+function applyInlineCommentFilter(
+	comments: CommandComment[],
+	filter: InlineCommentFilter,
+): { comments: CommandComment[]; summary: AppliedInlineCommentFilter } {
+	const kept: CommandComment[] = [];
+	let hiddenInlineCount = 0;
+	let hiddenResolvedInlineCount = 0;
+	let hiddenOutdatedInlineCount = 0;
+	let keptInlineWithoutThreadMetadataCount = 0;
+
+	for (const comment of comments) {
+		if (!isInlineReviewComment(comment)) {
+			kept.push(comment);
+			continue;
+		}
+
+		const reviewThread = comment.reviewThread;
+		const hasThreadMetadata = Boolean(reviewThread?.metadataAvailable);
+		const hideForResolved = filter.hideResolved && reviewThread?.isResolved === true;
+		const hideForOutdated = filter.hideOutdated && reviewThread?.isOutdated === true;
+		if (hideForResolved || hideForOutdated) {
+			hiddenInlineCount += 1;
+			if (hideForResolved) hiddenResolvedInlineCount += 1;
+			if (hideForOutdated) hiddenOutdatedInlineCount += 1;
+			continue;
+		}
+
+		if (!hasThreadMetadata) keptInlineWithoutThreadMetadataCount += 1;
+		kept.push(comment);
+	}
+
+	const commentsWithFilterMetadata = kept.map((comment) => ({
+		...comment,
+		metadata: compactRecord({
+			...comment.metadata,
+			preFilterDisplayNumber: comment.displayNumber,
+		}),
+	}));
+
+	const summary: AppliedInlineCommentFilter = {
+		filter,
+		originalCount: comments.length,
+		displayedCount: kept.length,
+		hiddenInlineCount,
+		hiddenResolvedInlineCount,
+		hiddenOutdatedInlineCount,
+		keptInlineWithoutThreadMetadataCount,
+	};
+
+	return { comments: assignDisplayNumbers(commentsWithFilterMetadata), summary };
+}
+
 function parseSelectionList(input: string, max: number): SelectionParseResult {
 	const trimmed = input.trim();
 	if (!trimmed) return { ok: false, error: 'Enter comment numbers such as 1,3-5.' };
@@ -1384,11 +1714,12 @@ async function choosePrComments(
 	ctx: ExtensionCommandContext,
 	pr: PullRequestContext,
 	comments: CommandComment[],
+	filterSummary?: AppliedInlineCommentFilter,
 ): Promise<CommandComment[] | undefined> {
 	const options = comments.length <= MAX_COMMENTS
 		? ['Investigate all displayed comments', 'Choose a subset', 'Cancel']
 		: ['Choose a subset', 'Cancel'];
-	const selectionPrompt = formatFetchedCommentsForSelection(pr, comments);
+	const selectionPrompt = formatFetchedCommentsForSelection(pr, comments, filterSummary);
 	const decision = await ctx.ui.select(selectionPrompt, options);
 	if (!decision || decision === 'Cancel') return undefined;
 	if (decision === 'Investigate all displayed comments') return comments;
@@ -1428,13 +1759,16 @@ function toPayloadComment(comment: CommandComment): Record<string, unknown> {
 
 function buildCommandPayload(
 	comments: CommandComment[],
-	options: { pr?: PullRequestContext; totalDisplayed: number; source: 'paste' | 'pr' },
+	options: { pr?: PullRequestContext; totalDisplayed: number; source: 'paste' | 'pr'; filterSummary?: AppliedInlineCommentFilter },
 ): TriageCommandPayload {
+	const prSelectionContext = options.filterSummary
+		? `Selected by /triage-comments after fetching ${options.filterSummary.originalCount} PR comment(s), applying the inline review-comment filter, displaying ${options.totalDisplayed} comment(s), and receiving explicit user selection. ${formatInlineFilterContext(options.filterSummary)}`
+		: `Selected by /triage-comments after displaying ${options.totalDisplayed} fetched PR comment(s) and receiving explicit user selection.`;
 	const payload: TriageCommandPayload = {
 		comments: comments.map(toPayloadComment),
 		context:
 			options.source === 'pr'
-				? `Selected by /triage-comments after displaying ${options.totalDisplayed} fetched PR comment(s) and receiving explicit user selection. Do not implement changes until the user chooses a handling option.`
+				? `${prSelectionContext} Do not implement changes until the user chooses a handling option.`
 				: 'Pasted feedback captured by /triage-comments. Do not implement changes until the user chooses a handling option.',
 	};
 
@@ -1490,6 +1824,18 @@ async function runPasteMode(pi: ExtensionAPI, ctx: ExtensionCommandContext, pref
 
 async function runPrMode(pi: ExtensionAPI, ctx: ExtensionCommandContext, target?: string): Promise<void> {
 	let prTarget = target?.trim();
+	let detectedPr: PullRequestContext | undefined;
+
+	if (!prTarget) {
+		ctx.ui.setStatus('triage-comments', 'triage-comments: checking current branch PR…');
+		detectedPr = await detectCurrentBranchPullRequest(pi, ctx);
+		ctx.ui.setStatus('triage-comments', undefined);
+		if (detectedPr) {
+			prTarget = detectedPr.url ?? String(detectedPr.number);
+			notifyCommand(ctx, `Detected PR ${detectedPr.repository}#${detectedPr.number} from the current branch.`, 'info');
+		}
+	}
+
 	if (!prTarget) {
 		const input = await ctx.ui.input('PR URL or number', 'For example: 123, #123, or https://github.com/owner/repo/pull/123');
 		if (input === undefined) return;
@@ -1504,16 +1850,26 @@ async function runPrMode(pi: ExtensionAPI, ctx: ExtensionCommandContext, target?
 	ctx.ui.setStatus('triage-comments', 'triage-comments: fetching PR comments…');
 	try {
 		notifyCommand(ctx, 'Fetching PR comments with gh (read-only)…', 'info');
-		const { pr, comments } = await fetchPrCommentsForTriage(pi, ctx, prTarget);
+		const { pr, comments } = detectedPr
+			? { pr: detectedPr, comments: await fetchCommentsForPullRequest(pi, ctx, detectedPr) }
+			: await fetchPrCommentsForTriage(pi, ctx, prTarget);
 		if (comments.length === 0) {
 			notifyCommand(ctx, `No review comments, issue comments, or review bodies were found for ${pr.repository}#${pr.number}.`, 'info');
 			return;
 		}
 
-		const selected = await choosePrComments(ctx, pr, comments);
+		const filter = await promptForInlineCommentFilter(ctx);
+		if (!filter) return;
+		const filtered = applyInlineCommentFilter(comments, filter);
+		if (filtered.comments.length === 0) {
+			notifyCommand(ctx, `${formatInlineFilterNotice(filtered.summary)} No comments remain to send to triage_comments.`, 'info');
+			return;
+		}
+
+		const selected = await choosePrComments(ctx, pr, filtered.comments, filtered.summary);
 		if (!selected || selected.length === 0) return;
-		const payload = buildCommandPayload(selected, { pr, totalDisplayed: comments.length, source: 'pr' });
-		sendTriageUserMessage(pi, ctx, payload, selected.length, comments.length);
+		const payload = buildCommandPayload(selected, { pr, totalDisplayed: filtered.comments.length, source: 'pr', filterSummary: filtered.summary });
+		sendTriageUserMessage(pi, ctx, payload, selected.length, filtered.comments.length);
 	} catch (error) {
 		notifyCommand(ctx, formatErrorMessage(error), 'error');
 	} finally {

package/extensions/triage-comments/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-triage-comments",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A pi extension that adds /triage-comments and a read-only triage_comments subagent tool for review-comment triage.",
   "keywords": ["pi-package", "pi", "triage", "comments", "review", "subagent"],
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "A collection of pi extensions for context management, review-comment triage, notifications, safety guards, GitHub research, todos, tool rendering, and model/provider helpers.",
   "keywords": ["pi-package", "pi", "terminal", "agent"],
   "license": "MIT",