@code-yeongyu/senpi-codemode 2026.10.30-1 → 2026.10.31-1

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [2026.10.31-1] - 2026-10-31
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.10.30-2] - 2026-10-30
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- Group-signal notices ignore inert quoted text and shell comments without hiding commands inside executable substitutions ([#3019](https://github.com/code-yeongyu/senpi/issues/3019)).
+- Keep held permission decisions parked until their two-second deadline when the host claims the shared slot before the worker waits (#4709).
+
+### Removed
+
 ## [2026.10.30-1] - 2026-10-30
 
 ### Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.10.30-1",
+	"version": "2026.10.31-1",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -33,15 +33,15 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.30-1",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.31-1",
 		"quickjs-wasi": "3.6.2",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.10.30-1"
+		"@code-yeongyu/senpi": "2026.10.31-1"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.10.30-1"
+		"@code-yeongyu/senpi": "2026.10.31-1"
 	},
 	"keywords": [
 		"senpi",

package/src/kernels/js/group-signal-notice.js

@@ -26,10 +26,286 @@ const PKILL_GROUP = new RegExp(String.raw`${COMMAND_POSITION}pkill\b[^\n;|&]*\s(
 // can include the agent's own (bun, node, senpi). Inside an `echo` string it is only text.
 const KILLALL = new RegExp(String.raw`${COMMAND_POSITION}killall\s`, "mu");
 
+// senpi#3019: a keyword inside quoted text is not a command position, so the scan runs on a copy whose inert text is
+// blanked: single-quoted strings, comments, and the literal parts of double-quoted strings and heredoc bodies (all of a
+// body whose delimiter is quoted). A command substitution, `$(...)` or a backtick pair, runs even inside double quotes
+// and unquoted heredoc bodies, so it keeps its text, as a `-c` script does; both are command lines, with their own inert
+// text blanked in turn. A `<<` whose delimiter line never comes blanks nothing.
+const SCRIPT_FLAG_BEFORE_QUOTE = /(?:^|\s)-[A-Za-z]*c\s+$/u;
+const WORD_END = /[\s;&|<>()]/u;
+const BEFORE_COMMENT = /[\s;&|()]/u;
+const MAX_SCAN_WORK = 262_144;
+const SCAN_LIMIT = Symbol("advisory scan limit");
+
+function scanStep(scan, nesting, work = 1) {
+	scan.remaining -= work;
+	if (scan.remaining < 0 || nesting > 64) throw SCAN_LIMIT;
+}
+
+function blank(text) {
+	return text.replace(/[^\n]/gu, "x");
+}
+
+// For a `$(` or a backtick at `index`: the index of the `)` or backtick that closes it, or -1 when none does. Anything
+// else: undefined.
+function substitutionEnd(text, index, scan, nesting) {
+	if (text[index] === "`") {
+		const end = text.indexOf("`", index + 1);
+		scanStep(scan, nesting, (end === -1 ? text.length : end) - index);
+		return end;
+	}
+	if (text[index] !== "$" || text[index + 1] !== "(") return undefined;
+	let depth = 0;
+	const cases = [];
+	let commandStart = true;
+	for (let at = index + 1; at < text.length; at++) {
+		scanStep(scan, nesting);
+		const char = text[at];
+		const currentCase = cases.at(-1);
+		const atCaseDepth = currentCase?.depth === depth;
+		if (char === "\\") {
+			if (text[at + 1] !== "\n") {
+				if (atCaseDepth && currentCase.header === 2) currentCase.header = 1;
+				if (atCaseDepth && currentCase.pattern) currentCase.patternStarted = true;
+				commandStart = false;
+			}
+			at++;
+		} else if (char === "#" && BEFORE_COMMENT.test(text[at - 1])) {
+			const end = text.indexOf("\n", at);
+			scanStep(scan, nesting, (end === -1 ? text.length : end) - at);
+			if (end === -1) return -1;
+			at = end;
+			commandStart = true;
+		} else if (char === "'" || char === '"' || char === "`") {
+			if (atCaseDepth && currentCase.header === 2) currentCase.header = 1;
+			if (atCaseDepth && currentCase.pattern) currentCase.patternStarted = true;
+			at = closingQuote(text, at, scan, nesting + 1);
+			commandStart = false;
+		} else if (char === "(") {
+			// A case pattern may open with "(", but its mandatory ")" never closes the substitution.
+			if (atCaseDepth && currentCase.pattern && !currentCase.patternStarted) currentCase.patternStarted = true;
+			else depth++;
+			commandStart = !currentCase?.pattern || text[at - 1] === "$";
+		} else if (char === ")") {
+			if (atCaseDepth && currentCase.pattern) {
+				currentCase.pattern = false;
+				commandStart = true;
+				continue;
+			}
+			depth--;
+			if (depth === 0) return at;
+			commandStart = false;
+		} else if (char === ";") {
+			const terminator = text.startsWith(";;&", at) ? 3 : text[at + 1] === ";" || text[at + 1] === "&" ? 2 : 0;
+			if (atCaseDepth && currentCase.header === 0 && !currentCase.pattern && terminator > 0) {
+				currentCase.pattern = true;
+				currentCase.patternStarted = false;
+				at += terminator - 1;
+			}
+			commandStart = true;
+		} else if (char === "\n" || char === "|" || char === "&") {
+			commandStart = true;
+		} else if (!WORD_END.test(char)) {
+			let end = at + 1;
+			while (end < text.length && !WORD_END.test(text[end]) && !["'", '"', "\\", "`"].includes(text[end])) {
+				scanStep(scan, nesting);
+				end++;
+			}
+			const word = text.slice(at, end);
+			if (atCaseDepth && currentCase.header === 2) {
+				currentCase.header = 1;
+				commandStart = false;
+			} else if (atCaseDepth && currentCase.header === 1 && word === "in") {
+				currentCase.header = 0;
+				currentCase.pattern = true;
+				commandStart = false;
+			} else if (atCaseDepth && currentCase.pattern) {
+				if (word === "esac" && !currentCase.patternStarted) cases.pop();
+				else currentCase.patternStarted = true;
+				commandStart = false;
+			} else if (word === "case" && commandStart) {
+				cases.push({ depth, header: 2, pattern: false, patternStarted: false });
+				commandStart = false;
+			} else if (word === "esac" && commandStart && atCaseDepth) {
+				cases.pop();
+				commandStart = false;
+			} else {
+				commandStart = commandStart && /^(?:if|then|do|else|elif|while|until|!|\{)$/u.test(word);
+			}
+			at = end - 1;
+		}
+	}
+	return -1;
+}
+
+// The index of the quote that closes the one at `open`, or the text length. A substitution inside double quotes is a
+// context of its own, so a quote inside it does not close the string.
+function closingQuote(text, open, scan, nesting) {
+	const quote = text[open];
+	let backslashes = 0;
+	if (quote === "'" && text[open - 1] === "$") {
+		for (let at = open - 2; text[at] === "\\"; at--) {
+			scanStep(scan, nesting);
+			backslashes++;
+		}
+	}
+	const ansi = quote === "'" && text[open - 1] === "$" && backslashes % 2 === 0;
+	for (let index = open + 1; index < text.length; index++) {
+		scanStep(scan, nesting);
+		if (text[index] === quote) return index;
+		if (ansi && text[index] === "\\") {
+			index++;
+			continue;
+		}
+		if (quote === "'") continue;
+		const end = substitutionEnd(text, index, scan, nesting + 1);
+		if (end === -1) return text.length;
+		if (end !== undefined) index = end;
+		else if (text[index] === "\\") index++;
+	}
+	return text.length;
+}
+
+function blankLiteralText(text, scan, nesting) {
+	let out = "";
+	let index = 0;
+	while (index < text.length) {
+		scanStep(scan, nesting);
+		const end = substitutionEnd(text, index, scan, nesting + 1);
+		if (end !== undefined && end !== -1) {
+			const open = text[index] === "`" ? 1 : 2;
+			out += text.slice(index, index + open) + blankQuotedText(text.slice(index + open, end), scan, nesting + 1) + text[end];
+			index = end + 1;
+			continue;
+		}
+		const step = text[index] === "\\" ? 2 : 1;
+		out += blank(text.slice(index, index + step));
+		index += step;
+	}
+	return out;
+}
+
+// `<<` or `<<-`, optional blanks, then the delimiter word up to an unquoted blank or operator. Quote removal gives the
+// delimiter, and any quoting in the word leaves the body unexpanded.
+function readHeredoc(text, at, scan, nesting) {
+	let index = at + 2;
+	const stripTabs = text[index] === "-";
+	if (stripTabs) index++;
+	while (text[index] === " " || text[index] === "\t") {
+		scanStep(scan, nesting);
+		index++;
+	}
+	let delimiter = "";
+	let quoted = false;
+	while (index < text.length && !WORD_END.test(text[index])) {
+		scanStep(scan, nesting);
+		const char = text[index];
+		if (char === "'" || char === '"') {
+			const end = text.indexOf(char, index + 1);
+			scanStep(scan, nesting, (end === -1 ? text.length : end) - index);
+			if (end === -1) return undefined;
+			delimiter += text.slice(index + 1, end);
+			quoted = true;
+			index = end + 1;
+		} else if (char === "\\") {
+			delimiter += text[index + 1] ?? "";
+			quoted = true;
+			index += 2;
+		} else {
+			delimiter += char;
+			index++;
+		}
+	}
+	return delimiter ? { delimiter, quoted, stripTabs, end: index } : undefined;
+}
+
+function closingLine(text, from, { delimiter, stripTabs }, scan, nesting) {
+	let start = from;
+	while (start < text.length) {
+		const newline = text.indexOf("\n", start);
+		const end = newline === -1 ? text.length : newline;
+		scanStep(scan, nesting, end - start + 1);
+		const line = text.slice(start, end);
+		if ((stripTabs ? line.replace(/^\t+/u, "") : line) === delimiter) return { start, end };
+		start = end + 1;
+	}
+	return undefined;
+}
+
+function blankQuotedText(text, scan, nesting) {
+	let out = "";
+	const heredocs = [];
+	let index = 0;
+	while (index < text.length) {
+		scanStep(scan, nesting);
+		const char = text[index];
+		if (char === "\\") {
+			out += text.slice(index, index + 2);
+			index += 2;
+			continue;
+		}
+		if (char === "'" || char === '"') {
+			const end = closingQuote(text, index, scan, nesting + 1);
+			const inner = text.slice(index + 1, end);
+			scanStep(scan, nesting, out.length);
+			if (SCRIPT_FLAG_BEFORE_QUOTE.test(out)) out += char + blankQuotedText(inner, scan, nesting + 1);
+			else out += char + (char === "'" ? blank(inner) : blankLiteralText(inner, scan, nesting + 1));
+			if (end < text.length) out += char;
+			index = end + 1;
+			continue;
+		}
+		if (char === "#" && (index === 0 || BEFORE_COMMENT.test(text[index - 1]))) {
+			const newline = text.indexOf("\n", index);
+			const end = newline === -1 ? text.length : newline;
+			scanStep(scan, nesting, end - index);
+			out += blank(text.slice(index, end));
+			index = end;
+			continue;
+		}
+		if (text.startsWith("<<<", index)) {
+			out += "<<<";
+			index += 3;
+			continue;
+		}
+		const heredoc = text.startsWith("<<", index) ? readHeredoc(text, index, scan, nesting) : undefined;
+		if (heredoc) {
+			heredocs.push(heredoc);
+			out += text.slice(index, heredoc.end);
+			index = heredoc.end;
+			continue;
+		}
+		out += char;
+		index++;
+		if (char !== "\n") continue;
+		// Each body starts on the line after its `<<` and ends at a line holding only its delimiter.
+		for (const pending of heredocs.splice(0)) {
+			const close = closingLine(text, index, pending, scan, nesting);
+			if (!close) break;
+			const body = text.slice(index, close.start);
+			out += (pending.quoted ? blank(body) : blankLiteralText(body, scan, nesting + 1)) + text.slice(close.start, close.end);
+			index = close.end;
+			if (text[index] === "\n") {
+				out += "\n";
+				index++;
+			}
+		}
+	}
+	return out;
+}
+
 export const GROUP_SIGNAL_NOTICE_TAG = "[senpi:group-signal]";
 
 export function signalsProcessGroup(commandText) {
-	return KILL_GROUP.test(commandText) || PKILL_GROUP.test(commandText) || KILLALL.test(commandText);
+	// Bound quote masking, but keep a conservative raw-text notice when the scan cannot finish.
+	let text = commandText;
+	if (commandText.length <= MAX_SCAN_WORK) {
+		try {
+			text = blankQuotedText(commandText, { remaining: MAX_SCAN_WORK }, 0);
+		} catch (error) {
+			if (error !== SCAN_LIMIT) throw error;
+		}
+	}
+	return KILL_GROUP.test(text) || PKILL_GROUP.test(text) || KILLALL.test(text);
 }
 
 export function groupSignalNotice(api, readGroup = agentProcessGroup) {