@gajae-code/coding-agent 0.7.1 → 0.7.2

package/dist/types/web/search/provider.d.ts

@@ -20,5 +20,22 @@ export declare function looksHostedModelId(modelId: string | undefined): boolean
 export declare function isLocalBaseUrl(baseUrl: string | undefined): boolean;
 export declare function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | undefined): SearchProviderId | undefined;
 export declare function canUseGenericCredentials(authStorage: AuthStorage, ctx: ActiveSearchModelContext | undefined, sessionId?: string, signal?: AbortSignal): Promise<boolean>;
-export declare function shouldTryGenericOpenAICompat(authStorage: AuthStorage, ctx: ActiveSearchModelContext | undefined, sessionId?: string, signal?: AbortSignal): Promise<boolean>;
+/**
+ * Native web-search provider to attempt by reusing the ACTIVE model's own
+ * credentials + baseUrl, dispatched by the model's wire protocol.
+ *
+ * This is the "native search over a proxy" path: when a model is served through
+ * a proxy/custom endpoint, its canonical search credentials (e.g. a dedicated
+ * `anthropic` key, or ChatGPT OAuth for `codex`) are usually absent, but the
+ * credential that authenticates the model itself — stored under the active
+ * provider id and aimed at `ctx.baseUrl` — can drive native web search just as
+ * well. Each provider's `search()` falls back to those active credentials when
+ * its canonical ones are missing.
+ *
+ * Returned ids are matched purely from the wire `api` (+ model-id family where a
+ * native tool only makes sense for that family); the providers themselves fail
+ * closed (and the chain falls through to DuckDuckGo) if the endpoint does not
+ * actually support web search.
+ */
+export declare function activeContextNativeId(ctx: ActiveSearchModelContext | undefined): SearchProviderId | undefined;
 export declare function resolveProviderChain(options: ResolveProviderChainOptions): Promise<SearchProvider[]>;

package/dist/types/web/search/providers/insane.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Insane Search Provider
+ *
+ * Native TypeScript, fail-closed adaptation of the MIT-licensed upstream
+ * fivetaku/insane-search public-route strategy. This ports only safe Phase 0
+ * concepts: deterministic no-auth public endpoints plus route-attempt tracing.
+ *
+ * Deliberately excluded from upstream: TLS impersonation, browser/cookie warming,
+ * CAPTCHA/paywall/login bypasses, credential storage, Playwright automation, and
+ * auto dependency installation. Unsupported or terminal auth/paywall/block states
+ * throw instead of pretending a shallow fetch succeeded.
+ */
+import type { AuthStorage } from "@gajae-code/ai";
+import type { SearchResponse, SearchSource } from "../../../web/search/types";
+import type { SearchParams } from "./base";
+import { SearchProvider } from "./base";
+export interface InsaneRouteAttempt {
+    platform: InsanePlatform;
+    route: string;
+    ok: boolean;
+    status: number;
+    bytes: number;
+    note?: string;
+}
+type InsanePlatform = "reddit" | "x" | "youtube" | "hackernews";
+interface RouteSuccess {
+    platform: InsanePlatform;
+    route: string;
+    finalUrl: string;
+    sources: SearchSource[];
+    attempts: InsaneRouteAttempt[];
+}
+interface RouteFailure {
+    platform: InsanePlatform;
+    attempts: InsaneRouteAttempt[];
+}
+type RouteResult = RouteSuccess | RouteFailure | null;
+export declare function routeInsanePublicUrl(rawUrl: string, signal?: AbortSignal): Promise<RouteResult>;
+/** Execute safe Insane Search public-route discovery. */
+export declare function searchInsane(params: {
+    query: string;
+    num_results?: number;
+    recency?: "day" | "week" | "month" | "year";
+    signal?: AbortSignal;
+}): Promise<SearchResponse>;
+/** Keyless provider that ports safe upstream public-route fallbacks only. */
+export declare class InsaneProvider extends SearchProvider {
+    readonly id = "insane";
+    readonly label = "Insane";
+    isAvailable(_authStorage: AuthStorage): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}
+export {};

package/dist/types/web/search/providers/text-citations.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Inline citation extraction shared by native web-search providers.
+ *
+ * Web-search-capable models sometimes return a genuinely grounded answer whose
+ * sources are written inline (markdown links or bare URLs) instead of as
+ * structured citation annotations. When a provider has independent proof that a
+ * web search actually ran, these helpers recover sources from the answer text so
+ * the result is not discarded.
+ */
+import type { SearchSource } from "../types";
+/** Append a source, de-duplicating by URL. */
+export declare function addSource(sources: SearchSource[], source: SearchSource): void;
+/**
+ * Strips prose punctuation and unmatched closing delimiters from extracted URLs.
+ * Models often return links embedded in markdown or sentence text.
+ */
+export declare function normalizeExtractedUrl(candidate: string): string | null;
+/**
+ * Extracts citation sources from markdown links and bare URLs in answer text.
+ * Used only as a fallback when a provider confirms a search ran but omits
+ * structured citation annotations.
+ */
+export declare function extractTextSources(text: string): SearchSource[];

package/dist/types/web/search/types.d.ts

@@ -4,7 +4,7 @@
  * Unified types for web search responses across supported providers.
  */
 /** Supported web search providers */
-export type SearchProviderId = "duckduckgo" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "xai" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng" | "openai-compatible";
+export type SearchProviderId = "duckduckgo" | "insane" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "xai" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng" | "openai-compatible";
 export type WebSearchMode = "on" | "off" | "auto";
 export interface ActiveSearchModelContext {
     provider: string;
@@ -15,7 +15,7 @@ export interface ActiveSearchModelContext {
     headers?: Record<string, string>;
     webSearch?: WebSearchMode;
 }
-export declare const CONFIGURABLE_SEARCH_PROVIDER_IDS: readonly ["duckduckgo", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "xai", "tavily", "parallel", "kagi", "synthetic", "searxng"];
+export declare const CONFIGURABLE_SEARCH_PROVIDER_IDS: readonly ["duckduckgo", "insane", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "xai", "tavily", "parallel", "kagi", "synthetic", "searxng"];
 export declare function isSearchProviderId(value: string): value is SearchProviderId;
 export declare function isConfigurableSearchProviderId(value: string): value is (typeof CONFIGURABLE_SEARCH_PROVIDER_IDS)[number];
 export declare function isSearchProviderPreference(value: string): value is (typeof CONFIGURABLE_SEARCH_PROVIDER_IDS)[number] | "auto";
@@ -96,6 +96,14 @@ export interface AnthropicCitation {
     cited_text: string;
     encrypted_index: string;
 }
+/**
+ * Error payload returned in `web_search_tool_result.content` when a server-side
+ * web search fails. Unlike the success case, this is an object, not an array.
+ */
+export interface AnthropicWebSearchToolResultError {
+    type: "web_search_tool_result_error";
+    error_code?: string;
+}
 export interface AnthropicContentBlock {
     type: string;
     /** Text content (for type="text") */
@@ -108,8 +116,8 @@ export interface AnthropicContentBlock {
     input?: {
         query: string;
     };
-    /** Search results (for type="web_search_tool_result") */
-    content?: AnthropicSearchResult[];
+    /** Search results array on success, or an error object on failure (type="web_search_tool_result") */
+    content?: AnthropicSearchResult[] | AnthropicWebSearchToolResultError;
 }
 export interface AnthropicApiResponse {
     id: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.7.1",
+	"version": "0.7.2",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -45,18 +45,19 @@
 		"generate-docs-index": "bun scripts/generate-docs-index.ts",
 		"prepack": "bun scripts/generate-docs-index.ts",
 		"generate-template": "bun scripts/generate-template.ts",
-		"install:defaults": "bun src/cli.ts setup defaults"
+		"install:defaults": "bun src/cli.ts setup defaults",
+		"verify:insane-vendor": "bun scripts/verify-insane-vendor.ts"
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.7.1",
-		"@gajae-code/agent-core": "0.7.1",
-		"@gajae-code/ai": "0.7.1",
-		"@gajae-code/natives": "0.7.1",
-		"@gajae-code/tui": "0.7.1",
-		"@gajae-code/utils": "0.7.1",
+		"@gajae-code/stats": "0.7.2",
+		"@gajae-code/agent-core": "0.7.2",
+		"@gajae-code/ai": "0.7.2",
+		"@gajae-code/natives": "0.7.2",
+		"@gajae-code/tui": "0.7.2",
+		"@gajae-code/utils": "0.7.2",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -84,6 +85,7 @@
 		"examples",
 		"README.md",
 		"CHANGELOG.md",
+		"vendor",
 		"dist/types"
 	],
 	"exports": {

package/scripts/verify-insane-vendor.ts

@@ -0,0 +1,132 @@
+#!/usr/bin/env bun
+/**
+ * Vendor verification for packages/coding-agent/vendor/insane-search.
+ *
+ * Asserts:
+ *   1. Forbidden upstream paths/patterns are absent (install hooks, star-baiting,
+ *      update-notifier, transcript-language scanner, .claude-plugin).
+ *   2. MANIFEST.json exists and pins a full 40-char upstream commit SHA.
+ *   3. The vendored runtime files are present.
+ *   4. `npm pack --dry-run --json` includes the vendor tree (engine entrypoint,
+ *      templates, LICENSE, manifest) in the published package.
+ *
+ * Exit code 0 on success, 1 on any failure.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const pkgDir = join(dirname(fileURLToPath(import.meta.url)), "..");
+const vendorDir = join(pkgDir, "vendor", "insane-search");
+const failures: string[] = [];
+
+function fail(msg: string): void {
+	failures.push(msg);
+}
+
+function walk(dir: string): string[] {
+	const out: string[] = [];
+	for (const entry of readdirSync(dir)) {
+		const full = join(dir, entry);
+		if (statSync(full).isDirectory()) out.push(...walk(full));
+		else out.push(full);
+	}
+	return out;
+}
+
+// 1. Forbidden paths / patterns
+if (!existsSync(vendorDir)) {
+	fail(`vendor tree missing at ${vendorDir}`);
+} else {
+	const files = walk(vendorDir).map(f => relative(vendorDir, f));
+	const forbiddenNames = ["setup.sh", "gptaku-update-check.cjs"];
+	const forbiddenSubpaths = [".claude-plugin/", "/references/", "/tests/coverage_battery"];
+	for (const f of files) {
+		const base = f.split("/").pop() ?? f;
+		if (forbiddenNames.includes(base)) fail(`forbidden file present: ${f}`);
+		for (const sub of forbiddenSubpaths) {
+			if (`/${f}`.includes(sub)) fail(`forbidden path present: ${f}`);
+		}
+	}
+	// Scan for star-baiting / settings.json mutation / transcript scanning patterns.
+	const forbiddenPatterns: Array<[RegExp, string]> = [
+		[/user\/starred/, "github star-baiting (user/starred)"],
+		[/gh\s+api\s+-X\s+PUT/, "gh api star write"],
+		[/SessionStart/, "settings.json SessionStart hook injection"],
+		[/\.claude\/projects/, "past-session transcript scanner"],
+	];
+	for (const f of files) {
+		if (f === "MANIFEST.json") continue; // manifest documents the excluded patterns by name
+		let body = "";
+		try {
+			body = readFileSync(join(vendorDir, f), "utf8");
+		} catch {
+			continue;
+		}
+		for (const [re, label] of forbiddenPatterns) {
+			if (re.test(body)) fail(`forbidden pattern (${label}) found in ${f}`);
+		}
+	}
+}
+
+// 2. Manifest with pinned SHA
+const manifestPath = join(vendorDir, "MANIFEST.json");
+let commit = "";
+if (!existsSync(manifestPath)) {
+	fail("MANIFEST.json missing");
+} else {
+	try {
+		const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as {
+			upstream?: { commit?: string };
+		};
+		commit = manifest.upstream?.commit ?? "";
+		if (!/^[0-9a-f]{40}$/.test(commit)) fail(`MANIFEST upstream.commit is not a full 40-char SHA: "${commit}"`);
+	} catch (err) {
+		fail(`MANIFEST.json is not valid JSON: ${(err as Error).message}`);
+	}
+}
+
+// 3. Required runtime files present
+const requiredFiles = [
+	"engine/__main__.py",
+	"engine/__init__.py",
+	"engine/fetch_chain.py",
+	"engine/templates/package.json",
+	"engine/templates/playwright_real_chrome.js",
+	"engine/waf_profiles.yaml",
+	"LICENSE",
+	"MANIFEST.json",
+];
+for (const rel of requiredFiles) {
+	if (!existsSync(join(vendorDir, rel))) fail(`required vendored file missing: ${rel}`);
+}
+
+// 4. Package pack inclusion
+try {
+	const raw = execFileSync("npm", ["pack", "--dry-run", "--json"], {
+		cwd: pkgDir,
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "ignore"],
+	});
+	const parsed = JSON.parse(raw) as Array<{ files?: Array<{ path: string }> }>;
+	const packed = new Set((parsed[0]?.files ?? []).map(f => f.path.replace(/\\/g, "/")));
+	const mustPack = [
+		"vendor/insane-search/engine/__main__.py",
+		"vendor/insane-search/engine/templates/playwright_real_chrome.js",
+		"vendor/insane-search/LICENSE",
+		"vendor/insane-search/MANIFEST.json",
+	];
+	for (const rel of mustPack) {
+		if (!packed.has(rel)) fail(`package pack does not include ${rel}`);
+	}
+} catch (err) {
+	fail(`npm pack --dry-run failed: ${(err as Error).message}`);
+}
+
+if (failures.length > 0) {
+	console.error("insane-vendor verification FAILED:");
+	for (const f of failures) console.error(`  - ${f}`);
+	process.exit(1);
+}
+console.log(`insane-vendor verification passed (pinned ${commit}).`);

package/src/cli/args.ts

@@ -265,7 +265,7 @@ export function getExtraHelpText(): string {
   GJC_SLOW_MODEL              - Override slow/reasoning model (see --slow)
   GJC_PLAN_MODEL              - Override planning model (see --plan)
   GJC_NO_PTY                  - Disable PTY-based interactive bash execution
-  --tmux                       - Launch interactive startup inside a new tmux session
+  --tmux                       - Launch interactive startup inside a fresh tmux session
   gjc session                  - List, inspect, create, remove, or attach tagged GJC-managed tmux sessions
   GJC_LAUNCH_POLICY           - Launch policy for --tmux startup: tmux or direct
   GJC_TMUX_SESSION            - Explicit tmux session name override for --tmux startup

package/src/cli/fast-help.ts

@@ -50,7 +50,7 @@ export function getExtraHelpText(): string {
   GJC_SLOW_MODEL              - Override slow/reasoning model (see --slow)
   GJC_PLAN_MODEL              - Override planning model (see --plan)
   GJC_NO_PTY                  - Disable PTY-based interactive bash execution
-  --tmux                       - Launch interactive startup inside a new tmux session
+  --tmux                       - Launch interactive startup inside a fresh tmux session
   gjc session                  - List, inspect, create, remove, or attach tagged GJC-managed tmux sessions
   GJC_LAUNCH_POLICY           - Launch policy for --tmux startup: tmux or direct
   GJC_TMUX_SESSION            - Explicit tmux session name override for --tmux startup

package/src/cli/notify-cli.ts

@@ -29,6 +29,8 @@ export interface NotifyCommandDeps {
 	pollIntervalMs?: number;
 	setupChatId?: string;
 	setupRedact?: boolean;
+	setupInteractive?: boolean;
+	threadedModePrompt?: (message: string) => Promise<string>;
 }
 
 interface TelegramApiResponse<T> {
@@ -47,6 +49,18 @@ interface TelegramUpdate {
 	};
 }
 
+interface TelegramUser {
+	id: number;
+	is_bot?: boolean;
+	first_name?: string;
+	username?: string;
+	has_topics_enabled?: boolean;
+	allows_users_to_create_topics?: boolean;
+}
+
+type ThreadedModeState = "enabled" | "disabled" | "unknown";
+type ThreadedModeFinalLabel = "verified" | "unverified" | "unknown";
+
 const DEFAULT_API_BASE = "https://api.telegram.org";
 const DEFAULT_POLL_TIMEOUT_MS = 60_000;
 const DEFAULT_POLL_INTERVAL_MS = 1_000;
@@ -120,7 +134,11 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 		throw new Error("Telegram bot token is required.");
 	}
 
-	await callTelegram(fetchImpl, apiBase, token, "getMe", {});
+	const user = await getMe(fetchImpl, apiBase, token);
+	const threadedState = await verifyThreadedMode(fetchImpl, apiBase, token, user, {
+		interactive: resolveSetupInteractive(deps),
+		prompt: deps.threadedModePrompt ?? promptForThreadedMode,
+	});
 	process.stdout.write(
 		"Token validated. Message your bot now from the private Telegram chat to pair notifications.\n",
 	);
@@ -145,7 +163,9 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 	if (deps.setupRedact) settings.set("notifications.redact", true);
 	await settings.flush();
 
-	process.stdout.write(`Notifications enabled. botToken=${maskToken(token)} chatId=${chatId}\n`);
+	process.stdout.write(
+		`Notifications enabled. botToken=${maskToken(token)} chatId=${chatId} threaded=${threadedLabel(threadedState)}\n`,
+	);
 }
 
 async function promptForToken(): Promise<string> {
@@ -160,14 +180,135 @@ async function promptForToken(): Promise<string> {
 	}
 }
 
+const THREADED_ENABLED_SUCCESS =
+	"Telegram Threaded Mode capability verified for this bot. GJC will request a private-chat topic per session; if Telegram ever refuses topic creation, notifications fall back to this flat chat with a one-time nudge.\n";
+
+const THREADED_MISSING_WARNING =
+	"Warning: Telegram getMe did not include has_topics_enabled, so GJC cannot verify private-chat Threaded Mode capability for this bot. Setup will continue; update Telegram/Bot API support or re-run setup if per-session topics fail.\n";
+
+const THREADED_NONINTERACTIVE_WARNING =
+	"Warning: Telegram Threaded Mode capability is OFF for this bot. Setup will be saved because this run is non-interactive, but per-session Telegram delivery may fail closed until the bot owner enables Threaded Mode in @BotFather. GJC cannot enable it through the Bot API.\n";
+
+const THREADED_DISABLED_GUIDANCE =
+	"Telegram Threaded Mode is OFF for this bot. GJC needs Telegram private-chat topics so each session can use its own thread.\n" +
+	"GJC cannot enable this through the Bot API. Open @BotFather, select this bot, enable Threaded Mode / forum topics for private chats, then return here.\n" +
+	"Telegram may require an additional Stars purchase fee for private-chat topics.\n";
+
+const THREADED_DISABLED_PROMPT =
+	"Press Enter after enabling Threaded Mode, or type skip to finish setup with a warning: ";
+
+const THREADED_STILL_OFF = "Telegram still reports Threaded Mode OFF for this bot.\n";
+
+const THREADED_RETRY_PROMPT = "Press Enter to check again, or type skip to finish setup with a warning: ";
+
+const THREADED_SKIP_WARNING =
+	"Warning: continuing without verified Telegram Threaded Mode capability. Setup will be saved, but per-session Telegram delivery may fail closed until Threaded Mode is enabled in BotFather.\n";
+
+const THREADED_INVALID_INPUT = "Type Enter to retry or skip to continue with a warning.\n";
+
+const THREADED_RETRY_INPUTS = new Set(["", "y", "yes", "r", "retry"]);
+const THREADED_SKIP_INPUTS = new Set(["s", "skip", "n", "no"]);
+
+function isTelegramUser(value: unknown): value is TelegramUser {
+	return Boolean(value) && typeof value === "object" && typeof (value as { id?: unknown }).id === "number";
+}
+
+async function getMe(fetchImpl: typeof fetch, apiBase: string, token: string): Promise<TelegramUser> {
+	const user = await callTelegram<unknown>(fetchImpl, apiBase, token, "getMe", {});
+	if (!isTelegramUser(user)) {
+		throw new Error("Telegram getMe returned invalid Telegram response: missing valid User result.");
+	}
+	return user;
+}
+
+function threadedModeState(user: TelegramUser): ThreadedModeState {
+	if (user.has_topics_enabled === true) return "enabled";
+	if (user.has_topics_enabled === false) return "disabled";
+	return "unknown";
+}
+
+function threadedLabel(state: ThreadedModeState): ThreadedModeFinalLabel {
+	if (state === "enabled") return "verified";
+	if (state === "disabled") return "unverified";
+	return "unknown";
+}
+
+function resolveSetupInteractive(deps: NotifyCommandDeps): boolean {
+	if (deps.setupInteractive !== undefined) return deps.setupInteractive;
+	return Boolean(process.stdin.isTTY) && !deps.setupChatId?.trim();
+}
+
+async function promptForThreadedMode(message: string): Promise<string> {
+	if (!process.stdin.isTTY) return "skip";
+	const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+	try {
+		return (await rl.question(message)).trim();
+	} finally {
+		rl.close();
+	}
+}
+
+async function verifyThreadedMode(
+	fetchImpl: typeof fetch,
+	apiBase: string,
+	token: string,
+	initialUser: TelegramUser,
+	opts: { interactive: boolean; prompt: (message: string) => Promise<string> },
+): Promise<ThreadedModeState> {
+	const classify = (user: TelegramUser): ThreadedModeState | undefined => {
+		const state = threadedModeState(user);
+		if (state === "enabled") {
+			process.stdout.write(THREADED_ENABLED_SUCCESS);
+			return "enabled";
+		}
+		if (state === "unknown") {
+			process.stdout.write(THREADED_MISSING_WARNING);
+			return "unknown";
+		}
+		return undefined;
+	};
+
+	const initial = classify(initialUser);
+	if (initial) return initial;
+
+	if (!opts.interactive) {
+		process.stdout.write(THREADED_NONINTERACTIVE_WARNING);
+		return "disabled";
+	}
+
+	process.stdout.write(THREADED_DISABLED_GUIDANCE);
+	let firstPrompt = true;
+	for (;;) {
+		const answer = (await opts.prompt(firstPrompt ? THREADED_DISABLED_PROMPT : THREADED_RETRY_PROMPT))
+			.trim()
+			.toLowerCase();
+		firstPrompt = false;
+		if (THREADED_SKIP_INPUTS.has(answer)) {
+			process.stdout.write(THREADED_SKIP_WARNING);
+			return "disabled";
+		}
+		if (!THREADED_RETRY_INPUTS.has(answer)) {
+			process.stdout.write(THREADED_INVALID_INPUT);
+			continue;
+		}
+		const resolved = classify(await getMe(fetchImpl, apiBase, token));
+		if (resolved) return resolved;
+		process.stdout.write(THREADED_STILL_OFF);
+	}
+}
+
 async function runStatus(deps: NotifyCommandDeps): Promise<void> {
 	const settings = await getSettings(deps);
 	const cfg = getNotificationConfig(settings);
 	process.stdout.write(
 		`${chalk.bold("Notifications")}\n` +
 			`  enabled: ${cfg.enabled}\n` +
-			`  botToken: ${maskToken(cfg.botToken)}\n` +
-			`  chatId: ${cfg.chatId ?? "(unset)"}\n` +
+			`  telegram.botToken: ${maskToken(cfg.botToken)}\n` +
+			`  telegram.chatId: ${cfg.chatId ?? "(unset)"}\n` +
+			`  discord.botToken: ${maskToken(cfg.discord.botToken)}\n` +
+			`  discord.channelId: ${cfg.discord.channelId ?? "(unset)"}\n` +
+			`  slack.botToken: ${maskToken(cfg.slack.botToken)}\n` +
+			`  slack.channelId: ${cfg.slack.channelId ?? "(unset)"}\n` +
 			`  redact: ${cfg.redact}\n`,
 	);
 }
@@ -263,12 +404,18 @@ ${chalk.bold("Usage:")}
   ${APP_NAME} notify status
 
 ${chalk.bold("Subcommands:")}
-  setup     Pair a Telegram bot token with a private chat
+  setup     Pair a Telegram bot token with a private chat and verify Threaded Mode capability
   status    Show notification configuration without secrets
 
 ${chalk.bold("Examples:")}
   ${APP_NAME} notify setup
   ${APP_NAME} notify setup --token <botToken> --chat-id <chatId> [--redact]
   ${APP_NAME} notify status
+
+${chalk.bold("Threaded Mode:")}
+  GJC uses Telegram private-chat topics for per-session threads. Setup verifies the bot
+  capability via getMe.has_topics_enabled. If it is off, enable Threaded Mode in @BotFather;
+  bots cannot toggle it through the Bot API. If Telegram refuses topic creation at runtime,
+  GJC delivers flat to the paired private chat and nudges you to enable Threaded Mode.
 `);
 }

package/src/commands/team.ts

@@ -95,7 +95,7 @@ export default class Team extends Command {
 	};
 
 	static examples = [
-		"gjc --tmux  # start/attach the required tmux-backed leader session first",
+		"gjc --tmux  # start the required tmux-backed leader session first",
 		'gjc team 3:executor "Implement the approved plan"',
 		"gjc team status <team-name> --json",
 		"gjc team monitor <team-name> --json",

package/src/config/settings-schema.ts

@@ -254,10 +254,14 @@ export const SETTINGS_SCHEMA = {
 	"auth.broker.url": { type: "string", default: undefined },
 	"auth.broker.token": { type: "string", default: undefined },
 
-	// Notifications (Telegram bundled reference client)
+	// Notifications (shared daemon with Telegram/Discord/Slack presentation adapters)
 	"notifications.enabled": { type: "boolean", default: false },
 	"notifications.telegram.botToken": { type: "string", default: undefined },
 	"notifications.telegram.chatId": { type: "string", default: undefined },
+	"notifications.discord.botToken": { type: "string", default: undefined },
+	"notifications.discord.channelId": { type: "string", default: undefined },
+	"notifications.slack.botToken": { type: "string", default: undefined },
+	"notifications.slack.channelId": { type: "string", default: undefined },
 	"notifications.redact": { type: "boolean", default: false },
 	"notifications.verbosity": {
 		type: "string",
@@ -2104,6 +2108,17 @@ export const SETTINGS_SCHEMA = {
 		ui: { tab: "tools", label: "Read URLs", description: "Allow the read tool to fetch and process URLs" },
 	},
 
+	"web.insaneFallback": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "Insane Search Fallback",
+			description:
+				"Opt in to the vendored insane-search escalation for blocked public URL reads (403/WAF/JS-gated). Off by default. Requires preinstalled python3 + curl_cffi (and node + playwright/stealth for the browser phase); changes network posture by enabling TLS/browser impersonation for public pages.",
+		},
+	},
+
 	"github.enabled": {
 		type: "boolean",
 		default: false,
@@ -2731,6 +2746,7 @@ export const SETTINGS_SCHEMA = {
 		values: [
 			"auto",
 			"duckduckgo",
+			"insane",
 			"exa",
 			"brave",
 			"jina",
@@ -2763,6 +2779,11 @@ export const SETTINGS_SCHEMA = {
 					label: "DuckDuckGo",
 					description: "Keyless default — no API key or OAuth required",
 				},
+				{
+					value: "insane",
+					label: "Insane",
+					description: "Keyless safe public-route fallback inspired by upstream insane-search",
+				},
 				{ value: "exa", label: "Exa", description: "Uses Exa API when EXA_API_KEY is set" },
 				{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },
 				{ value: "jina", label: "Jina", description: "Requires JINA_API_KEY" },
@@ -3177,6 +3198,14 @@ export interface NotificationsSettings {
 		botToken: string | undefined;
 		chatId: string | undefined;
 	};
+	discord: {
+		botToken: string | undefined;
+		channelId: string | undefined;
+	};
+	slack: {
+		botToken: string | undefined;
+		channelId: string | undefined;
+	};
 	redact: boolean;
 	daemon: {
 		idleTimeoutMs: number;