pi-quiver 6.1.0 → 6.3.0

package/CHANGELOG.md

@@ -8,6 +8,14 @@ Published to npm as `pi-quiver` (`pi install npm:pi-quiver`). Pushing a
 via OIDC trusted publishing. The release helper at
 `.agents/skills/release/scripts/release.sh` cuts the tag; CI publishes.
 
+## v6.3.0 - 2026-09-16
+
+- `session-name` Herdr sink claims any numeric tab label (optionally behind one `* `) at any position instead of only the label equal to the tab's live position, so tabs reordered before the first auto-name - or after a `/new` restore - get named; the claim resets at every `session_start` (`/new`, resume, fork behave like a fresh process) and a tab that reverts to a bare number is re-claimed on the next turn. The extension never writes a digits-only label (`1234` -> `#1234`) and the naming prompt asks for `PR 1234` / `issue 123` / `ticket ABC-123` over a bare ID.
+
+## v6.2.0 - 2026-09-15
+
+- `slack_thread` flattens Block Kit blocks in its default rendering (blocks joined by ` / `, `[<type>]` for unknown types) and gains an opt-in `raw: true` mode returning thread messages as a pure JSON array for `slack_update` round-trips; both modes go through the existing size gate. (#21)
+
 ## v6.1.0 - 2026-09-15
 
 - `slack`: tokens also resolve from a fixed per-user file - `$XDG_CONFIG_HOME/pi-quiver/.env` or `~/.config/pi-quiver/.env` (Linux/macOS), `%APPDATA%\pi-quiver\.env` (Windows) - after process env, the repo `.env`, and the primary checkout's `.env`. Every rung now falls through when it lacks the key; a repo `.env` holding only the bot token no longer blocks the user token. Breaking: an unreadable `.env` at any rung propagates the raw filesystem error instead of collapsing to `missing_token`; the `missing_token` message now lists every checked path (#22).

package/README.md

@@ -70,7 +70,7 @@ A 300 KB changelog page never touches your context window - you get a preview an
 | `extensions/sword-header.ts` | `/builtin-header` | Themed ASCII startup header replacing pi's default logo. OFF by default. |
 | `extensions/fast-mode.ts` | `/fast` | Inject Anthropic fast-mode (`speed: "fast"` + `anthropic-beta: fast-mode-2026-02-01`) into every Claude Opus 4.8 / Opus 5 request, any thinking level. `--fast` flag + `/fast [on\|off\|status]`. OFF by default. |
 | `extensions/provider-stall-watchdog.ts` | - | Opt-in provider-stall recovery, in two tiers: a pre-first-event deadline (`firstEventMs`, 20s) on every provider request in every mode, and the mid-stream pair (warn at 2 min, recover at 4 min) in TUI runs only. Policy D offers each stall to Pi's retry loop until the stall retry budget (`maxStallRetries`, default = `retry.maxRetries`) is exhausted. OFF by default. |
-| `extensions/slack.ts` | `slack_search`, `slack_thread`, `slack_post`, `slack_update`, `slack_delete`, `slack_pin`, `slack_upload`, `slack_cache_refresh` | Context-safe Slack search/threads/posting with dual `user`/`bot` token identities, a workspace-keyed channel/user name->ID cache, DM targets by `@name` / user ID, fetch-style output size gating, and a transactional headline+detail-thread announce protocol with a documented recovery path. OFF by default. Behavior lives in `lib/slack-core.ts` and `lib/slack-cache.ts`. |
+| `extensions/slack.ts` | `slack_search`, `slack_thread`, `slack_post`, `slack_update`, `slack_delete`, `slack_pin`, `slack_upload`, `slack_cache_refresh` | Context-safe Slack search/threads/posting with dual `user`/`bot` token identities, Block Kit flattening and optional raw JSON output for threads, a workspace-keyed channel/user name->ID cache, DM targets by `@name` / user ID, fetch-style output size gating, and a transactional headline+detail-thread announce protocol with a documented recovery path. OFF by default. Behavior lives in `lib/slack-core.ts` and `lib/slack-cache.ts`. |
 
 Full routing rules, size-gate mechanics, and config: [doc/fetch.md](doc/fetch.md), [doc/doc-to-md.md](doc/doc-to-md.md), [doc/slack.md](doc/slack.md).
 
@@ -200,7 +200,7 @@ survive untouched.
 
 `sessionAutoName.enabled` makes one extra short LLM call per session (once, after the first turn) to title it; `false` (default) makes no model calls. `rules` appends house conventions to the naming prompt (later rules win when they conflict with the built-ins). Literal, case-insensitive `deny` phrases are stripped from every name; whitespace inside a phrase is loose, so `"acme corp"` also catches `AcmeCorp`. `revisitFirstTurn` re-evaluates the name once that many model round trips have completed, while `revisitEveryTurns` does so at every multiple; both default to `0` (off) because each revisit costs another short LLM call. For example, `10` and `100` mark round trips 10, 100, 200, 300. Revisits only run when the agent has fully settled (idle, nothing queued) - an automated multi-turn run such as a subagent chain is never renamed or delayed mid-flight; cadence points it crossed fire once, at the settle. A machine-generated name is replaced when stale. A name set by a human is never overwritten: the extension strongly prefers it, and announces a suggestion only when the work has clearly moved on. Counts come from the persisted transcript, so they survive resume.
 
-`herdrTab` (default `true`) mirrors the same curated label to the Herdr tab bar over Herdr's unix socket, independent of `ghosttyTab` - either sink can be toggled off without affecting the other. It's claim-once: the extension adopts a tab only while it still shows its default numeric label (its live 1-based position among the workspace's tabs); a manually renamed tab, or one renamed mid-session by hand, is never touched again for that session - the human's label always wins. One exception: exactly one leading `* ` (herdr-ntfy-notify's armed marker) is not a human rename - it is preserved across renames and the shutdown restore, and removing it keeps the claim. On every shutdown (quit, reload, `/new`, resume, fork) a claimed tab's label is restored to its then-current default position, so a successor session in the same pane can claim cleanly. It only ever runs in TUI mode, on an attached TTY, under Herdr (`HERDR_ENV`/`HERDR_TAB_ID`/`HERDR_SOCKET_PATH` all set) - `pi -p`/json/rpc runs and background subagents never touch the tab. Caveats: a hard crash (`kill -9`) skips the restore and leaves the stale label - rename the tab by hand to recover; and the restored label is internally a custom name (Herdr has no clear-to-auto API), so that tab keeps a number-looking label but stops renumbering on later tab closes/reorders.
+`herdrTab` (default `true`) mirrors the same curated label to the Herdr tab bar over Herdr's unix socket, independent of `ghosttyTab` - either sink can be toggled off without affecting the other. A tab is claimable while its label is a bare number (`1`, `4`, ...) at any position - Herdr's vocabulary for "unnamed" - so reordering tabs before or after naming never matters; a tab you deliberately name `3` is taken over too. A non-numeric label is treated as a human's and is never overwritten; the check repeats every turn, so renumbering the tab by hand hands it back. Exactly one leading `* ` (herdr-ntfy-notify's armed marker) is not a human rename - it is preserved across renames and the shutdown restore, and removing it keeps the claim. Every session claims afresh: on each shutdown (quit, reload, `/new`, resume, fork) a claimed tab is restored to its then-current position number, and the successor session in the pane claims it again on its first name. The label the extension writes is never digits-only - a bare `1234` becomes `#1234`, and the naming prompt asks the model for `PR 1234` / `issue 123` / `ticket ABC-123` instead of a bare ID. It only ever runs in TUI mode, on an attached TTY, under Herdr (`HERDR_ENV`/`HERDR_TAB_ID`/`HERDR_SOCKET_PATH` all set) - `pi -p`/json/rpc runs and background subagents never touch the tab. Caveat: the restored number is internally a custom name (Herdr has no clear-to-auto API), so that tab keeps a number-looking label but stops renumbering on later tab closes/reorders.
 
 `fastMode` only affects `claude-opus-4-8` and `claude-opus-5` requests on Anthropic's `anthropic-messages` API; enabling it opts into premium fast-mode pricing. `--fast` forces it on for one launch; `/fast on|off` toggles live. Proxy providers (opencode, cloudflare-ai-gateway) are excluded. `fastMode`'s header injection needs the `before_provider_headers` hook (pi bundling `@earendil-works/pi-coding-agent` >= 0.80.5); on older pi the beta header is silently not sent. The `anthropic-beta` header is discovered at request time by probing pi's own request assembly (no network), so conditional betas pi adds - e.g. `server-side-fallback-2026-07-01` for models with server-side fallback - are preserved alongside `fast-mode-2026-02-01`. If the probe fails, the header falls back to the static OAuth-identity + fast-mode list. See [doc/fetch.md](doc/fetch.md) and [doc/doc-to-md.md](doc/doc-to-md.md) for the ingestion tools' full reference; session-name/sword-header behavior above is complete.
 
@@ -280,7 +280,7 @@ Operational notes:
 | `botTokenEnv` | `SLACK_BOT_TOKEN` | Env var name holding the bot token. |
 | `uploadThresholdChars` | `4000` | Link-collapsed length above which an announce/thread detail body is delivered as a file upload instead of inline text. |
 
-Each setting can also be overridden per-process via `PI_QUIVER_SLACK_ENABLED`, `PI_QUIVER_SLACK_CACHE_PATH`, `PI_QUIVER_SLACK_USER_TOKEN_ENV`, `PI_QUIVER_SLACK_BOT_TOKEN_ENV`, and `PI_QUIVER_SLACK_UPLOAD_THRESHOLD_CHARS` - applied on top of the resolved `settings.json` layers, same override rung the extension's config resolver defines. `userTokenCommand` and `userTokenCommandTimeoutSeconds` are settings-only: pi executes the argv directly, without a shell, on every user-identity Slack tool call. For example, macOS Keychain can supply the token with `"userTokenCommand": ["security", "find-generic-password", "-s", "slack-user-token", "-w"]`. Its stdout is the token; empty output, nonzero exit, or timeout is a sanitized hard error and never falls back to `userTokenEnv`. Without the command, tokens resolve per call from process env, then the repo `.env`, then the primary checkout's `.env` (linked worktrees), then a per-user `~/.config/pi-quiver/.env` (`$XDG_CONFIG_HOME` / `%APPDATA%` aware); a file lacking the key falls through to the next rung - see [doc/slack.md](doc/slack.md). Bot resolution is unchanged. Restart pi after changing Slack settings because the extension captures them at session start. Full reference incl. cache layering, the announce protocol, and the `search.messages`/`conversations.replies` throttle caveats: [doc/slack.md](doc/slack.md).
+Each setting can also be overridden per-process via `PI_QUIVER_SLACK_ENABLED`, `PI_QUIVER_SLACK_CACHE_PATH`, `PI_QUIVER_SLACK_USER_TOKEN_ENV`, `PI_QUIVER_SLACK_BOT_TOKEN_ENV`, and `PI_QUIVER_SLACK_UPLOAD_THRESHOLD_CHARS` - applied on top of the resolved `settings.json` layers, same override rung the extension's config resolver defines. `userTokenCommand` and `userTokenCommandTimeoutSeconds` are settings-only: pi executes the argv directly, without a shell, on every user-identity Slack tool call. For example, macOS Keychain can supply the token with `"userTokenCommand": ["security", "find-generic-password", "-s", "slack-user-token", "-w"]`. Its stdout is the token; empty output, nonzero exit, or timeout is a sanitized hard error and never falls back to `userTokenEnv`. Without the command, tokens resolve per call from process env, then the repo `.env`, then the primary checkout's `.env` (linked worktrees), then a per-user `~/.config/pi-quiver/.env` (`$XDG_CONFIG_HOME` / `%APPDATA%` aware); a file lacking the key falls through to the next rung - see [doc/slack.md](doc/slack.md). Bot resolution is unchanged. Restart pi after changing Slack settings because the extension captures them at session start. `slack_thread` flattens Block Kit blocks by default and accepts `raw: true` for JSON output suitable for `slack_update` round-trips. Full reference incl. cache layering, the announce protocol, thread output modes, and the `search.messages`/`conversations.replies` throttle caveats: [doc/slack.md](doc/slack.md).
 
 ### doc_to_md settings
 

package/extensions/session-name.ts

@@ -173,12 +173,15 @@ export function isGhosttyActive(
 }
 
 export function toTabLabel(name: string, maxWords = 4): string {
-	return name
+	const label = name
 		.replace(/[\u0000-\u001f\u007f]/g, " ")
 		.split(/\s+/)
 		.filter(Boolean)
 		.slice(0, maxWords)
 		.join(" ");
+	// A bare number is Herdr's "unnamed tab" vocabulary; our own label must
+	// never look like one or a successor session would treat it as claimable.
+	return /^\d+$/.test(label) ? `#${label}` : label;
 }
 
 /**
@@ -338,6 +341,7 @@ export function buildNamingPrompt(conversation: string, opts: PromptOptions = {}
 		"- Describe the actual task, NOT the tool/skill/command used to start it.",
 		"- Lead with an action verb (e.g. refine, fix, add, rework).",
 		"- Preserve ticket/issue IDs (e.g. ABC-123, PROJ-42, #99) verbatim.",
+		"- If the whole TAB would be just an ID, say what it is: PR 1234, issue 123, ticket ABC-123. Never reply with digits only.",
 		"- No quotes, no trailing punctuation, plain ASCII.",
 		...rules.map((r) => `- ${r}`),
 		"Example -> SESSION: Refine Linear Ticket ABC-123 / TAB: Refine ABC-123",
@@ -496,12 +500,15 @@ export function installSessionName(pi: ExtensionAPI, generate: NameGenerator = g
 		if (currentTabLabel) renameGhosttyTab(currentTabLabel, cfg.ghosttyTab);
 	};
 
-	// Herdr sink. Claim-once: adopt the tab only while it shows its default
-	// (position) label; a human rename - before or during the session - wins
-	// permanently. The one exception is exactly one leading "* ": that is
-	// herdr-ntfy-notify's armed marker, ignored for ownership and carried
-	// through on every write. All syncs serialize on one chain so overlapping
-	// hooks never interleave a read with a rename.
+	// Herdr sink. A tab is claimable while its label is a bare number - Herdr's
+	// vocabulary for "unnamed", and the only label this extension or
+	// herdr-ntfy-notify ever write back - regardless of position: Herdr stores a
+	// renamed number as a permanent custom label that reorders never update. A
+	// non-numeric label is a human's and is never overwritten; it is re-checked
+	// each turn so a tab renumbered by hand becomes claimable again. Exactly one
+	// leading "* " is herdr-ntfy-notify's armed marker, ignored for ownership and
+	// carried through on every write. All syncs serialize on one chain so
+	// overlapping hooks never interleave a read with a rename.
 	// Used both for turn_start syncs (bounds a wedged-but-accepting Herdr so it
 	// can't stall the turn) and for the session_end restore.
 	const HERDR_TIMEOUT_MS = 500;
@@ -514,44 +521,42 @@ export function installSessionName(pi: ExtensionAPI, generate: NameGenerator = g
 	};
 
 	const ARMED_PREFIX = "* ";
+	const NUMERIC = /^\d+$/;
 	const matchOwned = (live: string, expected: string): { owned: boolean; armed: boolean } => {
 		if (live === expected) return { owned: true, armed: false };
 		if (live === ARMED_PREFIX + expected) return { owned: true, armed: true };
 		return { owned: false, armed: false };
 	};
+	const matchClaimable = (live: string): { claimable: boolean; armed: boolean } => {
+		if (NUMERIC.test(live)) return { claimable: true, armed: false };
+		if (live.startsWith(ARMED_PREFIX) && NUMERIC.test(live.slice(ARMED_PREFIX.length))) return { claimable: true, armed: true };
+		return { claimable: false, armed: false };
+	};
 
 	const syncHerdrTab = (cfg: Config, label: string | null, mode: Mode | undefined): Promise<void> => {
 		const run = async (): Promise<void> => {
 			if (!cfg.herdrTab || mode !== "tui" || !label) return;
-			if (herdrClaim === "backed-off") return;
 			if (!isHerdrActive()) return;
 			const sock = process.env.HERDR_SOCKET_PATH as string;
 			const tabId = process.env.HERDR_TAB_ID as string;
-			if (herdrClaim === null) {
-				const tabs = await listTabs(sock, HERDR_TIMEOUT_MS);
-				if (!tabs) return; // transient; retry next sync
-				const position = positionOf(tabs, tabId);
-				if (position === -1) return; // stale tab id (pane moved); retry harmlessly
-				const own = tabs.find((t) => t.tab_id === tabId)!;
-				const owned = matchOwned(own.label, String(position));
-				if (!owned.owned) {
-					herdrClaim = "backed-off"; // human (or crashed predecessor) owns it
+			const live = await getTab(sock, tabId, HERDR_TIMEOUT_MS);
+			if (!live) return; // transient or stale tab id; a failed read is never a human rename
+			if (typeof herdrClaim === "object" && herdrClaim !== null) {
+				const owned = matchOwned(live.label, herdrClaim.lastWritten);
+				if (owned.owned) {
+					if (label === herdrClaim.lastWritten) return;
+					if (await renameTab(sock, tabId, (owned.armed ? ARMED_PREFIX : "") + label, HERDR_TIMEOUT_MS)) herdrClaim.lastWritten = label;
 					return;
 				}
-				if (await renameTab(sock, tabId, (owned.armed ? ARMED_PREFIX : "") + label, HERDR_TIMEOUT_MS)) {
-					herdrClaim = { lastWritten: label };
-				}
-				return;
 			}
-			const live = await getTab(sock, tabId, HERDR_TIMEOUT_MS);
-			if (!live) return; // failed read is not a human rename; stay claimed
-			const owned = matchOwned(live.label, herdrClaim.lastWritten);
-			if (!owned.owned) {
-				herdrClaim = "backed-off";
+			const claim = matchClaimable(live.label);
+			if (!claim.claimable) {
+				herdrClaim = "backed-off"; // human owns it until the label is numeric again
 				return;
 			}
-			if (label === herdrClaim.lastWritten) return;
-			if (await renameTab(sock, tabId, (owned.armed ? ARMED_PREFIX : "") + label, HERDR_TIMEOUT_MS)) herdrClaim.lastWritten = label;
+			if (await renameTab(sock, tabId, (claim.armed ? ARMED_PREFIX : "") + label, HERDR_TIMEOUT_MS)) {
+				herdrClaim = { lastWritten: label };
+			}
 		};
 		herdrChain = herdrChain.then(run, run);
 		return herdrChain;
@@ -595,6 +600,10 @@ export function installSessionName(pi: ExtensionAPI, generate: NameGenerator = g
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
+		// Every session claims afresh, exactly like a fresh process: /new, resume,
+		// and fork each tear the previous session down (restore included) first.
+		// Before loadConfig so `enabled: false, herdrTab: true` resets too.
+		herdrClaim = null;
 		const cfg = loadConfig(ctx);
 		if (!cfg.enabled) return; // off by default; opt in via settings.json
 		const current = pi.getSessionName();
@@ -646,9 +655,9 @@ export function installSessionName(pi: ExtensionAPI, generate: NameGenerator = g
 	});
 
 	// Restore the numeric label on every teardown reason (quit/reload/new/
-	// resume/fork): a successor session in this pane must find the default so
-	// claim-once stays sound. The restored label is internally a custom name -
-	// Herdr has no clear-to-auto API - so it looks right but won't renumber.
+	// resume/fork) so the pane reads as unnamed again. The restored label is
+	// internally a custom name - Herdr has no clear-to-auto API - so it won't
+	// renumber on reorders; the successor claims any numeric label regardless.
 	pi.on("session_shutdown", async () => {
 		await restoreHerdrTab();
 	});

package/extensions/slack.ts

@@ -161,7 +161,8 @@ export function searchResultText(result: SearchResult): string {
 	return `${result.output}\n\ntotal: ${result.total} | page: ${result.page} of ${result.pageCount}`;
 }
 
-export function threadResultText(result: ThreadResult): string {
+export function threadResultText(result: ThreadResult, raw = false): string {
+	if (raw) return result.output;
 	const lines = [result.output, "", `complete: ${result.complete}`];
 	if (!result.complete && result.nextCursor) lines.push(`next_cursor: ${result.nextCursor}`);
 	if (result.caveat) lines.push(result.caveat);
@@ -269,21 +270,25 @@ export default function slackExtension(pi: ExtensionAPI) {
 			label: "Slack Thread",
 			promptSnippet: "Read all replies in a Slack thread",
 			description:
-				'Read a Slack thread via conversations.replies. Always uses the "user" identity (no `as` param). Provide either `channel` (#name, channel ID, @name, or user ID (DM)) plus `ts`, or a `permalink` (parsed for channel+ts). Paginates by cursor until Slack reports no more replies or a cap of 50 pages / 5,000 messages is hit; the result carries a `complete` flag and a resumable `next_cursor` when capped. Caveat: since 2025-05-29, conversations.replies is rate-limited to ~1 request/minute (limit capped at 15) for apps that are neither Marketplace-listed nor classified internal - hitting that throttle mid-pagination returns the messages collected so far plus a caveat and a resumable cursor instead of spinning. Output is size-gated like slack_search.',
+				'Read a Slack thread via conversations.replies. Always uses the "user" identity (no `as` param). Provide either `channel` (#name, channel ID, @name, or user ID (DM)) plus `ts`, or a `permalink` (parsed for channel+ts). Paginates by cursor until Slack reports no more replies or a cap of 50 pages / 5,000 messages is hit; the result carries a `complete` flag and a resumable `next_cursor` when capped. Caveat: since 2025-05-29, conversations.replies is rate-limited to ~1 request/minute (limit capped at 15) for apps that are neither Marketplace-listed nor classified internal - hitting that throttle mid-pagination returns the messages collected so far plus a caveat and a resumable cursor instead of spinning. Default output is one line per message; messages with Block Kit blocks render those blocks flattened (blocks joined by " / ") instead of the text fallback. `raw: true` is for block extraction and slack_update round-trips: it returns the thread messages as a pure JSON array (no status trailer - `complete`/`next_cursor` stay in the result details and are not visible in the content, so an incomplete raw thread is a partial array with no in-content signal: try JSON.parse, on failure read the file named in the truncation line, and use default mode when completeness matters). Both modes are size-gated like slack_search: over the cap the full output is written to a temp file.',
 			parameters: Type.Object({
 				channel: Type.Optional(Type.String({ description: "#name, channel ID, @name, or user ID (DM)" })),
 				ts: Type.Optional(Type.String({ description: "Thread parent timestamp" })),
 				permalink: Type.Optional(Type.String({ description: "A Slack message permalink URL to parse channel+ts from" })),
 				cursor: Type.Optional(Type.String({ description: "Resume pagination from a next_cursor returned by a prior capped call" })),
+				raw: Type.Optional(Type.Boolean({ description: "Return thread messages as a JSON array of raw message objects (blocks untouched) instead of compact lines" })),
 			}),
 			async execute(_toolCallId, params, signal) {
 				return guarded(async () => {
 					const { deps, cacheCtx } = await resolveCall("user", cfg, ctx, signal, repoRoot);
 					const channel =
 						params.permalink === undefined && params.channel !== undefined ? await resolveChannel(params.channel, cacheCtx) : undefined;
-					const result = await readThread({ channel, ts: params.ts, permalink: params.permalink, cursor: params.cursor }, deps);
+					const result = await readThread(
+						{ channel, ts: params.ts, permalink: params.permalink, cursor: params.cursor, raw: params.raw },
+						deps,
+					);
 					return {
-						content: [{ type: "text" as const, text: threadResultText(result) }],
+						content: [{ type: "text" as const, text: threadResultText(result, params.raw === true) }],
 						details: result,
 					};
 				}, "user");

package/lib/slack-core.ts

@@ -567,15 +567,107 @@ export async function searchMessages(
 	return { ...gated, total, page, pageCount };
 }
 
+function inlineElementText(element: unknown): string {
+	if (typeof element !== "object" || element === null) return "[unknown]";
+	const el = element as Record<string, unknown>;
+	const type = typeof el.type === "string" ? el.type : "unknown";
+	switch (type) {
+		case "text":
+			return typeof el.text === "string" ? el.text : "[text]";
+		case "user":
+			return typeof el.user_id === "string" ? `<@${el.user_id}>` : "[user]";
+		case "channel":
+			return typeof el.channel_id === "string" ? `<#${el.channel_id}>` : "[channel]";
+		case "link":
+			if (typeof el.text === "string" && el.text.length > 0) return el.text;
+			return typeof el.url === "string" ? el.url : "[link]";
+		case "emoji":
+			return typeof el.name === "string" ? `:${el.name}:` : "[emoji]";
+		default:
+			return `[${type}]`;
+	}
+}
+
+function richTextContainerText(element: unknown): string {
+	if (typeof element !== "object" || element === null) return "[unknown]";
+	const el = element as Record<string, unknown>;
+	const type = typeof el.type === "string" ? el.type : "unknown";
+	switch (type) {
+		case "rich_text_section":
+		case "rich_text_quote":
+		case "rich_text_preformatted":
+			return Array.isArray(el.elements) ? el.elements.map(inlineElementText).join("") : "";
+		case "rich_text_list":
+			return Array.isArray(el.elements)
+				? el.elements.map(richTextContainerText).filter((s) => s.length > 0).join(" ")
+				: "";
+		default:
+			return `[${type}]`;
+	}
+}
+
+function contextElementText(element: unknown): string {
+	if (typeof element !== "object" || element === null) return "[unknown]";
+	const el = element as Record<string, unknown>;
+	const type = typeof el.type === "string" ? el.type : "unknown";
+	if (type === "plain_text" || type === "mrkdwn") {
+		return typeof el.text === "string" ? el.text : `[${type}]`;
+	}
+	return `[${type}]`;
+}
+
+function blockText(block: unknown): string {
+	if (typeof block !== "object" || block === null) return "[unknown]";
+	const b = block as Record<string, unknown>;
+	const type = typeof b.type === "string" ? b.type : "unknown";
+	switch (type) {
+		case "header": {
+			const text = (b.text as Record<string, unknown> | undefined)?.text;
+			return typeof text === "string" ? text : "";
+		}
+		case "section": {
+			const parts: string[] = [];
+			const text = (b.text as Record<string, unknown> | undefined)?.text;
+			if (typeof text === "string" && text.length > 0) parts.push(text);
+			if (Array.isArray(b.fields)) {
+				for (const field of b.fields) {
+					const fieldText = (field as Record<string, unknown> | undefined)?.text;
+					if (typeof fieldText === "string" && fieldText.length > 0) parts.push(fieldText);
+				}
+			}
+			return parts.join(" ");
+		}
+		case "context":
+			return Array.isArray(b.elements)
+				? b.elements.map(contextElementText).filter((s) => s.length > 0).join(" ")
+				: "";
+		case "rich_text":
+			return Array.isArray(b.elements)
+				? b.elements.map(richTextContainerText).filter((s) => s.length > 0).join(" ")
+				: "";
+		default:
+			return `[${type}]`;
+	}
+}
+
+export function renderBlocks(blocks: unknown[]): string {
+	return blocks
+		.map(blockText)
+		.filter((s) => s.length > 0)
+		.join(" / ")
+		.replace(/\r?\n/g, " ");
+}
+
 function renderThreadLine(message: Record<string, unknown>): string {
 	const author = typeof message.user === "string" ? message.user : String(message.username ?? "unknown");
 	const ts = String(message.ts ?? "");
-	const text = typeof message.text === "string" ? message.text.replace(/\r?\n/g, " ") : "";
-	return `${author} | ${ts} | ${text}`;
+	const flattened = Array.isArray(message.blocks) && message.blocks.length > 0 ? renderBlocks(message.blocks) : "";
+	const body = (flattened.length > 0 ? flattened : typeof message.text === "string" ? message.text : "").replace(/\r?\n/g, " ");
+	return `${author} | ${ts} | ${body}`;
 }
 
 export async function readThread(
-	args: { channel?: string; ts?: string; permalink?: string; cursor?: string },
+	args: { channel?: string; ts?: string; permalink?: string; cursor?: string; raw?: boolean },
 	deps: CoreDeps,
 ): Promise<ThreadResult> {
 	let channel = args.channel;
@@ -641,7 +733,7 @@ export async function readThread(
 		cursor = fetchedCursor;
 	}
 
-	const rendered = messages.map(renderThreadLine).join("\n");
+	const rendered = args.raw === true ? JSON.stringify(messages, null, 2) : messages.map(renderThreadLine).join("\n");
 	const gated = gateOutput(rendered, "thread");
 	return { ...gated, complete, nextCursor, caveat, messageCount: messages.length };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-quiver",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "description": "Personal pack of Pi coding-agent extensions: context-safe fetch, doc_to_md PDF/DOCX/PPTX-to-Markdown conversion, session naming, a themed ASCII startup header, Opus 4.8 fast mode, and a provider-stall watchdog.",
   "author": "Jacek Juraszek",
   "license": "MIT",