@sayknow-cli/coding-agent 0.3.0 → 0.3.2

package/src/slash-commands/builtin-registry.ts

@@ -6,6 +6,7 @@ import { getOAuthProviders } from "@sayknow-cli/ai/utils/oauth";
 import { Spacer, Text } from "@sayknow-cli/tui";
 import { setProjectDir } from "@sayknow-cli/utils";
 import { jobElapsedMs } from "../async";
+import { materializeActiveModelProfileAssignment } from "../config/model-profile-activation";
 import {
 	SKC_MODEL_ASSIGNMENT_TARGET_IDS,
 	SKC_MODEL_ASSIGNMENT_TARGETS,
@@ -299,6 +300,12 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 							selector: selection.selector,
 							thinkingLevel: selection.thinkingLevel,
 						});
+						materializeActiveModelProfileAssignment({
+							session: runtime.session,
+							settings: runtime.settings,
+							role: parsedArgs.targetId,
+							selector: persistedSelector,
+						});
 						if (selection.thinkingLevel) {
 							runtime.session.setThinkingLevel(selection.thinkingLevel);
 						}
@@ -317,10 +324,23 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 							selection.thinkingLevel ??
 							extractExplicitThinkingSelector(overrides[parsedArgs.targetId], runtime.settings);
 						const roleSelector = formatModelSelectorValue(selection.selector, thinkingLevel);
-						runtime.settings.set("task.agentModelOverrides", {
-							...overrides,
-							[parsedArgs.targetId]: roleSelector,
+						const materializedProfile = materializeActiveModelProfileAssignment({
+							session: runtime.session,
+							settings: runtime.settings,
+							role: parsedArgs.targetId,
+							selector: roleSelector,
 						});
+						if (!materializedProfile) {
+							const target = SKC_MODEL_ASSIGNMENT_TARGETS[parsedArgs.targetId];
+							if (target.settingsPath === "modelRoles") {
+								runtime.settings.setModelRole(parsedArgs.targetId, roleSelector);
+							} else {
+								runtime.settings.set("task.agentModelOverrides", {
+									...overrides,
+									[parsedArgs.targetId]: roleSelector,
+								});
+							}
+						}
 						runtime.settings.getStorage()?.recordModelUsage(`${selection.model.provider}/${selection.model.id}`);
 						await runtime.output(`${parsedArgs.targetId} agent model set to ${roleSelector}.`);
 					}

package/src/slash-commands/helpers/fast-status-report.ts

@@ -56,6 +56,12 @@ export interface FastStatusSessionLike {
 	readonly model?: Model;
 	/** Fast predicate against the main session tier (current model + `modelRoles`). */
 	isFastForProvider(provider?: string): boolean;
+	/**
+	 * Current-model EFFECTIVE fast state (intent minus any provider auto-disable).
+	 * Used for the current-model row so it matches what the next request does.
+	 * Optional so lightweight fakes can omit it; falls back to `isFastForProvider`.
+	 */
+	isFastModeActive?(): boolean;
 	/** Fast predicate against the effective subagent tier (`task.agentModelOverrides` roles). */
 	isFastForSubagentProvider(provider?: string): boolean;
 	resolveRoleModelWithThinking(role: string): { model?: Model };
@@ -95,9 +101,13 @@ export interface BuildFastStatusReportArgs {
  */
 export function buildFastStatusReport(args: BuildFastStatusReportArgs): string {
 	const { session, roleTargets, iconFast, formatInactive } = args;
-	const rows: FastStatusRow[] = [
-		{ label: "현재 모델", model: session.model, fast: session.isFastForProvider(session.model?.provider) },
-	];
+	// Current-model row uses the EFFECTIVE predicate (intent minus any provider
+	// auto-disable) so it matches the next request; `modelRoles` rows below stay
+	// on pure intent. Fall back to intent when a fake omits `isFastModeActive`.
+	const currentFast = session.isFastModeActive
+		? session.isFastModeActive()
+		: session.isFastForProvider(session.model?.provider);
+	const rows: FastStatusRow[] = [{ label: "현재 모델", model: session.model, fast: currentFast }];
 	for (const target of roleTargets) {
 		const resolved = session.resolveRoleModelWithThinking(target.id);
 		if (resolved.model) {

package/src/slash-commands/helpers/parse.ts

@@ -1,3 +1,4 @@
+import { parseCommandArgs } from "../../utils/command-args";
 import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
 
 export interface ParsedSubcommand {
@@ -65,7 +66,7 @@ export function errorMessage(error: unknown): string {
  * "name required" diagnostics with their own messaging.
  */
 export function parseNamedScopeArgs(rest: string, invalidScopeMessage: string): NamedScopeArgs {
-	const tokens = rest.split(/\s+/).filter(Boolean);
+	const tokens = parseCommandArgs(rest);
 	let name: string | undefined;
 	let scope: ConfigScope = "project";
 	let i = 0;

package/src/system-prompt.ts

@@ -336,6 +336,8 @@ export interface BuildSystemPromptOptions {
 	toolNames?: string[];
 	/** Text to append to system prompt. */
 	appendSystemPrompt?: string;
+	/** Rendered SKC plugin system-appendix blocks (lower-authority, appended last). */
+	pluginAppendices?: string;
 	/** Repeat full tool descriptions in system prompt. Default: false */
 	repeatToolDescriptions?: boolean;
 	/** Skills settings for discovery. */
@@ -380,6 +382,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		customPrompt,
 		tools,
 		appendSystemPrompt,
+		pluginAppendices,
 		repeatToolDescriptions = false,
 		skillsSettings,
 		toolNames: providedToolNames,
@@ -579,5 +582,11 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		systemPrompt.push(projectPrompt);
 	}
 
+	// Plugin system appendices are appended last as a lower-authority block; they
+	// can never override base/project/developer instructions above them.
+	if (pluginAppendices?.trim()) {
+		systemPrompt.push(pluginAppendices.trim());
+	}
+
 	return { systemPrompt };
 }

package/src/task/executor.ts

@@ -9,6 +9,7 @@ import * as fs from "node:fs/promises";
 import path from "node:path";
 import type { AgentEvent, AgentIdentity, AgentTelemetryConfig, ThinkingLevel } from "@sayknow-cli/agent-core";
 import { recordHandoff, resolveTelemetry } from "@sayknow-cli/agent-core";
+import type { ServiceTier } from "@sayknow-cli/ai";
 import { type JsonSchemaValidationIssue, validateJsonSchemaValue } from "@sayknow-cli/ai/utils/schema";
 import { logger, prompt, untilAborted } from "@sayknow-cli/utils";
 import { AsyncJobManager } from "../async";
@@ -19,7 +20,7 @@ import { Settings } from "../config/settings";
 import { SETTINGS_SCHEMA, type SettingPath } from "../config/settings-schema";
 import { runExtensionCompact, runExtensionSetModel } from "../extensibility/extensions/compact-handler";
 import { getSessionSlashCommands } from "../extensibility/extensions/get-commands-handler";
-import { buildAgentSubskillInjection } from "../extensibility/skc-plugins";
+import { buildAgentSubskillInjection, renderAgentPromptAdditions } from "../extensibility/skc-plugins";
 import { buildSkillPromptMessage, type Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
@@ -146,6 +147,13 @@ export interface ExecutorOptions {
 	authStorage?: AuthStorage;
 	modelRegistry?: ModelRegistry;
 	settings?: Settings;
+	/**
+	 * Live service-tier intent of the parent session (`AgentSession.serviceTier`),
+	 * used as the inherited tier when `task.serviceTier === "inherit"`. Passing the
+	 * live value (not the stale settings snapshot) lets a runtime `/fast on` reach
+	 * subagents, and a main-model fast-mode auto-disable does not clobber it.
+	 */
+	inheritedServiceTier?: ServiceTier;
 	/** Override local:// protocol options so subagent shares parent's local:// root */
 	localProtocolOptions?: LocalProtocolOptions;
 	/**
@@ -482,15 +490,19 @@ function getUsageTokens(usage: unknown): number {
 	return firstNumberField(record, ["totalTokens", "total_tokens"]) ?? 0;
 }
 
-export function createSubagentSettings(baseSettings: Settings): Settings {
+export function createSubagentSettings(baseSettings: Settings, inheritedServiceTier?: ServiceTier): Settings {
 	const snapshot: Partial<Record<SettingPath, unknown>> = {};
 	for (const key of Object.keys(SETTINGS_SCHEMA) as SettingPath[]) {
 		snapshot[key] = baseSettings.get(key);
 	}
-	// Subagent-scoped service-tier override: "inherit" keeps the snapshotted main
-	// session tier; any explicit value applies only to subagent sessions.
+	// Subagent-scoped service-tier override: "inherit" uses the parent session's
+	// LIVE intent (so a runtime `/fast on` reaches subagents and a main-model
+	// fast-mode auto-disable never clobbers it); any explicit value applies only
+	// to subagent sessions and wins over inherited intent.
 	const taskServiceTier = baseSettings.get("task.serviceTier");
-	if (taskServiceTier !== "inherit") {
+	if (taskServiceTier === "inherit") {
+		snapshot.serviceTier = inheritedServiceTier ?? "none";
+	} else {
 		snapshot.serviceTier = taskServiceTier;
 	}
 	return Settings.isolated({
@@ -571,7 +583,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	}
 
 	const settings = options.settings ?? Settings.isolated();
-	const subagentSettings = createSubagentSettings(settings);
+	const subagentSettings = createSubagentSettings(settings, options.inheritedServiceTier);
 	const maxRecursionDepth = settings.get("task.maxRecursionDepth") ?? 2;
 	const maxRuntimeMs = Math.max(0, Math.trunc(Number(settings.get("task.maxRuntimeMs") ?? 0) || 0));
 	const parentDepth = options.taskDepth ?? 0;
@@ -1229,6 +1241,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				agentName: agent.name,
 			});
 
+			let agentPromptAdditions = { appendix: "", advertisement: "" };
+			try {
+				agentPromptAdditions = await renderAgentPromptAdditions({ cwd, agentName: agent.name });
+			} catch (error) {
+				logger.warn("Failed to render SKC plugin agent prompt additions", { error });
+			}
+
 			const { session } = await awaitAbortable(
 				createAgentSession({
 					cwd: worktree ?? cwd,
@@ -1259,7 +1278,12 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 							ircSelfId: ircEnabled ? id : "",
 							forkContext: forkContextNotice,
 						});
-						const promptWithSubskills = `${subagentPrompt}${agentSubskillBlock}`;
+						// Order: base agent prompt -> agent appendix -> Tier-1 advertisement -> Tier-2 body.
+						const appendixPart = agentPromptAdditions.appendix ? `\n\n${agentPromptAdditions.appendix}` : "";
+						const advertPart = agentPromptAdditions.advertisement
+							? `\n\n${agentPromptAdditions.advertisement}`
+							: "";
+						const promptWithSubskills = `${subagentPrompt}${appendixPart}${advertPart}${agentSubskillBlock}`;
 						return defaultPrompt.length === 0
 							? [promptWithSubskills]
 							: [...defaultPrompt.slice(0, -1), promptWithSubskills, defaultPrompt[defaultPrompt.length - 1]];

package/src/task/index.ts

@@ -1311,6 +1311,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						authStorage: this.session.authStorage,
 						modelRegistry: this.session.modelRegistry,
 						settings: this.session.settings,
+						inheritedServiceTier: this.session.serviceTier,
 						contextFiles,
 						skills: availableSkills,
 						autoloadSkills: resolvedAutoloadSkills,
@@ -1372,6 +1373,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						authStorage: this.session.authStorage,
 						modelRegistry: this.session.modelRegistry,
 						settings: this.session.settings,
+						inheritedServiceTier: this.session.serviceTier,
 						contextFiles,
 						skills: availableSkills,
 						autoloadSkills: resolvedAutoloadSkills,

package/src/tools/ask.ts

@@ -260,7 +260,11 @@ async function askSingleQuestion(
 			? "up/down navigate  enter select  ←/→ question  esc cancel"
 			: "up/down navigate  enter select  esc cancel";
 		const helpText =
-			scrollTitleRows === undefined ? baseHelpText : `${baseHelpText}  wheel/PgUp/PgDn scroll question`;
+			scrollTitleRows === undefined
+				? baseHelpText
+				: navigation
+					? "↑/↓ select  enter  ←/→ question  esc  PgUp/PgDn/Ctrl+u/d: question · Wheel: transcript"
+					: "↑/↓ select  enter  esc  PgUp/PgDn/Ctrl+u/d: question · Wheel: transcript";
 		const dialogOptions = {
 			initialIndex,
 			timeout,

package/src/tools/bash.ts

@@ -25,6 +25,7 @@ import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-intera
 import { checkBashInterception } from "./bash-interceptor";
 import { canUseInteractiveBashPty } from "./bash-pty-selection";
 import { expandInternalUrls, type InternalUrlExpansionOptions } from "./bash-skill-urls";
+import { checkComposerBashPolicy } from "./composer-bash-policy";
 import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
 import { resolveToCwd } from "./path-utils";
 import { formatToolWorkingDirectory, replaceTabs } from "./render-utils";
@@ -570,6 +571,14 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			}
 		}
 
+		const composerPolicy = checkComposerBashPolicy({
+			modelId: this.session.getActiveModelString?.() ?? this.session.getModelString?.() ?? this.session.model?.id,
+			commands: rawCommand === command ? [command] : [rawCommand, command],
+		});
+		if (!composerPolicy.allowed) {
+			throw new ToolError(composerPolicy.message);
+		}
+
 		const internalUrlOptions: InternalUrlExpansionOptions = {
 			skills: this.session.skills ?? [],
 			internalRouter: InternalUrlRouter.instance(),

package/src/tools/composer-bash-policy.ts

@@ -0,0 +1,96 @@
+import { isComposerHarnessModel } from "@sayknow-cli/ai/providers/composer-discipline";
+
+export const COMPOSER_BASH_POLICY_ERROR =
+	"Composer bash policy blocked repository file I/O. Use find, search, read, and edit tools for file discovery, file inspection, and file mutation.";
+
+type ComposerBashPolicyResult =
+	| { allowed: true }
+	| {
+			allowed: false;
+			reason: string;
+			message: string;
+	  };
+
+const BLOCK_PATTERNS: Array<{ id: string; pattern: RegExp }> = [
+	{ id: "pipe", pattern: /\|/ },
+	{ id: "process-substitution", pattern: /<[>(]/ },
+	{ id: "heredoc", pattern: /<<[-~]?/ },
+	{ id: "command-substitution", pattern: /\$\(|`/ },
+	{ id: "redirection", pattern: /(^|[^<>])(?:>>?|<)(?!=)/ },
+	{ id: "tee", pattern: /(?:^|[;&|\s])tee(?:\s|$)/ },
+	{
+		id: "shell-file-read-discovery",
+		pattern: /(?:^|[;&|()\s])(?:\S*\/)?(?:cat|head|tail|less|more|grep|rg|find|fd|tree|ls)\b/,
+	},
+	{
+		id: "shell-file-mutation",
+		pattern: /(?:^|[;&|()\s])(?:\S*\/)?(?:cp|mv|rm|touch|mkdir|chmod|chown|ln)\b/,
+	},
+	{ id: "sed-print", pattern: /(?:^|[;&|()\s])sed\s+(?:-[^\s]*n\b|.*\bp\b)/ },
+	{ id: "awk-print", pattern: /(?:^|[;&|()\s])awk\b/ },
+	{ id: "git-ls-files", pattern: /(?:^|[;&|()\s])git(?:\s+-C\s+\S+)?\s+ls-files\b/ },
+	{ id: "git-grep", pattern: /(?:^|[;&|()\s])git(?:\s+-C\s+\S+)?\s+grep\b/ },
+	{ id: "git-show-path", pattern: /(?:^|[;&|()\s])git(?:\s+-C\s+\S+)?\s+show\s+\S+:\S+/ },
+	{ id: "git-diff", pattern: /(?:^|[;&|()\s])git(?:\s+-C\s+\S+)?\s+diff(?:\s|$)/ },
+	{ id: "git-cat-file", pattern: /(?:^|[;&|()\s])git(?:\s+-C\s+\S+)?\s+cat-file\b/ },
+	{
+		id: "git-show-discovery",
+		pattern: /(?:^|[;&|()\s])git(?:\s+-C\s+\S+)?\s+show\b.*(?:--name-only|--name-status|--stat)/,
+	},
+	{
+		id: "git-log-path-discovery",
+		pattern: /(?:^|[;&|()\s])git(?:\s+-C\s+\S+)?\s+log\b.*(?:--name-only|--name-status|--stat)/,
+	},
+	{ id: "sed-in-place", pattern: /(?:^|[;&|()\s])sed\s+-[^\s]*i\b/ },
+	{ id: "perl-in-place", pattern: /(?:^|[;&|()\s])perl\s+-[^\s]*p[^\s]*i\b/ },
+	{
+		id: "script-file-io",
+		pattern:
+			/(?:^|[;&|()\s])(?:python3?|node|bun)\s+(?:-\s*<<|-c\b|-e\b|--eval\b).*?(?:read_text|read_bytes|write_text|iterdir|listdir|glob\.glob|readFile|readFileSync|writeFile|writeFileSync|readdir|readdirSync|stat|statSync|cpSync|rmSync|mkdirSync|createReadStream|createWriteStream|Bun\.file|Bun\.write|fs\.readFile|fs\.writeFile|fs\.readdir|fs\.stat|fs\.cp|fs\.rm|fs\.mkdir|open\s*\()/s,
+	},
+	{
+		id: "contaminated-command",
+		pattern: /```|^\s*(?:I\s+(?:will|need|am going)|We\s+(?:need|will)|First[, ]|Now[, ]|Let's)\b/im,
+	},
+];
+
+const ALLOWED_TERMINAL_PATTERNS: RegExp[] = [
+	/^bun\s+test(?:\s+[\w./:@=-]+)*$/,
+	/^bun\s+run\s+(?:check(?::[\w-]+)?|test(?::[\w-]+)?|build(?::[\w-]+)?)(?:\s+[\w./:@=-]+)*$/,
+	/^bun\s+--version$/,
+	/^mise\s+x\s+bun@\d+\.\d+\.\d+\s+--\s+bun\s+test(?:\s+[\w./:@=-]+)*$/,
+	/^mise\s+x\s+bun@\d+\.\d+\.\d+\s+--\s+bun\s+run\s+(?:check(?::[\w-]+)?|test(?::[\w-]+)?|build(?::[\w-]+)?)(?:\s+[\w./:@=-]+)*$/,
+	/^cargo\s+(?:test|check|build)(?:\s+[\w./:@=-]+)*$/,
+	/^git\s+status(?:\s+--short)?(?:\s+--branch)?$/,
+	/^git\s+rev-parse\s+HEAD$/,
+	/^npm\s+--version$/,
+	/^pnpm\s+--version$/,
+	/^yarn\s+--version$/,
+];
+
+function isAllowedComposerTerminalCommand(command: string): boolean {
+	const normalized = command.trim().replace(/\s+/g, " ");
+	return ALLOWED_TERMINAL_PATTERNS.some(pattern => pattern.test(normalized));
+}
+
+export function isComposerBashPolicyModel(modelId: string | undefined): boolean {
+	return Boolean(modelId && isComposerHarnessModel(modelId));
+}
+
+export function checkComposerBashPolicy(input: {
+	modelId?: string;
+	commands: readonly string[];
+}): ComposerBashPolicyResult {
+	if (!isComposerBashPolicyModel(input.modelId)) return { allowed: true };
+	for (const command of input.commands) {
+		for (const block of BLOCK_PATTERNS) {
+			if (block.pattern.test(command)) {
+				return { allowed: false, reason: block.id, message: COMPOSER_BASH_POLICY_ERROR };
+			}
+		}
+		if (!isAllowedComposerTerminalCommand(command)) {
+			return { allowed: false, reason: "not-allowlisted", message: COMPOSER_BASH_POLICY_ERROR };
+		}
+	}
+	return { allowed: true };
+}

package/src/tools/fetch.ts

@@ -16,6 +16,8 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { ensureTool } from "../utils/tools-manager";
+import { INSANE_NOTES, tryInsaneFetch } from "../web/insane/bridge";
+import { validatePublicHttpUrl, validatePublicHttpUrlForInsane } from "../web/insane/url-guard";
 import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
@@ -705,6 +707,55 @@ async function handleSpecialUrls(
 // Main Render Function
 // =============================================================================
 
+/**
+ * Opt-in insane-search fallback for blocked / degraded public URL reads.
+ *
+ * Returns a finalized `method: "insane"` result on success, or null (so the
+ * caller continues with its normal degraded behavior). Fail-closed: no note,
+ * guard DNS, dependency probe, or subprocess when raw mode or the opt-in
+ * setting is off. The public-URL guard runs BEFORE any probe/spawn.
+ */
+export async function tryInsaneFallback(args: {
+	url: string;
+	finalUrl: string;
+	timeout: number;
+	raw: boolean;
+	settings: Settings;
+	signal: AbortSignal | undefined;
+	fetchedAt: string;
+	notes: string[];
+}): Promise<FetchRenderResult | null> {
+	if (args.raw) return null;
+	if (args.settings.get("web.insaneFallback") !== true) return null;
+
+	const target = args.finalUrl || args.url;
+	const guard = await validatePublicHttpUrlForInsane(target);
+	if (!guard.ok) {
+		args.notes.push(INSANE_NOTES.guardBlocked(guard.reason));
+		return null;
+	}
+
+	const result = await tryInsaneFetch(guard.url.toString(), {
+		timeoutMs: args.timeout * 1000,
+		signal: args.signal,
+	});
+	if (result.ok) {
+		const output = finalizeOutput(result.content);
+		return {
+			url: args.url,
+			finalUrl: target,
+			contentType: "text/markdown",
+			method: "insane",
+			content: output.content,
+			fetchedAt: args.fetchedAt,
+			truncated: output.truncated,
+			notes: [...args.notes, ...result.notes],
+		};
+	}
+	for (const note of result.notes) args.notes.push(note);
+	return null;
+}
+
 /**
  * Main render function implementing the full pipeline
  */
@@ -738,6 +789,21 @@ async function renderUrl(
 
 	// Step 0: Normalize URL (ensure scheme for special handlers)
 	url = normalizeUrl(url);
+	const publicUrl = await validatePublicHttpUrl(url);
+	if (!publicUrl.ok) {
+		notes.push(`Blocked URL fetch: target URL is not public HTTP(S): ${publicUrl.reason}`);
+		return {
+			url,
+			finalUrl: url,
+			contentType: "unknown",
+			method: "failed",
+			content: "",
+			fetchedAt,
+			truncated: false,
+			notes,
+		};
+	}
+	url = publicUrl.url.toString();
 
 	// Step 1: Try special handlers for known sites (unless raw mode)
 	if (!raw) {
@@ -751,6 +817,20 @@ async function renderUrl(
 		throw new ToolAbortError();
 	}
 	if (!response.ok) {
+		const failureNote =
+			response.error ?? (response.status ? `Failed to fetch URL (HTTP ${response.status})` : "Failed to fetch URL");
+		notes.push(failureNote);
+		const insane = await tryInsaneFallback({
+			url,
+			finalUrl: response.finalUrl || url,
+			timeout,
+			raw,
+			settings,
+			signal,
+			fetchedAt,
+			notes,
+		});
+		if (insane) return insane;
 		return {
 			url,
 			finalUrl: response.finalUrl || url,
@@ -759,7 +839,7 @@ async function renderUrl(
 			content: "",
 			fetchedAt,
 			truncated: false,
-			notes: [response.status ? `Failed to fetch URL (HTTP ${response.status})` : "Failed to fetch URL"],
+			notes,
 		};
 	}
 
@@ -1062,6 +1142,8 @@ async function renderUrl(
 		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal, storage);
 		if (!htmlResult.ok) {
 			notes.push("html rendering failed (lynx/html2text unavailable)");
+			const insane = await tryInsaneFallback({ url, finalUrl, timeout, raw, settings, signal, fetchedAt, notes });
+			if (insane) return insane;
 			const output = finalizeOutput(rawContent);
 			return {
 				url,
@@ -1122,6 +1204,17 @@ async function renderUrl(
 				};
 			}
 
+			const insaneLowQuality = await tryInsaneFallback({
+				url,
+				finalUrl,
+				timeout,
+				raw,
+				settings,
+				signal,
+				fetchedAt,
+				notes,
+			});
+			if (insaneLowQuality) return insaneLowQuality;
 			notes.push("Page appears to require JavaScript or is mostly navigation");
 		}
 

package/src/tools/index.ts

@@ -1,5 +1,5 @@
 import type { AgentTelemetryConfig, AgentTool } from "@sayknow-cli/agent-core";
-import type { Model, ToolChoice } from "@sayknow-cli/ai";
+import type { Model, ServiceTier, ToolChoice } from "@sayknow-cli/ai";
 import { $env, $flag, logger } from "@sayknow-cli/utils";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
@@ -58,6 +58,7 @@ import { SearchToolBm25Tool } from "./search-tool-bm25";
 import { SkillTool } from "./skill";
 import { loadSshTool } from "./ssh";
 import { SubagentTool } from "./subagent";
+import { TelegramSendTool } from "./telegram-send";
 import { type TodoPhase, TodoWriteTool } from "./todo-write";
 import { WriteTool } from "./write";
 import { YieldTool } from "./yield";
@@ -96,6 +97,7 @@ export * from "./search-tool-bm25";
 export * from "./skill";
 export * from "./ssh";
 export * from "./subagent";
+export * from "./telegram-send";
 export * from "./todo-write";
 export * from "./vim";
 export * from "./write";
@@ -220,6 +222,8 @@ export interface ToolSession {
 	agentOutputManager?: AgentOutputManager;
 	/** Settings instance for passing to subagents */
 	settings: Settings;
+	/** Live service-tier intent of the parent session, inherited by `inherit` subagents. */
+	serviceTier?: ServiceTier;
 	/** Plan mode state (if active) */
 	getPlanModeState?: () => PlanModeState | undefined;
 	/** Goal mode state (if active or paused) */
@@ -402,6 +406,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	todo_write: s => new TodoWriteTool(s),
 	web_search: s => new WebSearchTool(s),
 	search_tool_bm25: SearchToolBm25Tool.createIf,
+	telegram_send: TelegramSendTool.createIf,
 	write: s => new WriteTool(s),
 	skill: SkillTool.createIf,
 	goal: s => new GoalTool(s),