@sayknow-cli/coding-agent 0.4.7 → 0.5.0

package/src/tools/skill-discovery.ts

@@ -21,6 +21,13 @@ export type SkillDiscoveryToolInput = z.infer<typeof skillDiscoverySchema>;
 export interface SkillDiscoveryToolDetails {
 	candidates: RuntimeSkillDiscoveryCandidate[];
 	count: number;
+	/**
+	 * Present only when zero candidates were returned AND discovery config gates
+	 * (`skills.enabled` / `skills.enablePiProject` / `skills.enablePiUser`)
+	 * prevented some or all of the requested scope from being searched. Without
+	 * this, a disabled config is indistinguishable from "no skills exist".
+	 */
+	notice?: string;
 }
 
 export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema, SkillDiscoveryToolDetails> {
@@ -57,17 +64,46 @@ export class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema
 		signal?: AbortSignal,
 	): Promise<AgentToolResult<SkillDiscoveryToolDetails>> {
 		return untilAborted(signal, async () => {
+			const source = input.source ?? "all";
 			const candidates = await discoverRuntimeSkills({
 				cwd: this.#session.cwd,
 				query: input.query,
-				source: input.source ?? "all",
+				source,
 				limit: input.limit,
 				policy: this.#getRuntimeSkillPolicy(),
 			});
+			const details: SkillDiscoveryToolDetails = { candidates, count: candidates.length };
+			if (candidates.length === 0) {
+				const notice = this.#disabledPolicyNotice(source);
+				if (notice) details.notice = notice;
+			}
 			return {
-				content: [{ type: "text", text: JSON.stringify({ candidates, count: candidates.length }, null, 2) }],
-				details: { candidates, count: candidates.length },
+				content: [{ type: "text", text: JSON.stringify(details, null, 2) }],
+				details,
 			};
 		});
 	}
+
+	/**
+	 * Explain an empty result that is caused by disabled discovery config rather
+	 * than by an actually empty skill catalog.
+	 */
+	#disabledPolicyNotice(source: "all" | "project" | "user"): string | undefined {
+		const policy = this.#getRuntimeSkillPolicy();
+		if (policy.enabled !== true) {
+			return "Runtime skill discovery is disabled: `skills.enabled` is false, so no skill directories were searched. Enable it with `skc config set skills.enabled true` (project and user scopes additionally require `skills.enablePiProject` / `skills.enablePiUser`).";
+		}
+		const skipped: string[] = [];
+		const commands: string[] = [];
+		if ((source === "all" || source === "project") && policy.enablePiProject !== true) {
+			skipped.push("project (`skills.enablePiProject` is false)");
+			commands.push("`skc config set skills.enablePiProject true`");
+		}
+		if ((source === "all" || source === "user") && policy.enablePiUser !== true) {
+			skipped.push("user (`skills.enablePiUser` is false)");
+			commands.push("`skc config set skills.enablePiUser true`");
+		}
+		if (skipped.length === 0) return undefined;
+		return `Skill discovery skipped disabled scope(s): ${skipped.join(", ")}. Enable them with ${commands.join(" and ")}.`;
+	}
 }

package/src/tools/sqlite-reader.ts

@@ -272,6 +272,7 @@ const COMMENT_OR_TERMINATOR_ERROR =
 	"SQLite 'where' clause must not contain comments or statement terminators; use '?q=SELECT ...' for raw SQL";
 const FORBIDDEN_KEYWORD_ERROR =
 	"SQLite 'where' clause must not contain LIMIT/OFFSET/UNION/INTERSECT/EXCEPT/ATTACH/DETACH/PRAGMA; use '?q=SELECT ...' for raw SQL";
+const RAW_QUERY_ERROR = "SQLite raw queries must contain exactly one explicit SELECT statement";
 
 /**
  * Scans a `where=` clause character-by-character, tracking single- and double-quoted
@@ -363,6 +364,66 @@ function validateWhereClause(where: string | undefined): string | undefined {
 	return trimmed;
 }
 
+/**
+ * Keep raw reads deliberately narrower than SQLite's full grammar. Comments are
+ * rejected, and a statement terminator is accepted only as the final
+ * non-whitespace character. Quoted semicolons remain ordinary query data.
+ */
+export function validateSqliteReadQuery(sql: string): string {
+	const trimmed = sql.trim();
+	if (!/^SELECT\b/i.test(trimmed)) {
+		throw new ToolError(RAW_QUERY_ERROR);
+	}
+
+	let quoteEnd: "'" | '"' | "`" | "]" | null = null;
+	for (let index = 0; index < trimmed.length; index++) {
+		const char = trimmed[index];
+		const next = trimmed[index + 1];
+		if (char === "\0") {
+			throw new ToolError(RAW_QUERY_ERROR);
+		}
+
+		if (quoteEnd) {
+			if (char === quoteEnd) {
+				if (quoteEnd !== "]" && next === quoteEnd) {
+					index += 1;
+				} else {
+					quoteEnd = null;
+				}
+			}
+			continue;
+		}
+
+		if (char === "'" || char === '"' || char === "`") {
+			quoteEnd = char;
+			continue;
+		}
+		if (char === "[") {
+			quoteEnd = "]";
+			continue;
+		}
+		if ((char === "-" && next === "-") || (char === "/" && next === "*") || (char === "*" && next === "/")) {
+			throw new ToolError(RAW_QUERY_ERROR);
+		}
+		if (char === ";" && trimmed.slice(index + 1).trim().length > 0) {
+			throw new ToolError(RAW_QUERY_ERROR);
+		}
+	}
+
+	if (quoteEnd) {
+		throw new ToolError(RAW_QUERY_ERROR);
+	}
+	return trimmed;
+}
+
+export function enforceSqliteQueryOnly(db: Database): void {
+	db.run("PRAGMA query_only = ON");
+	const enabled = db.prepare<{ query_only: number }, []>("PRAGMA query_only").get()?.query_only;
+	if (enabled !== 1) {
+		throw new ToolError("SQLite read connection could not enable query-only mode");
+	}
+}
+
 function normalizeWriteValue(value: unknown, column: string): SqliteBinding {
 	if (value === null) return null;
 	if (
@@ -444,10 +505,7 @@ export function parseSqliteSelector(subPath: string, queryString: string): Sqlit
 		if (normalizedSubPath || otherKeys.length > 0) {
 			throw new ToolError("SQLite raw queries cannot be combined with table selectors or pagination");
 		}
-		if (!rawQuery.trim()) {
-			throw new ToolError("SQLite query parameter 'q' cannot be empty");
-		}
-		return { kind: "raw", sql: rawQuery };
+		return { kind: "raw", sql: validateSqliteReadQuery(rawQuery) };
 	}
 
 	if (!normalizedSubPath) {
@@ -602,7 +660,7 @@ export function executeReadQuery(
 	sql: string,
 	maxRows: number = MAX_RAW_QUERY_ROWS,
 ): { columns: string[]; rows: Record<string, unknown>[]; truncated: boolean } {
-	const statement = db.prepare<SqliteRow, []>(sql);
+	const statement = db.prepare<SqliteRow, []>(validateSqliteReadQuery(sql));
 	if (statement.paramsCount > 0) {
 		throw new ToolError("SQLite raw queries do not support bound parameters");
 	}

package/src/tools/subagent-render.ts

@@ -11,6 +11,12 @@ import type { Component } from "@sayknow-cli/tui";
 import { Text } from "@sayknow-cli/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
+import {
+	collectProviderDegradationGroups,
+	hasActiveProviderRetryInProgress,
+	providerProgressAgeLabel,
+	providerRetryPhaseLabel,
+} from "../task/provider-retry-status";
 import { renderSubagentLiveProgress } from "../task/render";
 import { Ellipsis, Hasher, renderStatusLine } from "../tui";
 import {
@@ -42,7 +48,8 @@ const PREVIEW_LINE_WIDTH = 80;
  * wall-clock displays are deliberately kept OUT of the cached body — the animated
  * spinner and the fresh duration live in the cheap per-subagent status line, and
  * `renderSubagentLiveProgress` is invoked with `staticTime` so current-tool elapsed
- * and retry countdowns are never baked into cached lines.
+ * and retry countdowns are never baked into cached lines. Snapshots with an active
+ * retry anywhere in their nested task tree bypass this cache and render dynamically.
  */
 const SUBAGENT_BODY_CACHE_MAX = 128;
 const subagentBodyCache = new Map<bigint, string[]>();
@@ -77,6 +84,15 @@ export const subagentBodyCacheTestHooks = {
 	},
 };
 
+function snapshotHasActiveRetry(snapshot: SubagentSnapshot): boolean {
+	if (snapshot.liveProgressAvailable === false || !snapshot.progress) return false;
+	return hasActiveProviderRetryInProgress(snapshot.progress);
+}
+
+function boundSubagentBodyLines(lines: string[], width: number): string[] {
+	return lines.map(line => (line.length > 0 ? truncateToWidth(replaceTabs(line), width, Ellipsis.Omit) : ""));
+}
+
 function renderCachedSubagentBody(
 	snapshot: SubagentSnapshot,
 	signature: string,
@@ -92,9 +108,7 @@ function renderCachedSubagentBody(
 		subagentBodyCache.set(key, hit);
 		return hit;
 	}
-	const lines = renderSubagentSnapshotBody(snapshot, expanded, theme).map(line =>
-		line.length > 0 ? truncateToWidth(line, width, Ellipsis.Omit) : "",
-	);
+	const lines = boundSubagentBodyLines(renderSubagentSnapshotBody(snapshot, expanded, theme), width);
 	subagentBodyRenderCount += 1;
 	subagentBodyCache.set(key, lines);
 	if (subagentBodyCache.size > SUBAGENT_BODY_CACHE_MAX) {
@@ -104,6 +118,16 @@ function renderCachedSubagentBody(
 	return lines;
 }
 
+function renderDynamicSubagentBody(
+	snapshot: SubagentSnapshot,
+	expanded: boolean,
+	width: number,
+	theme: Theme,
+): string[] {
+	subagentBodyRenderCount += 1;
+	return boundSubagentBodyLines(renderSubagentSnapshotBody(snapshot, expanded, theme, false), width);
+}
+
 function statusIconKind(status: SubagentSnapshot["status"]): ToolUIStatus {
 	switch (status) {
 		case "completed":
@@ -131,15 +155,25 @@ function renderSubagentStatusLine(snapshot: SubagentSnapshot, theme: Theme, spin
 		snapshot.status === "running" ? spinnerFrame : undefined,
 	);
 	const id = theme.fg("muted", truncateToWidth(replaceTabs(snapshot.id), PREVIEW_LINE_WIDTH, Ellipsis.Unicode));
-	const status = theme.fg("dim", snapshot.status);
+	const retryState = snapshot.liveProgressAvailable !== false ? snapshot.progress?.retryState : undefined;
+	const status = retryState
+		? theme.fg(
+				"warning",
+				`provider degraded · ${providerRetryPhaseLabel(retryState.kind)} · ${providerProgressAgeLabel(retryState, Date.now())}`,
+			)
+		: theme.fg("dim", snapshot.status);
 	const duration = theme.fg("dim", formatDuration(snapshot.durationMs));
 	return `${icon} ${id} ${status} ${duration}`;
 }
 
-// Heavy, cacheable per-subagent body: a pure function of (snapshot content, expanded,
-// theme). No spinner frame and no wall-clock displays leak in (live progress uses
-// `staticTime`), so the module body cache can never serve stale or frozen-ticking lines.
-function renderSubagentSnapshotBody(snapshot: SubagentSnapshot, expanded: boolean, theme: Theme): string[] {
+// Heavy per-subagent body. The cache path uses staticTime=true; the bounded dynamic
+// path opts into wall-clock displays when an active retry exists in the nested tree.
+function renderSubagentSnapshotBody(
+	snapshot: SubagentSnapshot,
+	expanded: boolean,
+	theme: Theme,
+	staticTime = true,
+): string[] {
 	const lines: string[] = [];
 
 	// Static receipt fields (parity with the markdown content for non-await actions).
@@ -174,9 +208,9 @@ function renderSubagentSnapshotBody(snapshot: SubagentSnapshot, expanded: boolea
 	// exists (subagent.ts #liveProgressFields), but the renderer also honors an
 	// explicit `liveProgressAvailable: false` so stale retained progress can never
 	// resurrect a live panel (AC5). `staticTime` keeps wall-clock displays out of
-	// these cached lines.
+	// cached lines when the body is served by the cache.
 	if (snapshot.progress && snapshot.liveProgressAvailable !== false) {
-		for (const pl of renderSubagentLiveProgress(snapshot.progress, expanded, theme, undefined, true)) {
+		for (const pl of renderSubagentLiveProgress(snapshot.progress, expanded, theme, undefined, staticTime)) {
 			lines.push(`  ${pl}`);
 		}
 	} else if (snapshot.liveProgressAvailable && (snapshot.status === "running" || snapshot.status === "queued")) {
@@ -251,26 +285,50 @@ export const subagentToolRenderer = {
 					},
 					theme,
 				);
-				const out: string[] = [truncateToWidth(header, width, Ellipsis.Omit)];
+				const out: string[] = [truncateToWidth(replaceTabs(header), width, Ellipsis.Omit)];
 				// Discoverability: the inline panel is a bounded preview; the session
 				// observer (ctrl+s) streams the full per-subagent message history.
 				if (runningCount > 0) {
-					out.push(truncateToWidth(`  ${theme.fg("dim", "(ctrl+s to observe sessions)")}`, width, Ellipsis.Omit));
+					out.push(
+						truncateToWidth(
+							replaceTabs(`  ${theme.fg("dim", "(ctrl+s to observe sessions)")}`),
+							width,
+							Ellipsis.Omit,
+						),
+					);
+				}
+				const liveProgress = subagents.flatMap(snapshot =>
+					snapshot.progress && snapshot.liveProgressAvailable !== false ? [snapshot.progress] : [],
+				);
+				for (const group of collectProviderDegradationGroups(liveProgress)) {
+					out.push(
+						truncateToWidth(
+							replaceTabs(
+								`  ${theme.fg("warning", `provider degraded: ${group.count} subagents retrying on ${group.provider}`)}`,
+							),
+							width,
+							Ellipsis.Omit,
+						),
+					);
 				}
 
 				snapshotSignatures ??= subagents.map(snapshot =>
 					subagentAwaitRenderedStateSignature([snapshot], result.details),
 				);
 				subagents.forEach((snapshot, index) => {
-					// Fresh per-subagent status line (cheap), then the cached heavy body.
+					// Fresh per-subagent status line (cheap), then a cached or dynamic body.
 					out.push(
 						truncateToWidth(
-							renderSubagentStatusLine(snapshot, theme, options.spinnerFrame),
+							replaceTabs(renderSubagentStatusLine(snapshot, theme, options.spinnerFrame)),
 							width,
 							Ellipsis.Omit,
 						),
 					);
-					out.push(...renderCachedSubagentBody(snapshot, snapshotSignatures![index]!, expanded, width, theme));
+					out.push(
+						...(snapshotHasActiveRetry(snapshot)
+							? renderDynamicSubagentBody(snapshot, expanded, width, theme)
+							: renderCachedSubagentBody(snapshot, snapshotSignatures![index]!, expanded, width, theme)),
+					);
 				});
 				return out;
 			},

package/src/tools/subagent.ts

@@ -936,6 +936,8 @@ function canonicalizeProgressForSignature(progress: AgentProgress): unknown {
 					attempt: progress.retryState.attempt,
 					maxAttempts: progress.retryState.maxAttempts,
 					unbounded: progress.retryState.unbounded ?? false,
+					kind: progress.retryState.kind,
+					provider: progress.retryState.provider ?? null,
 					delayMs: progress.retryState.delayMs,
 					errorMessage: progress.retryState.errorMessage,
 					// startedAtMs intentionally excluded (drives countdown only).

package/src/tools/tool-result.ts

@@ -1,6 +1,6 @@
 import type { AgentToolResult } from "@sayknow-cli/agent-core";
 import type { ImageContent, TextContent } from "@sayknow-cli/ai";
-import type { OutputSummary, TruncationResult } from "../session/streaming-output";
+import type { OutputSummary, ReadWindow, TruncationResult } from "../session/streaming-output";
 import type { OutputMeta, TruncationOptions, TruncationSummaryOptions, TruncationTextOptions } from "./output-meta";
 import { outputMeta } from "./output-meta";
 
@@ -32,6 +32,19 @@ export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
 		return this;
 	}
 
+	truncationWindows(
+		windows: ReadWindow,
+		options?: {
+			artifactId?: string;
+			noticeOwner?: "body";
+			maxBytes?: number;
+			rangeBase?: "file" | "window";
+		},
+	): this {
+		this.#meta.truncationWindows(windows, options);
+		return this;
+	}
+
 	truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this {
 		this.#meta.truncationFromSummary(summary, options);
 		return this;

package/src/utils/edit-mode.ts

@@ -1,4 +1,4 @@
-import { $env } from "@sayknow-cli/utils/env";
+import { $pickenv } from "@sayknow-cli/utils/env";
 
 export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch";
 
@@ -34,7 +34,7 @@ export function resolveEditMode(session: EditModeSessionLike): EditMode {
 	const modelVariant = session.settings.getEditVariantForModel?.(activeModel);
 	if (modelVariant) return modelVariant;
 
-	const envMode = normalizeEditMode($env.PI_EDIT_VARIANT);
+	const envMode = normalizeEditMode($pickenv("SKC_EDIT_VARIANT", "PI_EDIT_VARIANT"));
 	if (envMode) return envMode;
 
 	const settingsMode = normalizeEditMode(String(session.settings.get("edit.mode") ?? ""));

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

@@ -143,6 +143,7 @@ function tokenizePastedPathCandidates(
 	text: string,
 	options: DecodePastedPathOptions,
 	maxCandidates: number,
+	requireCompletePayload = false,
 ): TokenizePastedPathsResult {
 	if (text.length > MAX_PASTED_IMAGE_PASTE_CHARACTERS) return { kind: "invalid" };
 	const platform = options.platform ?? process.platform;
@@ -154,7 +155,9 @@ function tokenizePastedPathCandidates(
 
 	const startCandidate = (): TokenizePastedPathsResult | undefined => {
 		if (candidateStarted) return undefined;
-		if (candidates.length >= maxCandidates) return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		if (!requireCompletePayload && candidates.length >= maxCandidates) {
+			return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		}
 		candidateStarted = true;
 		return undefined;
 	};
@@ -167,7 +170,9 @@ function tokenizePastedPathCandidates(
 	const finishCandidate = (): TokenizePastedPathsResult | undefined => {
 		if (!candidateStarted) return undefined;
 		if (!candidate) return { kind: "invalid" };
-		if (candidates.length >= maxCandidates) return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		if (!requireCompletePayload && candidates.length >= maxCandidates) {
+			return { kind: "too-many", maxCandidates, candidates: [...candidates] };
+		}
 		const decoded = decodeListToken(candidate, options, platform);
 		if (decoded === undefined) return { kind: "invalid" };
 		candidates.push(decoded);
@@ -225,6 +230,7 @@ function tokenizePastedPathCandidates(
 	if (state !== "normal") return { kind: "invalid" };
 	const finalResult = finishCandidate();
 	if (finalResult) return finalResult;
+	if (candidates.length > maxCandidates) return { kind: "too-many", maxCandidates, candidates };
 	return candidates.length === 0 ? { kind: "invalid" } : { kind: "candidates", candidates };
 }
 
@@ -257,8 +263,12 @@ function isRecognizedClipboardTempPath(filePath: string, platform: NodeJS.Platfo
 /** Resolve one recognized clipboard-temp image path lexically, before any filesystem access. */
 export function resolvePastedImagePath(text: string, options: ResolvePastedImagePathOptions = {}): string | undefined {
 	const platform = options.platform ?? process.platform;
-	const candidate = decodePastedPathCandidate(text, options);
-	if (!candidate || !IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
+	const terminalNewlinesTrimmed = text.replace(/(?:\r\n|\r|\n)+$/, "");
+	if (/\r|\n/.test(terminalNewlinesTrimmed)) return undefined;
+	const candidates = decodePastedPathCandidates(terminalNewlinesTrimmed, options, 1);
+	if (candidates?.length !== 1) return undefined;
+	const candidate = candidates[0];
+	if (!IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
 	if (platform === "win32" && isRemoteWindowsPath(candidate)) return undefined;
 	const resolved = resolveCandidate(candidate, options, platform);
 	return isRecognizedClipboardTempPath(resolved, platform) ? resolved : undefined;
@@ -274,10 +284,9 @@ export function parsePastedImagePaths(
 	options: ResolvePastedImagePathOptions = {},
 ): PastedImagePathParseResult | undefined {
 	const platform = options.platform ?? process.platform;
-	const tokenized = tokenizePastedPathCandidates(text, options, MAX_PASTED_IMAGE_COUNT);
+	const tokenized = tokenizePastedPathCandidates(text, options, MAX_PASTED_IMAGE_COUNT, true);
 	if (tokenized.kind === "too-many") {
 		if (
-			tokenized.candidates.length !== MAX_PASTED_IMAGE_COUNT ||
 			tokenized.candidates.some(
 				candidate =>
 					!IMAGE_FILE_EXTENSION_PATTERN.test(candidate) ||