@sayknow-cli/coding-agent 0.3.6 → 0.3.7

package/src/system-prompt.ts

@@ -356,6 +356,10 @@ export interface BuildSystemPromptOptions {
 	mcpDiscoveryMode?: boolean;
 	/** Discoverable MCP server summaries to advertise when discovery mode is active. */
 	mcpDiscoveryServerSummaries?: string[];
+	/** Whether built-in tool discovery ("all" mode) is active; enables the tool-discovery prompt block. */
+	toolDiscoveryActive?: boolean;
+	/** Hidden discoverable tools to advertise (name + one-line summary) when tool discovery is active. */
+	discoverableTools?: Array<{ name: string; summary: string }>;
 	/** Encourage the agent to delegate via tasks unless changes are trivial. */
 	eagerTasks?: boolean;
 	/** Rules with alwaysApply=true — their full content is injected into the prompt. */
@@ -394,6 +398,8 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		intentField,
 		mcpDiscoveryMode = false,
 		mcpDiscoveryServerSummaries = [],
+		toolDiscoveryActive = false,
+		discoverableTools = [],
 		eagerTasks = false,
 		secretsEnabled = false,
 		workspaceTree: providedWorkspaceTree,
@@ -572,6 +578,8 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		mcpDiscoveryMode,
 		hasMCPDiscoveryServers: mcpDiscoveryServerSummaries.length > 0,
 		mcpDiscoveryServerSummaries,
+		toolDiscoveryActive,
+		discoverableTools,
 		eagerTasks,
 		secretsEnabled,
 	};

package/src/task/executor.ts

@@ -1535,6 +1535,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					);
 					await awaitAbortable(session.waitForIdle());
 				} catch (err) {
+					// An abort (parent cancel, session shutdown, timeout) rejects
+					// awaitAbortable with ToolAbortError — a cancellation, not a prompt
+					// failure. Mirror the outer catch's `!abortSignal.aborted` guard so
+					// expected cancellations aren't logged at error level.
+					if (abortSignal.aborted || err instanceof ToolAbortError) break;
 					logger.error("Subagent prompt failed", {
 						error: err instanceof Error ? err.message : String(err),
 					});

package/src/tools/ast-grep.ts

@@ -223,13 +223,16 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				const modelOut: string[] = [];
 				const displayOut: string[] = [];
 				const fileMatches = matchesByFile.get(relativePath) ?? [];
-				const lineNumberWidth = fileMatches.reduce((width, match) => {
-					const lineCount = match.text.split("\n").length;
-					const endLine = match.startLine + lineCount - 1;
-					return Math.max(width, String(match.startLine).length, String(endLine).length);
-				}, 0);
-				for (const match of fileMatches) {
-					const matchLines = match.text.split("\n");
+				const preparedMatches = fileMatches.map(match => {
+					const lines = match.text.split("\n");
+					const endLine = match.startLine + lines.length - 1;
+					return { match, lines, endLine };
+				});
+				const lineNumberWidth = preparedMatches.reduce(
+					(width, entry) => Math.max(width, String(entry.match.startLine).length, String(entry.endLine).length),
+					0,
+				);
+				for (const { match, lines: matchLines } of preparedMatches) {
 					for (let index = 0; index < matchLines.length; index++) {
 						const lineNumber = match.startLine + index;
 						const isMatch = index === 0;

package/src/tools/bash.ts

@@ -14,7 +14,10 @@ import bashDescription from "../prompts/tools/bash.md" with { type: "text" };
 import type { ClientBridgeTerminalExitStatus, ClientBridgeTerminalOutput } from "../session/client-bridge";
 import { DEFAULT_MAX_BYTES, streamTailUpdates, TailBuffer } from "../session/streaming-output";
 import { buildSkcRuntimeSessionEnv } from "../skc-runtime/goal-mode-request";
-import { SKC_RESTRICTED_ROLE_AGENT_BASH_ENV } from "../skc-runtime/restricted-role-agent-bash";
+import {
+	SKC_RALPLAN_ARTIFACT_ENV,
+	SKC_RESTRICTED_ROLE_AGENT_BASH_ENV,
+} from "../skc-runtime/restricted-role-agent-bash";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { getSixelLineMask } from "../utils/sixel";
@@ -530,13 +533,24 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 
 		const rawCommand = input.command;
 		const allowedPrefixes = this.session.bashAllowedPrefixes;
+		const isRestrictedRalplanArtifactEnv =
+			allowedPrefixes &&
+			allowedPrefixes.length > 0 &&
+			this.session.bashRestrictionProfile !== "read-only" &&
+			env &&
+			Object.keys(env).length === 1 &&
+			Object.hasOwn(env, SKC_RALPLAN_ARTIFACT_ENV) &&
+			rawCommand.includes(`--artifact-env ${SKC_RALPLAN_ARTIFACT_ENV}`);
 		if (
 			(this.session.bashRestrictionProfile === "read-only" || (allowedPrefixes && allowedPrefixes.length > 0)) &&
 			env &&
-			Object.keys(env).length > 0
+			Object.keys(env).length > 0 &&
+			!isRestrictedRalplanArtifactEnv
 		) {
 			const mode = this.session.bashRestrictionProfile === "read-only" ? "Read-only" : "Restricted role-agent";
-			throw new ToolError(`${mode} bash does not allow per-command env overrides.`);
+			throw new ToolError(
+				`${mode} bash only allows the ${SKC_RALPLAN_ARTIFACT_ENV} env override for --artifact-env.`,
+			);
 		}
 		if (allowedPrefixes && allowedPrefixes.length > 0) {
 			const commandsToCheck = rawCommand === command ? [command] : [rawCommand, command];
@@ -597,11 +611,13 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					await Promise.all(
 						Object.entries(env).map(async ([key, value]) => [
 							key,
-							await expandInternalUrls(value, {
-								...internalUrlOptions,
-								ensureLocalParentDirs: true,
-								noEscape: true,
-							}),
+							key === SKC_RALPLAN_ARTIFACT_ENV
+								? value
+								: await expandInternalUrls(value, {
+										...internalUrlOptions,
+										ensureLocalParentDirs: true,
+										noEscape: true,
+									}),
 						]),
 					),
 				)
@@ -817,9 +833,22 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			});
 		}
 
+		// Route through the client terminal when the client advertises the terminal capability.
+		// Skip when pty=true (PTY needs the local terminal UI).
+		const clientBridge =
+			this.session.bashRestrictionProfile === "read-only" ? undefined : this.session.getClientBridge?.();
+		const clientTerminalActive = Boolean(clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty);
+
 		const autoBgManager = AsyncJobManager.instance();
-		if (this.#autoBackgroundEnabled && !pty && autoBgManager) {
-			const autoBackgroundWaitMs = this.#resolveAutoBackgroundWaitMs(timeoutMs);
+		// Run non-PTY bash through the managed job path so Ctrl+B-twice fold-on-demand works
+		// even when auto-background is disabled. When a client terminal will handle the
+		// command, keep the existing bridge path unless auto-background is enabled.
+		if (!pty && autoBgManager && (this.#autoBackgroundEnabled || !clientTerminalActive)) {
+			// With auto-background off, wait past the command's own timeout so the job only
+			// leaves the foreground on an explicit Ctrl+B fold, never on an auto-background timer.
+			const autoBackgroundWaitMs = this.#autoBackgroundEnabled
+				? this.#resolveAutoBackgroundWaitMs(timeoutMs)
+				: timeoutMs + 1_000;
 			const startBackgrounded = autoBackgroundWaitMs === 0;
 			const job = this.#startManagedBashJob({
 				command,
@@ -875,10 +904,6 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			});
 		}
 
-		// Route through the client terminal when the client advertises the terminal capability.
-		// Skip when pty=true (PTY needs the local terminal UI).
-		const clientBridge =
-			this.session.bashRestrictionProfile === "read-only" ? undefined : this.session.getClientBridge?.();
 		if (clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty) {
 			const handle = await clientBridge.createTerminal({
 				command,

package/src/tools/index.ts

@@ -325,7 +325,14 @@ export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool |
 export type BuiltinToolLoadMode = "essential" | "discoverable";
 
 /** Default essential tool names when tools.essentialOverride is empty. */
-export const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[] = ["read", "bash", "edit"] as const;
+export const DEFAULT_ESSENTIAL_TOOL_NAMES: readonly string[] = [
+	"read",
+	"bash",
+	"edit",
+	"write",
+	"search",
+	"find",
+] as const;
 
 /**
  * Resolve the active essential built-in tool names from settings.

package/src/tools/skill.ts

@@ -50,7 +50,7 @@ export class SkillTool implements AgentTool<typeof skillSchema, SkillToolDetails
 	readonly name = "skill";
 	readonly label = "Skill";
 	readonly summary = "Chain into another available skill in the current turn";
-	readonly loadMode = "discoverable";
+	readonly loadMode = "essential";
 	readonly description: string;
 	readonly parameters = skillSchema;
 	readonly strict = true;

package/src/utils/cmux-workspace.ts

@@ -0,0 +1,233 @@
+import { logger } from "@sayknow-cli/utils";
+
+const CMUX_COMMAND = "cmux";
+const CMUX_WORKSPACE_ID_ENV = "CMUX_WORKSPACE_ID";
+const CMUX_NO_RENAME_ENV = "SKC_NO_CMUX_RENAME";
+const CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
+const CMUX_WORKSPACE_TITLE_PREFIX = "SKC: ";
+const CMUX_WORKSPACE_RENAME_TIMEOUT_MS = 1500;
+const CMUX_WORKSPACE_LIST_TIMEOUT_MS = 1500;
+
+export interface CmuxWorkspaceRenameCommand {
+	command: string;
+	args: string[];
+}
+
+/** Current ownership state of a cmux workspace, read back from `cmux workspace list`. */
+export interface CmuxWorkspaceOwnership {
+	/** cmux marks a workspace `has_custom_title` once an explicit title is set (by the user or by SKC). */
+	hasCustomTitle: boolean;
+	/** The workspace's current display title. */
+	title: string;
+}
+
+export interface CmuxWorkspaceRenameProcess {
+	exited: Promise<number>;
+	kill(): void;
+	unref(): void;
+}
+
+export interface CmuxWorkspaceTitleSyncOptions {
+	env?: NodeJS.ProcessEnv;
+	isTty?: boolean;
+	which?: (command: string) => string | null;
+	spawn?: (
+		command: string[],
+		options: { env: NodeJS.ProcessEnv; stdin: "ignore"; stdout: "ignore"; stderr: "ignore" },
+	) => CmuxWorkspaceRenameProcess;
+	/** Reads the current ownership state of `workspaceId`. Injectable for tests. */
+	readOwnership?: (
+		cmuxCommand: string,
+		workspaceId: string,
+		env: NodeJS.ProcessEnv,
+	) => Promise<CmuxWorkspaceOwnership | null>;
+}
+
+function defaultSpawn(
+	command: string[],
+	options: { env: NodeJS.ProcessEnv; stdin: "ignore"; stdout: "ignore"; stderr: "ignore" },
+): CmuxWorkspaceRenameProcess {
+	return Bun.spawn(command, options);
+}
+
+function isEnvSet(value: string | undefined): boolean {
+	if (!value) return false;
+	const normalized = value.trim().toLowerCase();
+	return normalized !== "" && normalized !== "0" && normalized !== "false";
+}
+
+export function sanitizeCmuxWorkspaceTitle(title: string | undefined): string | undefined {
+	if (!title) return undefined;
+	const sanitized = title.replace(CONTROL_CHARS, " ").replace(/\s+/g, " ").trim();
+	return sanitized || undefined;
+}
+
+export function formatCmuxWorkspaceTitle(title: string | undefined): string | undefined {
+	const sanitized = sanitizeCmuxWorkspaceTitle(title);
+	if (!sanitized) return undefined;
+	return sanitized.startsWith(CMUX_WORKSPACE_TITLE_PREFIX) ? sanitized : `${CMUX_WORKSPACE_TITLE_PREFIX}${sanitized}`;
+}
+
+export function buildCmuxWorkspaceRenameCommand(
+	sessionName: string | undefined,
+	env: NodeJS.ProcessEnv = process.env,
+): CmuxWorkspaceRenameCommand | null {
+	const workspaceId = env[CMUX_WORKSPACE_ID_ENV]?.trim();
+	if (!workspaceId) return null;
+
+	const title = formatCmuxWorkspaceTitle(sessionName);
+	if (!title) return null;
+
+	return {
+		command: CMUX_COMMAND,
+		args: ["workspace", "rename", workspaceId, "--title", title],
+	};
+}
+
+/** Parse `cmux workspace list --json --id-format both` output and return the
+ * ownership state of the workspace matching `workspaceId` (by UUID `id` or `ref`). */
+export function parseCmuxWorkspaceOwnership(jsonText: string, workspaceId: string): CmuxWorkspaceOwnership | null {
+	const target = workspaceId.trim().toLowerCase();
+	if (!target) return null;
+
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(jsonText);
+	} catch {
+		return null;
+	}
+
+	const workspaces = (parsed as { workspaces?: unknown }).workspaces;
+	if (!Array.isArray(workspaces)) return null;
+
+	for (const entry of workspaces) {
+		if (!entry || typeof entry !== "object") continue;
+		const record = entry as Record<string, unknown>;
+		const id = typeof record.id === "string" ? record.id.toLowerCase() : "";
+		const ref = typeof record.ref === "string" ? record.ref.toLowerCase() : "";
+		if (id !== target && ref !== target) continue;
+		return {
+			hasCustomTitle: record.has_custom_title === true,
+			title: typeof record.title === "string" ? record.title : "",
+		};
+	}
+	return null;
+}
+
+/** Only rename when SKC owns the name:
+ * - unknown ownership (read failed) → skip (fail safe, never clobber)
+ * - already the desired title → skip (no-op)
+ * - workspace still on its default title → rename
+ * - any custom title (user- or peer-set) → skip
+ * This makes SKC name a fresh workspace once and then leave it alone, so it
+ * never overwrites a user-pinned name and multiple sessions sharing one
+ * CMUX_WORKSPACE_ID do not thrash the workspace title. */
+export function shouldRenameCmuxWorkspace(ownership: CmuxWorkspaceOwnership | null, desiredTitle: string): boolean {
+	if (!ownership) return false;
+	if ((sanitizeCmuxWorkspaceTitle(ownership.title) ?? "") === desiredTitle) return false;
+	return !ownership.hasCustomTitle;
+}
+
+async function defaultReadOwnership(
+	cmuxCommand: string,
+	workspaceId: string,
+	env: NodeJS.ProcessEnv,
+): Promise<CmuxWorkspaceOwnership | null> {
+	try {
+		const proc = Bun.spawn([cmuxCommand, "workspace", "list", "--json", "--id-format", "both"], {
+			env: { ...env, CMUX_QUIET: "1" },
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "ignore",
+		});
+		const timer = setTimeout(() => {
+			try {
+				proc.kill();
+			} catch {}
+		}, CMUX_WORKSPACE_LIST_TIMEOUT_MS);
+		timer.unref?.();
+		const text = await new Response(proc.stdout).text();
+		await proc.exited;
+		clearTimeout(timer);
+		return parseCmuxWorkspaceOwnership(text, workspaceId);
+	} catch (error) {
+		logger.debug("cmux workspace list failed", { error: String(error) });
+		return null;
+	}
+}
+
+/**
+ * Best-effort sync of the containing cmux workspace title to the current SKC
+ * session name. Ownership-guarded: SKC reads the current workspace title and
+ * only renames a workspace that still has its default title, so it never
+ * overwrites a name the user pinned or a name a peer session (sharing the same
+ * CMUX_WORKSPACE_ID) set. Opt out with SKC_NO_CMUX_RENAME.
+ */
+export async function syncCmuxWorkspaceTitle(
+	sessionName: string | undefined,
+	options: CmuxWorkspaceTitleSyncOptions = {},
+): Promise<void> {
+	const env = options.env ?? process.env;
+	if (isEnvSet(env[CMUX_NO_RENAME_ENV])) return;
+
+	const isTty = options.isTty ?? process.stdout.isTTY === true;
+	if (!isTty) return;
+
+	const workspaceId = env[CMUX_WORKSPACE_ID_ENV]?.trim();
+	if (!workspaceId) return;
+
+	const desired = formatCmuxWorkspaceTitle(sessionName);
+	if (!desired) return;
+
+	const which = options.which ?? Bun.which;
+	let resolvedCommand: string | null;
+	try {
+		resolvedCommand = which(CMUX_COMMAND);
+	} catch (error) {
+		logger.debug("cmux workspace rename command lookup failed", { error: String(error) });
+		return;
+	}
+	if (!resolvedCommand) return;
+
+	let ownership: CmuxWorkspaceOwnership | null;
+	try {
+		const readOwnership = options.readOwnership ?? defaultReadOwnership;
+		ownership = await readOwnership(resolvedCommand, workspaceId, env);
+	} catch (error) {
+		logger.debug("cmux workspace ownership read failed", { error: String(error) });
+		return;
+	}
+
+	if (!shouldRenameCmuxWorkspace(ownership, desired)) return;
+
+	const plan = buildCmuxWorkspaceRenameCommand(sessionName, env);
+	if (!plan) return;
+
+	const spawn = options.spawn ?? defaultSpawn;
+	try {
+		const proc = spawn([resolvedCommand, ...plan.args], {
+			env,
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "ignore",
+		});
+		proc.unref();
+		const timer = setTimeout(() => {
+			try {
+				proc.kill();
+			} catch {}
+		}, CMUX_WORKSPACE_RENAME_TIMEOUT_MS);
+		timer.unref?.();
+		void proc.exited
+			.then(exitCode => {
+				clearTimeout(timer);
+				if (exitCode !== 0) logger.debug("cmux workspace rename exited non-zero", { exitCode });
+			})
+			.catch(error => {
+				clearTimeout(timer);
+				logger.debug("cmux workspace rename failed", { error: String(error) });
+			});
+	} catch (error) {
+		logger.debug("cmux workspace rename failed to start", { error: String(error) });
+	}
+}

package/src/utils/title-generator.ts

@@ -9,6 +9,7 @@ import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
+import { syncCmuxWorkspaceTitle } from "./cmux-workspace";
 
 const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 
@@ -218,6 +219,7 @@ export function setTerminalTitle(title: string): void {
 
 export function setSessionTerminalTitle(sessionName: string | undefined, cwd?: string): void {
 	setTerminalTitle(formatSessionTerminalTitle(sessionName, cwd));
+	void syncCmuxWorkspaceTitle(sessionName);
 }
 
 /**

package/src/web/kagi.ts

@@ -147,7 +147,7 @@ export async function searchWithKagi(
 
 	const response = await fetch(requestUrl, {
 		headers: getAuthHeaders(apiKey),
-		signal: withHardTimeout(options.signal),
+		signal: withHardTimeout(options.signal, "api"),
 	});
 	if (!response.ok) {
 		throw parseKagiErrorResponse(response.status, await response.text());

package/src/web/parallel.ts

@@ -306,7 +306,7 @@ export async function searchWithParallel(
 				max_chars_per_result: options.maxCharsPerResult ?? 10_000,
 			},
 		}),
-		signal: withHardTimeout(options.signal),
+		signal: withHardTimeout(options.signal, "api"),
 	});
 	if (!response.ok) {
 		throw parseParallelErrorResponse(response.status, await response.text());
@@ -338,7 +338,7 @@ export async function extractWithParallel(
 			excerpts: options.excerpts ?? true,
 			full_content: options.fullContent ?? false,
 		}),
-		signal: withHardTimeout(options.signal),
+		signal: withHardTimeout(options.signal, "api"),
 	});
 	if (!response.ok) {
 		throw parseParallelErrorResponse(response.status, await response.text());