@ottocode/sdk 0.1.237 → 0.1.243

package/src/providers/src/oauth-models.ts

@@ -5,6 +5,7 @@ const OAUTH_MODEL_PREFIXES: Partial<Record<ProviderId, string[]>> = {
 		'claude-haiku-4-5',
 		'claude-opus-4-5',
 		'claude-opus-4-6',
+		'claude-opus-4-7',
 		'claude-sonnet-4-5',
 		'claude-sonnet-4-6',
 	],
@@ -19,6 +20,7 @@ const OAUTH_MODEL_IDS: Partial<Record<ProviderId, string[]>> = {
 		'gpt-5.2-codex',
 		'gpt-5.3-codex',
 		'gpt-5.4',
+		'gpt-5.4-mini',
 	],
 };
 

package/src/providers/src/utils.ts

@@ -40,7 +40,7 @@ const PREFERRED_FAST_MODELS: Partial<Record<ProviderId, string[]>> = {
 };
 
 const PREFERRED_FAST_MODELS_OAUTH: Partial<Record<ProviderId, string[]>> = {
-	openai: ['gpt-5.1-codex-mini'],
+	openai: ['gpt-5.4-mini'],
 	anthropic: ['claude-haiku-4-5'],
 };
 

package/src/skills/loader.ts

@@ -74,6 +74,7 @@ export async function discoverSkills(
 	let current = cwd;
 	const visited = new Set<string>();
 	while (current && !visited.has(current)) {
+		if (repoRoot && !current.startsWith(repoRoot)) break;
 		visited.add(current);
 		const scope: SkillScope =
 			current === cwd ? 'cwd' : current === repoRoot ? 'repo' : 'parent';
@@ -82,7 +83,6 @@ export async function discoverSkills(
 		}
 		const parent = dirname(current);
 		if (parent === current) break;
-		if (repoRoot && !current.startsWith(repoRoot)) break;
 		current = parent;
 	}
 

package/src/skills/parser.ts

@@ -35,50 +35,225 @@ function parseYamlFrontmatter(
 ): Record<string, unknown> {
 	const result: Record<string, unknown> = {};
 	const lines = yaml.split('\n');
-	let currentKey: string | null = null;
-	let currentIndent = 0;
-	let nestedObject: Record<string, string> | null = null;
+	let index = 0;
 
-	for (const line of lines) {
-		if (!line.trim()) continue;
+	while (index < lines.length) {
+		const line = lines[index];
+		if (!line || !line.trim()) {
+			index += 1;
+			continue;
+		}
 
 		const indent = line.search(/\S/);
+		if (indent > 0) {
+			index += 1;
+			continue;
+		}
+
 		const trimmed = line.trim();
+		const colonIdx = trimmed.indexOf(':');
+		if (colonIdx === -1) {
+			index += 1;
+			continue;
+		}
 
-		if (indent === 0 || (indent <= currentIndent && nestedObject)) {
-			if (nestedObject && currentKey) {
-				result[currentKey] = nestedObject;
-				nestedObject = null;
-				currentKey = null;
-			}
+		const key = normalizeKey(trimmed.slice(0, colonIdx).trim());
+		const value = trimmed.slice(colonIdx + 1).trim();
+
+		// Handle YAML block scalars with optional chomping/indentation indicators:
+		// `|`, `>`, `|-`, `>-`, `|+`, `>+`, `|2`, `>2-`, etc.
+		const blockScalarMatch = value.match(/^([|>])[-+]?\d*[-+]?$/);
+		if (blockScalarMatch) {
+			const style = blockScalarMatch[1] as '|' | '>';
+			const { content, nextIndex } = readBlockScalar(
+				lines,
+				index + 1,
+				indent,
+				style,
+			);
+			result[key] = content;
+			index = nextIndex;
+			continue;
+		}
+
+		if (!value) {
+			const { content, nextIndex } = readIndentedValue(
+				lines,
+				index + 1,
+				indent,
+			);
+			result[key] = content;
+			index = nextIndex;
+			continue;
+		}
+
+		result[key] = parseYamlValue(value);
+		index += 1;
+	}
+
+	return result;
+}
+
+function readIndentedValue(
+	lines: string[],
+	startIndex: number,
+	parentIndent: number,
+): { content: Record<string, string> | string; nextIndex: number } {
+	for (let index = startIndex; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (!line || !line.trim()) continue;
+
+		const indent = line.search(/\S/);
+		if (indent <= parentIndent) {
+			return { content: '', nextIndex: index };
 		}
 
+		if (isNestedObjectLine(line.trim())) {
+			return readNestedObject(lines, startIndex, parentIndent);
+		}
+
+		return readIndentedScalar(lines, startIndex, parentIndent);
+	}
+
+	return { content: '', nextIndex: lines.length };
+}
+
+function readNestedObject(
+	lines: string[],
+	startIndex: number,
+	parentIndent: number,
+): { content: Record<string, string>; nextIndex: number } {
+	const result: Record<string, string> = {};
+	let index = startIndex;
+
+	while (index < lines.length) {
+		const line = lines[index];
+		if (!line || !line.trim()) {
+			index += 1;
+			continue;
+		}
+
+		const indent = line.search(/\S/);
+		if (indent <= parentIndent) break;
+
+		const trimmed = line.trim();
 		const colonIdx = trimmed.indexOf(':');
-		if (colonIdx === -1) continue;
+		if (colonIdx === -1) {
+			index += 1;
+			continue;
+		}
 
-		const key = trimmed.slice(0, colonIdx).trim();
+		const key = normalizeKey(trimmed.slice(0, colonIdx).trim());
 		const value = trimmed.slice(colonIdx + 1).trim();
 
-		if (indent > 0 && nestedObject) {
-			nestedObject[key] = parseYamlValue(value);
+		const blockScalarMatch = value.match(/^([|>])[-+]?\d*[-+]?$/);
+		if (blockScalarMatch) {
+			const style = blockScalarMatch[1] as '|' | '>';
+			const block = readBlockScalar(lines, index + 1, indent, style);
+			result[key] = block.content;
+			index = block.nextIndex;
 			continue;
 		}
 
-		if (!value) {
-			currentKey = normalizeKey(key);
-			currentIndent = indent;
-			nestedObject = {};
+		result[key] = String(parseYamlValue(value));
+		index += 1;
+	}
+
+	return { content: result, nextIndex: index };
+}
+
+function readIndentedScalar(
+	lines: string[],
+	startIndex: number,
+	parentIndent: number,
+): { content: string; nextIndex: number } {
+	const scalarLines: string[] = [];
+	let index = startIndex;
+	let contentIndent: number | null = null;
+
+	while (index < lines.length) {
+		const line = lines[index];
+		if (!line) {
+			scalarLines.push('');
+			index += 1;
+			continue;
+		}
+
+		if (!line.trim()) {
+			scalarLines.push('');
+			index += 1;
+			continue;
+		}
+
+		const indent = line.search(/\S/);
+		if (indent <= parentIndent) break;
+
+		contentIndent ??= indent;
+		scalarLines.push(line.slice(contentIndent));
+		index += 1;
+	}
+
+	return { content: foldBlockScalar(scalarLines), nextIndex: index };
+}
+
+function readBlockScalar(
+	lines: string[],
+	startIndex: number,
+	parentIndent: number,
+	style: '|' | '>',
+): { content: string; nextIndex: number } {
+	const blockLines: string[] = [];
+	let index = startIndex;
+	let contentIndent: number | null = null;
+
+	while (index < lines.length) {
+		const line = lines[index];
+		if (!line) {
+			blockLines.push('');
+			index += 1;
+			continue;
+		}
+
+		if (!line.trim()) {
+			blockLines.push('');
+			index += 1;
 			continue;
 		}
 
-		result[normalizeKey(key)] = parseYamlValue(value);
+		const indent = line.search(/\S/);
+		if (indent <= parentIndent) break;
+
+		contentIndent ??= indent;
+		blockLines.push(line.slice(contentIndent));
+		index += 1;
 	}
 
-	if (nestedObject && currentKey) {
-		result[currentKey] = nestedObject;
+	const content =
+		style === '>' ? foldBlockScalar(blockLines) : blockLines.join('\n').trim();
+	return { content, nextIndex: index };
+}
+
+function foldBlockScalar(lines: string[]): string {
+	const segments: string[] = [];
+	let current = '';
+
+	for (const line of lines) {
+		if (!line.trim()) {
+			if (current) {
+				segments.push(current.trim());
+				current = '';
+			}
+			continue;
+		}
+
+		current = current ? `${current} ${line.trim()}` : line.trim();
 	}
 
-	return result;
+	if (current) {
+		segments.push(current.trim());
+	}
+
+	return segments.join('\n');
 }
 
 function normalizeKey(key: string): string {
@@ -86,13 +261,29 @@ function normalizeKey(key: string): string {
 	return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
 
-function parseYamlValue(value: string): string {
+function isNestedObjectLine(line: string): boolean {
+	return /^[A-Za-z0-9_-]+\s*:/.test(line);
+}
+
+function parseYamlValue(value: string): unknown {
 	if (
 		(value.startsWith('"') && value.endsWith('"')) ||
 		(value.startsWith("'") && value.endsWith("'"))
 	) {
 		return value.slice(1, -1);
 	}
+
+	if (
+		(value.startsWith('{') && value.endsWith('}')) ||
+		(value.startsWith('[') && value.endsWith(']'))
+	) {
+		try {
+			return JSON.parse(value) as unknown;
+		} catch {
+			return value;
+		}
+	}
+
 	return value;
 }
 

package/src/skills/tool.ts

@@ -120,32 +120,53 @@ async function loadSubFile(
 
 function buildSkillDescription(): string {
 	if (cachedSkillList.length === 0) {
-		return 'Load a skill by name. No skills are currently available.';
+		return 'Load a skill by name to get detailed, task-specific instructions. No skills are currently available.';
 	}
 
-	const skillsXml = cachedSkillList
+	// Dedupe by name — later scopes (cwd > repo > user) have already overwritten
+	// earlier ones in the loader, so the cached list is deduplicated. We re-dedupe
+	// defensively here in case the same name slipped through from different dirs.
+	const seen = new Set<string>();
+	const unique: DiscoveredSkill[] = [];
+	for (const s of cachedSkillList) {
+		const key = s.name.trim();
+		if (!key || seen.has(key)) continue;
+		seen.add(key);
+		unique.push(s);
+	}
+	unique.sort((a, b) => a.name.localeCompare(b.name));
+
+	const skillsXml = unique
 		.map(
 			(s) =>
-				`<skill><name>${escapeXml(s.name)}</name><description>${escapeXml(s.description)}</description></skill>`,
+				`<skill><name>${escapeXml(s.name)}</name><description>${escapeXml(summarizeDescription(s.description))}</description><location>${escapeXml(s.scope)}</location></skill>`,
 		)
 		.join('\n');
 
-	return `Load a skill by name to get detailed instructions.
+	return `Load a skill by name to get detailed, task-specific instructions.
 
-<available_skills>
-${skillsXml}
-</available_skills>
+<skills_instructions>
+When the user's request matches one of the available skills below, call this tool with the skill name to load its full instructions. Skills provide specialized capabilities and domain knowledge.
 
-Call this tool with the skill name when you need the full instructions.
-If the skill references sub-files (e.g. rules/animations.md), load them with the \`file\` parameter:
-  skill({ name: "skill-name", file: "rules/animations.md" })
+How to use skills:
+- Invoke with \`skill({ name: "<skill-name>" })\` — only the name is required.
+- The response contains the skill's full body plus \`availableFiles\` for sub-files.
+- For sub-files: \`skill({ name: "<skill-name>", file: "rules/animations.md" })\`.
 
-The response includes \`availableFiles\` listing all loadable sub-files in the skill directory.
-If \`securityNotices\` are present, review them — they flag hidden content (HTML comments, invisible characters, etc.) that may not be visible when reading the markdown normally.`;
+Rules:
+- Only invoke skills listed in <available_skills> below.
+- Do NOT invoke speculatively. Only call when the user's request clearly matches a skill's description or trigger phrases.
+- Do NOT invoke the same skill twice in one turn.
+- If a skill response includes \`securityNotices\`, review them — they flag hidden content (HTML comments, invisible characters, etc.) that may not render visibly.
+</skills_instructions>
+
+<available_skills>
+${skillsXml}
+</available_skills>`;
 }
 
 function escapeXml(str: string): string {
-	return str
+	return String(str)
 		.replace(/&/g, '&amp;')
 		.replace(/</g, '&lt;')
 		.replace(/>/g, '&gt;')
@@ -153,6 +174,63 @@ function escapeXml(str: string): string {
 		.replace(/'/g, '&apos;');
 }
 
+// Condense a SKILL.md description to "what it does + when to use it".
+//
+// Most frontmatter follows one of two shapes:
+//   A. "<what>. Use when <triggers>. Also use when … For X, see Y."
+//   B. "When the user wants X. Also use when <mega trigger list>. For Y, see Z."
+//
+// Rule: keep up to two sentences, but STOP early at cues that mark pure
+// trigger-list expansion or see-also chatter ("Also use when …", "For X, see Y",
+// "Use this …"). Sentence 1 is always kept. Sentence 2 is kept only if it's a
+// "Use when …" clause (trigger phrases the model actually needs) — not an
+// "Also use when" balloon.
+const SENTENCE_END = /[.!?]\s/g;
+const SKIP_PREFIXES = [
+	/^also use when\b/i,
+	/^for [^.]*?,?\s*see\b/i,
+	/^see\s+/i,
+	/^use this\b/i,
+	/^use proactively\b/i,
+	/^distinct from\b/i,
+	/^different from\b/i,
+	/^not for\b/i,
+];
+
+function shouldSkipSentence(sentence: string): boolean {
+	const s = sentence.trim();
+	return SKIP_PREFIXES.some((re) => re.test(s));
+}
+
+export function summarizeDescription(raw: string): string {
+	const text = String(raw ?? '')
+		.replace(/\s+/g, ' ')
+		.trim();
+	if (!text) return '';
+
+	// Split into sentences, keeping terminal punctuation.
+	const sentences: string[] = [];
+	SENTENCE_END.lastIndex = 0;
+	let lastIndex = 0;
+	let match: RegExpExecArray | null;
+	// biome-ignore lint/suspicious/noAssignInExpressions: standard regex iteration
+	while ((match = SENTENCE_END.exec(text)) !== null) {
+		sentences.push(text.slice(lastIndex, match.index + 1).trim());
+		lastIndex = match.index + match[0].length;
+	}
+	if (lastIndex < text.length) sentences.push(text.slice(lastIndex).trim());
+
+	if (sentences.length === 0) return text;
+
+	const kept: string[] = [sentences[0]]; // always keep sentence 1 (what)
+	// Keep sentence 2 only if it adds routing signal (e.g. starts with "Use when").
+	if (sentences[1] && !shouldSkipSentence(sentences[1])) {
+		kept.push(sentences[1]);
+	}
+
+	return kept.join(' ');
+}
+
 export function rebuildSkillDescription(): string {
 	return buildSkillDescription();
 }

package/src/types/src/config.ts

@@ -8,7 +8,7 @@ export type Scope = 'global' | 'local';
 /**
  * Default settings for the CLI
  */
-export type ToolApprovalMode = 'auto' | 'dangerous' | 'all';
+export type ToolApprovalMode = 'auto' | 'dangerous' | 'all' | 'yolo';
 export type ReasoningLevel =
 	| 'minimal'
 	| 'low'
@@ -27,6 +27,7 @@ export type DefaultConfig = {
 	reasoningLevel?: ReasoningLevel;
 	theme?: string;
 	fullWidthContent?: boolean;
+	autoCompactThresholdTokens?: number | null;
 };
 
 export type ProviderSettings = Record<