@sayknow-cli/coding-agent 0.3.9 → 0.3.10

package/src/session/agent-session.ts

@@ -473,6 +473,8 @@ export interface PromptOptions {
 	images?: ImageContent[];
 	/** When streaming, how to queue the message: "steer" (interrupt) or "followUp" (wait). */
 	streamingBehavior?: "steer" | "followUp";
+	/** When set to "sequential", this follow-up is delivered one prompt at a time even if followUpMode is "all". */
+	followUpQueuePolicy?: "respect-mode" | "sequential";
 	/** Optional tool choice override for the next LLM call. */
 	toolChoice?: ToolChoice;
 	/** Send as developer/system message instead of user. Providers that support it use the developer role; others fall back to user. */
@@ -5304,7 +5306,9 @@ export class AgentSession {
 				throw new AgentBusyError();
 			}
 			if (options.streamingBehavior === "followUp") {
-				await this.#queueFollowUp(expandedText, options?.images);
+				await this.#queueFollowUp(expandedText, options?.images, {
+					forceOneAtATime: options.followUpQueuePolicy === "sequential",
+				});
 			} else {
 				await this.#queueSteer(expandedText, options?.images);
 			}
@@ -5422,7 +5426,7 @@ export class AgentSession {
 
 	async promptCustomMessage<T = unknown>(
 		message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">,
-		options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice">,
+		options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy">,
 	): Promise<void> {
 		const textContent =
 			typeof message.content === "string"
@@ -5436,7 +5440,10 @@ export class AgentSession {
 			if (!options?.streamingBehavior) {
 				throw new AgentBusyError();
 			}
-			await this.sendCustomMessage(message, { deliverAs: options.streamingBehavior });
+			await this.sendCustomMessage(message, {
+				deliverAs: options.streamingBehavior,
+				followUpQueuePolicy: options.followUpQueuePolicy,
+			});
 			return;
 		}
 
@@ -5783,13 +5790,19 @@ export class AgentSession {
 	/**
 	 * Queue a follow-up message to process after the agent would otherwise stop.
 	 */
-	async followUp(text: string, images?: ImageContent[]): Promise<void> {
+	async followUp(
+		text: string,
+		images?: ImageContent[],
+		options?: Pick<PromptOptions, "followUpQueuePolicy">,
+	): Promise<void> {
 		if (text.startsWith("/")) {
 			this.#throwIfExtensionCommand(text);
 		}
 
 		const expandedText = expandPromptTemplate(text, [...this.#promptTemplates]);
-		await this.#queueFollowUp(expandedText, images);
+		await this.#queueFollowUp(expandedText, images, {
+			forceOneAtATime: options?.followUpQueuePolicy === "sequential",
+		});
 	}
 
 	/**
@@ -5826,19 +5839,22 @@ export class AgentSession {
 	/**
 	 * Internal: Queue a follow-up message (already expanded, no extension command check).
 	 */
-	async #queueFollowUp(text: string, images?: ImageContent[]): Promise<void> {
+	async #queueFollowUp(text: string, images?: ImageContent[], options?: { forceOneAtATime?: boolean }): Promise<void> {
 		const displayText = text || (images && images.length > 0 ? "[Image]" : "");
 		this.#followUpMessages.push(this.#createQueuedDisplayEntry(displayText));
 		const content: (TextContent | ImageContent)[] = [{ type: "text", text }];
 		if (images && images.length > 0) {
 			content.push(...images);
 		}
-		this.agent.followUp({
-			role: "user",
-			content,
-			attribution: "user",
-			timestamp: Date.now(),
-		});
+		this.agent.followUp(
+			{
+				role: "user",
+				content,
+				attribution: "user",
+				timestamp: Date.now(),
+			},
+			options?.forceOneAtATime ? { forceOneAtATime: true } : undefined,
+		);
 		// When fully idle AND the session is in a resumable assistant-ended state,
 		// schedule an immediate continue so the queued follow-up is delivered
 		// without waiting for the next user turn. We gate on isStreaming (model
@@ -5986,7 +6002,11 @@ export class AgentSession {
 	 */
 	async sendCustomMessage<T = unknown>(
 		message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">,
-		options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" | "nextTurn" },
+		options?: {
+			triggerTurn?: boolean;
+			deliverAs?: "steer" | "followUp" | "nextTurn";
+			followUpQueuePolicy?: "respect-mode" | "sequential";
+		},
 	): Promise<void> {
 		const appMessage: CustomMessage<T> = {
 			role: "custom",
@@ -6004,7 +6024,10 @@ export class AgentSession {
 			}
 
 			if (options?.deliverAs === "followUp") {
-				this.agent.followUp(appMessage);
+				this.agent.followUp(
+					appMessage,
+					options.followUpQueuePolicy === "sequential" ? { forceOneAtATime: true } : undefined,
+				);
 			} else {
 				this.agent.steer(appMessage);
 			}
@@ -6930,7 +6953,7 @@ export class AgentSession {
 
 	/**
 	 * Set thinking level.
-	 * Saves the effective metadata-clamped level to session and settings only if it changes.
+	 * Saves the effective metadata-clamped level to the session, and to settings when requested.
 	 */
 	setThinkingLevel(level: ThinkingLevel | undefined, persist: boolean = false): void {
 		const effectiveLevel = resolveThinkingLevelForModel(this.model, level);
@@ -6939,11 +6962,12 @@ export class AgentSession {
 		this.#thinkingLevel = effectiveLevel;
 		this.agent.setThinkingLevel(toReasoningEffort(effectiveLevel));
 
+		if (persist && effectiveLevel !== undefined) {
+			this.settings.set("defaultThinkingLevel", effectiveLevel);
+		}
+
 		if (isChanging) {
 			this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-			if (persist && effectiveLevel !== undefined && effectiveLevel !== ThinkingLevel.Off) {
-				this.settings.set("defaultThinkingLevel", effectiveLevel);
-			}
 			this.#emit({ type: "thinking_level_changed", thinkingLevel: effectiveLevel });
 		}
 	}

package/src/skc-runtime/psmux-detect.ts

@@ -115,6 +115,20 @@ function outputMentionsPsmux(output: string): boolean {
 	return PSMUX_VERSION_MARKERS.some(marker => output.includes(marker));
 }
 
+function normalizedCommandBaseName(command: string): string {
+	const normalized = command
+		.trim()
+		.replace(/^['"]|['"]$/g, "")
+		.replace(/\\/g, "/");
+	const basename = normalized.slice(normalized.lastIndexOf("/") + 1).toLowerCase();
+	return basename.endsWith(".exe") ? basename.slice(0, -4) : basename;
+}
+
+function isNamedPsmuxCommand(command: string): boolean {
+	const basename = normalizedCommandBaseName(command);
+	return basename === "psmux" || basename === "pmux";
+}
+
 function resolveBinaryPath(candidate: string): string | null {
 	return activeBinaryResolver(candidate);
 }
@@ -194,13 +208,14 @@ export function resolveSkcTmuxBinary(options: ResolveSkcTmuxBinaryOptions = {}):
 	const runner = options.runner ?? readSpawnRunner();
 	const explicit = env.SKC_TMUX_COMMAND?.trim() || env.SKC_TEAM_TMUX_COMMAND?.trim();
 	if (explicit) {
-		const isPsmux = detectPsmux(explicit, { env, runner });
+		const isPsmux =
+			platform === "win32" && isNamedPsmuxCommand(explicit) ? true : detectPsmux(explicit, { env, runner });
 		return { command: explicit, isPsmux, viaExplicitOverride: true };
 	}
 	if (platform === "win32") {
 		for (const candidate of PSMUX_BINARY_NAMES) {
 			if (resolveBinaryPath(candidate)) {
-				const isPsmux = detectPsmux(candidate, { env, runner });
+				const isPsmux = isNamedPsmuxCommand(candidate) ? true : detectPsmux(candidate, { env, runner });
 				return { command: candidate, isPsmux, viaExplicitOverride: false };
 			}
 		}

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}`);
 			}