@sayknow-cli/coding-agent 0.3.8 → 0.3.10

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

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ThinkingLevel } from "@sayknow-cli/agent-core";
+import { ThinkingLevel } from "@sayknow-cli/agent-core";
 import { type Model, modelsAreEqual } from "@sayknow-cli/ai";
 import { getOAuthProviders } from "@sayknow-cli/ai/utils/oauth";
 import { Spacer, Text } from "@sayknow-cli/tui";
@@ -380,6 +380,60 @@ function modelSelectionUsage(runtime: SlashCommandRuntime, currentModelLine?: st
 		.join("\n\n");
 }
 
+const EFFORT_COMMAND_INPUT_HINT = "[inherit|off|minimal|low|medium|high|xhigh|max]";
+const EFFORT_COMMAND_ACCEPTED_VALUES = ["inherit", "off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+function effortCommandUsage(prefix?: string): string {
+	return [prefix, `Usage: /effort ${EFFORT_COMMAND_INPUT_HINT}`]
+		.filter((line): line is string => Boolean(line))
+		.join("\n");
+}
+
+function formatEffortStatus(runtime: SlashCommandRuntime): string {
+	const current = runtime.session.thinkingLevel ?? ThinkingLevel.Off;
+	const configuredDefault = runtime.settings.get("defaultThinkingLevel");
+	const supported = runtime.session.getAvailableThinkingLevels();
+	return [
+		`Current effective effort: ${current}`,
+		`Configured default effort: ${configuredDefault}`,
+		`Accepted values: ${EFFORT_COMMAND_ACCEPTED_VALUES.join(", ")}`,
+		`Current-model supported levels: ${supported.length > 0 ? supported.join(", ") : "(none reported)"}`,
+	].join("\n");
+}
+
+async function handleEffortCommand(
+	command: ParsedSlashCommand,
+	runtime: SlashCommandRuntime,
+): Promise<SlashCommandResult> {
+	const tokens = command.args.trim().split(/\s+/).filter(Boolean);
+	if (tokens.length === 0) {
+		await runtime.output(formatEffortStatus(runtime));
+		return commandConsumed();
+	}
+	if (tokens.length !== 1) {
+		return usage(effortCommandUsage("Invalid effort input."), runtime);
+	}
+
+	const requestedToken = tokens[0];
+	const requestedLevel = parseThinkingLevel(requestedToken);
+	if (!requestedToken || !requestedLevel) {
+		return usage(effortCommandUsage(`Invalid effort: ${tokens[0] ?? ""}.`), runtime);
+	}
+
+	const levelToApply =
+		requestedLevel === ThinkingLevel.Inherit ? runtime.settings.get("defaultThinkingLevel") : requestedLevel;
+	runtime.session.setThinkingLevel(levelToApply, false);
+	const effectiveLevel = runtime.session.thinkingLevel ?? ThinkingLevel.Off;
+	const requestedLabel =
+		requestedLevel === ThinkingLevel.Inherit ? `${requestedLevel} (${levelToApply})` : requestedLevel;
+	const clampedSuffix =
+		effectiveLevel === levelToApply ? "" : ` Requested ${levelToApply}; effective ${effectiveLevel}.`;
+	await runtime.output(
+		`Reasoning effort set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
+	);
+	return commandConsumed();
+}
+
 function refreshStatusLine(ctx: InteractiveModeContext): void {
 	ctx.statusLine.invalidate();
 	ctx.updateEditorTopBorder();
@@ -588,6 +642,29 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "effort",
+		description: "Show or set model reasoning effort",
+		acpDescription: "Show or set model reasoning effort",
+		inlineHint: EFFORT_COMMAND_INPUT_HINT,
+		acpInputHint: EFFORT_COMMAND_INPUT_HINT,
+		allowArgs: true,
+		handle: handleEffortCommand,
+		handleTui: async (command, runtime) => {
+			if (command.args.trim()) {
+				const result = await handleEffortCommand(command, toSlashCommandRuntime(runtime));
+				runtime.ctx.statusLine.invalidate();
+				runtime.ctx.updateEditorBorderColor();
+				runtime.ctx.updateEditorTopBorder();
+				runtime.ctx.editor.setText("");
+				runtime.ctx.ui.requestRender();
+				return result;
+			}
+
+			runtime.ctx.showEffortSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "fast",
 		description: "Toggle priority service tier (OpenAI service_tier=priority, Anthropic speed=fast)",

package/src/system-prompt.ts

@@ -507,7 +507,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 				? loadSkills({ ...skillsSettings, cwd: resolvedCwd }).then(result => result.skills)
 				: Promise.resolve([]);
 
-	const [resolvedCustomPrompt, resolvedAppendPrompt, systemPromptCustomization, contextFiles, skills, workspaceTree] =
+	const [resolvedCustomPrompt, resolvedAppendPrompt, systemPromptCustomization, contextFiles, , workspaceTree] =
 		await Promise.all([
 			withDeadline(
 				"customPrompt",
@@ -581,11 +581,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		description: tools?.get(name)?.description ?? "",
 	}));
 
-	// Filter skills for the rendered system prompt:
-	// - require the `read` tool so the model can actually fetch skill content;
-	// - drop skills with frontmatter `hide: true` (still loadable via skill:// and /skill:<name>).
-	const hasRead = tools?.has("read");
-	const filteredSkills = hasRead ? skills.filter(skill => skill.hide !== true) : [];
+	// Runtime skills are discovered by `skill_discovery` and loaded narrowly through
+	// `skill`; do not dump the full custom skill catalog into the core prompt.
+	const filteredSkills: Skill[] = [];
 
 	const effectiveSystemPromptCustomization = dedupePromptSource(systemPromptCustomization, [
 		resolvedCustomPrompt,

package/src/tools/index.ts

@@ -56,6 +56,7 @@ import { reportFindingTool } from "./review";
 import { SearchTool } from "./search";
 import { SearchToolBm25Tool } from "./search-tool-bm25";
 import { SkillTool } from "./skill";
+import { SkillDiscoveryTool } from "./skill-discovery";
 import { loadSshTool } from "./ssh";
 import { SubagentTool } from "./subagent";
 import { TelegramSendTool } from "./telegram-send";
@@ -95,6 +96,7 @@ export * from "./review";
 export * from "./search";
 export * from "./search-tool-bm25";
 export * from "./skill";
+export * from "./skill-discovery";
 export * from "./ssh";
 export * from "./subagent";
 export * from "./telegram-send";
@@ -411,6 +413,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,
+	skill_discovery: SkillDiscoveryTool.createIf,
 	telegram_send: TelegramSendTool.createIf,
 	write: s => new WriteTool(s),
 	skill: SkillTool.createIf,
@@ -570,6 +573,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "search_tool_bm25") return discoveryActive;
 		if (name === "calc") return session.settings.get("calc.enabled");
 		if (name === "skill") return session.settings.get("skill.enabled");
+		if (name === "skill_discovery") return session.settings.get("skill.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "computer") return isComputerCallable(session);
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");

package/src/tools/skill-discovery.ts

@@ -0,0 +1,73 @@
+import type { AgentTool, AgentToolResult } from "@sayknow-cli/agent-core";
+import { prompt, untilAborted } from "@sayknow-cli/utils";
+import * as z from "zod/v4";
+import { discoverRuntimeSkills, type RuntimeSkillDiscoveryCandidate } from "../extensibility/runtime-skill-discovery";
+import skillDiscoveryDescription from "../prompts/tools/skill-discovery.md" with { type: "text" };
+import type { ToolSession } from ".";
+
+const skillDiscoverySchema = z
+	.object({
+		query: z
+			.string()
+			.optional()
+			.describe("words to match against skill name, description, source, or use conditions"),
+		source: z.enum(["all", "project", "user"]).default("all").optional().describe("skill source scope to search"),
+		limit: z.number().min(1).max(50).default(20).optional().describe("maximum results"),
+	})
+	.strict();
+
+export type SkillDiscoveryToolInput = z.infer<typeof skillDiscoverySchema>;
+
+export interface SkillDiscoveryToolDetails {
+	candidates: RuntimeSkillDiscoveryCandidate[];
+	count: number;
+}
+
+export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema, SkillDiscoveryToolDetails> {
+	readonly name = "skill_discovery";
+	readonly label = "SkillDiscovery";
+	readonly summary = "Discover project and user runtime skills by thin metadata";
+	readonly loadMode = "essential";
+	readonly description: string;
+	readonly parameters = skillDiscoverySchema;
+	readonly strict = true;
+
+	readonly #session: ToolSession;
+
+	constructor(session: ToolSession) {
+		this.#session = session;
+		this.description = prompt.render(skillDiscoveryDescription);
+	}
+
+	#getRuntimeSkillPolicy() {
+		return {
+			...this.#session.settings.getGroup("skills"),
+			disabledExtensions: this.#session.settings.get("disabledExtensions"),
+		};
+	}
+
+	static createIf(session: ToolSession): SkillDiscoveryTool | null {
+		if (session.settings.get("skill.enabled") === false) return null;
+		return new SkillDiscoveryTool(session);
+	}
+
+	async execute(
+		_toolCallId: string,
+		input: SkillDiscoveryToolInput,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<SkillDiscoveryToolDetails>> {
+		return untilAborted(signal, async () => {
+			const candidates = await discoverRuntimeSkills({
+				cwd: this.#session.cwd,
+				query: input.query,
+				source: input.source ?? "all",
+				limit: input.limit,
+				policy: this.#getRuntimeSkillPolicy(),
+			});
+			return {
+				content: [{ type: "text", text: JSON.stringify({ candidates, count: candidates.length }, null, 2) }],
+				details: { candidates, count: candidates.length },
+			};
+		});
+	}
+}

package/src/tools/skill.ts

@@ -18,6 +18,7 @@
 import type { AgentTool, AgentToolResult } from "@sayknow-cli/agent-core";
 import { prompt, untilAborted } from "@sayknow-cli/utils";
 import * as z from "zod/v4";
+import { findRuntimeSkillByName } from "../extensibility/runtime-skill-discovery";
 import { resolveSubskillActivationForSkillInvocation } from "../extensibility/skc-plugins";
 import { buildSkillPromptMessage } from "../extensibility/skills";
 import skillDescription from "../prompts/tools/skill.md" with { type: "text" };
@@ -64,6 +65,13 @@ export class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails
 		this.description = prompt.render(skillDescription);
 	}
 
+	#getRuntimeSkillPolicy() {
+		return {
+			...this.#session.settings.getGroup("skills"),
+			disabledExtensions: this.#session.settings.get("disabledExtensions"),
+		};
+	}
+
 	static createIf(session: ToolSession): SkillTool | null {
 		// The tool can only chain when the session can deliver the same-turn
 		// custom message. Without `sendCustomMessage` (e.g. minimal tool
@@ -110,10 +118,15 @@ export class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails
 				);
 			}
 
-			const skill = skills.find(s => s.name === requestedName);
+			const skill =
+				skills.find(s => s.name === requestedName) ??
+				(await findRuntimeSkillByName(this.#session.cwd, requestedName, this.#getRuntimeSkillPolicy()));
 			if (!skill) {
 				const available = skills.map(s => s.name).sort();
-				const hint = available.length > 0 ? ` Available: ${available.join(", ")}` : "";
+				const hint =
+					available.length > 0
+						? ` Available: ${available.join(", ")}. Use skill_discovery to find project/user runtime skills.`
+						: " Use skill_discovery to find project/user runtime skills.";
 				throw new ToolError(`skill tool: unknown skill "${requestedName}".${hint}`);
 			}
 

package/src/utils/pasted-image-path.ts

@@ -0,0 +1,170 @@
+/**
+ * Resolve pasted editor text to an image file path.
+ *
+ * Terminals insert a shell-escaped filesystem path when a file is drag-dropped
+ * onto them (e.g. macOS `Screenshot\ 2026-07-07\ at\ 11.06.38 PM.png`, where
+ * the visible "space" before AM/PM is U+202F and stays unescaped). When the
+ * entire paste is a single path to an existing image file, the interactive
+ * editor attaches the image and inserts an `[image N]` placeholder instead of
+ * leaving the raw path in the prompt.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const IMAGE_FILE_EXTENSION_PATTERN = /\.(?:png|jpe?g|gif|webp)$/i;
+
+export interface DecodePastedPathOptions {
+	/**
+	 * Platform whose path semantics apply when decoding (shell unescaping,
+	 * `file://` drive letters / UNC hosts). Defaults to `process.platform`;
+	 * injectable so tests can pin the win32 contract from any host.
+	 */
+	platform?: NodeJS.Platform;
+	/** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
+	homedir?: string;
+}
+
+export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
+	/** Base directory for relative paths. Defaults to `process.cwd()`. */
+	cwd?: string;
+}
+
+/**
+ * Convert a `file://` URI to a filesystem path for the given platform, or
+ * `undefined` when the URI is invalid.
+ *
+ * The production path (injected platform === host platform, always true
+ * outside tests) delegates to Node's `fileURLToPath`. When tests inject a
+ * foreign platform, a mirror of `fileURLToPath`'s rules is applied instead —
+ * Bun (1.3) accepts but ignores `fileURLToPath`'s `windows` option, so the
+ * native call cannot emulate a foreign platform.
+ */
+function decodeFileUrl(candidate: string, platform: NodeJS.Platform): string | undefined {
+	let url: URL;
+	try {
+		url = new URL(candidate);
+	} catch {
+		return undefined;
+	}
+	if (url.protocol !== "file:") return undefined;
+
+	if (platform === process.platform) {
+		try {
+			return fileURLToPath(url);
+		} catch {
+			return undefined;
+		}
+	}
+
+	// Foreign-platform mirror of fileURLToPath (tests only).
+	if (/%2f/i.test(url.pathname) || (platform === "win32" && /%5c/i.test(url.pathname))) return undefined;
+	let pathname: string;
+	try {
+		pathname = decodeURIComponent(url.pathname);
+	} catch {
+		return undefined;
+	}
+	if (platform === "win32") {
+		if (url.hostname && url.hostname !== "localhost") {
+			// UNC: file://server/share/img.png -> \\server\share\img.png
+			return `\\\\${url.hostname}${pathname.replaceAll("/", "\\")}`;
+		}
+		// Drive letter required: file:///C:/x -> C:\x
+		if (!/^\/[A-Za-z]:/.test(pathname)) return undefined;
+		return pathname.slice(1).replaceAll("/", "\\");
+	}
+	if (url.hostname && url.hostname !== "localhost") return undefined;
+	return pathname;
+}
+
+/**
+ * Decode pasted text into a filesystem path candidate. No filesystem access.
+ *
+ * Handles terminal drag-drop shell escaping (`\ `, `\(`, ...; skipped on
+ * win32 where `\` is the path separator), quoted paths, `file://` URIs
+ * (drive-letter, `file://localhost`, and UNC forms on win32), and `~/`
+ * expansion. Returns `undefined` when the text is empty, spans multiple
+ * lines, or is an invalid `file://` URI.
+ */
+export function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined {
+	const platform = options?.platform ?? process.platform;
+	let candidate = text.trim();
+	if (!candidate || /[\r\n]/.test(candidate)) return undefined;
+
+	// Quoted paths (some terminals quote instead of escaping).
+	if (
+		candidate.length >= 2 &&
+		(candidate.startsWith('"') || candidate.startsWith("'")) &&
+		candidate.endsWith(candidate[0])
+	) {
+		candidate = candidate.slice(1, -1);
+	}
+
+	if (candidate.startsWith("file://")) {
+		const decoded = decodeFileUrl(candidate, platform);
+		if (decoded === undefined) return undefined;
+		candidate = decoded;
+	} else if (platform !== "win32") {
+		// Terminal drag-drop escapes shell-special characters (`\ `, `\(`, ...).
+		// Skipped on Windows where `\` is the path separator.
+		candidate = candidate.replace(/\\(.)/g, "$1");
+	}
+
+	if (candidate.startsWith("~/")) {
+		candidate = path.join(options?.homedir ?? os.homedir(), candidate.slice(2));
+	}
+
+	return candidate;
+}
+
+/**
+ * Sniff the file header for a supported image signature (PNG, JPEG, GIF,
+ * WEBP). Prevents existing non-image files with image-looking extensions
+ * (e.g. a text file named `not-image.png`) from being treated as image
+ * candidates — consuming such a paste would lose the raw path when the
+ * image loader later rejects the content.
+ */
+function hasSupportedImageMagic(filePath: string): boolean {
+	let fd: number;
+	try {
+		fd = fs.openSync(filePath, "r");
+	} catch {
+		return false;
+	}
+	try {
+		// Zero-filled; short reads leave trailing zeros so comparisons fail safely.
+		const header = Buffer.alloc(12);
+		fs.readSync(fd, header, 0, 12, 0);
+		if (header[0] === 0x89 && header[1] === 0x50 && header[2] === 0x4e && header[3] === 0x47) return true; // PNG
+		if (header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff) return true; // JPEG
+		const ascii6 = header.toString("latin1", 0, 6);
+		if (ascii6 === "GIF87a" || ascii6 === "GIF89a") return true; // GIF
+		if (header.toString("latin1", 0, 4) === "RIFF" && header.toString("latin1", 8, 12) === "WEBP") return true; // WEBP
+		return false;
+	} catch {
+		return false;
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+
+/**
+ * Returns the resolved path when the whole pasted text is a single path to an
+ * existing image file (verified by extension AND content signature),
+ * otherwise `undefined` (the paste is inserted as text).
+ */
+export function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined {
+	const candidate = decodePastedPathCandidate(text, options);
+	if (!candidate || !IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
+
+	const resolved = path.resolve(options?.cwd ?? process.cwd(), candidate);
+	try {
+		if (!fs.statSync(resolved).isFile()) return undefined;
+	} catch {
+		return undefined;
+	}
+	if (!hasSupportedImageMagic(resolved)) return undefined;
+	return resolved;
+}