@sayknow-cli/coding-agent 0.3.6 → 0.3.8

package/src/tools/ultragoal-ask-guard.ts

@@ -10,6 +10,29 @@ const ULTRAGOAL_ASK_GUARD = Symbol.for("sayknow-cli.ultragoalAskGuard");
 
 type GuardedTool = AgentTool & { [ULTRAGOAL_ASK_GUARD]?: true };
 
+export interface UltragoalAskGuardContext {
+	activeSkillState?: { skill?: string; session_id?: string } | null;
+	sessionId?: string | null;
+}
+
+const UPSTREAM_PLANNING_ASK_SKILLS = new Set(["deep-interview", "ralplan"]);
+
+function normalizedActiveSkill(context?: UltragoalAskGuardContext): string | undefined {
+	const skill = context?.activeSkillState?.skill?.trim();
+	return skill || undefined;
+}
+
+function sessionScopedAskGuardId(
+	context: UltragoalAskGuardContext,
+	activeSkill: string | undefined,
+): string | undefined {
+	if (activeSkill !== "ultragoal" && !UPSTREAM_PLANNING_ASK_SKILLS.has(activeSkill ?? "")) return undefined;
+	const activeSessionId = context.activeSkillState?.session_id?.trim();
+	if (activeSessionId) return activeSessionId;
+	const sessionId = context.sessionId?.trim();
+	return sessionId || undefined;
+}
+
 export function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiagnostic): string {
 	return [
 		diagnostic.message,
@@ -18,15 +41,26 @@ export function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiag
 	].join("\n");
 }
 
-export async function assertUltragoalAskAllowed(cwd: string): Promise<void> {
-	const diagnostic = await isUltragoalAskBlocked(cwd);
+export async function assertUltragoalAskAllowed(cwd: string, context: UltragoalAskGuardContext = {}): Promise<void> {
+	const activeSkill = normalizedActiveSkill(context);
+	// Deep-interview and ralplan are upstream planning workflows whose core gates
+	// are `ask` calls. Scope their Ultragoal check to the current session so stale
+	// or ambiguous Ultragoal durable state from another session cannot hijack those
+	// prompts; same-session active Ultragoal state still falls through to the
+	// blocker/nudge checks below.
+	const sessionId = sessionScopedAskGuardId(context, activeSkill);
+	const diagnostic = await isUltragoalAskBlocked(cwd, { sessionId });
 	if (!diagnostic.active) return;
-	const nudge = await consumeUltragoalAskNudge(cwd);
+	const nudge = await consumeUltragoalAskNudge(cwd, sessionId);
 	if (nudge.nudged) throw new ToolError(nudge.message);
 	throw new ToolError(formatUltragoalAskBlockMessage(diagnostic));
 }
 
-export function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string): T {
+export function guardToolForUltragoalAsk<T extends AgentTool>(
+	tool: T,
+	getCwd: () => string,
+	getContext: () => UltragoalAskGuardContext = () => ({}),
+): T {
 	if (tool.name !== "ask") return tool;
 	const candidate = tool as GuardedTool;
 	if (candidate[ULTRAGOAL_ASK_GUARD]) return tool;
@@ -35,7 +69,7 @@ export function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: (
 			if (prop === ULTRAGOAL_ASK_GUARD) return true;
 			if (prop !== "execute") return Reflect.get(target, prop, receiver);
 			return async (...args: unknown[]): Promise<unknown> => {
-				await assertUltragoalAskAllowed(getCwd());
+				await assertUltragoalAskAllowed(getCwd(), getContext());
 				return Reflect.apply(target.execute, target, args);
 			};
 		},

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/file-mentions.ts

@@ -159,24 +159,32 @@ async function resolveMentionPath(
 	return best?.candidate.path ?? null;
 }
 
-function buildTextOutput(textContent: string): { output: string; lineCount: number } {
+/**
+ * Default inline cap for auto-read file mentions, deliberately below the
+ * read-tool cap (`DEFAULT_MAX_BYTES`, 50KB) so an incidental `@path` mention
+ * injects a smaller snippet than an explicit `read`. Overridable per call.
+ */
+export const DEFAULT_FILE_MENTION_INLINE_BYTES = 20 * 1024;
+
+function buildTextOutput(textContent: string, maxInlineBytes?: number): { output: string; lineCount: number } {
+	const cap = maxInlineBytes && maxInlineBytes > 0 ? maxInlineBytes : DEFAULT_FILE_MENTION_INLINE_BYTES;
 	const allLines = textContent.split("\n");
 	const totalFileLines = allLines.length;
-	const truncation = truncateHead(textContent);
+	const truncation = truncateHead(textContent, { maxBytes: cap });
 
 	if (truncation.firstLineExceedsLimit) {
 		const firstLine = allLines[0] ?? "";
 		const firstLineBytes = Buffer.byteLength(firstLine, "utf-8");
-		const snippet = truncateHeadBytes(firstLine, DEFAULT_MAX_BYTES);
+		const snippet = truncateHeadBytes(firstLine, cap);
 		let outputText = snippet.text;
 
 		if (outputText.length > 0) {
 			outputText += `\n\n[Line 1 is ${formatBytes(firstLineBytes)}, exceeds ${formatBytes(
-				DEFAULT_MAX_BYTES,
+				cap,
 			)} limit. Showing first ${formatBytes(snippet.bytes)} of the line.]`;
 		} else {
 			outputText = `[Line 1 is ${formatBytes(firstLineBytes)}, exceeds ${formatBytes(
-				DEFAULT_MAX_BYTES,
+				cap,
 			)} limit. Unable to display a valid UTF-8 snippet.]`;
 		}
 
@@ -277,7 +285,18 @@ export function extractFileMentions(text: string): string[] {
 export async function generateFileMentionMessages(
 	filePaths: string[],
 	cwd: string,
-	options?: { autoResizeImages?: boolean; useHashLines?: boolean },
+	options?: {
+		autoResizeImages?: boolean;
+		useHashLines?: boolean;
+		/** Inline byte cap for auto-read text. Default: DEFAULT_FILE_MENTION_INLINE_BYTES. */
+		maxInlineBytes?: number;
+		/**
+		 * Resolved paths already shown (read or mentioned) recently in the
+		 * conversation. A mention of one of these emits a compact duplicate note
+		 * instead of re-injecting the full body.
+		 */
+		recentlyShownPaths?: ReadonlySet<string>;
+	},
 ): Promise<AgentMessage[]> {
 	if (filePaths.length === 0) return [];
 
@@ -290,12 +309,25 @@ export async function generateFileMentionMessages(
 		return mentionCandidatesPromise;
 	};
 
+	const shownInBatch = new Set<string>();
 	for (const filePath of filePaths) {
 		const resolvedPath = await resolveMentionPath(filePath, cwd, getMentionCandidates);
 		if (!resolvedPath) {
 			continue;
 		}
 		const absolutePath = resolveReadPath(resolvedPath, cwd);
+		// Duplicate suppression, keyed by absolute path: same path shown earlier this
+		// batch or recently in the conversation → compact note, no re-read (the path
+		// stays referenced so the model can re-fetch via the read tool).
+		if (shownInBatch.has(absolutePath) || options?.recentlyShownPaths?.has(absolutePath)) {
+			files.push({
+				path: resolvedPath,
+				content: `(already shown in this conversation; not re-read — use the read tool to fetch \`${resolvedPath}\` again)`,
+				duplicate: true,
+			});
+			continue;
+		}
+		shownInBatch.add(absolutePath);
 		try {
 			const stat = await Bun.file(absolutePath).stat();
 			if (stat.isDirectory()) {
@@ -354,7 +386,7 @@ export async function generateFileMentionMessages(
 			}
 
 			const content = await Bun.file(absolutePath).text();
-			let { output, lineCount } = buildTextOutput(content);
+			let { output, lineCount } = buildTextOutput(content, options?.maxInlineBytes);
 			if (options?.useHashLines) {
 				output = formatHashLines(output);
 			}

package/src/utils/git.ts

@@ -1317,6 +1317,79 @@ export async function clean(
 	await runEffect(cwd, args, { signal: options.signal });
 }
 
+// ════════════════════════════════════════════════════════════════════════════
+// API: bisect
+// ════════════════════════════════════════════════════════════════════════════
+
+export interface BisectCommitInfo {
+	sha: string;
+	author: string;
+	date: string;
+	subject: string;
+	stat: string;
+}
+
+/**
+ * Thin wrappers over `git bisect`. The marking commands (`good`/`bad`/`skip`)
+ * return the raw {@link GitCommandResult} without throwing so callers can both
+ * detect a genuine failure (non-zero exit) and scan the output for the
+ * "<sha> is the first bad commit" conclusion. `reset` is best-effort and never
+ * throws so it is safe to call from a `finally` block to restore the worktree.
+ */
+export const bisect = {
+	/** Begin a bisect session (does not seed good/bad endpoints). */
+	async start(cwd: string, signal?: AbortSignal): Promise<void> {
+		await runEffect(cwd, ["bisect", "start"], { signal });
+	},
+
+	/** Mark a revision (or current HEAD when omitted) good. Returns raw output. */
+	async good(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ref ? ["bisect", "good", ref] : ["bisect", "good"], { signal });
+	},
+
+	/** Mark a revision (or current HEAD when omitted) bad. Returns raw output. */
+	async bad(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ref ? ["bisect", "bad", ref] : ["bisect", "bad"], { signal });
+	},
+
+	/** Skip the current (untestable) revision. Returns raw output. */
+	async skip(cwd: string, signal?: AbortSignal): Promise<GitCommandResult> {
+		return runCommand(cwd, ["bisect", "skip"], { signal });
+	},
+
+	/** Read the replayable bisect log for the current session. */
+	async log(cwd: string, signal?: AbortSignal): Promise<string> {
+		return runText(cwd, ["bisect", "log"], { signal });
+	},
+
+	/** End the bisect session, restoring the original HEAD. Never throws. */
+	async reset(cwd: string, signal?: AbortSignal): Promise<void> {
+		await runCommand(cwd, ["bisect", "reset"], { signal });
+	},
+
+	/** True when `ancestor` is a first-parent-or-merge ancestor of `descendant`. */
+	async isAncestor(cwd: string, ancestor: string, descendant: string, signal?: AbortSignal): Promise<boolean> {
+		const result = await runCommand(cwd, ["merge-base", "--is-ancestor", ancestor, descendant], {
+			readOnly: true,
+			signal,
+		});
+		return result.exitCode === 0;
+	},
+
+	/** Resolve author/date/subject and a diffstat for a commit (for the receipt). */
+	async describe(cwd: string, sha: string, signal?: AbortSignal): Promise<BisectCommitInfo> {
+		// Newline-delimited so the format string carries no NUL byte (argv cannot
+		// contain NUL); %s is already a single line, so the four fields never wrap.
+		const meta = await runText(cwd, ["show", "-s", "--format=%H%n%an <%ae>%n%aI%n%s", sha], {
+			readOnly: true,
+			signal,
+		});
+		const [resolvedSha = sha, author = "", date = "", subject = ""] = meta.split("\n");
+		const stat = await runText(cwd, ["show", "--stat", "--format=", sha], { readOnly: true, signal });
+		return { sha: resolvedSha, author, date, subject, stat: stat.trim() };
+	},
+};
+
 // ════════════════════════════════════════════════════════════════════════════
 // API: ls
 // ════════════════════════════════════════════════════════════════════════════

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());

package/src/web/scrapers/youtube.ts

@@ -10,44 +10,56 @@ import { extractWithParallel, findParallelApiKey, getParallelExtractContent } fr
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, formatMediaDuration, formatNumber } from "./types";
 
-interface YouTubeUrl {
+export interface YouTubeUrl {
 	videoId: string;
 	playlistId?: string;
 }
 
+const YOUTUBE_VIDEO_ID_PATTERN = /^[a-zA-Z0-9_-]{11}$/;
+
+function isYouTubeHost(hostname: string): boolean {
+	return hostname === "youtube.com" || hostname === "m.youtube.com" || hostname === "music.youtube.com";
+}
+
+function isYouTubeEmbedHost(hostname: string): boolean {
+	return isYouTubeHost(hostname) || hostname === "youtube-nocookie.com";
+}
+
 /**
  * Parse YouTube URL into components
  */
-function parseYouTubeUrl(url: string): YouTubeUrl | null {
+export function parseYouTubeUrl(url: string): YouTubeUrl | null {
 	try {
 		const parsed = new URL(url);
 		const hostname = parsed.hostname.replace(/^www\./, "");
 
-		// youtube.com/watch?v=VIDEO_ID
-		if ((hostname === "youtube.com" || hostname === "m.youtube.com") && parsed.pathname === "/watch") {
+		// youtube.com/watch?v=VIDEO_ID and music.youtube.com/watch?v=VIDEO_ID
+		if (isYouTubeHost(hostname) && parsed.pathname === "/watch") {
 			const videoId = parsed.searchParams.get("v");
 			const playlistId = parsed.searchParams.get("list") || undefined;
-			if (videoId) return { videoId, playlistId };
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) return { videoId, playlistId };
 		}
 
-		// youtube.com/v/VIDEO_ID or youtube.com/embed/VIDEO_ID
-		if (hostname === "youtube.com" || hostname === "m.youtube.com") {
-			const match = parsed.pathname.match(/^\/(v|embed)\/([a-zA-Z0-9_-]{11})/);
+		// youtube.com/v/VIDEO_ID, youtube.com/embed/VIDEO_ID, youtube.com/live/VIDEO_ID,
+		// and youtube-nocookie.com/embed/VIDEO_ID. Require the id segment to end
+		// before matching so malformed overlong ids are not silently truncated.
+		if (isYouTubeEmbedHost(hostname)) {
+			const match = parsed.pathname.match(/^\/(v|embed|live)\/([a-zA-Z0-9_-]{11})(?:$|\/)/);
 			if (match) return { videoId: match[2] };
 		}
 
 		// youtu.be/VIDEO_ID
 		if (hostname === "youtu.be") {
 			const videoId = parsed.pathname.slice(1).split("/")[0];
-			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) {
 				return { videoId };
 			}
 		}
 
-		// youtube.com/shorts/VIDEO_ID
-		if (hostname === "youtube.com" && parsed.pathname.startsWith("/shorts/")) {
+		// youtube.com/shorts/VIDEO_ID and m.youtube.com/shorts/VIDEO_ID
+		if (isYouTubeHost(hostname) && parsed.pathname.startsWith("/shorts/")) {
 			const videoId = parsed.pathname.replace("/shorts/", "").split("/")[0];
-			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+			if (videoId && YOUTUBE_VIDEO_ID_PATTERN.test(videoId)) {
 				return { videoId };
 			}
 		}