pi-quiver 6.0.1 → 6.2.0

package/CHANGELOG.md

@@ -8,6 +8,15 @@ 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.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).
+- `slack`: every `channel` parameter accepts `@name` or a user ID (`U...`/`W...`) and targets that person's DM - `resolveChannel` opens it via `conversations.open` (needs `im:write`; `slack_thread` DM reads need `im:history`) and tools echo the resulting `D...`. Cached display/real-name aliases are trusted only after a `slack_cache_refresh` snapshot (#20).
+
 ## v6.0.1 - 2026-09-13
 
 - `session-name` Herdr sink tolerates herdr-ntfy-notify's armed marker: exactly one leading `* ` on the live label no longer counts as a human rename, is preserved on every rename and on the shutdown restore, and its removal keeps the claim (#19).

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, 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).
 
@@ -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 and then `.env` (or the primary checkout's, for a worktree with none). 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/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,20 +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 or channel ID; user @names not accepted) 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 or channel ID (user @names not accepted)" })),
+				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.channel !== undefined ? await resolveChannel(params.channel, cacheCtx) : undefined;
-					const result = await readThread({ channel, ts: params.ts, permalink: params.permalink, cursor: params.cursor }, deps);
+					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, 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");
@@ -296,10 +302,10 @@ export default function slackExtension(pi: ExtensionAPI) {
 			label: "Slack Post",
 			promptSnippet: "Post a Slack message, reply, or headline+detail announcement",
 			description:
-				"Post a Slack message via chat.postMessage, as `as: \"user\"` or `as: \"bot\"`. `channel` accepts #name or a channel ID (user @names not accepted). Plain post: `text` and/or `blocks` (Block Kit JSON, passed through unvalidated). Threaded reply: also set `thread_ts` - no headline is ever emitted, `thread_body` (or `text`) becomes the reply body. Announce mode: set `thread_body` WITHOUT `thread_ts` - posts a short single-line `text` headline, then posts `thread_body` as the first threaded reply in the same call; if `thread_body`'s rendered length exceeds the configured uploadThresholdChars (default 4000), it is delivered as a threaded file upload instead. Recovery: re-invoke with `thread_ts` set (never re-omit it) to post only into the existing thread - a second headline is never sent. On detail-delivery failure the headline is marked \"detail pending\" and the detail is saved to a temp file; the error names the path. `unfurl_links`/`unfurl_media` apply to this post only, are omitted when unset (Slack's default stands), and slack_update cannot change unfurling after the fact.",
+				"Post a Slack message via chat.postMessage, as `as: \"user\"` or `as: \"bot\"`. `channel` accepts #name, channel ID, @name, or user ID (DM). Plain post: `text` and/or `blocks` (Block Kit JSON, passed through unvalidated). Threaded reply: also set `thread_ts` - no headline is ever emitted, `thread_body` (or `text`) becomes the reply body. Announce mode: set `thread_body` WITHOUT `thread_ts` - posts a short single-line `text` headline, then posts `thread_body` as the first threaded reply in the same call; if `thread_body`'s rendered length exceeds the configured uploadThresholdChars (default 4000), it is delivered as a threaded file upload instead. Recovery: re-invoke with `thread_ts` set (never re-omit it) to post only into the existing thread - a second headline is never sent. On detail-delivery failure the headline is marked \"detail pending\" and the detail is saved to a temp file; the error names the path. `unfurl_links`/`unfurl_media` apply to this post only, are omitted when unset (Slack's default stands), and slack_update cannot change unfurling after the fact.",
 			parameters: Type.Object({
 				as: IDENTITY,
-				channel: Type.String({ description: "#name or channel ID (user @names not accepted)" }),
+				channel: Type.String({ description: "#name, channel ID, @name, or user ID (DM)" }),
 				text: Type.Optional(Type.String({ description: "Message text, or the announce headline when thread_body is set" })),
 				blocks: Type.Optional(Type.Array(Type.Unknown(), { description: "Block Kit JSON array, passed through unvalidated" })),
 				thread_ts: Type.Optional(Type.String({ description: "Reply into this existing thread instead of posting a new headline" })),
@@ -378,10 +384,10 @@ export default function slackExtension(pi: ExtensionAPI) {
 			label: "Slack Update",
 			promptSnippet: "Edit an existing Slack message",
 			description:
-				'Edit a message via chat.update, as `as: "user"` or `as: "bot"`. `channel` accepts #name or a channel ID (user @names not accepted). Only the identity that originally posted the message can edit it (Slack constraint; surfaced as an error otherwise). Accepts `text` and/or `blocks` (Block Kit JSON, unvalidated).',
+				'Edit a message via chat.update, as `as: "user"` or `as: "bot"`. `channel` accepts #name, channel ID, @name, or user ID (DM). Only the identity that originally posted the message can edit it (Slack constraint; surfaced as an error otherwise). Accepts `text` and/or `blocks` (Block Kit JSON, unvalidated).',
 			parameters: Type.Object({
 				as: IDENTITY,
-				channel: Type.String({ description: "#name or channel ID (user @names not accepted)" }),
+				channel: Type.String({ description: "#name, channel ID, @name, or user ID (DM)" }),
 				ts: Type.String({ description: "Timestamp of the message to edit" }),
 				text: Type.Optional(Type.String()),
 				blocks: Type.Optional(Type.Array(Type.Unknown(), { description: "Block Kit JSON array, passed through unvalidated" })),
@@ -408,10 +414,10 @@ export default function slackExtension(pi: ExtensionAPI) {
 			label: "Slack Delete",
 			promptSnippet: "Delete a Slack message",
 			description:
-				'Delete a message via chat.delete, as `as: "user"` or `as: "bot"`. `channel` accepts #name or a channel ID (user @names not accepted). Only the identity that originally posted the message can delete it (Slack constraint; surfaced as an error otherwise).',
+				'Delete a message via chat.delete, as `as: "user"` or `as: "bot"`. `channel` accepts #name, channel ID, @name, or user ID (DM). Only the identity that originally posted the message can delete it (Slack constraint; surfaced as an error otherwise).',
 			parameters: Type.Object({
 				as: IDENTITY,
-				channel: Type.String({ description: "#name or channel ID (user @names not accepted)" }),
+				channel: Type.String({ description: "#name, channel ID, @name, or user ID (DM)" }),
 				ts: Type.String({ description: "Timestamp of the message to delete" }),
 			}),
 			async execute(_toolCallId, params, signal) {
@@ -434,10 +440,10 @@ export default function slackExtension(pi: ExtensionAPI) {
 			label: "Slack Pin",
 			promptSnippet: "Pin a Slack message to its channel",
 			description:
-				'Pin a message via pins.add, as `as: "user"` or `as: "bot"`. `channel` accepts #name or a channel ID (user @names not accepted). Slack errors are mapped: already_pinned, not_pinnable (this message type cannot be pinned), too_many_pins (the channel hit Slack\'s pin limit).',
+				'Pin a message via pins.add, as `as: "user"` or `as: "bot"`. `channel` accepts #name, channel ID, @name, or user ID (DM). Slack errors are mapped: already_pinned, not_pinnable (this message type cannot be pinned), too_many_pins (the channel hit Slack\'s pin limit).',
 			parameters: Type.Object({
 				as: IDENTITY,
-				channel: Type.String({ description: "#name or channel ID (user @names not accepted)" }),
+				channel: Type.String({ description: "#name, channel ID, @name, or user ID (DM)" }),
 				ts: Type.String({ description: "Timestamp of the message to pin" }),
 			}),
 			async execute(_toolCallId, params, signal) {
@@ -460,10 +466,10 @@ export default function slackExtension(pi: ExtensionAPI) {
 			label: "Slack Upload",
 			promptSnippet: "Upload a file to a Slack channel or thread",
 			description:
-				'Upload a file to Slack (getUploadURLExternal -> upload -> completeUploadExternal), as `as: "user"` or `as: "bot"`. `channel` accepts #name or a channel ID (user @names not accepted). `path` is an absolute path or resolved relative to the current working directory; a missing file errors before any network call. `filename` defaults to the path\'s basename. Optional `title`, `thread_ts` (attach to an existing thread), and `initial_comment`.',
+				'Upload a file to Slack (getUploadURLExternal -> upload -> completeUploadExternal), as `as: "user"` or `as: "bot"`. `channel` accepts #name, channel ID, @name, or user ID (DM). `path` is an absolute path or resolved relative to the current working directory; a missing file errors before any network call. `filename` defaults to the path\'s basename. Optional `title`, `thread_ts` (attach to an existing thread), and `initial_comment`.',
 			parameters: Type.Object({
 				as: IDENTITY,
-				channel: Type.String({ description: "#name or channel ID (user @names not accepted)" }),
+				channel: Type.String({ description: "#name, channel ID, @name, or user ID (DM)" }),
 				path: Type.String({ description: "Absolute path, or a path relative to the current working directory" }),
 				filename: Type.Optional(Type.String({ description: "Defaults to the basename of path" })),
 				title: Type.Optional(Type.String()),

package/lib/slack-cache.ts

@@ -119,13 +119,21 @@ function toUserEntry(u: SlackUser): UserEntry {
 	};
 }
 
+/** DM conversations are opened per identity: Slack returns the existing D... for a repeat call, so this is idempotent and safe to retry. */
+async function openDm(userId: string, ctx: CacheCtx): Promise<string> {
+	const data = await ctx.apiCall("conversations.open", ctx.token, { users: userId }, { retry: true, signal: ctx.signal });
+	const channel = data.channel as { id?: unknown } | undefined;
+	if (typeof channel?.id !== "string") {
+		throw new SlackError("unexpected_response", 'conversations.open returned an unexpected response: missing "channel.id".');
+	}
+	return channel.id;
+}
+
 export async function resolveChannel(input: string, ctx: CacheCtx): Promise<string> {
 	if (RAW_CHANNEL_ID.test(input)) return input;
-	if (input.startsWith("@")) {
-		throw new SlackError(
-			"invalid_channel",
-			`"${input}" looks like a user name, which is not accepted in a channel position (opening a DM is out of scope).`,
-		);
+	if (RAW_USER_ID.test(input) || input.startsWith("@")) {
+		const userId = await resolveUser(input, ctx);
+		return openDm(userId, ctx);
 	}
 	const name = stripPrefix(input);
 
@@ -189,22 +197,26 @@ export async function resolveUser(input: string, ctx: CacheCtx): Promise<string>
 		const byUsername = cached.users[name];
 		if (byUsername) return byUsername.id;
 
-		const displayMatches = Object.values(cached.users).filter((u) => u.display_name === name);
-		if (displayMatches.length === 1) return displayMatches[0].id;
-		if (displayMatches.length > 1) {
-			throw new SlackError(
-				"ambiguous_user",
-				`Multiple users have display name "${name}": ${displayMatches.map((u) => u.id).join(", ")}.`,
-			);
-		}
+		// Same gate as resolveMentions' aliasTrusted: an alias match is conclusive only against a
+		// complete workspace snapshot; a partial cache may hold a different person with that alias.
+		if (cached.snapshot_at !== undefined) {
+			const displayMatches = Object.values(cached.users).filter((u) => u.display_name === name);
+			if (displayMatches.length === 1) return displayMatches[0].id;
+			if (displayMatches.length > 1) {
+				throw new SlackError(
+					"ambiguous_user",
+					`Multiple users have display name "${name}": ${displayMatches.map((u) => u.id).join(", ")}.`,
+				);
+			}
 
-		const realMatches = Object.values(cached.users).filter((u) => u.real_name === name);
-		if (realMatches.length === 1) return realMatches[0].id;
-		if (realMatches.length > 1) {
-			throw new SlackError(
-				"ambiguous_user",
-				`Multiple users have real name "${name}": ${realMatches.map((u) => u.id).join(", ")}.`,
-			);
+			const realMatches = Object.values(cached.users).filter((u) => u.real_name === name);
+			if (realMatches.length === 1) return realMatches[0].id;
+			if (realMatches.length > 1) {
+				throw new SlackError(
+					"ambiguous_user",
+					`Multiple users have real name "${name}": ${realMatches.map((u) => u.id).join(", ")}.`,
+				);
+			}
 		}
 	}
 

package/lib/slack-core.ts

@@ -191,14 +191,25 @@ export function parseEnvFile(content: string): Map<string, string> {
 	return result;
 }
 
-function readEnvFile(dir: string): Map<string, string> | undefined {
+export function userConfigEnvPath(
+	env: Record<string, string | undefined>,
+	platform: NodeJS.Platform = process.platform,
+): string | undefined {
+	if (platform === "win32") {
+		return env.APPDATA ? join(env.APPDATA, "pi-quiver", ".env") : undefined;
+	}
+	if (env.XDG_CONFIG_HOME) return join(env.XDG_CONFIG_HOME, "pi-quiver", ".env");
+	if (env.HOME) return join(env.HOME, ".config", "pi-quiver", ".env");
+	return undefined;
+}
+
+function readEnvFile(path: string): Map<string, string> | undefined {
 	try {
-		return parseEnvFile(readFileSync(join(dir, ".env"), "utf8"));
+		return parseEnvFile(readFileSync(path, "utf8"));
 	} catch (err) {
-		// Deliberate: a genuinely absent .env degrades to "token not found", not a thrown error.
+		// Deliberate: a genuinely absent .env degrades to "token not found". Anything else (permissions,
+		// a directory at that path) is a misconfiguration the caller must see, so it propagates raw.
 		if ((err as NodeJS.ErrnoException)?.code === "ENOENT") return undefined;
-		// Present but unreadable (e.g. permissions): re-thrown so callers treat it as present-but-empty,
-		// not absent - this must NOT authorize the primary-checkout fallback.
 		throw err;
 	}
 }
@@ -208,45 +219,29 @@ export function resolveToken(
 	cfg: SlackConfig,
 	env: Record<string, string | undefined>,
 	repoRoot: string,
+	platform: NodeJS.Platform = process.platform,
 ): string {
 	const envVar = identity === "user" ? cfg.userTokenEnv : cfg.botTokenEnv;
 
 	const fromEnv = env[envVar];
 	if (fromEnv) return fromEnv;
 
-	let repoEnvFile: Map<string, string> | undefined;
-	let repoEnvUnreadable = false;
-	try {
-		repoEnvFile = readEnvFile(repoRoot);
-	} catch {
-		repoEnvUnreadable = true;
-	}
+	const candidates = [join(repoRoot, ".env")];
+	const primaryRoot = primaryCheckoutRoot(repoRoot);
+	if (primaryRoot !== undefined && primaryRoot !== repoRoot) candidates.push(join(primaryRoot, ".env"));
+	const userPath = userConfigEnvPath(env, platform);
+	if (userPath !== undefined) candidates.push(userPath);
 
-	if (repoEnvFile) {
-		// An empty (after quote-strip) .env value is treated as missing, not a usable empty token.
-		const value = repoEnvFile.get(envVar);
+	for (const path of candidates) {
+		const parsed = readEnvFile(path);
+		// An empty (after quote-strip) value is treated as missing, not a usable empty token.
+		const value = parsed?.get(envVar);
 		if (value) return value;
-	} else if (!repoEnvUnreadable) {
-		// File-level fallback only, per spec: this only triggers when the worktree root has no .env at
-		// all (ENOENT); an existing-but-unreadable local .env blocks the fallback just like an existing
-		// one that lacks this key.
-		const primaryRoot = primaryCheckoutRoot(repoRoot);
-		if (primaryRoot && primaryRoot !== repoRoot) {
-			// Best-effort: any error reading the primary .env (missing or otherwise) just means no fallback.
-			let primaryEnvFile: Map<string, string> | undefined;
-			try {
-				primaryEnvFile = readEnvFile(primaryRoot);
-			} catch {
-				primaryEnvFile = undefined;
-			}
-			const value = primaryEnvFile?.get(envVar);
-			if (value) return value;
-		}
 	}
 
 	throw new SlackError(
 		"missing_token",
-		`No Slack ${identity} token: env var ${envVar} is empty and no .env entry was found.`,
+		`No Slack ${identity} token: env var ${envVar} is empty and no entry found in ${candidates.join(", ")}.`,
 	);
 }
 
@@ -279,11 +274,12 @@ export async function resolveCredential(
 	cfg: SlackConfig,
 	env: Record<string, string | undefined>,
 	repoRoot: string,
+	platform: NodeJS.Platform = process.platform,
 ): Promise<string> {
 	if (identity === "user" && cfg.userTokenCommand) {
 		return runCredentialCommand(cfg.userTokenCommand, Math.ceil(cfg.userTokenCommandTimeoutSeconds * 1000));
 	}
-	return resolveToken(identity, cfg, env, repoRoot);
+	return resolveToken(identity, cfg, env, repoRoot, platform);
 }
 
 /**
@@ -571,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;
@@ -645,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.0.1",
+  "version": "6.2.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",