@sayknow-cli/coding-agent 0.3.5 → 0.3.7

package/src/web/search/providers/gemini.ts

@@ -29,7 +29,11 @@ const ANTIGRAVITY_ENDPOINT_FALLBACKS = [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_
 const DEFAULT_MODEL = "gemini-2.5-flash";
 const MAX_RETRIES = 3;
 const BASE_DELAY_MS = 1000;
-const RATE_LIMIT_BUDGET_MS = 5 * 60 * 1000;
+// Retry-delay ceiling for 429/5xx. The web_search chain always terminates in
+// the keyless DuckDuckGo fallback, so a rate-limited Gemini should fail
+// through in seconds instead of parking the chain behind long server-provided
+// retry delays (previously a 5-minute budget).
+const RATE_LIMIT_BUDGET_MS = 30 * 1000;
 
 const GEMINI_PROVIDERS = ["google-gemini-cli", "google-antigravity"] as const;
 type GeminiProviderId = (typeof GEMINI_PROVIDERS)[number];
@@ -230,7 +234,7 @@ async function callGeminiSearch(
 			...headers,
 		},
 		body: JSON.stringify(requestBody),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "llm"),
 	});
 	const urlFor = (attempt: number) =>
 		`${endpoints[Math.min(attempt, endpoints.length - 1)]}/v1internal:streamGenerateContent?alt=sse`;
@@ -466,7 +470,7 @@ async function searchGeminiViaGenerativeLanguage(params: SearchParams): Promise<
 		method: "POST",
 		headers: { ...(ctx.headers ?? {}), "x-goog-api-key": apiKey, "Content-Type": "application/json" },
 		body: JSON.stringify(body),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "llm"),
 	});
 	const text = await response.text();
 	if (!response.ok) {

package/src/web/search/providers/jina.ts

@@ -41,7 +41,7 @@ async function callJinaSearch(apiKey: string, query: string, signal?: AbortSigna
 			Accept: "application/json",
 			Authorization: `Bearer ${apiKey}`,
 		},
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/kimi.ts

@@ -19,6 +19,11 @@ const KIMI_SEARCH_URL = "https://api.kimi.com/coding/v1/search";
 const DEFAULT_NUM_RESULTS = 10;
 const MAX_NUM_RESULTS = 20;
 const DEFAULT_TIMEOUT_SECONDS = 30;
+// Local hard ceiling aligned with the upstream `timeout_seconds` request budget
+// (plus transport headroom) instead of the generic 15s "api" class: Kimi
+// legitimately runs search + page crawling up to its advertised 30s window,
+// and aborting earlier would discard valid in-budget responses.
+const KIMI_HARD_TIMEOUT_MS = (DEFAULT_TIMEOUT_SECONDS + 5) * 1000;
 
 export interface KimiSearchParams {
 	query: string;
@@ -87,7 +92,7 @@ async function callKimiSearch(
 			enable_page_crawling: params.includeContent,
 			timeout_seconds: DEFAULT_TIMEOUT_SECONDS,
 		}),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, KIMI_HARD_TIMEOUT_MS),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/openai-compatible.ts

@@ -134,7 +134,7 @@ export class OpenAICompatibleSearchProvider extends SearchProvider {
 				method: "POST",
 				headers,
 				body: JSON.stringify(payload),
-				signal: withHardTimeout(params.signal),
+				signal: withHardTimeout(params.signal, "llm"),
 			});
 
 		// Web search is a Responses-API capability: many OpenAI-compatible

package/src/web/search/providers/parallel.ts

@@ -139,7 +139,7 @@ async function searchWithAuthStorage(
 				max_chars_per_result: 10_000,
 			},
 		}),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "api"),
 	});
 	if (!response.ok) {
 		throw parseParallelErrorResponse(response.status, await response.text());

package/src/web/search/providers/perplexity.ts

@@ -251,7 +251,7 @@ async function callPerplexityApi(
 			"Content-Type": "application/json",
 		},
 		body: JSON.stringify(request),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "llm"),
 	});
 
 	if (!response.ok) {
@@ -370,7 +370,7 @@ async function callPerplexityOAuth(
 				skip_search_enabled: true,
 			},
 		}),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "llm"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/searxng.ts

@@ -214,7 +214,7 @@ async function callSearXNGSearch(
 
 	const response = await fetch(url, {
 		headers,
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/synthetic.ts

@@ -47,7 +47,7 @@ async function callSyntheticSearch(
 			Authorization: `Bearer ${apiKey}`,
 		},
 		body: JSON.stringify({ query }),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/tavily.ts

@@ -96,7 +96,7 @@ async function callTavilySearch(apiKey: string, params: TavilySearchParams): Pro
 			Authorization: `Bearer ${apiKey}`,
 		},
 		body: JSON.stringify(buildRequestBody(params)),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/providers/utils.ts

@@ -44,38 +44,81 @@ export function findCredential(
 }
 
 /**
- * Default hard ceiling for a single web-search round-trip. 300s tolerates
- * legitimate slow LLM-mediated responses (anthropic web_search_20250305,
- * perplexity, gemini, OpenAI code backend) while still guaranteeing the session unfreezes
- * if Bun's `AbortSignal` fails to propagate on Windows.
- *
- * Pure search APIs (brave, exa, jina, tavily, searxng, synthetic, zai)
- * settle far faster in practice; reusing the same ceiling keeps the wiring
- * uniform without compromising correctness.
+ * Legacy hard ceiling for a single web-search round-trip, retained as the
+ * fallback for call sites that do not declare a timeout class. 300s tolerates
+ * pathological cases while still guaranteeing the session unfreezes if Bun's
+ * `AbortSignal` fails to propagate on Windows.
  */
 export const SEARCH_HARD_TIMEOUT_MS = 300_000;
 
+/**
+ * Hard ceiling for pure search APIs (brave, exa, jina, tavily, kagi,
+ * parallel, searxng, synthetic, zai, duckduckgo). These settle in ~1-3s in
+ * practice; a hung TCP/TLS connection should fall through to the next
+ * provider in seconds, not minutes. Kimi is the exception: it declares an
+ * explicit ceiling aligned with its upstream 30s request budget.
+ */
+export const SEARCH_API_TIMEOUT_MS = 15_000;
+
+/**
+ * Hard ceiling for LLM-mediated search providers (anthropic, codex, gemini,
+ * perplexity, xai, openai-compatible). These legitimately take tens of
+ * seconds because a model performs the search and synthesizes an answer.
+ */
+export const SEARCH_LLM_TIMEOUT_MS = 120_000;
+
+/** Timeout class a provider declares for its outbound round-trips. */
+export type SearchTimeoutClass = "api" | "llm";
+
+const TIMEOUT_CLASS_MS: Record<SearchTimeoutClass, number> = {
+	api: SEARCH_API_TIMEOUT_MS,
+	llm: SEARCH_LLM_TIMEOUT_MS,
+};
+
 /**
  * Runtime-configurable hard timeout, seeded from the `web_search.timeout`
- * setting via {@link setSearchHardTimeoutMs}. Falls back to
- * {@link SEARCH_HARD_TIMEOUT_MS} when unset or invalid.
+ * setting via {@link setSearchHardTimeoutMs}. When set, it overrides every
+ * class default so users keep a single knob. Unset means class defaults apply.
  */
-let configuredHardTimeoutMs = SEARCH_HARD_TIMEOUT_MS;
+let configuredHardTimeoutMs: number | undefined;
 
 /**
  * Override the hard timeout applied to every web-search round-trip.
  *
  * @param ms - Hard timeout in milliseconds. Non-finite or non-positive
- *   values reset the timeout to {@link SEARCH_HARD_TIMEOUT_MS}.
+ *   values clear the override so per-class defaults apply.
  */
 export function setSearchHardTimeoutMs(ms: number | undefined): void {
-	configuredHardTimeoutMs = typeof ms === "number" && Number.isFinite(ms) && ms > 0 ? ms : SEARCH_HARD_TIMEOUT_MS;
+	configuredHardTimeoutMs = typeof ms === "number" && Number.isFinite(ms) && ms > 0 ? ms : undefined;
+}
+
+/** Structural settings source for {@link applyConfiguredSearchTimeout}. */
+export interface SearchTimeoutSettingSource {
+	get(path: "web_search.timeout"): unknown;
+	has(path: "web_search.timeout"): boolean;
+}
+
+/**
+ * Install the `web_search.timeout` override from settings — but only when the
+ * user explicitly configured it. The settings schema ships a default value
+ * (300), and consuming that default via `get()` alone would reinstall a
+ * uniform 300s ceiling on every session, silently disabling the per-class
+ * timeout defaults. `has()` distinguishes loaded/overridden settings from
+ * schema defaults; unset clears any previous override so class defaults apply.
+ */
+export function applyConfiguredSearchTimeout(settings: SearchTimeoutSettingSource): void {
+	if (!settings.has("web_search.timeout")) {
+		setSearchHardTimeoutMs(undefined);
+		return;
+	}
+	const value = settings.get("web_search.timeout");
+	setSearchHardTimeoutMs(typeof value === "number" && Number.isFinite(value) && value > 0 ? value * 1000 : undefined);
 }
 
 /**
  * Compose a caller-supplied {@link AbortSignal} with a hard timeout so an
- * outbound `fetch()` is guaranteed to settle within `ms` even when the
- * runtime fails to propagate cancellation to the underlying transport.
+ * outbound `fetch()` is guaranteed to settle even when the runtime fails to
+ * propagate cancellation to the underlying transport.
  *
  * Bun's WinHTTP backend on Windows is known to ignore `AbortSignal` once a
  * TCP/TLS connection stalls (oven-sh/bun#15275, oven-sh/bun#18536); without
@@ -83,9 +126,16 @@ export function setSearchHardTimeoutMs(ms: number | undefined): void {
  * because the user's Esc is never delivered to the native layer.
  *
  * @param signal - Caller cancellation signal, if any.
- * @param ms - Hard timeout in milliseconds. Defaults to the configured value.
+ * @param msOrClass - Explicit timeout in milliseconds, or a
+ *   {@link SearchTimeoutClass} resolved to its class default. Omitted falls
+ *   back to the legacy {@link SEARCH_HARD_TIMEOUT_MS} ceiling. A user-set
+ *   `web_search.timeout` overrides class defaults (but not explicit ms).
  */
-export function withHardTimeout(signal: AbortSignal | undefined, ms: number = configuredHardTimeoutMs): AbortSignal {
+export function withHardTimeout(signal: AbortSignal | undefined, msOrClass?: number | SearchTimeoutClass): AbortSignal {
+	const ms =
+		typeof msOrClass === "number"
+			? msOrClass
+			: (configuredHardTimeoutMs ?? (msOrClass ? TIMEOUT_CLASS_MS[msOrClass] : SEARCH_HARD_TIMEOUT_MS));
 	const timeout = AbortSignal.timeout(ms);
 	return signal ? AbortSignal.any([signal, timeout]) : timeout;
 }

package/src/web/search/providers/xai.ts

@@ -441,7 +441,7 @@ export async function searchXai(params: XaiSearchParams): Promise<SearchResponse
 				noInlineCitations: params.no_inline_citations,
 			}),
 		),
-		signal: withHardTimeout(params.signal),
+		signal: withHardTimeout(params.signal, "llm"),
 	});
 
 	const text = await response.text();

package/src/web/search/providers/zai.ts

@@ -79,7 +79,7 @@ async function callZaiTool(apiKey: string, args: Record<string, unknown>, signal
 				arguments: args,
 			},
 		}),
-		signal: withHardTimeout(signal),
+		signal: withHardTimeout(signal, "api"),
 	});
 
 	if (!response.ok) {

package/src/web/search/render.ts

@@ -66,6 +66,7 @@ function renderFallbackText(contentText: string, expanded: boolean, theme: Theme
 export interface SearchRenderDetails {
 	response: SearchResponse;
 	error?: string;
+	warning?: string;
 }
 
 /** Render web search result with tree-based layout */
@@ -130,6 +131,8 @@ export function renderSearchResult(
 
 	const metaLines: string[] = [];
 	metaLines.push(`${theme.fg("muted", "Provider:")} ${theme.fg("text", providerLabel)}`);
+	if (details.warning)
+		metaLines.push(`${theme.fg("muted", "Fallback:")} ${theme.fg("warning", truncateToWidth(details.warning, 110))}`);
 	if (response.authMode)
 		metaLines.push(
 			`${theme.fg("muted", "Auth:")} ${theme.fg("text", response.authMode === "oauth" ? "OAuth" : response.authMode === "api_key" ? "API key" : response.authMode)}`,

package/src/workflow/workflow-intent-diff.ts

@@ -0,0 +1,199 @@
+export const WORKFLOW_INTENT_DIFF_CUSTOM_TYPE = "workflow-intent-diff";
+
+export type WorkflowIntentRoute = "direct" | "deep-interview" | "ralplan" | "ultragoal" | "team";
+export type DirectTrackingMode = "custom-entry-only" | "not-direct";
+export type RootCausePhaseStatus = "active" | "inactive";
+
+export interface WorkflowIntentDiff {
+	readonly version: 1;
+	readonly route: WorkflowIntentRoute;
+	readonly reason: string;
+	readonly directTracking: DirectTrackingMode;
+	readonly recommendedSkill?: Exclude<WorkflowIntentRoute, "direct">;
+	readonly recommendedInvocation?: string;
+	readonly triggers: readonly string[];
+	readonly rootCausePhase: {
+		readonly status: RootCausePhaseStatus;
+		readonly triggers: readonly string[];
+	};
+	readonly promptPreview: string;
+}
+
+interface RouteMatch {
+	readonly route: WorkflowIntentRoute;
+	readonly reason: string;
+	readonly recommendedInvocation?: string;
+	readonly triggers: readonly string[];
+}
+
+const PROMPT_PREVIEW_LIMIT = 240;
+
+const DURABLE_TRACKING_PATTERNS = [
+	/\bultragoal\b/i,
+	/\bdurable (?:goal|tracking|ledger|plan)\b/i,
+	/\b(?:goal|tracking|plan) ledger\b/i,
+	/\bcheckpoint(?:ed|ing)? (?:goal|plan|workflow|release|work)\b/i,
+	/\bcheckpoint (?:this|the) (?:goal|plan|workflow|release|work)\b/i,
+] as const;
+
+const AMBIGUOUS_REQUIREMENT_PATTERNS = [
+	/\bambiguous (?:requirement|requirements|request|requests|scope)\b/i,
+	/\bdeep[- ]interview\b/i,
+	/\binterview me\b/i,
+	/\bdon't assume\b/i,
+	/\bnot sure\b/i,
+	/\bunclear\b/i,
+	/\bvague\b/i,
+] as const;
+
+const ARCHITECTURE_SEQUENCE_PATTERNS = [
+	/\barchitecture\b/i,
+	/\barchitectural\b/i,
+	/\bsequence\b/i,
+	/\bmigrate\b/i,
+	/\bmigration\b/i,
+	/\bauth(?:entication|orization)? (?:migration|sequence|rollout|release|refactor|rewrite|transition)\b/i,
+	/\bsecurity\b/i,
+	/\bcompliance\b/i,
+	/\bPII\b/i,
+	/\bproduction (?:release|rollout|deployment|migration|incident|data|change|cutover)\b/i,
+	/\bdeploy(?:ing)? to production\b/i,
+	/\bbreaking change\b/i,
+	/\bdata loss\b/i,
+	/\bdestructive\b/i,
+] as const;
+
+const TEAM_PATTERNS = [
+	/\buse (?:a )?team\b/i,
+	/\bcoordinated (?:persistent )?workers\b/i,
+	/\bpersistent workers\b/i,
+	/\bworker coordination\b/i,
+] as const;
+
+const ROOT_CAUSE_TRIGGERS = [
+	{ name: "contradiction", pattern: /\bcontradict(?:ion|s|ory)?\b/i },
+	{ name: "regression", pattern: /\bregression\b/i },
+	{
+		name: "high-risk transition",
+		pattern:
+			/\b(?:migrate|migration|auth(?:entication|orization)? (?:migration|sequence|rollout|release|refactor|rewrite|transition)|security|breaking change|data loss|destructive|production (?:release|rollout|deployment|migration|incident|data|change|cutover)|deploy(?:ing)? to production|compliance|PII)\b/i,
+	},
+] as const;
+
+function matchesAny(text: string, patterns: readonly RegExp[]): boolean {
+	return patterns.some(pattern => pattern.test(text));
+}
+
+function withGlobal(pattern: RegExp): RegExp {
+	const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+	return new RegExp(pattern.source, flags);
+}
+
+function isNegatedAt(text: string, index: number): boolean {
+	const prefix = text.slice(Math.max(0, index - 48), index).toLowerCase();
+	const boundary = Math.max(
+		prefix.lastIndexOf("."),
+		prefix.lastIndexOf(","),
+		prefix.lastIndexOf(";"),
+		prefix.lastIndexOf(":"),
+		prefix.lastIndexOf("?"),
+		prefix.lastIndexOf("!"),
+		prefix.lastIndexOf("\n"),
+		prefix.lastIndexOf(" but "),
+		prefix.lastIndexOf(" however "),
+		prefix.lastIndexOf(" yet "),
+		prefix.lastIndexOf(" then "),
+	);
+	const localPrefix = boundary >= 0 ? prefix.slice(boundary + 1) : prefix;
+	return /(?:^|[\s([{])(?:no|not|without|excluding|exclude|absent|absence of|avoid)\b[^.,!?;:\n]{0,48}$/.test(
+		localPrefix,
+	);
+}
+
+function matchesAnyNonNegated(text: string, patterns: readonly RegExp[]): boolean {
+	return patterns.some(pattern => {
+		for (const match of text.matchAll(withGlobal(pattern))) {
+			if (!isNegatedAt(text, match.index ?? 0)) return true;
+		}
+		return false;
+	});
+}
+
+function collectRootCauseTriggers(text: string): readonly string[] {
+	return ROOT_CAUSE_TRIGGERS.filter(trigger => matchesAnyNonNegated(text, [trigger.pattern])).map(
+		trigger => trigger.name,
+	);
+}
+
+function buildPromptPreview(text: string): string {
+	const compact = text.replace(/\s+/g, " ").trim();
+	return compact.length > PROMPT_PREVIEW_LIMIT ? `${compact.slice(0, PROMPT_PREVIEW_LIMIT - 3)}...` : compact;
+}
+
+function classifyRoute(text: string): RouteMatch {
+	if (matchesAny(text, AMBIGUOUS_REQUIREMENT_PATTERNS)) {
+		return {
+			route: "deep-interview",
+			reason: "ambiguous requirements need clarification",
+			recommendedInvocation: "/skill:deep-interview",
+			triggers: ["ambiguous requirements"],
+		};
+	}
+
+	if (matchesAny(text, DURABLE_TRACKING_PATTERNS)) {
+		return {
+			route: "ultragoal",
+			reason: "durable tracking requested",
+			recommendedInvocation: "/skill:ultragoal",
+			triggers: ["durable tracking"],
+		};
+	}
+
+	if (matchesAnyNonNegated(text, ARCHITECTURE_SEQUENCE_PATTERNS)) {
+		return {
+			route: "ralplan",
+			reason: "architecture or sequence risk requires deliberate planning",
+			recommendedInvocation: "/skill:ralplan --deliberate",
+			triggers: ["architecture/sequence risk"],
+		};
+	}
+
+	if (matchesAny(text, TEAM_PATTERNS)) {
+		return {
+			route: "team",
+			reason: "coordinated persistent workers requested",
+			recommendedInvocation: "/skill:team",
+			triggers: ["coordinated workers"],
+		};
+	}
+
+	return {
+		route: "direct",
+		reason: "clear low-risk prompt stays on direct implementation path",
+		triggers: ["low-risk direct"],
+	};
+}
+
+export function buildWorkflowIntentDiff(text: string): WorkflowIntentDiff | null {
+	const promptPreview = buildPromptPreview(text);
+	if (!promptPreview) return null;
+
+	const route = classifyRoute(text);
+	const rootCauseTriggers = collectRootCauseTriggers(text);
+	const rootCauseActive = rootCauseTriggers.length > 0;
+	const direct = route.route === "direct";
+
+	return {
+		version: 1,
+		route: route.route,
+		reason: route.reason,
+		directTracking: direct ? "custom-entry-only" : "not-direct",
+		...(direct ? {} : { recommendedSkill: route.route, recommendedInvocation: route.recommendedInvocation }),
+		triggers: route.triggers,
+		rootCausePhase: {
+			status: rootCauseActive ? "active" : "inactive",
+			triggers: rootCauseTriggers,
+		},
+		promptPreview,
+	};
+}

package/vendor/insane-search/MANIFEST.json

@@ -20,9 +20,7 @@
   ],
   "exclusionRationale": "Excludes upstream install hooks (SessionStart settings.json mutation), GitHub star-baiting (gh api user/starred), the update-notifier, and the past-session transcript-language scanner. Only the runtime Phase 0-3 engine and its Playwright/stealth templates are vendored.",
   "localPatches": [
-    "engine/content_safety.py + FetchResult trust/risk metadata (content_trust, prompt_injection_risk, prompt_injection_signals, untrusted_content_boundary) and to_untrusted_text(): cherry-picked from insane-search a16f7c1 (upstream PR #5, v0.9.0). Adds prompt-injection labelling to the JSON surface (to_dict); the default CLI text output is intentionally left unchanged (plain content preserved, no envelope).",
-    "engine/transport.py SessionPool.warmup(): SKC-local fix. warmup() called _fetch_following(..., allow_private, DEFAULT_MAX_REDIRECTS, ...) with both names undefined in that scope -> NameError on every public-root warmup, silently breaking WAF sensor-cookie warmup (Akamai _abck etc.) that protected/adult sites rely on. Now binds allow_private = safety.allow_private_default() and uses safety.DEFAULT_MAX_REDIRECTS. Verified by engine/tests/test_u4.py warmup_once_guard. Re-apply on upstream re-sync.",
-    "engine/validators.py Layer 6 (+ engine/tests/test_u1.py): SKC-local fix. A SOFT challenge marker (captcha/datadome/access denied/checking your browser) hit with no success_selectors no longer forces CHALLENGE when the body is a COMPLETE content-bearing HTML page (_looks_complete_content_page). Such pages (e.g. adult/e-commerce sites that embed reCAPTCHA/age-gate/login scripts site-wide) were fully retrieved yet silently dropped (ok=false), blocking public-page QA. Complete page + soft marker -> WEAK_OK (reason soft_on_complete:*); script-only/incomplete stubs still -> CHALLENGE; HARD markers unchanged. Adds 2 regression tests. Re-apply on upstream re-sync."
+    "engine/content_safety.py + FetchResult trust/risk metadata (content_trust, prompt_injection_risk, prompt_injection_signals, untrusted_content_boundary) and to_untrusted_text(): cherry-picked from insane-search a16f7c1 (upstream PR #5, v0.9.0). Adds prompt-injection labelling to the JSON surface (to_dict); the default CLI text output is intentionally left unchanged (plain content preserved, no envelope)."
   ],
   "notes": "Runtime engine is invoked via `python3 -m engine \"<url>\" --json` with cwd=this directory and PYTHONPATH pointed at this directory. Phase 0-2 require python3 + curl_cffi; Phase 3 requires node + playwright/playwright-extra/puppeteer-extra-plugin-stealth installed under engine/templates. SKC never auto-installs these dependencies."
 }

package/vendor/insane-search/engine/tests/test_u1.py

@@ -163,32 +163,6 @@ def t_validator_small_fragment_still_challenge():
     print(f"  ✓ incomplete fragment → {v.verdict.value}")
 
 
-def t_validator_soft_marker_on_complete_page_is_weak_ok():
-    # A COMPLETE content page that merely embeds a soft marker (e.g. a site-wide
-    # reCAPTCHA / login-modal / age-gate script, common on adult & e-commerce
-    # sites) is a real page we actually retrieved — not a challenge. Regression
-    # guard for the soft-marker false positive that silently dropped fully
-    # rendered pages whose body was already in hand.
-    body = ('<!doctype html><html lang="en"><head><title>Real Page</title>'
-            '<script src="https://www.google.com/recaptcha/api.js"></script></head>'
-            '<body><h1>Welcome</h1><p>' + ('real content ' * 400) +
-            '</p><div class="captcha">protected</div></body></html>')
-    v = validate(_Resp(200, body, headers={"Content-Type": "text/html"}))
-    assert v.body_size >= 3000, v.body_size
-    assert v.verdict == Verdict.WEAK_OK, (v.verdict, v.reasons)
-    assert any("soft_on_complete" in r for r in v.reasons), v.reasons
-    print(f"  ✓ soft marker on complete page → {v.verdict.value} ({v.reasons})")
-
-
-def t_validator_soft_marker_on_stub_still_challenge():
-    # A soft marker on a script-only / incomplete stub (no real visible text)
-    # stays a challenge — the fix must not swallow genuine interstitials.
-    body = '<html><head></head><body><script>showCaptcha();</script></body></html>'
-    v = validate(_Resp(200, body, headers={"Content-Type": "text/html"}))
-    assert v.verdict == Verdict.CHALLENGE, (v.verdict, v.reasons)
-    print(f"  ✓ soft marker on script stub → {v.verdict.value}")
-
-
 ALL = [
     ("scheduler_diversity_under_cap", t_scheduler_diversity_under_cap),
     ("scheduler_avoid_deprioritized_not_deleted", t_scheduler_avoid_deprioritized_not_deleted),
@@ -202,8 +176,6 @@ ALL = [
     ("validator_small_complete_page_is_weak_ok", t_validator_small_complete_page_is_weak_ok),
     ("validator_small_script_stub_still_challenge", t_validator_small_script_stub_still_challenge),
     ("validator_small_fragment_still_challenge", t_validator_small_fragment_still_challenge),
-    ("validator_soft_marker_on_complete_page_is_weak_ok", t_validator_soft_marker_on_complete_page_is_weak_ok),
-    ("validator_soft_marker_on_stub_still_challenge", t_validator_soft_marker_on_stub_still_challenge),
 ]
 
 

package/vendor/insane-search/engine/transport.py

@@ -77,15 +77,14 @@ class SessionPool:
         if ent is None or ent.warmed:
             return False
         from . import safety
-        allow_private = safety.allow_private_default()
-        ok, _reason = safety.classify_url(root_url, allow_private)
+        ok, _reason = safety.classify_url(root_url, safety.allow_private_default())
         if not ok:
             ent.warmed = True   # don't retry a blocked root
             return False
         ent.warmed = True  # mark first to avoid duplicate warmups under race
         def _do_get(u):
             return ent.session.get(u, timeout=timeout, allow_redirects=False)
-        resp, err = self._fetch_following(_do_get, root_url, allow_private, safety.DEFAULT_MAX_REDIRECTS, ent)
+        resp, err = self._fetch_following(_do_get, root_url, allow_private, DEFAULT_MAX_REDIRECTS, ent)
         return resp is not None and err is None
 
     def inject_cookies(self, host: str, impersonate: str,

package/vendor/insane-search/engine/validators.py

@@ -292,20 +292,6 @@ def validate(
     # --- Layer 6: no positive proof — heuristics --------------------------
     soft = _soft_marker_hits(lowered)
     if soft:
-        # Soft markers ("captcha", "datadome", "access denied", "checking your
-        # browser") legitimately appear site-wide in scripts, login/age-gate
-        # modals, and consent banners on real content pages — notably adult and
-        # e-commerce sites that embed reCAPTCHA everywhere. Treating a lone soft
-        # hit as decisive silently drops fully-rendered pages whose body we
-        # actually retrieved. Real WAF interstitials are caught by the HARD
-        # markers above, or are script-only / incomplete stubs that fail the
-        # completeness check. So: a COMPLETE, content-bearing HTML document that
-        # merely mentions a soft marker is a real page (terminal WEAK_OK); only
-        # an incomplete / script-only / stub body stays a challenge.
-        if _looks_complete_content_page(text, lowered):
-            r.verdict = Verdict.WEAK_OK
-            r.reasons.extend(f"soft_on_complete:{m}" for m in soft[:3])
-            return r
         r.verdict = Verdict.CHALLENGE
         r.reasons.extend(f"soft:{m}" for m in soft[:3])
         return r

package/src/defaults/skc/rules/ponytail.md

@@ -1,68 +0,0 @@
----
-name: ponytail
-description: "Lazy senior dev mode — always pick the simplest, shortest solution that works (YAGNI, reuse, stdlib/native first), never cutting validation, error handling, security, or accessibility."
-alwaysApply: true
-license: MIT
-source: https://github.com/DietrichGebert/ponytail
----
-
-# Ponytail — lazy senior dev mode
-
-You write code like the laziest senior dev in the room. Lazy means efficient,
-not careless. The best code is the code you never wrote. This rule governs
-*what* you build, not how you talk.
-
-## The ladder
-
-After you understand the problem, stop at the first rung that holds:
-
-1. **Does this need to exist at all?** Speculative need → skip it, say so in one line (YAGNI).
-2. **Already in this codebase?** A helper, util, type, or pattern that lives here → reuse it. Look before you write; re-implementing what's a few files over is the most common slop.
-3. **Stdlib does it?** Use it.
-4. **Native platform feature covers it?** `<input type="date">` over a picker lib, CSS over JS, DB constraint over app code.
-5. **Already-installed dependency solves it?** Use it. Never add a new dependency for what a few lines can do.
-6. **Can it be one line?** One line.
-7. **Only then:** the minimum code that works.
-
-The ladder runs *after* comprehension, not instead of it. Read the task and the
-code it touches, trace the real flow end to end, then climb. Two rungs work →
-take the higher one and move on.
-
-**Bug fix = root cause, not symptom.** Grep every caller of the function you are
-about to touch. One guard in the shared function is a smaller diff than a guard
-in every caller — and patching only the path the ticket names leaves every
-sibling caller broken.
-
-## Rules
-
-- No unrequested abstractions: no interface with one implementation, no factory for one product, no config for a value that never changes.
-- No boilerplate or scaffolding "for later" — later can scaffold for itself.
-- Deletion over addition. Boring over clever; clever is what someone decodes at 3am.
-- Fewest files possible. Shortest working diff wins — but only once you understand the problem. The smallest change in the wrong place is a second bug, not laziness.
-- Two stdlib options the same size? Take the one that is correct on edge cases.
-- Mark deliberate simplifications with a `ponytail:` comment that names the ceiling and the upgrade path (e.g. `// ponytail: global lock, per-account locks if throughput matters`).
-
-## Output
-
-Code first. Then at most three short lines: what was skipped, when to add it.
-No essays defending a simplification — every paragraph of defense is complexity
-smuggled back in as prose. Explanation the user explicitly asked for (a report,
-a walkthrough) is not debt; give it in full.
-
-Pattern: `[code] → skipped: [X], add when [Y].`
-
-## When NOT to be lazy
-
-Never simplify away: input validation at trust boundaries, error handling that
-prevents data loss, security measures, accessibility basics, or anything
-explicitly requested. Never be lazy about *understanding* the problem — the
-ladder shortens the solution, never the reading. A confident small diff in the
-wrong place is the dangerous kind of lazy.
-
-Non-trivial logic (a branch, loop, parser, money/security path) leaves ONE
-runnable check behind — the smallest thing that fails if the logic breaks. No
-frameworks or fixtures unless asked. Trivial one-liners need no test.
-
----
-
-Adapted from [ponytail](https://github.com/DietrichGebert/ponytail) (MIT) by DietrichGebert.