@code-yeongyu/senpi 2026.7.25 → 2026.7.26

package/node_modules/@code-yeongyu/senpi-codemode/src/prompt/eval-prompt.ts

@@ -21,7 +21,7 @@ export interface EvalPromptOptions {
 }
 
 /** Prompt dialect for the eval-first batching emphasis. */
-export type EvalEmphasisStyle = "default" | "claude" | "codex" | "kimi";
+export type EvalEmphasisStyle = "default" | "claude" | "codex" | "gpt" | "kimi";
 
 const CLAUDE_MODEL_RE = /(^|[/.:])claude[-.]/i;
 const GLM_MODEL_RE = /(^|[/.:@-])glm[-.]?\d/i;
@@ -32,14 +32,22 @@ const OPENAI_MODEL_RE = /(^|[/.:])(gpt|chatgpt|codex)[-.]|(^|[/.:])o[134](?:[-.]
  * Selects the eval-first batching dialect for a model id:
  * - `claude`: Claude/GLM — direct imperatives; both are steered most reliably
  *   by explicit tagged directives (GLM prompting guidance routes to Claude's).
- * - `codex`: OpenAI reasoning families — terse bounded rules, no emphasis spam.
+ * - `gpt`: GPT models — terse composition-forward rules that direct detached
+ *   cells to notify on completion instead of being polled.
+ * - `codex`: Other OpenAI reasoning families — terse bounded rules, no emphasis spam.
  * - `kimi`: Kimi K-series — maximum-emphasis POSITIVE imperatives (uppercase/
  *   bold DO-framing); all-caps NEVER prohibitions stay out because they make
  *   K-series overthink instead of comply.
  * - `default`: everything else (and no model) — maximum-emphasis fallback.
  */
+/** True only for GPT model ids that receive the terse eval composition dialect. */
+export function isGptCodeModeModel(modelId: string | undefined): boolean {
+	return modelId !== undefined && /(^|[/.:])gpt[-.]/iu.test(modelId);
+}
+
 export function evalEmphasisStyle(modelId: string | undefined): EvalEmphasisStyle {
 	if (!modelId) return "default";
+	if (isGptCodeModeModel(modelId)) return "gpt";
 	if (CLAUDE_MODEL_RE.test(modelId) || GLM_MODEL_RE.test(modelId)) return "claude";
 	if (KIMI_MODEL_RE.test(modelId)) return "kimi";
 	if (OPENAI_MODEL_RE.test(modelId)) return "codex";
@@ -92,7 +100,11 @@ Work incrementally: imports in one call, define in the next, test, then use —
 - Enumerate every lookup the step needs, then run all independent ones simultaneously with \`parallel(thunks)\` inside the cell; keep calls sequential only when one result feeds the next.
 - Write real code around the calls: loop or comprehend over file sets with \`read()\`/stdlib, branch per case, and wrap risky calls in try/except so one failure degrades only its item — recover or retry inside the cell, keep the batch alive.
 - Post-process \`tool.<name>()\` results programmatically and return distilled facts, not raw dumps.
-</eval_first_batching>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
+</eval_first_batching>{{/if}}{{#if styleGpt}}<gpt_eval_dialect>
+GPT eval: compose multi-tool work inside one cell with \`tool.<name>(args)\` and \`parallel(thunks)\`; do not split a planned step into serial tool calls.
+- Long pure-compute cells detach on timeout and notify on completion. Do not poll or re-run them; use \`eval({ action: "peek"|"stop", cell_id })\` only to inspect or stop a detached cell.
+- Reduce tool results in the cell and return only decision-relevant facts.
+</gpt_eval_dialect>{{/if}}{{#if styleCodex}}Route multi-call steps through eval: one cell per step, independent lookups dispatched together via \`parallel(thunks)\`; keep work sequential only when one result determines the next action.
 - Loop or comprehend over file sets with \`read()\`/stdlib instead of reading files one call at a time; post-process \`tool.<name>()\` results programmatically.
 - Wrap failable calls in try/except inside the cell; a failed item degrades only itself. After two distinct failed strategies for the same fact, fall back to direct tool calls.
 - Reduce large results in-kernel to the facts the task needs before returning.{{/if}}{{#if styleKimi}}**EVAL IS YOUR SUPERPOWER — MAKE IT YOUR DEFAULT WAY TO ACT.** Before any step, think: "how do I execute this WHOLE step in ONE parallelized cell?" — then write that ONE cell.
@@ -112,13 +124,17 @@ Fields:
 - \`code\` — cell body, verbatim. Newlines/quotes JSON-encoded; no fences, no headers.
 - \`title\` (optional) — short transcript label (e.g. \`"imports"\`).
 - \`timeout\` (optional) — seconds. Raise only for heavy compute or long{{#if spawns}} non-agent{{/if}} tool calls.
+- \`on_timeout\` (optional) — \`"detach"\` keeps pure computation running in interactive sessions (the default); \`"error"\` interrupts for deadline-sensitive work and is the print/json default.
 - \`reset\` (optional) — wipe this language's kernel first.{{#ifAll py js}} Per-language: a \`py\` reset never touches the JS VM.{{/ifAll}}
+- \`action\` (optional) — defaults to \`"run"\`. A detached cell returns its id: use \`eval({ action: "peek", cell_id })\` for buffered output/state or \`eval({ action: "stop", cell_id })\` to cancel it.
+
+A detached cell keeps its language kernel busy while it finishes. Do not re-run a detached cell: the same-language busy error names its cell id and output tail; another language can continue. Completion arrives as one notification with the final value/error and buffered output. Stopping a cell interrupts its kernel; the stop result states whether kernel state survived or the kernel was restarted and its variables lost.
 
 {{#if py}}Live event loop: use top-level \`await\` directly; \`asyncio.run(…)\` raises "cannot be called from a running event loop".{{/if}}
 {{#if js}}JS runs under Node.js worker: top-level \`await\`/\`return\` work; \`fetch\`/\`Buffer\` available.{{/if}}
 {{#if rb}}Ruby: synchronous; helper options are keyword args{{#if spawns}} (e.g. \`output("id", limit: 2)\`){{/if}}; the last expression auto-displays unless it is \`nil\`, an assignment, or a definition (like IRB).{{/if}}
 {{#if jl}}Julia: synchronous; helper options are standard keyword args{{#if spawns}} (e.g. \`output("id", limit=2)\`){{/if}}; the last expression auto-displays unless it is an assignment or a definition (like the Julia REPL).{{/if}}
-On error, fix and re-run only the failing step — prior calls' state survives.
+On error, fix and re-run only the failing step. State usually survives a normal error, but a timeout or stop may have restarted the kernel — its message says which. Before rebuilding state, check a sentinel (a variable you defined earlier); only re-establish what is actually gone, since blind re-runs duplicate side effects.
 </instruction>
 
 <prelude>
@@ -135,7 +151,7 @@ write(path, content) → str
 env(key?=None, value?=None) → str | None | dict
     No args → full env dict; one → value of \`key\`; two → set \`key=value\`, return value.
 {{#if spawns}}output(*ids, format?="raw", offset?=None, limit?=None) → str | dict | list[dict]
-    Task/agent output by id. \`format\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
+    Task/agent output by id. Reads immediately: running tasks return their status; \`format\` selects full (\`"raw"\`) or trailing (\`"tail"\`) output.
 {{/if}}tool.<name>(args) → unknown
     Invoke any session tool; \`args\` = its parameter object.
 completion(prompt, model?="default", system?=None, schema?=None) → str | dict
@@ -186,6 +202,7 @@ export function buildEvalPrompt(
 		spawnDefaultAgent,
 		styleClaude: style === "claude",
 		styleCodex: style === "codex",
+		styleGpt: style === "gpt",
 		styleKimi: style === "kimi",
 		styleDefault: style === "default",
 		hostLine: options.hostLine ?? "",
@@ -225,6 +242,7 @@ const BATCHING_GUIDELINES: Record<EvalEmphasisStyle, string> = {
 	claude:
 		"Prefer eval for any step needing more than one tool call: one cell that runs independent calls in parallel, handles per-call failures in code, and returns distilled facts.",
 	codex: "Route multi-call steps through eval: one cell per step, independent calls dispatched in parallel; fall back to direct tool calls when one call is sufficient or each result changes the next decision.",
+	gpt: "Use eval to compose tool work in one cell; long cells detach on timeout and notify on completion, so do not poll.",
 	kimi: "**EVAL IS YOUR SUPERPOWER — DEFAULT TO IT.** Execute EVERY multi-call step as ONE eval cell: run ALL independent calls simultaneously via parallel(thunks), handle failures per item in code, and return ONLY distilled facts.",
 };
 

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/detached-cell-manager.ts

@@ -0,0 +1,322 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import type { EvalKernel, EvalLanguage, EvalToolDetails, EvalToolInput } from "./types.ts";
+
+const NOTIFICATION_TAIL_BYTES = 512;
+
+export type EvalDetachedCellState = "running" | "detached" | "completed" | "failed" | "cancelled";
+
+type ManagedCell = {
+	readonly cellId: string;
+	readonly input: EvalToolInput;
+	readonly spillPath: string | undefined;
+	state: EvalDetachedCellState;
+	canDetach: boolean;
+	wasDetached: boolean;
+	kernel: EvalKernel | undefined;
+	/** Set after an interrupt-driven stop; undefined until the kernel reports its fate. */
+	stateRetained: boolean | undefined;
+	outputTail: (() => string) | undefined;
+	result: AgentToolResult<EvalToolDetails> | undefined;
+	notificationQueued: boolean;
+	readonly terminal: PromiseWithResolvers<EvalDetachedCellSnapshot>;
+};
+
+export interface EvalDetachedCellSnapshot {
+	readonly cellId: string;
+	readonly language: EvalLanguage;
+	readonly state: EvalDetachedCellState;
+	readonly outputTail: string;
+	readonly result: AgentToolResult<EvalToolDetails> | undefined;
+	readonly stateRetained: boolean | undefined;
+}
+
+export interface EvalDetachedCellNotification {
+	readonly cellId: string;
+	readonly content: string;
+}
+
+export interface EvalDetachedCellNotifier {
+	notify(cells: readonly EvalDetachedCellNotification[]): void;
+}
+
+export interface EvalDetachedCellManagerOptions {
+	readonly artifactsDir?: string;
+	readonly notifier?: EvalDetachedCellNotifier;
+}
+
+/**
+ * Session-owned lifecycle owner for eval cells that outlive their tool call.
+ *
+ * All state changes are synchronous and funnel through #transition. That is the
+ * atomic boundary for timeout, kernel completion, explicit stop, and session
+ * disposal races; exactly one path can release a language's detached busy mark.
+ */
+export class EvalDetachedCellManager {
+	readonly #artifactsDir: string | undefined;
+	readonly #notifier: EvalDetachedCellNotifier | undefined;
+	readonly #cells = new Map<string, ManagedCell>();
+	readonly #detachedByLanguage = new Map<EvalLanguage, ManagedCell>();
+	#notificationQueue: ManagedCell[] = [];
+	#notificationFlush: Promise<void> | undefined;
+
+	constructor(options: EvalDetachedCellManagerOptions = {}) {
+		this.#artifactsDir = options.artifactsDir;
+		this.#notifier = options.notifier;
+	}
+
+	create(cellId: string, input: EvalToolInput): ManagedCell {
+		const existing = this.#cells.get(cellId);
+		if (existing !== undefined) throw new Error(`Eval cell ${cellId} is already managed`);
+		const spillPath =
+			this.#artifactsDir === undefined
+				? undefined
+				: join(this.#artifactsDir, "local", `detached-eval-${safeCellId(cellId)}.log`);
+		const cell: ManagedCell = {
+			cellId,
+			input,
+			spillPath,
+			state: "running",
+			canDetach: false,
+			wasDetached: false,
+			kernel: undefined,
+			stateRetained: undefined,
+			outputTail: undefined,
+			result: undefined,
+			notificationQueued: false,
+			terminal: Promise.withResolvers<EvalDetachedCellSnapshot>(),
+		};
+		this.#cells.set(cellId, cell);
+		return cell;
+	}
+
+	markRunning(cell: ManagedCell, kernel: EvalKernel, outputTail: () => string): void {
+		if (cell.state !== "running") return;
+		cell.kernel = kernel;
+		cell.outputTail = outputTail;
+		cell.canDetach = true;
+	}
+
+	detach(cell: ManagedCell): boolean {
+		if (!cell.canDetach || !this.#transition(cell, "detached")) return false;
+		cell.wasDetached = true;
+		this.#detachedByLanguage.set(cell.input.language, cell);
+		return true;
+	}
+
+	complete(cell: ManagedCell, result: AgentToolResult<EvalToolDetails>): boolean {
+		cell.result = result;
+		return this.#transition(cell, result.details.isError === true ? "failed" : "completed");
+	}
+
+	fail(cell: ManagedCell, error: Error): boolean {
+		const result = errorResult(cell, error);
+		cell.result = result;
+		return this.#transition(cell, "failed");
+	}
+
+	async stop(cellId: string, reason = "Stopped detached eval cell"): Promise<EvalDetachedCellSnapshot> {
+		const cell = this.#get(cellId);
+		if (cell.state === "detached" && this.#transition(cell, "cancelled")) {
+			const kernel = cell.kernel;
+			if (kernel !== undefined) {
+				const handle = await kernel.interrupt(reason);
+				cell.stateRetained = await handle.stateRetained;
+			}
+		}
+		return this.#snapshot(cell);
+	}
+
+	peek(cellId: string): EvalDetachedCellSnapshot {
+		return this.#snapshot(this.#get(cellId));
+	}
+
+	busyFor(language: EvalLanguage): EvalDetachedCellSnapshot | undefined {
+		const cell = this.#detachedByLanguage.get(language);
+		return cell === undefined ? undefined : this.#snapshot(cell);
+	}
+
+	async waitForTerminal(cellId: string): Promise<EvalDetachedCellSnapshot> {
+		return await this.#get(cellId).terminal.promise;
+	}
+
+	async dispose(): Promise<void> {
+		const detached = [...this.#detachedByLanguage.values()];
+		await Promise.allSettled(
+			detached.map(async (cell) => await this.stop(cell.cellId, "Session ended; detached eval cell cancelled")),
+		);
+		await this.flushNotifications();
+	}
+
+	async flushNotifications(): Promise<void> {
+		const flush = this.#notificationFlush;
+		if (flush !== undefined) await flush;
+	}
+
+	#transition(cell: ManagedCell, next: EvalDetachedCellState): boolean {
+		if (!allowsTransition(cell.state, next)) return false;
+		cell.state = next;
+		if (next !== "running" && next !== "detached") cell.terminal.resolve(this.#snapshot(cell));
+		if (cell.wasDetached && next !== "detached") {
+			if (this.#detachedByLanguage.get(cell.input.language) === cell)
+				this.#detachedByLanguage.delete(cell.input.language);
+			this.#queueNotification(cell);
+		}
+		return true;
+	}
+
+	#queueNotification(cell: ManagedCell): void {
+		if (cell.notificationQueued) return;
+		cell.notificationQueued = true;
+		this.#notificationQueue.push(cell);
+		this.#scheduleNotificationFlush();
+	}
+
+	#scheduleNotificationFlush(): void {
+		if (this.#notificationFlush !== undefined) return;
+		const flush = Promise.resolve().then(async () => {
+			const cells = this.#notificationQueue.splice(0);
+			const notifications = await Promise.all(cells.map(async (candidate) => await this.#notification(candidate)));
+			this.#notifier?.notify(notifications);
+		});
+		this.#notificationFlush = flush;
+		void flush.then(
+			() => this.#finishNotificationFlush(flush),
+			() => this.#finishNotificationFlush(flush),
+		);
+	}
+
+	#finishNotificationFlush(flush: Promise<void>): void {
+		if (this.#notificationFlush !== flush) return;
+		this.#notificationFlush = undefined;
+		if (this.#notificationQueue.length > 0) this.#scheduleNotificationFlush();
+	}
+
+	async #notification(cell: ManagedCell): Promise<EvalDetachedCellNotification> {
+		const snapshot = this.#snapshot(cell);
+		const body = notificationBody(snapshot);
+		const overflow = Buffer.byteLength(body, "utf8") > NOTIFICATION_TAIL_BYTES;
+		let spillNotice = "";
+		if (overflow && cell.spillPath !== undefined) {
+			try {
+				await mkdir(dirname(cell.spillPath), { recursive: true });
+				await writeFile(cell.spillPath, body, "utf8");
+				spillNotice = `\nBuffered output overflowed; full output: ${localUri(cell.spillPath, this.#artifactsDir)}`;
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				spillNotice = `\nBuffered output overflow could not be spilled: ${message}`;
+			}
+		}
+		return {
+			cellId: cell.cellId,
+			content: `${overflow ? notificationPreview(snapshot) : body}${overflow ? "\n[…notification tail capped…]" : ""}${spillNotice}`,
+		};
+	}
+
+	#get(cellId: string): ManagedCell {
+		const cell = this.#cells.get(cellId);
+		if (cell === undefined) throw new Error(`Unknown detached eval cell "${cellId}"`);
+		return cell;
+	}
+
+	#snapshot(cell: ManagedCell): EvalDetachedCellSnapshot {
+		return {
+			cellId: cell.cellId,
+			language: cell.input.language,
+			state: cell.state,
+			outputTail: cell.outputTail?.() ?? "",
+			result: cell.result,
+			stateRetained: cell.stateRetained,
+		};
+	}
+}
+
+function allowsTransition(from: EvalDetachedCellState, to: EvalDetachedCellState): boolean {
+	if (from === "running") return to === "detached" || to === "completed" || to === "failed" || to === "cancelled";
+	if (from === "detached") return to === "completed" || to === "failed" || to === "cancelled";
+	return false;
+}
+
+function errorResult(cell: ManagedCell, error: Error): AgentToolResult<EvalToolDetails> {
+	const output = cell.outputTail?.() ?? "";
+	return {
+		content: [{ type: "text", text: output.length > 0 ? `${output}\n${error.message}` : error.message }],
+		details: {
+			language: cell.input.language,
+			languages: [cell.input.language],
+			durationMs: 0,
+			toolCalls: [],
+			truncated: false,
+			isError: true,
+			cells: [
+				{
+					index: 0,
+					code: cell.input.code,
+					language: cell.input.language,
+					output,
+					status: "error",
+				},
+			],
+		},
+	};
+}
+
+function notificationBody(cell: EvalDetachedCellSnapshot): string {
+	const outcome = cell.state === "completed" ? "completed" : cell.state === "cancelled" ? "cancelled" : "failed";
+	const resultText =
+		cell.result?.content
+			.filter((part) => part.type === "text")
+			.map((part) => part.text)
+			.join("\n") ?? cell.outputTail;
+	const stateNote =
+		cell.state === "cancelled" && cell.language === "js"
+			? "JavaScript worker was restarted; VM state was lost."
+			: cell.state === "cancelled" && cell.language === "py"
+				? "Python kernel was interrupted; its existing variables are preserved."
+				: "Kernel state updated - variables are available to the next eval cell.";
+	return [
+		`<system-reminder>Detached eval cell ${cell.cellId} (${cell.language}) ${outcome}.`,
+		resultText.length === 0 ? "(no output)" : resultText,
+		`${stateNote}</system-reminder>`,
+	].join("\n");
+}
+
+function notificationPreview(cell: EvalDetachedCellSnapshot): string {
+	const outcome = cell.state === "completed" ? "completed" : cell.state === "cancelled" ? "cancelled" : "failed";
+	const resultText =
+		cell.result?.content
+			.filter((part) => part.type === "text")
+			.map((part) => part.text)
+			.join("\n") ?? cell.outputTail;
+	const stateNote =
+		cell.state === "cancelled" && cell.language === "js"
+			? "JavaScript worker was restarted; VM state was lost."
+			: cell.state === "cancelled" && cell.language === "py"
+				? "Python kernel was interrupted; its existing variables are preserved."
+				: "Kernel state updated - variables are available to the next eval cell.";
+	return [
+		`<system-reminder>Detached eval cell ${cell.cellId} (${cell.language}) ${outcome}.`,
+		"Buffered output tail:",
+		truncateTailUtf8(resultText, NOTIFICATION_TAIL_BYTES),
+		`${stateNote}</system-reminder>`,
+	].join("\n");
+}
+
+function safeCellId(cellId: string): string {
+	return cellId.replace(/[^a-zA-Z0-9_-]/gu, "_");
+}
+
+function localUri(path: string, artifactsDir: string | undefined): string {
+	if (artifactsDir === undefined) return `local://${path}`;
+	const root = join(artifactsDir, "local");
+	return path.startsWith(`${root}/`) ? `local://${path.slice(root.length + 1)}` : `local://${path}`;
+}
+
+function truncateTailUtf8(text: string, maxBytes: number): string {
+	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+	const bytes = Buffer.from(text, "utf8");
+	let start = bytes.length - maxBytes;
+	while (start < bytes.length && (bytes[start] & 0xc0) === 0x80) start++;
+	return bytes.subarray(start).toString("utf8");
+}