@code-yeongyu/senpi 2026.8.13 → 2026.8.16

package/node_modules/@code-yeongyu/senpi-codemode/src/tool/eval-execution-event.ts

@@ -0,0 +1,201 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import {
+	capCodePoints,
+	MAX_AGGREGATED_TOOL_NAMES,
+	MAX_CAPTURED_IDENTIFIER_CODE_POINTS,
+	MAX_ENRICHED_TOOL_CALLS,
+	MAX_RPC_EVENT_BYTES,
+} from "./call-capture.ts";
+import type { CellState } from "./cell-runtime.ts";
+import type { EvalLanguage, EvalToolCallSummary, EvalToolDetails } from "./types.ts";
+
+export const EVAL_EXECUTION_EVENT = "senpi.eval.execution";
+
+export interface EvalToolAggregate {
+	readonly count: number;
+	readonly totalDurationMs: number;
+	readonly okCount: number;
+	readonly errorCount: number;
+	readonly pendingCount: number;
+}
+
+export type EvalToolAggregates = Record<string, EvalToolAggregate>;
+
+interface EvalExecutionBasePayload {
+	readonly version: 1;
+	readonly cellId: string;
+	readonly language: EvalLanguage;
+	readonly ok: boolean;
+	readonly startedAt: number;
+	readonly completedAt: number;
+	readonly durationMs: number;
+	readonly kernelDurationMs?: number;
+	readonly detached: boolean;
+	readonly toolCallCount: number;
+	readonly pendingToolCallCount: number;
+	readonly distinctToolsCalled: readonly string[];
+	readonly toolAggregates: EvalToolAggregates;
+	readonly toolAggregatesTruncated: boolean;
+	readonly toolAggregateOverflow?: EvalToolAggregate;
+}
+
+export interface EvalExecutionEventPayload extends EvalExecutionBasePayload {
+	readonly detailLevel: "full";
+	readonly error?: string;
+	readonly toolCalls: readonly EvalToolCallSummary[];
+}
+
+export interface EvalExecutionRpcToolCallSummary {
+	readonly name: string;
+	readonly ok: boolean;
+	readonly durationMs?: number;
+}
+
+export interface EvalExecutionRpcPayload extends EvalExecutionBasePayload {
+	readonly detailLevel: "metadata";
+	readonly rpcTruncated: boolean;
+	readonly toolCalls: readonly EvalExecutionRpcToolCallSummary[];
+}
+
+export type EvalExecutionSettleOutcome =
+	| { readonly result: AgentToolResult<EvalToolDetails> }
+	| { readonly error: unknown };
+
+export interface BuildEvalExecutionEventPayloadOptions {
+	readonly cellId: string;
+	readonly state: CellState;
+	readonly outcome: EvalExecutionSettleOutcome;
+	readonly completedAt: number;
+	readonly detached: boolean;
+}
+
+export function buildEvalExecutionEventPayload(
+	options: BuildEvalExecutionEventPayloadOptions,
+): EvalExecutionEventPayload {
+	const { cellId, state, outcome, completedAt, detached } = options;
+	const result = "result" in outcome ? outcome.result : undefined;
+	const ok = result?.details.isError !== true && !("error" in outcome);
+	const aggregateState = aggregateToolCalls(state, completedAt);
+	const error = ok ? undefined : settleError(state, outcome);
+	return {
+		version: 1,
+		detailLevel: "full",
+		cellId: capCodePoints(cellId, MAX_CAPTURED_IDENTIFIER_CODE_POINTS),
+		language: state.input.language,
+		ok,
+		...(error === undefined ? {} : { error: capCodePoints(error, 512) }),
+		startedAt: state.startedAt,
+		completedAt,
+		durationMs: Math.max(0, completedAt - state.startedAt),
+		...(result === undefined ? {} : { kernelDurationMs: result.details.durationMs }),
+		detached,
+		toolCallCount: state.toolCallMetrics.length,
+		pendingToolCallCount: aggregateState.pendingCount,
+		toolCalls: state.toolCalls.slice(0, MAX_ENRICHED_TOOL_CALLS),
+		distinctToolsCalled: [...aggregateState.aggregates.keys()],
+		toolAggregates: Object.fromEntries(aggregateState.aggregates),
+		toolAggregatesTruncated: aggregateState.overflow !== undefined,
+		...(aggregateState.overflow === undefined ? {} : { toolAggregateOverflow: aggregateState.overflow }),
+	};
+}
+
+export function toEvalExecutionRpcPayload(payload: EvalExecutionEventPayload): EvalExecutionRpcPayload {
+	const candidate: EvalExecutionRpcPayload = {
+		version: payload.version,
+		detailLevel: "metadata",
+		rpcTruncated: false,
+		cellId: payload.cellId,
+		language: payload.language,
+		ok: payload.ok,
+		startedAt: payload.startedAt,
+		completedAt: payload.completedAt,
+		durationMs: payload.durationMs,
+		...(payload.kernelDurationMs === undefined ? {} : { kernelDurationMs: payload.kernelDurationMs }),
+		detached: payload.detached,
+		toolCallCount: payload.toolCallCount,
+		pendingToolCallCount: payload.pendingToolCallCount,
+		toolCalls: payload.toolCalls.map((call) => ({
+			name: call.name,
+			ok: call.ok,
+			...(call.durationMs === undefined ? {} : { durationMs: call.durationMs }),
+		})),
+		distinctToolsCalled: payload.distinctToolsCalled,
+		toolAggregates: payload.toolAggregates,
+		toolAggregatesTruncated: payload.toolAggregatesTruncated,
+		...(payload.toolAggregateOverflow === undefined ? {} : { toolAggregateOverflow: payload.toolAggregateOverflow }),
+	};
+	if (serializedBytes(candidate) <= MAX_RPC_EVENT_BYTES) return candidate;
+	return {
+		...candidate,
+		rpcTruncated: true,
+		toolCalls: [],
+		distinctToolsCalled: [],
+		toolAggregates: {},
+		toolAggregatesTruncated: true,
+		toolAggregateOverflow: totalAggregate(payload),
+	};
+}
+
+function aggregateToolCalls(
+	state: CellState,
+	completedAt: number,
+): {
+	readonly aggregates: Map<string, EvalToolAggregate>;
+	readonly overflow: EvalToolAggregate | undefined;
+	readonly pendingCount: number;
+} {
+	const aggregates = new Map<string, EvalToolAggregate>();
+	let overflow: EvalToolAggregate | undefined;
+	let pendingCount = 0;
+	for (const metric of state.toolCallMetrics) {
+		const item: EvalToolAggregate = {
+			count: 1,
+			totalDurationMs: metric.durationMs ?? Math.max(0, completedAt - metric.startedAt),
+			okCount: metric.ok === true ? 1 : 0,
+			errorCount: metric.ok === false ? 1 : 0,
+			pendingCount: metric.ok === undefined ? 1 : 0,
+		};
+		pendingCount += item.pendingCount;
+		const existing = aggregates.get(metric.name);
+		if (existing !== undefined) {
+			aggregates.set(metric.name, addAggregate(existing, item));
+			continue;
+		}
+		if (aggregates.size < MAX_AGGREGATED_TOOL_NAMES) {
+			aggregates.set(metric.name, item);
+			continue;
+		}
+		overflow = overflow === undefined ? item : addAggregate(overflow, item);
+	}
+	return { aggregates, overflow, pendingCount };
+}
+
+function addAggregate(left: EvalToolAggregate, right: EvalToolAggregate): EvalToolAggregate {
+	return {
+		count: left.count + right.count,
+		totalDurationMs: left.totalDurationMs + right.totalDurationMs,
+		okCount: left.okCount + right.okCount,
+		errorCount: left.errorCount + right.errorCount,
+		pendingCount: left.pendingCount + right.pendingCount,
+	};
+}
+
+function totalAggregate(payload: EvalExecutionEventPayload): EvalToolAggregate {
+	let total: EvalToolAggregate = { count: 0, totalDurationMs: 0, okCount: 0, errorCount: 0, pendingCount: 0 };
+	for (const aggregate of Object.values(payload.toolAggregates)) total = addAggregate(total, aggregate);
+	if (payload.toolAggregateOverflow !== undefined) total = addAggregate(total, payload.toolAggregateOverflow);
+	return total;
+}
+
+function serializedBytes(value: unknown): number {
+	return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+
+function settleError(state: CellState, outcome: EvalExecutionSettleOutcome): string | undefined {
+	if (state.error !== undefined) return state.error;
+	if ("error" in outcome) return outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
+	for (const part of outcome.result.content) {
+		if (part.type === "text" && part.text.length > 0) return part.text.trimEnd();
+	}
+	return undefined;
+}

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

@@ -5,6 +5,7 @@ import type { ResolvedCodemodeSettings } from "../config/settings.ts";
 import type { EvalExecutionTracker } from "../extension/session-manager.ts";
 import type { EvalTimeoutFactory } from "./cell-execution.ts";
 import type { EvalDetachedCellManager } from "./detached-cell-manager.ts";
+import type { EvalExecutionEventPayload } from "./eval-execution-event.ts";
 import type { EvalImageResizer } from "./image.ts";
 import type {
 	EnabledEvalLanguages,
@@ -29,6 +30,7 @@ export interface CreateEvalToolOptions {
 	readonly imageResizer?: EvalImageResizer;
 	readonly executionTracker?: EvalExecutionTracker;
 	readonly cellManager?: EvalDetachedCellManager;
+	readonly onCellSettled?: (payload: EvalExecutionEventPayload) => void;
 	readonly timeoutFactory?: EvalTimeoutFactory;
 	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;
 	readonly renderers?: Pick<ToolDefinition<EvalInputSchema, EvalToolDetails>, "renderCall" | "renderResult">;

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

@@ -8,6 +8,7 @@ import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-executi
 import { CellHandler, type CellState } from "./cell-handler.ts";
 import { EvalDetachedCellManager } from "./detached-cell-manager.ts";
 import { detachedKernelBusyError, executeEvalControl, resultAfterDetach } from "./detached-eval-result.ts";
+import { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from "./eval-execution-event.ts";
 import { clampEvalSummary, evalTimeoutBehavior, isEvalControlRequest, parseEvalRequest } from "./eval-request.ts";
 import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
 import { describeTimeoutState } from "./interrupt-note.ts";
@@ -99,18 +100,22 @@ async function runEvalCell(
 	const bridgeContext: ExtensionContext = { ...invocation.ctx, signal: cellSignal };
 	const state: CellState = {
 		input: invocation.input,
+		startedAt: Date.now(),
 		signal: cellSignal,
 		onUpdate: invocation.onUpdate,
 		toolCalls: [],
+		toolCallMetrics: [],
 		pendingBridgeCalls: [],
 		statusEvents: [],
 		active: true,
 		output: "",
 		phase: undefined,
+		error: undefined,
 		durationMs: 0,
 		status: "pending",
 	};
 	const cell = cellManager.create(invocation.cellId, invocation.input);
+	let detached = false;
 	let execution: CellExecution;
 	execution = new CellExecution({
 		callerSignal: invocation.signal,
@@ -119,6 +124,7 @@ async function runEvalCell(
 		timeoutFactory: options.timeoutFactory ?? defaultTimeoutFactory,
 		onTimeout: (error) => {
 			if (timeoutBehavior === "detach" && cellManager.detach(cell)) {
+				detached = true;
 				execution.detach();
 				return;
 			}
@@ -139,13 +145,29 @@ async function runEvalCell(
 		bridgeContext,
 		bridgeAbortController,
 	);
+	let settleEventEmitted = false;
+	const emitSettled = (outcome: EvalExecutionSettleOutcome): void => {
+		if (settleEventEmitted) return;
+		settleEventEmitted = true;
+		options.onCellSettled?.(
+			buildEvalExecutionEventPayload({
+				cellId: invocation.cellId,
+				state,
+				outcome,
+				completedAt: Date.now(),
+				detached,
+			}),
+		);
+	};
 	const finalized = running.then(
 		(result) => {
 			cellManager.complete(cell, result);
+			emitSettled({ result });
 			return result;
 		},
 		(error: unknown) => {
 			cellManager.fail(cell, error instanceof Error ? error : new Error(String(error)));
+			emitSettled({ error });
 			throw error;
 		},
 	);

package/node_modules/@earendil-works/pi-agent-core/dist/harness/env/nodejs.d.ts

@@ -1,4 +1,29 @@
 import { type ExecutionEnv, ExecutionError, FileError, type FileInfo, type Result, type ShellExecOptions } from "../types.ts";
+/**
+ * Ordered `taskkill` launchers to try, most reliable first.
+ *
+ * `spawn("taskkill", ...)` relies on a PATH lookup, so any session whose PATH lost
+ * `%SystemRoot%\System32` (a POSIX-style PATH inherited from a Git Bash/MSYS launcher,
+ * a truncated user PATH, a locked-down service account) fails to resolve it. A broken PATH
+ * must not cost us the process-tree kill, so every absolute System32 location that actually
+ * exists is tried before the bare PATH-resolved name.
+ */
+export declare function windowsTaskkillCandidates(env?: NodeJS.ProcessEnv): string[];
+/**
+ * Kill a process and all its children on Windows via `taskkill /T`.
+ *
+ * Synchronous on purpose. A caller that tears down and exits in the same tick would never
+ * observe an asynchronous killer's `error` event, leaving the target alive. `spawnSync`
+ * also reports a failed executable lookup on its returned `error` field instead of
+ * emitting it, so a PATH without `%SystemRoot%\System32` can no longer surface as an
+ * uncaught `spawn taskkill ENOENT`.
+ *
+ * The direct `process.kill` at the end is a degraded last resort reached only when no
+ * `taskkill.exe` can be launched at all. It maps to `TerminateProcess`, which does not
+ * touch descendants; nothing in-process can walk a Windows process tree without an
+ * external tool, so this still beats leaving the whole tree running.
+ */
+export declare function killWindowsProcessTree(pid: number, taskkillPaths?: string[]): void;
 export declare class NodeExecutionEnv implements ExecutionEnv {
     cwd: string;
     private shellPath?;

package/node_modules/@earendil-works/pi-agent-core/dist/harness/env/nodejs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodejs.d.ts","sourceRoot":"","sources":["../../../src/harness/env/nodejs.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"nodejs.d.ts","sourceRoot":"","sources":["../../../src/harness/env/nodejs.ts"],"names":[],"mappings":"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"}

package/node_modules/@earendil-works/pi-agent-core/dist/harness/env/nodejs.js

@@ -1,6 +1,6 @@
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { constants, createReadStream } from "node:fs";
+import { constants, createReadStream, existsSync } from "node:fs";
 import { access, appendFile, lstat, mkdir, mkdtemp, readdir, readFile, realpath, rename, rm, writeFile, } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { basename, isAbsolute, join, resolve } from "node:path";
@@ -198,18 +198,83 @@ function getShellEnv(baseEnv, extraEnv, inheritEnv = true) {
         ...extraEnv,
     };
 }
+/**
+ * Ordered `taskkill` launchers to try, most reliable first.
+ *
+ * `spawn("taskkill", ...)` relies on a PATH lookup, so any session whose PATH lost
+ * `%SystemRoot%\System32` (a POSIX-style PATH inherited from a Git Bash/MSYS launcher,
+ * a truncated user PATH, a locked-down service account) fails to resolve it. A broken PATH
+ * must not cost us the process-tree kill, so every absolute System32 location that actually
+ * exists is tried before the bare PATH-resolved name.
+ */
+export function windowsTaskkillCandidates(env = process.env) {
+    // A bare `SystemDrive` is drive-relative ("C:"), so anchor it before joining.
+    const systemDrive = env.SystemDrive ? `${env.SystemDrive}\\` : undefined;
+    const roots = [env.SystemRoot, env.SYSTEMROOT, env.windir, systemDrive && join(systemDrive, "Windows")];
+    const candidates = [];
+    for (const root of roots) {
+        if (!root)
+            continue;
+        // Sysnative reaches the real 64-bit System32 from a 32-bit process, where System32
+        // is redirected to SysWOW64.
+        for (const systemDir of ["System32", "Sysnative"]) {
+            const absolute = join(root, systemDir, "taskkill.exe");
+            if (!candidates.includes(absolute) && existsSync(absolute))
+                candidates.push(absolute);
+        }
+    }
+    candidates.push("taskkill.exe");
+    return candidates;
+}
+function killProcessDirectly(pid) {
+    try {
+        process.kill(pid);
+    }
+    catch {
+        // Process already dead.
+    }
+}
+/** Upper bound on how long a teardown may block waiting for `taskkill` to finish. */
+const TASKKILL_TIMEOUT_MS = 5_000;
+function taskkillHandledTree(pid, taskkillPath) {
+    try {
+        const result = spawnSync(taskkillPath, ["/F", "/T", "/PID", String(pid)], {
+            stdio: "ignore",
+            windowsHide: true,
+            timeout: TASKKILL_TIMEOUT_MS,
+        });
+        // `error` means the launcher never started (ENOENT, EACCES); a null status means
+        // the timeout killed it. Any real taskkill exit code counts as handled.
+        return result.error === undefined && result.status !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Kill a process and all its children on Windows via `taskkill /T`.
+ *
+ * Synchronous on purpose. A caller that tears down and exits in the same tick would never
+ * observe an asynchronous killer's `error` event, leaving the target alive. `spawnSync`
+ * also reports a failed executable lookup on its returned `error` field instead of
+ * emitting it, so a PATH without `%SystemRoot%\System32` can no longer surface as an
+ * uncaught `spawn taskkill ENOENT`.
+ *
+ * The direct `process.kill` at the end is a degraded last resort reached only when no
+ * `taskkill.exe` can be launched at all. It maps to `TerminateProcess`, which does not
+ * touch descendants; nothing in-process can walk a Windows process tree without an
+ * external tool, so this still beats leaving the whole tree running.
+ */
+export function killWindowsProcessTree(pid, taskkillPaths = windowsTaskkillCandidates()) {
+    for (const taskkillPath of taskkillPaths) {
+        if (taskkillHandledTree(pid, taskkillPath))
+            return;
+    }
+    killProcessDirectly(pid);
+}
 function killProcessTree(pid) {
     if (process.platform === "win32") {
-        try {
-            spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
-                stdio: "ignore",
-                detached: true,
-                windowsHide: true,
-            });
-        }
-        catch {
-            // Ignore errors.
-        }
+        killWindowsProcessTree(pid);
         return;
     }
     try {