@oh-my-pi/pi-coding-agent 16.3.8 → 16.3.9

package/dist/types/commands/say.d.ts

@@ -1,19 +1,24 @@
 import { Command } from "@oh-my-pi/pi-utils/cli";
 export default class Say extends Command {
+    #private;
     static description: string;
     static args: {
         text: import("@oh-my-pi/pi-utils/cli").ArgDescriptor & {
-            required: true;
             description: string;
         };
     };
     static flags: {
         voice: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
+            options: readonly string[];
         };
         model: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        file: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+        };
         out: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             char: string;
             description: string;

package/dist/types/commit/agentic/lock-files.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Lock-file handling for the split-commit workflow.
+ *
+ * The commit agent hides these machine-generated files from analysis so the
+ * model does not waste tokens on them and does not treat them as evidence for
+ * commit boundaries. That leaves them staged but unseen: without deterministic
+ * post-plan placement the split validator rejects the plan with
+ * `Split commit plan missing staged files: <lockfile>`, and the executor
+ * (`git stage.reset` -> per-group `stage.hunks`) would silently drop the file
+ * if the validator were skipped. See issue #4632.
+ */
+import type { SplitCommitPlan } from "./state.js";
+/**
+ * Lock file basename -> ordered sibling manifests. Order matters: the first
+ * manifest present in a commit group's changes wins.
+ */
+export declare const LOCK_FILE_MANIFESTS: Readonly<Record<string, readonly string[]>>;
+/**
+ * Lock-file basenames the commit agent excludes from `git_overview` output and
+ * from split-commit validation. Derived from {@link LOCK_FILE_MANIFESTS} so a
+ * single edit keeps both the analysis filter and the post-plan pairing in sync.
+ */
+export declare const EXCLUDED_LOCK_FILES: ReadonlySet<string>;
+/**
+ * Attach staged lock files the model never saw to the split plan.
+ *
+ * Placement precedence per lock file:
+ *   1. commit group that touches a sibling manifest (same directory)
+ *   2. commit group that touches a manifest in any directory
+ *   3. last commit group (fallback)
+ *
+ * Mutates {@link plan} in place. No-ops on an empty plan, on lock files
+ * already present in some commit group, and on staged files that are not
+ * recognized lock files.
+ */
+export declare function assignLockFilesToPlan(plan: SplitCommitPlan, stagedFiles: readonly string[]): void;

package/dist/types/config/model-discovery.d.ts

@@ -38,8 +38,9 @@ export interface DiscoveryContext {
     getBearerApiKeyResolver(provider: string): Promise<ApiKey | undefined>;
 }
 type LlamaCppDiscoveredModelRuntimeMetadata = {
-    contextWindow: number;
-    maxTokens: number;
+    contextWindow?: number;
+    maxTokens?: number;
+    input?: ("text" | "image")[];
 };
 export declare function discoverModelsByProviderType(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverOllamaModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.3.8",
+	"version": "16.3.9",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -56,17 +56,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.3.8",
-		"@oh-my-pi/omp-stats": "16.3.8",
-		"@oh-my-pi/pi-agent-core": "16.3.8",
-		"@oh-my-pi/pi-ai": "16.3.8",
-		"@oh-my-pi/pi-catalog": "16.3.8",
-		"@oh-my-pi/pi-mnemopi": "16.3.8",
-		"@oh-my-pi/pi-natives": "16.3.8",
-		"@oh-my-pi/pi-tui": "16.3.8",
-		"@oh-my-pi/pi-utils": "16.3.8",
-		"@oh-my-pi/pi-wire": "16.3.8",
-		"@oh-my-pi/snapcompact": "16.3.8",
+		"@oh-my-pi/hashline": "16.3.9",
+		"@oh-my-pi/omp-stats": "16.3.9",
+		"@oh-my-pi/pi-agent-core": "16.3.9",
+		"@oh-my-pi/pi-ai": "16.3.9",
+		"@oh-my-pi/pi-catalog": "16.3.9",
+		"@oh-my-pi/pi-mnemopi": "16.3.9",
+		"@oh-my-pi/pi-natives": "16.3.9",
+		"@oh-my-pi/pi-tui": "16.3.9",
+		"@oh-my-pi/pi-utils": "16.3.9",
+		"@oh-my-pi/pi-wire": "16.3.9",
+		"@oh-my-pi/snapcompact": "16.3.9",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/commands/say.ts

@@ -1,17 +1,20 @@
 /**
  * Synthesize text with the local TTS engine and play it (or save it with --out).
  *
- * Demonstrates the on-device speech stack end to end: the first run downloads
- * the configured local model, synthesis happens in the TTS worker subprocess,
- * and the resulting WAV is either played through the speakers or written to disk.
+ * Text comes from the argument or --file. Input is segmented into
+ * sentence-sized chunks ({@link SpeakableStream}) and synthesized through the
+ * streaming TTS worker, so arbitrarily long text plays gaplessly instead of
+ * hitting Kokoro's single-call ~510-phoneme truncation. --out concatenates the
+ * streamed segments into one WAV. The first run downloads the configured local
+ * model into the worker's cache.
  */
-import * as os from "node:os";
-import * as path from "node:path";
-import { getProjectDir, Snowflake } from "@oh-my-pi/pi-utils";
+import { getProjectDir } from "@oh-my-pi/pi-utils";
 import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import chalk from "chalk";
 import { Settings, settings } from "../config/settings";
-import { playAudioFile, removeTempFile } from "../tts/player";
+import { TTS_LOCAL_VOICE_VALUES } from "../tts/models";
+import { SpeakableStream } from "../tts/speakable";
+import { StreamingAudioPlayer } from "../tts/streaming-player";
 import { shutdownTtsClient, ttsClient } from "../tts/tts-client";
 import { encodeWav } from "../tts/wav";
 
@@ -19,24 +22,28 @@ export default class Say extends Command {
 	static description = "Synthesize text with the local TTS engine and play it through the speakers";
 
 	static args = {
-		text: Args.string({ required: true, description: "Text to speak" }),
+		text: Args.string({ description: "Text to speak (or use --file)" }),
 	};
 
 	static flags = {
-		voice: Flags.string({ description: "Voice id" }),
+		voice: Flags.string({ description: "Voice id", options: TTS_LOCAL_VOICE_VALUES }),
 		model: Flags.string({ description: "Local TTS model key" }),
+		file: Flags.string({ char: "f", description: "Read the text to speak from this file" }),
 		out: Flags.string({ char: "o", description: "Write WAV to this path instead of playing" }),
 	};
 
 	static examples = [
 		'omp say "hello world"',
+		"omp say --file notes.md --voice bm_fable",
 		'omp say "hello world" --out /tmp/hello.wav',
-		'omp say "bonjour" --voice af_heart --model kokoro',
 	];
 
 	async run(): Promise<void> {
 		const { args, flags } = await this.parse(Say);
-		const text = args.text ?? "";
+		if (args.text && flags.file) {
+			process.stderr.write(chalk.red("error: pass either text or --file, not both\n"));
+			process.exit(1);
+		}
 
 		await Settings.init({ cwd: getProjectDir() });
 		const model = flags.model ?? settings.get("tts.localModel");
@@ -55,23 +62,42 @@ export default class Say extends Command {
 		});
 
 		try {
-			const audio = await ttsClient.synthesize(model, text, { voice });
-			if (!audio) {
-				process.stderr.write(
-					chalk.red(
-						`error: could not synthesize with local TTS model "${model}". ` +
-							"Run `omp setup speech` to install it.\n",
-					),
-				);
+			const text = flags.file ? await Bun.file(flags.file).text() : (args.text ?? "");
+			const splitter = new SpeakableStream();
+			const segments = [...splitter.push(text), ...splitter.flush()];
+			if (segments.length === 0) {
+				process.stderr.write(chalk.red("error: nothing speakable in the input\n"));
 				exitCode = 1;
 				return;
 			}
 
-			const wav = encodeWav(audio.pcm, audio.sampleRate);
-			const durationSec = audio.pcm.length / audio.sampleRate;
+			const stream = ttsClient.synthesizeStream(model, { voice });
+			for (const segment of segments) stream.push(segment);
+			stream.end();
 
 			if (flags.out) {
+				const pcms: Float32Array[] = [];
+				let total = 0;
+				let sampleRate = 0;
+				for await (const chunk of stream.chunks) {
+					pcms.push(chunk.pcm);
+					total += chunk.pcm.length;
+					sampleRate = chunk.sampleRate;
+				}
+				if (total === 0) {
+					this.#synthesisFailed(model);
+					exitCode = 1;
+					return;
+				}
+				const pcm = new Float32Array(total);
+				let offset = 0;
+				for (const part of pcms) {
+					pcm.set(part, offset);
+					offset += part.length;
+				}
+				const wav = encodeWav(pcm, sampleRate);
 				await Bun.write(flags.out, wav);
+				const durationSec = total / sampleRate;
 				process.stdout.write(
 					`${chalk.green("saved")} ${flags.out} ` +
 						`${chalk.dim(`(${voice}, ${model}, ${durationSec.toFixed(1)}s, ${wav.byteLength} bytes)`)}\n`,
@@ -79,16 +105,25 @@ export default class Say extends Command {
 				return;
 			}
 
-			const tmp = path.join(os.tmpdir(), `omp-say-${Snowflake.next()}.wav`);
-			await Bun.write(tmp, wav);
-			try {
-				await playAudioFile(tmp);
-				process.stdout.write(
-					`${chalk.green("spoke")} ${chalk.dim(`(${voice}, ${model}, ${durationSec.toFixed(1)}s)`)}\n`,
-				);
-			} finally {
-				await removeTempFile(tmp);
+			const player = new StreamingAudioPlayer();
+			let spoken = 0;
+			let seconds = 0;
+			for await (const chunk of stream.chunks) {
+				player.start(chunk.sampleRate);
+				player.write(chunk.pcm);
+				spoken++;
+				seconds += chunk.pcm.length / chunk.sampleRate;
 			}
+			if (spoken === 0) {
+				player.stop();
+				this.#synthesisFailed(model);
+				exitCode = 1;
+				return;
+			}
+			await player.end();
+			process.stdout.write(
+				`${chalk.green("spoke")} ${chalk.dim(`(${voice}, ${model}, ${seconds.toFixed(1)}s, ${spoken} segments)`)}\n`,
+			);
 		} catch (err) {
 			process.stderr.write(chalk.red(`error: ${err instanceof Error ? err.message : String(err)}\n`));
 			exitCode = 1;
@@ -99,4 +134,12 @@ export default class Say extends Command {
 
 		if (exitCode !== 0) process.exit(exitCode);
 	}
+
+	#synthesisFailed(model: string): void {
+		process.stderr.write(
+			chalk.red(
+				`error: could not synthesize with local TTS model "${model}". Run \`omp setup speech\` to install it.\n`,
+			),
+		);
+	}
 }

package/src/commit/agentic/index.ts

@@ -13,6 +13,7 @@ import { discoverAuthStorage, discoverContextFiles } from "../../sdk";
 import * as git from "../../utils/git";
 import { type ExistingChangelogEntries, runCommitAgentSession } from "./agent";
 import { generateFallbackProposal } from "./fallback";
+import { assignLockFilesToPlan } from "./lock-files";
 import splitConfirmPrompt from "./prompts/split-confirm.md" with { type: "text" };
 import type { CommitAgentState, CommitProposal, HunkSelector, SplitCommitPlan } from "./state";
 import { computeDependencyOrder } from "./topo-sort";
@@ -230,6 +231,7 @@ async function runSplitCommit(
 		appendFilesToLastCommit(plan, ctx.additionalFiles);
 	}
 	const stagedFiles = await git.diff.changedFiles(ctx.cwd, { cached: true });
+	assignLockFilesToPlan(plan, stagedFiles);
 	const plannedFiles = new Set(plan.commits.flatMap(commit => commit.changes.map(change => change.path)));
 	const missingFiles = stagedFiles.filter(file => !plannedFiles.has(file));
 	if (missingFiles.length > 0) {
@@ -266,7 +268,7 @@ async function runSplitCommit(
 		throw new Error(order.error);
 	}
 
-	const stagedDiff = await git.diff(ctx.cwd, { cached: true });
+	const stagedDiff = await git.diff(ctx.cwd, { cached: true, binary: true });
 	await git.stage.reset(ctx.cwd);
 	for (const commitIndex of order) {
 		const commit = plan.commits[commitIndex];

package/src/commit/agentic/lock-files.ts

@@ -0,0 +1,107 @@
+/**
+ * Lock-file handling for the split-commit workflow.
+ *
+ * The commit agent hides these machine-generated files from analysis so the
+ * model does not waste tokens on them and does not treat them as evidence for
+ * commit boundaries. That leaves them staged but unseen: without deterministic
+ * post-plan placement the split validator rejects the plan with
+ * `Split commit plan missing staged files: <lockfile>`, and the executor
+ * (`git stage.reset` -> per-group `stage.hunks`) would silently drop the file
+ * if the validator were skipped. See issue #4632.
+ */
+
+import type { SplitCommitPlan } from "./state";
+
+/**
+ * Lock file basename -> ordered sibling manifests. Order matters: the first
+ * manifest present in a commit group's changes wins.
+ */
+export const LOCK_FILE_MANIFESTS: Readonly<Record<string, readonly string[]>> = {
+	"Cargo.lock": ["Cargo.toml"],
+	"package-lock.json": ["package.json"],
+	"yarn.lock": ["package.json"],
+	"pnpm-lock.yaml": ["package.json"],
+	"bun.lock": ["package.json"],
+	"bun.lockb": ["package.json"],
+	"go.sum": ["go.mod"],
+	"poetry.lock": ["pyproject.toml"],
+	"Pipfile.lock": ["Pipfile"],
+	"uv.lock": ["pyproject.toml"],
+	"composer.lock": ["composer.json"],
+	"Gemfile.lock": ["Gemfile"],
+	"flake.lock": ["flake.nix"],
+	"pubspec.lock": ["pubspec.yaml"],
+	"Podfile.lock": ["Podfile"],
+	"mix.lock": ["mix.exs"],
+	"gradle.lockfile": ["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"],
+};
+
+/**
+ * Lock-file basenames the commit agent excludes from `git_overview` output and
+ * from split-commit validation. Derived from {@link LOCK_FILE_MANIFESTS} so a
+ * single edit keeps both the analysis filter and the post-plan pairing in sync.
+ */
+export const EXCLUDED_LOCK_FILES: ReadonlySet<string> = new Set(Object.keys(LOCK_FILE_MANIFESTS));
+
+/**
+ * Attach staged lock files the model never saw to the split plan.
+ *
+ * Placement precedence per lock file:
+ *   1. commit group that touches a sibling manifest (same directory)
+ *   2. commit group that touches a manifest in any directory
+ *   3. last commit group (fallback)
+ *
+ * Mutates {@link plan} in place. No-ops on an empty plan, on lock files
+ * already present in some commit group, and on staged files that are not
+ * recognized lock files.
+ */
+export function assignLockFilesToPlan(plan: SplitCommitPlan, stagedFiles: readonly string[]): void {
+	if (plan.commits.length === 0) return;
+
+	const planned = new Set(plan.commits.flatMap(commit => commit.changes.map(change => change.path)));
+	const orphanedLockFiles: string[] = [];
+	for (const file of stagedFiles) {
+		if (planned.has(file)) continue;
+		const parts = file.split("/");
+		const basename = parts[parts.length - 1];
+		if (EXCLUDED_LOCK_FILES.has(basename)) orphanedLockFiles.push(file);
+	}
+	if (orphanedLockFiles.length === 0) return;
+
+	for (const lockFile of orphanedLockFiles) {
+		const parts = lockFile.split("/");
+		const basename = parts[parts.length - 1];
+		const dir = parts.slice(0, -1).join("/");
+		const manifests = LOCK_FILE_MANIFESTS[basename] ?? [];
+		const targetIndex = findManifestCommitIndex(plan, dir, manifests);
+		plan.commits[targetIndex].changes.push({ path: lockFile, hunks: { type: "all" } });
+		planned.add(lockFile);
+	}
+}
+
+function findManifestCommitIndex(plan: SplitCommitPlan, lockDir: string, manifests: readonly string[]): number {
+	// Prefer a manifest in the same directory as the lock file — the strongest
+	// semantic signal (e.g. workspace-crate `Cargo.toml` next to `Cargo.lock`).
+	for (const manifestName of manifests) {
+		for (let i = 0; i < plan.commits.length; i++) {
+			for (const change of plan.commits[i].changes) {
+				const parts = change.path.split("/");
+				const basename = parts[parts.length - 1];
+				const dir = parts.slice(0, -1).join("/");
+				if (basename === manifestName && dir === lockDir) return i;
+			}
+		}
+	}
+	// Fall back to any matching manifest — a monorepo may lock at repo root
+	// while the manifest sits under a subpath.
+	for (const manifestName of manifests) {
+		for (let i = 0; i < plan.commits.length; i++) {
+			for (const change of plan.commits[i].changes) {
+				const parts = change.path.split("/");
+				if (parts[parts.length - 1] === manifestName) return i;
+			}
+		}
+	}
+	// Nothing matched: attach to the last commit so the file still ships.
+	return plan.commits.length - 1;
+}

package/src/commit/agentic/tools/git-overview.ts

@@ -3,26 +3,7 @@ import type { CommitAgentState, GitOverviewSnapshot } from "../../../commit/agen
 import { extractScopeCandidates } from "../../../commit/analysis/scope";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
-
-const EXCLUDED_LOCK_FILES = new Set([
-	"Cargo.lock",
-	"package-lock.json",
-	"yarn.lock",
-	"pnpm-lock.yaml",
-	"bun.lock",
-	"bun.lockb",
-	"go.sum",
-	"poetry.lock",
-	"Pipfile.lock",
-	"uv.lock",
-	"composer.lock",
-	"Gemfile.lock",
-	"flake.lock",
-	"pubspec.lock",
-	"Podfile.lock",
-	"mix.lock",
-	"gradle.lockfile",
-]);
+import { EXCLUDED_LOCK_FILES } from "../lock-files";
 
 function isExcludedFile(path: string): boolean {
 	const basename = path.split("/").pop() ?? path;

package/src/config/model-discovery.ts

@@ -151,8 +151,9 @@ type LlamaCppDiscoveredServerMetadata = {
 };
 
 type LlamaCppDiscoveredModelRuntimeMetadata = {
-	contextWindow: number;
-	maxTokens: number;
+	contextWindow?: number;
+	maxTokens?: number;
+	input?: ("text" | "image")[];
 };
 
 type LlamaCppModelListEntry = {
@@ -594,12 +595,14 @@ export async function discoverLlamaCppModelRuntimeMetadata(
 			entry.configuredContextWindow ??
 			serverMetadata?.contextWindow ??
 			entry.trainingContextWindow;
+		const input = serverMetadata?.input;
 		if (contextWindow === undefined) {
-			return undefined;
+			return input === undefined ? undefined : { input };
 		}
 		return {
 			contextWindow,
 			maxTokens: resolveLlamaCppMaxTokens(contextWindow, serverMetadata?.maxTokens),
+			...(input !== undefined ? { input } : {}),
 		};
 	};
 	try {

package/src/config/model-registry.ts

@@ -866,12 +866,13 @@ export class ModelRegistry {
 		if (runtimeMetadata === undefined) {
 			return this.find(model.provider, model.id) ?? model;
 		}
-		const { contextWindow, maxTokens } = runtimeMetadata;
+		const { contextWindow, maxTokens, input } = runtimeMetadata;
 		const current = this.find(model.provider, model.id) ?? model;
 		const override = this.#resolveLiveModelOverride(current);
 		const customModel = this.#resolveLiveCustomModelOverlay(current);
 		const patch: ModelPatch = {};
 		if (
+			contextWindow !== undefined &&
 			override?.contextWindow === undefined &&
 			customModel?.contextWindow === undefined &&
 			current.contextWindow !== contextWindow
@@ -884,15 +885,25 @@ export class ModelRegistry {
 			patch.contextWindow ??
 			current.contextWindow ??
 			contextWindow;
-		const effectiveMaxTokens = Math.min(maxTokens, effectiveContextWindow);
+		if (maxTokens !== undefined && effectiveContextWindow !== undefined) {
+			const effectiveMaxTokens = Math.min(maxTokens, effectiveContextWindow);
+			if (
+				override?.maxTokens === undefined &&
+				customModel?.maxTokens === undefined &&
+				current.maxTokens !== effectiveMaxTokens
+			) {
+				patch.maxTokens = effectiveMaxTokens;
+			}
+		}
 		if (
-			override?.maxTokens === undefined &&
-			customModel?.maxTokens === undefined &&
-			current.maxTokens !== effectiveMaxTokens
+			input !== undefined &&
+			override?.input === undefined &&
+			customModel?.input === undefined &&
+			(current.input.length !== input.length || current.input.some((value, index) => value !== input[index]))
 		) {
-			patch.maxTokens = effectiveMaxTokens;
+			patch.input = input;
 		}
-		if (patch.contextWindow === undefined && patch.maxTokens === undefined) {
+		if (patch.contextWindow === undefined && patch.maxTokens === undefined && patch.input === undefined) {
 			return current;
 		}
 		const patched = applyModelPatch(current, patch, "merge");

package/src/discovery/claude.ts

@@ -167,17 +167,21 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	const userSkillsDir = path.join(getUserClaude(ctx), "skills");
 
-	// Walk up from cwd finding .claude/skills/ in ancestors
+	// Walk up from cwd finding .claude/skills/ in ancestors. Skip $HOME:
+	// that path is already scanned as the Claude user source below, and scanning
+	// it again as project would bypass enableClaudeUser when project skills stay enabled.
 	const projectScans: Promise<LoadResult<Skill>>[] = [];
 	let current = ctx.cwd;
 	while (true) {
-		projectScans.push(
-			scanSkillsFromDir(ctx, {
-				dir: path.join(current, CONFIG_DIR, "skills"),
-				providerId: PROVIDER_ID,
-				level: "project",
-			}),
-		);
+		if (current !== ctx.home) {
+			projectScans.push(
+				scanSkillsFromDir(ctx, {
+					dir: path.join(current, CONFIG_DIR, "skills"),
+					providerId: PROVIDER_ID,
+					level: "project",
+				}),
+			);
+		}
 		if (current === (ctx.repoRoot ?? ctx.home)) break;
 		const parent = path.dirname(current);
 		if (parent === current) break; // filesystem root

package/src/extensibility/skills.ts

@@ -190,12 +190,18 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	const disabledSkillNames = new Set(
 		(disabledExtensions ?? []).filter(id => id.startsWith("skill:")).map(id => id.slice(6)),
 	);
-	// Filter skills by source and patterns first
-	const filteredSkills = result.items.filter(capSkill => {
+	// Select authored skills from the pre-dedup superset. `loadCapability`
+	// dedupes before source toggles, so a disabled high-priority provider must
+	// not hide an enabled lower-priority provider with the same skill name.
+	const seenAuthoredSkillNames = new Set<string>();
+	const filteredSkills = result.all.filter(capSkill => {
+		if (capSkill._source.provider === MANAGED_SKILLS_PROVIDER_ID) return false;
 		if (disabledSkillNames.has(capSkill.name)) return false;
 		if (!isSourceEnabled(capSkill._source)) return false;
 		if (matchesIgnorePatterns(capSkill.name)) return false;
 		if (!matchesIncludePatterns(capSkill.name)) return false;
+		if (seenAuthoredSkillNames.has(capSkill.name)) return false;
+		seenAuthoredSkillNames.add(capSkill.name);
 		return true;
 	});
 
@@ -213,9 +219,6 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	// Process skills with resolved paths
 	for (let i = 0; i < filteredSkills.length; i++) {
 		const capSkill = filteredSkills[i];
-		// Managed (auto-learn) skills are resolved dead-last (below) so any
-		// authored skill of the same name — from ANY provider or custom dir — wins.
-		if (capSkill._source.provider === MANAGED_SKILLS_PROVIDER_ID) continue;
 		const resolvedPath = realPaths[i];
 
 		// Skip silently if we've already loaded this exact file (via symlink)

package/src/tts/speakable.ts

@@ -318,15 +318,20 @@ export class SpeakableStream {
 		this.#drain(out);
 	}
 
-	/** Emit every buffered character, force-splitting anything over the cap. */
+	/**
+	 * Emit every buffered character. Runs the bounded streaming segmenter first
+	 * so a large buffer (paste-sized delta, one-shot push) prefers sentence and
+	 * clause cuts within {@link MAX_SEGMENT}, instead of word-splitting whole
+	 * paragraphs at the cap ("…a big jump is" / "coming"). Not byte-identical to
+	 * char-by-char streaming — the soft-clause latency cut can fire earlier
+	 * there — but every segment obeys the same cap and boundary preferences.
+	 * {@link #extract} leaves at most MAX_SEGMENT behind, emitted as the
+	 * trailing segment.
+	 */
 	#drain(out: string[]): void {
-		let text = this.#buf;
+		this.#extract(out);
+		const text = this.#buf;
 		this.#buf = "";
-		while (text.length > MAX_SEGMENT) {
-			const cut = findForcedCut(text, MAX_SEGMENT);
-			this.#emit(text.slice(0, cut), out);
-			text = text.slice(cut);
-		}
 		this.#emit(text, out);
 	}
 
@@ -335,14 +340,19 @@ export class SpeakableStream {
 		for (;;) {
 			const buf = this.#buf;
 			const min = this.#spoke ? MIN_SEGMENT : FIRST_SEGMENT_MIN;
+			// Bounded: a sentence past MAX_SEGMENT risks Kokoro's ~510-phoneme
+			// truncation — fall through to clause/word cuts instead.
 			const sentence = findSentenceCut(buf, min);
-			if (sentence !== -1) {
+			if (sentence !== -1 && sentence <= MAX_SEGMENT) {
 				this.#cut(sentence, out);
 				continue;
 			}
 			if (!this.#spoke && buf.length >= FIRST_CLAUSE_MIN) {
+				// Bounded like the sentence branch: in a one-shot buffer the earliest
+				// clause can lie far past the cap; per-char streaming would have
+				// force-cut at FIRST_FORCED_MAX long before seeing it.
 				const clause = findClauseCut(buf, FIRST_SEGMENT_MIN);
-				if (clause !== -1) {
+				if (clause !== -1 && clause <= FIRST_FORCED_MAX) {
 					this.#cut(clause, out);
 					continue;
 				}