@sayknow-cli/coding-agent 0.3.2 → 0.3.5

package/dist/types/skc-runtime/state-renderer.d.ts

@@ -39,6 +39,11 @@ export declare function renderUltragoalStatusMarkdown(summary: {
     };
     counts: Record<string, number>;
     goals: unknown[];
+    nudgeBudget?: number;
+    nudgeCount?: number;
+    nudgeRemaining?: number;
+    nudgeGoalId?: string;
+    nudgeTargetKind?: string;
 }): string;
 export declare function renderTeamStatusMarkdown(snapshot: {
     team_name: string;

package/dist/types/skc-runtime/ultragoal-guard.d.ts

@@ -1,4 +1,4 @@
-import { type UltragoalGoal, type UltragoalLedgerEvent, type UltragoalPlan, type UltragoalReceiptKind } from "./ultragoal-runtime";
+import { type UltragoalGoal, type UltragoalLedgerEvent, type UltragoalNudgeSurface, type UltragoalPlan, type UltragoalReceiptKind } from "./ultragoal-runtime";
 export type UltragoalGuardState = "inactive" | "unrelated_goal" | "active_verified_complete" | "active_missing_receipt" | "active_stale_receipt" | "active_missing_final_receipt" | "active_dirty_quality_gate" | "active_review_blocked_unrecorded" | "active_review_blocked_recorded" | "unreadable_fail_closed";
 export interface UltragoalGuardDiagnostic {
     state: UltragoalGuardState;
@@ -30,6 +30,29 @@ export declare function readUltragoalVerificationState(input: {
     sessionId?: string | null;
 }): Promise<UltragoalGuardDiagnostic>;
 export declare function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic>;
+/**
+ * Escalating per-attempt refusal text. Deliberately avoids every
+ * `isUltragoalBypassPrompt` trigger: no `update_goal(`, no "skip/weaken verification",
+ * no "mark ... complete", no "--status complete", and the word "complete" never
+ * appears (so the `goal` ... `complete` proximity rule cannot match).
+ */
+export declare function formatUltragoalNudgeMessage(input: {
+    surface: UltragoalNudgeSurface;
+    attempt: number;
+    budget: number;
+    goalId: string;
+}): string;
+/**
+ * Assert-path entry for the `ask` surface (the ask guard lives in another module).
+ * Resolves the active (leader) Ultragoal session so subagent/headless asks consume
+ * the leader run's budget rather than a fresh child ledger.
+ */
+export declare function consumeUltragoalAskNudge(cwd: string, sessionId?: string | null): Promise<{
+    nudged: true;
+    message: string;
+} | {
+    nudged: false;
+}>;
 export declare function assertCanCompleteCurrentGoal(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;
@@ -49,3 +72,16 @@ export interface UltragoalPauseBlockDiagnostic {
  */
 export declare function isUltragoalPauseBlocked(cwd: string): Promise<UltragoalPauseBlockDiagnostic>;
 export declare function assertUltragoalPauseAllowed(cwd: string): Promise<void>;
+/**
+ * Guard `goal({"op":"drop"})` during an active Ultragoal run. A *real give-up* (an
+ * aggregate run still mid-flight with incomplete required stories) is nudged while
+ * budget remains; once exhausted it falls through to today's drop behavior. Legitimate
+ * aggregate-reset drops — no durable run, unrelated goal, an already dropped/stale
+ * aggregate, or an all-stories-complete run — are never nudged. If durable state
+ * exists but cannot be read to classify the drop, fail closed.
+ */
+export declare function assertUltragoalDropAllowed(input: {
+    cwd: string;
+    currentGoal?: CurrentGoalLike | null;
+    sessionId?: string | null;
+}): Promise<void>;

package/dist/types/skc-runtime/ultragoal-runtime.d.ts

@@ -53,6 +53,41 @@ export interface UltragoalLedgerEvent extends JsonObject {
     goalId?: string;
     timestamp?: string;
 }
+export type UltragoalNudgeSurface = "pause" | "drop" | "ask" | "premature_complete";
+export type UltragoalNudgeTargetKind = "story" | "final_aggregate_receipt";
+export interface UltragoalNudgeLedgerEvent extends UltragoalLedgerEvent {
+    event: "nudge";
+    goalId: string;
+    targetKind: UltragoalNudgeTargetKind;
+    surface: UltragoalNudgeSurface;
+    attempt: number;
+    budget: number;
+    reason: string;
+    currentGoalObjective?: string;
+}
+export interface UltragoalNudgeTarget {
+    goalId: string;
+    targetKind: UltragoalNudgeTargetKind;
+}
+export type UltragoalNudgeOutcome = {
+    nudged: true;
+    attempt: number;
+    budget: number;
+    goalId: string;
+    targetKind: UltragoalNudgeTargetKind;
+    event: UltragoalNudgeLedgerEvent;
+} | {
+    nudged: false;
+    exhausted: true;
+    count: number;
+    budget: number;
+    goalId: string;
+    targetKind: UltragoalNudgeTargetKind;
+} | {
+    nudged: false;
+    inactive: true;
+    reason: string;
+};
 export interface UltragoalPaths {
     dir: string;
     briefPath: string;
@@ -67,6 +102,11 @@ export interface UltragoalStatusSummary {
     currentGoal?: UltragoalGoal;
     counts: Record<UltragoalGoalStatus, number>;
     goals: UltragoalGoal[];
+    nudgeBudget?: number;
+    nudgeCount?: number;
+    nudgeRemaining?: number;
+    nudgeGoalId?: string;
+    nudgeTargetKind?: UltragoalNudgeTargetKind;
 }
 export interface UltragoalCommandResult {
     reviewBlockerGoalIds?: string[];
@@ -82,6 +122,46 @@ interface JsonObject {
 export declare function hashStructuredValue(value: unknown): string;
 export declare function getUltragoalPaths(cwd: string, sessionId?: string | null): UltragoalPaths;
 export declare function readUltragoalLedger(cwd: string, sessionId?: string | null): Promise<UltragoalLedgerEvent[]>;
+export declare const DEFAULT_ULTRAGOAL_NUDGE_BUDGET = 10;
+/** Pure: count ledger `nudge` rows for an exact goalId. */
+export declare function countUltragoalNudges(ledger: readonly UltragoalLedgerEvent[], goalId: string): number;
+/**
+ * Resolve the per-story nudge budget. Project `./.skc/settings.json` overrides the
+ * user settings (`$SKC_CONFIG_DIR/settings.json` or `~/.skc/settings.json`), else the
+ * default. Mirrors the `skc.deepInterview.ambiguityThreshold` user+project precedence.
+ */
+export declare function resolveUltragoalNudgeBudget(cwd: string): Promise<{
+    budget: number;
+    source: string;
+}>;
+/**
+ * Pure canonical selector shared by guards and status so `nudgeGoalId` can never
+ * diverge between what a guard consumes and what status displays. Prefers the active
+ * current-goal objective, then active > pending > failed (matching `chooseNextGoal`),
+ * then the aggregate final-receipt target when all stories are complete but the
+ * aggregate run still needs a final receipt. Returns null for verified-complete or
+ * absent/unrelated plans.
+ */
+export declare function selectUltragoalNudgeTarget(plan: UltragoalPlan, options?: {
+    currentGoalObjective?: string;
+    retryFailed?: boolean;
+}): UltragoalNudgeTarget | null;
+/**
+ * Atomic consuming writer. Locks the ledger path, rereads + counts nudge rows for the
+ * target story, and appends exactly one `nudge` row inside the same critical section
+ * only while budget remains. Reuses the lockless `appendLedger` inside the lock (it
+ * does not acquire a conflicting lock), so concurrent guarded attempts cannot both
+ * observe `count = budget - 1` and overshoot the budget.
+ */
+export declare function recordUltragoalNudgeIfBudgetRemaining(input: {
+    cwd: string;
+    sessionId?: string | null;
+    target: UltragoalNudgeTarget;
+    surface: UltragoalNudgeSurface;
+    budget: number;
+    reason: string;
+    currentGoalObjective?: string;
+}): Promise<UltragoalNudgeOutcome>;
 export declare function computeUltragoalPlanGeneration(input: {
     plan: UltragoalPlan;
     ledger: readonly UltragoalLedgerEvent[];

package/dist/types/tools/browser/tab-supervisor.d.ts

@@ -28,6 +28,10 @@ export interface TabSession {
     kindTag: BrowserKindTag;
     /** Session that acquired this tab; used for session-scoped teardown (F13). */
     ownerId?: string;
+    /** Unix-ms timestamp of the last acquire/run activity; drives GC idle + LRU ordering. */
+    lastUsedAt: number;
+    /** Set synchronously by the shared begin-release guard so concurrent release is a no-op. */
+    releasing?: boolean;
 }
 export interface AcquireTabOptions {
     url?: string;
@@ -58,6 +62,33 @@ export interface ReleaseTabOptions {
     kill?: boolean;
 }
 export declare function getTab(name: string): TabSession | undefined;
+/** Read-only, GC-facing projection of a live tab. Never exposes the mutable `tabs` map. */
+export interface TabGcSnapshot {
+    name: string;
+    ownerId?: string;
+    state: TabSession["state"];
+    pendingCount: number;
+    kindTag: BrowserKindTag;
+    lastUsedAt: number;
+    browserRefCount: number;
+}
+export interface BrowserGcEligibilityPolicy {
+    now: () => number;
+    idleMs: number;
+}
+/** Snapshot every live tab for GC ordering/diagnostics. */
+export declare function listTabsForGc(): TabGcSnapshot[];
+/**
+ * Evict a tab only if it is still GC-eligible against the LIVE supervisor state. The full
+ * predicate is checked synchronously and `releaseTab` is invoked with no intervening await,
+ * so a tab that became busy after a GC snapshot cannot be closed (its run rejected). Returns
+ * true only when the tab was actually released.
+ */
+export declare function releaseTabIfGcEligible(name: string, policy: BrowserGcEligibilityPolicy): Promise<boolean>;
+/** Test-only: install a fabricated tab session. */
+export declare function setTabForTest(tab: TabSession): void;
+/** Test-only: clear the tab registry between cases. */
+export declare function clearTabsForTest(): void;
 export declare function acquireTab(name: string, browser: BrowserHandle, opts: AcquireTabOptions): Promise<AcquireTabResult>;
 export declare function runInTab(name: string, opts: RunInTabOptions): Promise<RunResultOk>;
 export declare function releaseTab(name: string, opts?: ReleaseTabOptions): Promise<boolean>;

package/dist/types/tools/computer-gc.d.ts

@@ -0,0 +1,23 @@
+/** Prefix of every computer-use screenshot fallback directory created under the OS temp dir. */
+export declare const SCREENSHOT_FALLBACK_DIR_PREFIX = "skc-computer-screenshots-";
+/** Lazy-arm marker: called when the first screenshot fallback dir is created this process. */
+export declare function markScreenshotFallbackDirCreatedForGc(): void;
+/** Whether any screenshot fallback dir has been created this process (GC lazy-arm gate). */
+export declare function hasCreatedScreenshotFallbackDir(): boolean;
+/** Test-only: reset the lazy-arm marker between cases. */
+export declare function resetScreenshotFallbackGcForTest(): void;
+export interface ScreenshotGcOptions {
+    now: () => number;
+    staleMs: number;
+    /** Base dir to scan; defaults to os.tmpdir(). Injectable for tests. */
+    tmpDir?: string;
+}
+/**
+ * Disk-only GC for stale computer-use screenshot fallback directories. Scans the temp dir for
+ * `skc-computer-screenshots-*` directories and removes those whose mtime is older than `staleMs`.
+ * Never throws on a per-directory failure; the whole sweep is best-effort.
+ */
+export declare function cleanupStaleScreenshotFallbackDirs(options: ScreenshotGcOptions): Promise<{
+    scanned: number;
+    removed: number;
+}>;

package/dist/types/tools/cron.d.ts

@@ -5,18 +5,18 @@ import type { ToolSession } from "./index";
 export declare const MAX_CRON_TASKS_PER_OWNER = 50;
 /** Recurring tasks auto-expire 7 days after creation (mirrors upstream). */
 export declare const CRON_RECURRING_MAX_AGE_MS: number;
-declare const cronCreateSchema: z.ZodObject<{
-    cron_expression: z.ZodString;
-    prompt: z.ZodString;
-    recurring: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-export type CronCreateParams = z.infer<typeof cronCreateSchema>;
-declare const cronListSchema: z.ZodObject<{}, z.core.$strip>;
-export type CronListParams = z.infer<typeof cronListSchema>;
-declare const cronDeleteSchema: z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>;
-export type CronDeleteParams = z.infer<typeof cronDeleteSchema>;
+declare const cronSchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        list: "list";
+    }>;
+    cron_expression: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    recurring: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CronParams = z.infer<typeof cronSchema>;
 export interface CronJobSnapshot {
     id: string;
     cron_expression: string;
@@ -35,18 +35,14 @@ export interface CronListJobDetails {
     prompt: string;
     humanSchedule: string;
 }
-export interface CronCreateToolDetails {
-    id: string;
-    cron_expression: string;
-    recurring: boolean;
+export interface CronToolDetails {
+    op: "create" | "list" | "delete";
+    id?: string;
+    cron_expression?: string;
+    recurring?: boolean;
     nextFireAt?: number;
-}
-export interface CronListToolDetails {
-    jobs: CronListJobDetails[];
-}
-export interface CronDeleteToolDetails {
-    id: string;
-    deleted: boolean;
+    jobs?: CronListJobDetails[];
+    deleted?: boolean;
 }
 /** Clear every schedule for an owner. Exported for tests + lifecycle teardown. */
 export declare function clearOwnerSchedules(ownerId: string | undefined): void;
@@ -68,49 +64,28 @@ export declare function calculateCronFireTimeMs(params: {
     nowMs: number;
     expiresAt?: number;
 }): number;
-export declare class CronCreateTool implements AgentTool<typeof cronCreateSchema, CronCreateToolDetails> {
-    private readonly session;
-    readonly name = "CronCreate";
-    readonly label = "CronCreate";
-    readonly summary = "Schedule a prompt on a 5-field cron expression";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        cron_expression: z.ZodString;
-        prompt: z.ZodString;
-        recurring: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>;
-    readonly strict = true;
-    readonly loadMode = "discoverable";
-    constructor(session: ToolSession);
-    static createIf(session: ToolSession): CronCreateTool | null;
-    execute(_toolCallId: string, params: CronCreateParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronCreateToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronCreateToolDetails>>;
-}
-export declare class CronListTool implements AgentTool<typeof cronListSchema, CronListToolDetails> {
-    private readonly session;
-    readonly name = "CronList";
-    readonly label = "CronList";
-    readonly summary = "List scheduled cron jobs";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{}, z.core.$strip>;
-    readonly strict = true;
-    readonly loadMode = "discoverable";
-    constructor(session: ToolSession);
-    static createIf(session: ToolSession): CronListTool | null;
-    execute(_toolCallId: string, _params: CronListParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronListToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronListToolDetails>>;
-}
-export declare class CronDeleteTool implements AgentTool<typeof cronDeleteSchema, CronDeleteToolDetails> {
+export declare class CronTool implements AgentTool<typeof cronSchema, CronToolDetails> {
+    #private;
     private readonly session;
-    readonly name = "CronDelete";
-    readonly label = "CronDelete";
-    readonly summary = "Cancel a scheduled cron job by ID";
+    readonly name = "cron";
+    readonly label = "Cron";
+    readonly summary = "Schedule, list, and cancel cron-style prompts (op: create | list | delete)";
     readonly description: string;
     readonly parameters: z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>;
+        op: z.ZodEnum<{
+            create: "create";
+            delete: "delete";
+            list: "list";
+        }>;
+        cron_expression: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+        recurring: z.ZodOptional<z.ZodBoolean>;
+        id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
     readonly strict = true;
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    static createIf(session: ToolSession): CronDeleteTool | null;
-    execute(_toolCallId: string, params: CronDeleteParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronDeleteToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronDeleteToolDetails>>;
+    static createIf(session: ToolSession): CronTool | null;
+    execute(_toolCallId: string, params: CronParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<CronToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<CronToolDetails>>;
 }
 export {};

package/dist/types/tools/index.d.ts

@@ -41,7 +41,6 @@ export * from "./eval";
 export * from "./find";
 export * from "./gh";
 export * from "./image-gen";
-export * from "./inspect-image";
 export * from "./irc";
 export * from "./job";
 export * from "./monitor";

package/dist/types/tools/resource-gc.d.ts

@@ -0,0 +1,54 @@
+import type { Settings } from "../config/settings";
+import { type TabGcSnapshot } from "./browser/tab-supervisor";
+export interface BrowserGcPolicy {
+    enabled: boolean;
+    idleMs: number;
+    rssLimitBytes: number;
+}
+export interface ComputerGcPolicy {
+    enabled: boolean;
+    staleMs: number;
+    scanIntervalMs: number;
+}
+export declare function resolveBrowserGcPolicy(settings: Settings): BrowserGcPolicy;
+export declare function resolveComputerGcPolicy(settings: Settings): ComputerGcPolicy;
+export declare function resolveSweepIntervalMs(settings: Settings): number;
+/** Injectable seams so the controller is fully testable without real browsers/filesystem/RSS. */
+export interface ResourceGcDeps {
+    now: () => number;
+    rssBytes: () => number;
+    logWarn: (msg: string, meta?: Record<string, unknown>) => void;
+    listTabs: () => TabGcSnapshot[];
+    releaseTab: (name: string, policy: {
+        now: () => number;
+        idleMs: number;
+    }) => Promise<boolean>;
+    cleanupScreenshots: (opts: {
+        now: () => number;
+        staleMs: number;
+    }) => Promise<{
+        scanned: number;
+        removed: number;
+    }>;
+    screenshotArmed: () => boolean;
+}
+export interface ResourceGcRegistration {
+    sessionId: string;
+    settings: Settings;
+}
+/**
+ * Register a session with the resource GC. Starts the single shared timer on the first
+ * registration. Returns an idempotent unregister function; the timer stops only when the last
+ * session unregisters.
+ */
+export declare function registerResourceGcSession(reg: ResourceGcRegistration): () => void;
+export declare function sweepOnce(d?: ResourceGcDeps): Promise<void>;
+export declare function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>): void;
+export declare function __runResourceGcTickForTest(): Promise<void>;
+export declare function __getResourceGcStateForTest(): {
+    timerActive: boolean;
+    sessionCount: number;
+    rssWarningActive: boolean;
+    inProgress: boolean;
+};
+export declare function __resetResourceGcForTest(): void;

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

@@ -111,5 +111,6 @@ export declare class WebSearchTool implements AgentTool<typeof webSearchSchema,
 export declare const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails>;
 export declare function getSearchTools(): CustomTool<any, any>[];
 export { getSearchProvider, setPreferredSearchProvider, setSearchFallbackProviders } from "./provider";
+export { setSearchHardTimeoutMs } from "./providers/utils";
 export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
 export { isConfigurableSearchProviderId, isSearchProviderPreference } from "./types";

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

@@ -15,16 +15,23 @@ import { SearchProviderError, type SearchProviderId, type SearchSource } from ".
  */
 export declare function findCredential(storage: AgentStorage | null | undefined, envKey: string | null | undefined, ...storageProviders: string[]): string | null;
 /**
- * Default hard ceiling for a single web-search round-trip. 60s tolerates
+ * 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
- * within a minute if Bun's `AbortSignal` fails to propagate on Windows.
+ * 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.
  */
-export declare const SEARCH_HARD_TIMEOUT_MS = 60000;
+export declare const SEARCH_HARD_TIMEOUT_MS = 300000;
+/**
+ * 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}.
+ */
+export declare function setSearchHardTimeoutMs(ms: number | undefined): void;
 /**
  * Compose a caller-supplied {@link AbortSignal} with a hard timeout so an
  * outbound `fetch()` is guaranteed to settle within `ms` even when the
@@ -36,7 +43,7 @@ export declare const SEARCH_HARD_TIMEOUT_MS = 60000;
  * 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 {@link SEARCH_HARD_TIMEOUT_MS}.
+ * @param ms - Hard timeout in milliseconds. Defaults to the configured value.
  */
 export declare function withHardTimeout(signal: AbortSignal | undefined, ms?: number): AbortSignal;
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/coding-agent",
-	"version": "0.3.2",
+	"version": "0.3.5",
 	"description": "Sayknow-CLI CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/jaybeyond/Sayknow_CLI",
 	"author": "jaybeyond",
@@ -52,12 +52,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@sayknow-cli/stats": "0.3.2",
-		"@sayknow-cli/agent-core": "0.3.2",
-		"@sayknow-cli/ai": "0.3.2",
-		"@sayknow-cli/natives": "0.3.2",
-		"@sayknow-cli/tui": "0.3.2",
-		"@sayknow-cli/utils": "0.3.2",
+		"@sayknow-cli/stats": "0.3.5",
+		"@sayknow-cli/agent-core": "0.3.5",
+		"@sayknow-cli/ai": "0.3.5",
+		"@sayknow-cli/natives": "0.3.5",
+		"@sayknow-cli/tui": "0.3.5",
+		"@sayknow-cli/utils": "0.3.5",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/verify-insane-vendor.ts

@@ -28,6 +28,11 @@ function fail(msg: string): void {
 function walk(dir: string): string[] {
 	const out: string[] = [];
 	for (const entry of readdirSync(dir)) {
+		// node_modules holds locally-installed Phase 3 runtime deps (gitignored,
+		// never vendored and never packed by npm). Vendor checks apply only to
+		// vendored upstream source; third-party package files legitimately carry
+		// paths like ".../references/" that would otherwise false-positive.
+		if (entry === "node_modules") continue;
 		const full = join(dir, entry);
 		if (statSync(full).isDirectory()) out.push(...walk(full));
 		else out.push(full);

package/src/cli/args.ts

@@ -284,7 +284,6 @@ ${chalk.bold("Available Tools (default-enabled unless noted):")}
   lsp           - Language server protocol (code intelligence)
   python        - Execute Python code (requires: ${APP_NAME} setup python)
   notebook      - Edit Jupyter notebooks
-  inspect_image - Analyze images with a vision model
   browser       - Browser automation (Puppeteer)
   task          - Launch sub-agents for parallel tasks
   todo_write    - Manage todo/task lists

package/src/cli/fast-help.ts

@@ -97,7 +97,6 @@ Available Tools (default-enabled unless noted):
   lsp           - Language server protocol (code intelligence)
   python        - Execute Python code (requires: ${APP_NAME} setup python)
   notebook      - Edit Jupyter notebooks
-  inspect_image - Analyze images with a vision model
   browser       - Browser automation (Puppeteer)
   task          - Launch sub-agents for parallel tasks
   todo_write    - Manage todo/task lists

package/src/cli/plugin-cli.ts

@@ -16,8 +16,8 @@ import {
 	getPluginsCacheDir,
 	MarketplaceManager,
 } from "../extensibility/plugins/marketplace/index.js";
-import { installSkcPluginBundle, isSkcPluginBundleSource, readRegistry } from "../extensibility/skc-plugins";
 import { type ScanReport, scanPluginDir } from "../extensibility/plugins/security-scanner";
+import { installSkcPluginBundle, isSkcPluginBundleSource, readRegistry } from "../extensibility/skc-plugins";
 import { theme } from "../modes/theme/theme";
 
 // =============================================================================

package/src/cli/web-search-cli.ts

@@ -15,6 +15,7 @@ import {
 	type SearchQueryParams,
 } from "../web/search/index";
 import { SEARCH_PROVIDER_ORDER, setPreferredSearchProvider, setSearchFallbackProviders } from "../web/search/provider";
+import { setSearchHardTimeoutMs } from "../web/search/providers/utils";
 import { renderSearchResult } from "../web/search/render";
 import type { SearchProviderId } from "../web/search/types";
 
@@ -179,6 +180,10 @@ export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 			configuredFallback.filter(value => typeof value === "string" && isConfigurableSearchProviderId(value)),
 		);
 	}
+	const configuredTimeout = settings.get("web_search.timeout");
+	if (typeof configuredTimeout === "number" && Number.isFinite(configuredTimeout) && configuredTimeout > 0) {
+		setSearchHardTimeoutMs(configuredTimeout * 1000);
+	}
 
 	const params: SearchQueryParams = {
 		query: cmd.query,

package/src/config/model-profile-activation.ts

@@ -9,6 +9,7 @@ import {
 } from "./model-profiles";
 import {
 	isAuthenticated,
+	kNoAuth,
 	type ModelRegistry,
 	SKC_MODEL_ASSIGNMENT_TARGETS,
 	type SkcModelAssignmentTargetId,
@@ -192,7 +193,12 @@ export async function prepareModelProfileActivation(
 	const authenticatedProviders: string[] = [];
 	for (const provider of allProviders) {
 		const apiKey = await options.modelRegistry.getApiKeyForProvider(provider, options.session.sessionId);
-		if (!isAuthenticated(apiKey)) {
+		// kNoAuth ("N/A") is the sentinel for keyless/no-auth providers (local LLMs,
+		// `--auth none` custom providers): usable WITHOUT a key. isAuthenticated()
+		// rejects it, so gate on usability ("a credential resolved OR keyless")
+		// rather than "has a real key" — otherwise activating a keyless profile
+		// throws a spurious "requires credentials" error and the model never applies.
+		if (!isAuthenticated(apiKey) && apiKey !== kNoAuth) {
 			missingProviders.push(provider);
 		} else {
 			authenticatedProviders.push(provider);

package/src/config/model-profiles.ts

@@ -23,8 +23,8 @@ export interface ModelProfileDefinition {
 
 export interface ResolvedProfileBinding {
 	defaultSelector?: string;
-	modelRoles: Partial<Record<"vision", string>>;
-	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default" | "vision">, string>>;
+	modelRoles: Record<string, string>;
+	agentModelOverrides: Partial<Record<Exclude<ModelProfileRole, "default">, string>>;
 }
 
 function parseModelSelectorProvider(selector: string): string | undefined {
@@ -383,9 +383,8 @@ export function mergeModelProfiles(userProfiles?: ModelsConfig["profiles"]): Map
 }
 
 export function resolveProfileBindings(definition: ModelProfileDefinition): ResolvedProfileBinding {
-	const { default: defaultSelector, vision, executor, architect, planner, critic } = definition.modelMapping;
+	const { default: defaultSelector, executor, architect, planner, critic } = definition.modelMapping;
 	const modelRoles: ResolvedProfileBinding["modelRoles"] = {};
-	if (vision !== undefined) modelRoles.vision = vision;
 	const agentModelOverrides: ResolvedProfileBinding["agentModelOverrides"] = {};
 	if (executor !== undefined) agentModelOverrides.executor = executor;
 	if (architect !== undefined) agentModelOverrides.architect = architect;

package/src/config/model-registry.ts

@@ -70,7 +70,7 @@ export function isAuthenticated(apiKey: string | undefined | null): apiKey is st
 	return Boolean(apiKey) && apiKey !== kNoAuth;
 }
 
-export type ModelRole = "default" | "vision";
+export type ModelRole = "default";
 
 export interface ModelRoleInfo {
 	tag?: string;
@@ -80,12 +80,11 @@ export interface ModelRoleInfo {
 
 export const MODEL_ROLES: Record<ModelRole, ModelRoleInfo> = {
 	default: { tag: "DEFAULT", name: "Default", color: "success" },
-	vision: { tag: "VISION", name: "Vision", color: "accent" },
 };
 
-export const MODEL_ROLE_IDS: ModelRole[] = ["default", "vision"];
+export const MODEL_ROLE_IDS: ModelRole[] = ["default"];
 
-export type SkcModelAssignmentTargetId = "default" | "vision" | "executor" | "architect" | "planner" | "critic";
+export type SkcModelAssignmentTargetId = "default" | "executor" | "architect" | "planner" | "critic";
 
 export interface SkcModelAssignmentTargetInfo extends ModelRoleInfo {
 	id: SkcModelAssignmentTargetId;
@@ -94,7 +93,6 @@ export interface SkcModelAssignmentTargetInfo extends ModelRoleInfo {
 
 export const SKC_MODEL_ASSIGNMENT_TARGET_IDS: SkcModelAssignmentTargetId[] = [
 	"default",
-	"vision",
 	"executor",
 	"architect",
 	"planner",
@@ -103,7 +101,6 @@ export const SKC_MODEL_ASSIGNMENT_TARGET_IDS: SkcModelAssignmentTargetId[] = [
 
 export const SKC_MODEL_ASSIGNMENT_TARGETS: Record<SkcModelAssignmentTargetId, SkcModelAssignmentTargetInfo> = {
 	default: { id: "default", tag: "DEFAULT", name: "Default", color: "success", settingsPath: "modelRoles" },
-	vision: { id: "vision", tag: "VISION", name: "Vision", color: "accent", settingsPath: "modelRoles" },
 	executor: {
 		id: "executor",
 		tag: "EXECUTOR",

package/src/config/models-config-schema.ts

@@ -81,7 +81,7 @@ const ModelBindingsSchema = z.object({
 	modelRoles: z.record(z.string(), z.string().min(1)).optional(),
 	agentModelOverrides: z.record(z.string(), z.string().min(1)).optional(),
 });
-export const ProfileRoleSchema = z.enum(["default", "vision", "executor", "architect", "planner", "critic"]);
+export const ProfileRoleSchema = z.enum(["default", "executor", "architect", "planner", "critic"]);
 
 function isValidProfileModelSelector(value: string): boolean {
 	if (value.includes(",")) return false;