@code-yeongyu/senpi-codemode 2026.9.22 → 2026.9.23-3

package/CHANGELOG.md

@@ -12,6 +12,84 @@
 
 ### Removed
 
+## [2026.9.23-3] - 2026-09-23
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+- Dense one-line JavaScript eval cells are previewed in the TUI broken at statement, block, and long-array boundaries with indentation, keeping the original tokens and comments. Unparseable, non-JavaScript, and already readable cells are shown as sent, and the code that runs is unchanged. ([#2050](https://github.com/code-yeongyu/senpi/issues/2050))
+- The `eval` `summary` guide asks for a progress update saying what the agent is doing and why, in the language the user writes in, and summaries no longer have a length limit (the 80-character truncation is gone). A collapsed eval block shows the first three summary lines; expanding it shows the rest. ([#2050](https://github.com/code-yeongyu/senpi/issues/2050))
+- Codemode CI tests use at most two fork workers, matching the coding-agent suite's interpreter-heavy test scheduling. Test deadlines, assertions, and local worker defaults are unchanged. ([#2039](https://github.com/code-yeongyu/senpi/issues/2039))
+
+### Fixed
+
+### Removed
+
+## [2026.9.23-2] - 2026-09-23
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.23] - 2026-09-23
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.22-4] - 2026-09-22
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.22-3] - 2026-09-22
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+### Removed
+
+## [2026.9.22-2] - 2026-09-22
+
+### Breaking Changes
+
+### Added
+
+### Changed
+
+### Fixed
+
+- `wake_source_state` (live detached eval cells) is now published on the rpc channel as well as the in-process event bus, so out-of-process consumers see live cells the way the TUI footer does (#1943).
+
+### Removed
+
 ## [2026.9.22] - 2026-09-21
 
 ### Breaking Changes

package/README.md

@@ -29,7 +29,9 @@ task-tool names are known.
   session-adjacent spill files for large streams.
 - TUI and HTML-export rendering for syntax-highlighted cells, status rows,
   task progress, structured display values, truncation warnings, and image
-  fallbacks.
+  fallbacks. A JavaScript cell sent as dense one-line code is previewed broken
+  at statement, block, and long-array boundaries; the cell itself runs exactly
+  as sent.
 - Runtime identity badges in eval headers — `eval py (3.14.7, ~/.venv/bin/python3)`,
   `eval js (node 26.7.0, /opt/…/bin/node)` — with the same `runtime` info on
   `EvalToolDetails` and its `cells` for RPC consumers; interpreter detection
@@ -207,13 +209,13 @@ same name/spec/mode; no worker state is reconstructed in the prelude.
 
 ## Required summary
 
-Every `eval` run call MUST include a `summary` — one line in the user's
-conversational language stating what the cell does and for what purpose (e.g.
-a Korean conversation produces a Korean summary such as "src 전체에서
-legacyClient 사용처 집계"). The summary is shown in the TUI while the cell
-runs and in the finished result, so you can always tell what is running and
-why. Values longer than 80 characters are force-truncated. A run request
-without a `summary` fails with a teaching error.
+Every `eval` run call MUST include a `summary` — one line in the language the
+user writes in: a progress update saying what the agent is doing and why, not
+a label for the code. The
+summary is shown in the TUI while the cell runs and in the finished result, so
+you can always tell what is running and why. It has no length limit; a
+collapsed block shows its first three lines. A run request without a
+`summary` fails with a teaching error.
 
 ## Detached cells
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-codemode",
-	"version": "2026.9.22",
+	"version": "2026.9.23-3",
 	"description": "Source-only senpi extension package for codemode evaluation tools",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -30,14 +30,14 @@
 	},
 	"dependencies": {
 		"@babel/parser": "8.0.4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.22",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.9.23-3",
 		"typebox": "1.3.34"
 	},
 	"peerDependencies": {
-		"@code-yeongyu/senpi": "2026.9.22"
+		"@code-yeongyu/senpi": "2026.9.23-3"
 	},
 	"devDependencies": {
-		"@code-yeongyu/senpi": "2026.9.22"
+		"@code-yeongyu/senpi": "2026.9.23-3"
 	},
 	"keywords": [
 		"senpi",

package/src/index.ts

@@ -114,6 +114,9 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		statusTicker.sync(entries);
 	};
 	const emitWakeSourceState = (state: WakeSourceState): void => {
+		// Same dual publication as the settle payload below: the in-process bus
+		// feeds the TUI footer, the rpc channel feeds out-of-process consumers.
+		pi.rpc?.emit(WAKE_SOURCE_STATE_EVENT, state);
 		pi.events?.emit(WAKE_SOURCE_STATE_EVENT, state);
 	};
 	const registerEvalForRuntime = (

package/src/tool/display-code.ts

@@ -0,0 +1,145 @@
+import { parse } from "@babel/parser";
+import type { EvalLanguage } from "./types.ts";
+
+// Display-only: models often send a JS cell as one long line of joined statements. The preview
+// breaks it at statement, block, and long-array boundaries and keeps every source token and
+// comment verbatim. The tool arguments are never touched (senpi#1472).
+const DENSE_LINE_LENGTH = 100;
+const ARRAY_BREAK_LENGTH = 60;
+const INDENT = "  ";
+const CACHE_LIMIT = 64;
+
+type SourceNode = { readonly type: string; readonly start: number; readonly end: number };
+
+// A whitespace/comma/comment region between two tokens that becomes a line break.
+type Gap = {
+	readonly start: number;
+	readonly end: number;
+	readonly contentDepth: number;
+	readonly nextDepth: number;
+};
+
+const cache = new Map<string, string>();
+
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function sourceNode(value: unknown): SourceNode | undefined {
+	if (!isRecord(value)) return undefined;
+	const { type, start, end } = value;
+	if (typeof type !== "string" || typeof start !== "number" || typeof end !== "number") return undefined;
+	return { type, start, end };
+}
+
+function sourceNodes(value: unknown): SourceNode[] {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => sourceNode(item) ?? []);
+}
+
+function isDense(code: string): boolean {
+	return code.split("\n").some((line) => line.length > DENSE_LINE_LENGTH);
+}
+
+function parseProgram(code: string): unknown {
+	try {
+		return parse(code, {
+			sourceType: "module",
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+			allowImportExportEverywhere: true,
+		}).program;
+	} catch (error) {
+		if (error instanceof SyntaxError) return undefined;
+		throw error;
+	}
+}
+
+function siblingGaps(children: readonly SourceNode[], depth: number): Gap[] {
+	return children.slice(1).map((child, index) => ({
+		start: children[index]?.end ?? child.start,
+		end: child.start,
+		contentDepth: depth,
+		nextDepth: depth,
+	}));
+}
+
+// Gaps for a bracketed container whose children move onto their own indented lines.
+function containerGaps(container: SourceNode, children: readonly SourceNode[], depth: number): Gap[] {
+	const first = children[0];
+	const last = children.at(-1);
+	if (first === undefined || last === undefined) return [];
+	const inner = depth + 1;
+	return [
+		{ start: container.start + 1, end: first.start, contentDepth: inner, nextDepth: inner },
+		...siblingGaps(children, inner),
+		{ start: last.end, end: container.end - 1, contentDepth: inner, nextDepth: depth },
+	];
+}
+
+function breakableChildren(node: SourceNode, record: Readonly<Record<string, unknown>>, code: string) {
+	if (node.type === "BlockStatement" || node.type === "StaticBlock") return sourceNodes(record.body);
+	if (node.type !== "ArrayExpression") return undefined;
+	const elements = sourceNodes(record.elements);
+	const text = code.slice(node.start, node.end);
+	if (elements.length < 2 || text.length <= ARRAY_BREAK_LENGTH || text.includes("\n")) return undefined;
+	return elements;
+}
+
+function collectGaps(value: unknown, depth: number, code: string, gaps: Gap[]): void {
+	if (Array.isArray(value)) {
+		for (const item of value) collectGaps(item, depth, code, gaps);
+		return;
+	}
+	if (!isRecord(value)) return;
+	const node = sourceNode(value);
+	const children = node === undefined ? undefined : breakableChildren(node, value, code);
+	const breaks = node !== undefined && children !== undefined && children.length > 0;
+	if (breaks) gaps.push(...containerGaps(node, children, depth));
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "loc" || key === "extra" || key.endsWith("Comments")) continue;
+		if (child !== null && typeof child === "object") collectGaps(child, breaks ? depth + 1 : depth, code, gaps);
+	}
+}
+
+function renderGap(text: string, gap: Gap): string {
+	let rest = text.trim();
+	let attached = "";
+	if (rest.startsWith(",") || rest.startsWith(";")) {
+		attached = rest.slice(0, 1);
+		rest = rest.slice(1).trim();
+	}
+	const contentIndent = INDENT.repeat(gap.contentDepth);
+	const content = rest
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line.length > 0)
+		.map((line) => `\n${contentIndent}${line}`)
+		.join("");
+	return `${attached}${content}\n${INDENT.repeat(gap.nextDepth)}`;
+}
+
+function reformat(code: string): string {
+	const program = parseProgram(code);
+	if (!isRecord(program)) return code;
+	const gaps = siblingGaps(sourceNodes(program.body), 0);
+	collectGaps(program.body, 0, code, gaps);
+	gaps.sort((left, right) => left.start - right.start);
+	let output = "";
+	let cursor = 0;
+	for (const gap of gaps) {
+		output += code.slice(cursor, gap.start) + renderGap(code.slice(gap.start, gap.end), gap);
+		cursor = gap.end;
+	}
+	return (output + code.slice(cursor)).trim();
+}
+
+export function displayCode(code: string, language: EvalLanguage): string {
+	if (language !== "js" || !isDense(code)) return code;
+	const cached = cache.get(code);
+	if (cached !== undefined) return cached;
+	const formatted = reformat(code);
+	if (cache.size >= CACHE_LIMIT) cache.delete(cache.keys().next().value ?? "");
+	cache.set(code, formatted);
+	return formatted;
+}

package/src/tool/eval-request.ts

@@ -1,19 +1,14 @@
 import type { ExtensionContext } from "@code-yeongyu/senpi";
-import { EVAL_SUMMARY_MAX_LENGTH, type EvalControlInput, type EvalToolInput, type EvalToolRequest } from "./types.ts";
+import type { EvalControlInput, EvalToolInput, EvalToolRequest } from "./types.ts";
 
 const NON_INTERACTIVE_MODES = new Set(["print", "json"]);
 
-const ELLIPSIS = "...";
-
-// Harness-side enforcement of the schema maxLength: the tool advertises the limit, but an
-// over-limit value is force-truncated here (prepareArguments runs before schema validation)
-// instead of failing the call.
-export function clampEvalSummary(value: unknown): string | undefined {
+// A summary is one line of any length: whitespace (including newlines) collapses to single
+// spaces, and a blank value counts as absent. The TUI bounds how much of it a collapsed block shows.
+export function normalizeEvalSummary(value: unknown): string | undefined {
 	if (typeof value !== "string") return undefined;
 	const normalized = value.trim().replace(/\s+/gu, " ");
-	if (normalized.length === 0) return undefined;
-	if (normalized.length <= EVAL_SUMMARY_MAX_LENGTH) return normalized;
-	return `${normalized.slice(0, EVAL_SUMMARY_MAX_LENGTH - ELLIPSIS.length)}${ELLIPSIS}`;
+	return normalized.length === 0 ? undefined : normalized;
 }
 
 export function parseEvalRequest(params: unknown): EvalToolRequest {
@@ -28,10 +23,10 @@ export function parseEvalRequest(params: unknown): EvalToolRequest {
 		throw new TypeError(`Unknown eval action "${String(params.action)}"`);
 	if (!isEvalLanguage(params.language)) throw new TypeError("eval run requires language");
 	if (typeof params.code !== "string") throw new TypeError("eval run requires code");
-	const summary = clampEvalSummary(params.summary);
+	const summary = normalizeEvalSummary(params.summary);
 	if (summary === undefined)
 		throw new TypeError(
-			"eval run requires summary — one line in the user's language: what this cell does and for what purpose",
+			"eval run requires summary — one line in the user's language: what you are working on and for what purpose",
 		);
 	if (params.on_timeout !== undefined && params.on_timeout !== "detach" && params.on_timeout !== "error")
 		throw new TypeError(`Unknown eval on_timeout value "${String(params.on_timeout)}"`);

package/src/tool/eval-tool.ts

@@ -8,7 +8,7 @@ import {
 import { buildEvalPrompt } from "../prompt/eval-prompt.ts";
 import { EvalDetachedCellManager } from "./detached-cell-manager.ts";
 import { executeEvalControl } from "./detached-eval-result.ts";
-import { clampEvalSummary, isEvalControlRequest, parseEvalRequest } from "./eval-request.ts";
+import { isEvalControlRequest, normalizeEvalSummary, parseEvalRequest } from "./eval-request.ts";
 import type { CreateEvalToolOptions } from "./eval-tool-options.ts";
 import { runEvalCell } from "./run-eval-cell.ts";
 import {
@@ -109,7 +109,7 @@ export function createEvalTool(options: CreateEvalToolOptions) {
 			const record = args as Record<string, unknown>;
 			if (record.action === "peek" || record.action === "stop" || record.action === "list")
 				return args as EvalToolRequest;
-			const summary = clampEvalSummary(record.summary);
+			const summary = normalizeEvalSummary(record.summary);
 			if (summary === undefined) delete record.summary;
 			else record.summary = summary;
 			return args as EvalToolRequest;

package/src/tool/render.ts

@@ -10,6 +10,8 @@ import {
 	truncateToVisualLines,
 } from "@code-yeongyu/senpi";
 import { formatTruncationWarning, stripOutputNotice, type TruncationMeta } from "../output/output-meta.ts";
+import { displayCode } from "./display-code.ts";
+import { normalizeEvalSummary } from "./eval-request.ts";
 import {
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
 	JSON_TREE_MAX_DEPTH_EXPANDED,
@@ -64,6 +66,7 @@ type RenderBlock =
 	| { readonly kind: "dynamic"; readonly render: (width: number) => readonly string[] };
 
 const CODE_PREVIEW_LINES = 4;
+const SUMMARY_PREVIEW_LINES = 3;
 const OUTPUT_PREVIEW_LINES = 8;
 const STATUS_PREVIEW_COUNT = 3;
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
@@ -182,6 +185,22 @@ function renderAllVisualLines(text: string, width: number): string[] {
 	return truncateToVisualLines(text, Number.POSITIVE_INFINITY, width).visualLines.map((line) => line.trimEnd());
 }
 
+// A summary has no length limit, so a collapsed block shows its first lines and marks the cut.
+function summaryVisualLines(summary: string, width: number, expanded: boolean): string[] {
+	const lines = renderAllVisualLines(summary, width);
+	if (expanded || lines.length <= SUMMARY_PREVIEW_LINES) return lines;
+	const kept = renderAllVisualLines(summary, Math.max(1, width - 1)).slice(0, SUMMARY_PREVIEW_LINES);
+	kept[SUMMARY_PREVIEW_LINES - 1] = `${kept[SUMMARY_PREVIEW_LINES - 1] ?? ""}\u2026`;
+	return kept;
+}
+
+function summaryBlock(summary: string, theme: Theme | undefined, expanded: boolean): RenderBlock {
+	return {
+		kind: "dynamic",
+		render: (width) => summaryVisualLines(summary, width, expanded).map((line) => style(theme, "muted", line)),
+	};
+}
+
 function renderTextBlock(block: Extract<RenderBlock, { kind: "text" }>, width: number): string[] {
 	if (block.maxVisualLines === undefined) return renderAllVisualLines(block.text, width);
 	const result = truncateToVisualLines(block.text, block.maxVisualLines, width);
@@ -286,7 +305,7 @@ function languageForHighlighter(language: EvalLanguage): "python" | "javascript"
 
 function highlightedCode(code: string, language: EvalLanguage, theme: Theme | undefined): string {
 	const normalizedCode = code.trim().length > 0 ? code : "...";
-	const lines = highlightCode(normalizedCode, languageForHighlighter(language));
+	const lines = highlightCode(displayCode(normalizedCode, language), languageForHighlighter(language));
 	return (theme === undefined ? lines.map((line) => line.replace(/\u001b\[[0-9;]*m/gu, "")) : lines).join("\n");
 }
 
@@ -618,11 +637,9 @@ function renderCell(cell: EvalCellResult, environment: RenderEnvironment, badges
 	if (cell.summary !== undefined) {
 		appendLines(
 			lines,
-			renderPrefixed(style(environment.theme, "muted", cell.summary), environment, {
-				prefix: "│ ",
-				continuation: "│ ",
-				color: "muted",
-			}),
+			summaryVisualLines(cell.summary, Math.max(1, environment.width - 2), environment.expanded).map(
+				(line) => `${style(environment.theme, "muted", "│ ")}${style(environment.theme, "muted", line)}`,
+			),
 		);
 	}
 	const innerWidth = Math.max(1, environment.width - 2);
@@ -883,6 +900,13 @@ function resultMetadata(
 	return [{ kind: "text", text: style(theme, "muted", metadata.join(" | ")) }];
 }
 
+// The call renderer reads the assistant message's raw arguments, which keep the provider's
+// original summary (senpi#1472 detached preparation from the message), so it normalizes here,
+// idempotently: an already-normalized value is returned unchanged.
+function displaySummary(summary: string | undefined): string | undefined {
+	return normalizeEvalSummary(summary);
+}
+
 export function renderEvalCall(
 	args: EvalToolRequest,
 	theme: Theme | undefined,
@@ -905,10 +929,16 @@ export function renderEvalCall(
 		const timeout = args.timeout === undefined ? "" : ` timeout ${args.timeout}s`;
 		component.setBlocks([
 			{ kind: "text", text: style(theme, "toolTitle", `eval ${args.language}${reset}${timeout}`) },
-			...(args.summary === undefined ? [] : [{ kind: "text" as const, text: style(theme, "muted", args.summary) }]),
+			...(displaySummary(args.summary) === undefined
+				? []
+				: [summaryBlock(displaySummary(args.summary) ?? "", theme, context.expanded)]),
 			{
 				kind: "text",
-				text: style(theme, "mdCodeBlock", args.code.trim().length > 0 ? args.code : "..."),
+				text: style(
+					theme,
+					"mdCodeBlock",
+					args.code.trim().length > 0 ? displayCode(args.code, args.language) : "...",
+				),
 				maxVisualLines: context.expanded ? undefined : CODE_PREVIEW_LINES,
 				collapseKind: "code",
 				theme,
@@ -930,7 +960,7 @@ export function renderEvalCall(
 				};
 				const cell: EvalCellResult = {
 					index: 0,
-					...(args.summary === undefined ? {} : { summary: args.summary }),
+					...(displaySummary(args.summary) === undefined ? {} : { summary: displaySummary(args.summary) ?? "" }),
 					code: args.code,
 					language: args.language,
 					output: "",
@@ -996,9 +1026,7 @@ export function renderEvalResult(
 	const status = resultStatus(details, options, context.isError);
 	const blocks: RenderBlock[] = [
 		{ kind: "text", text: resultHeader(details, status, theme) },
-		...(details?.summary === undefined
-			? []
-			: [{ kind: "text" as const, text: style(theme, "muted", details.summary) }]),
+		...(details?.summary === undefined ? [] : [summaryBlock(details.summary, theme, expanded)]),
 		...resultMetadata(details, options, theme, status),
 		{ kind: "blank" },
 	];

package/src/tool/types.ts

@@ -17,8 +17,6 @@ export function enabledLanguageList(enabled: EnabledEvalLanguages): EvalLanguage
 	return evalLanguageOrder.filter((language) => enabled[language]);
 }
 
-export const EVAL_SUMMARY_MAX_LENGTH = 80;
-
 /** The deadlines the schema teaches the model; every number comes from the resolved settings. */
 export interface EvalDeadlineSeconds {
 	readonly runBudgetSeconds: number;
@@ -79,9 +77,8 @@ function evalInputProperties<Language extends TSchema>(languageSchema: Language,
 		code: Type.Optional(Type.String({ description: "Cell body, verbatim." })),
 		summary: Type.Optional(
 			Type.String({
-				maxLength: EVAL_SUMMARY_MAX_LENGTH,
 				description:
-					"REQUIRED for run. ONE line in the USER'S conversational language (Korean conversation -> Korean summary) stating WHAT this cell does and FOR WHAT PURPOSE; shown in the TUI while the cell runs. Longer values are force-truncated to 80 chars.",
+					"REQUIRED for run. One line in the language the user writes in: a progress update saying what you are doing and why, not a label for the code; shown in the TUI while the cell runs.",
 			}),
 		),
 		timeout: Type.Optional(Type.Number({ minimum: 1, description: timeoutFieldDescription(deadlines) })),