maka-agent 0.2.0-dev.14.20260902 → 0.2.0-dev.16.20260903

package/node_modules/@maka/eval/dist/harness-executor.js

@@ -28,6 +28,7 @@ import { decodeJsonObject } from './experiment.js';
 import { BUNDLED_HARNESS_RELAY_ROOT, createHarnessPreparationEnvironment, resolveRealPathWithinRoot, } from './harness-environment.js';
 import { preflightHarnessInstallation, } from './install-preflight.js';
 import { MAKA_RUNTIME_ARTIFACT_PATH, MAKA_SUBJECT_STDERR_PATH, MAKA_SUBJECT_STDOUT_PATH, } from './maka-artifacts.js';
+import { terminateProcess } from './process-termination.js';
 const PIER_FRAMEWORK_LOG_MOUNTS = Object.freeze([
     { directory: 'agent', target: '/logs/agent' },
     { directory: 'verifier', target: '/logs/verifier' },
@@ -911,7 +912,7 @@ async function waitForTrial(child, wait) {
             outcome: completed.code === 0 && completed.signal === null ? 'completed' : 'failed',
         };
     }
-    child.kill('SIGTERM');
+    await terminateProcess(child, 'SIGTERM');
     const terminated = await within(exit, wait.deadlineMs);
     if (terminated) {
         return {
@@ -921,7 +922,7 @@ async function waitForTrial(child, wait) {
             outcome: terminated.code === 0 && terminated.signal === null ? 'confirmed' : 'terminated',
         };
     }
-    child.kill('SIGKILL');
+    await terminateProcess(child, 'SIGKILL');
     const killed = await within(exit, KILL_SETTLEMENT_DEADLINE_MS);
     if (killed) {
         return {

package/node_modules/@maka/eval/dist/install-preflight.js

@@ -21,6 +21,7 @@ import { constants } from 'node:fs';
 import { access, lstat, stat } from 'node:fs/promises';
 import { dirname, isAbsolute, resolve } from 'node:path';
 import { BUNDLED_HARNESS_RELAY_ROOT, createHarnessPreparationEnvironment, resolvePathWithinRoot, resolveRealPathWithinRoot, } from './harness-environment.js';
+import { terminateProcess } from './process-termination.js';
 const PREFLIGHT_TIMEOUT_MS = 10_000;
 const PREFLIGHT_OUTPUT_LIMIT_BYTES = 16 * 1024;
 const PYTHON_FRAMEWORK_PROBE = [
@@ -105,21 +106,49 @@ export async function preflightHarnessInstallation(input, dependencies = {}) {
 async function runCheckedCommand(command, args, environment, cwd, signal) {
     signal?.throwIfAborted();
     await new Promise((resolvePromise, rejectPromise) => {
-        execFile(command, [...args], {
-            env: environment,
-            cwd,
-            timeout: PREFLIGHT_TIMEOUT_MS,
-            killSignal: 'SIGKILL',
-            maxBuffer: PREFLIGHT_OUTPUT_LIMIT_BYTES,
-            encoding: 'utf8',
-            ...(signal ? { signal } : {}),
-        }, (error, _stdout, stderr) => {
+        let settled = false;
+        let timeout;
+        let child;
+        const onAbort = () => {
+            void terminateProcess(child, 'SIGTERM');
+        };
+        const settle = (error, stderr = '') => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout)
+                clearTimeout(timeout);
+            signal?.removeEventListener('abort', onAbort);
             if (!error) {
                 resolvePromise();
                 return;
             }
             rejectPromise(new Error(stderr.trim() || error.message));
-        });
+        };
+        try {
+            child = execFile(command, [...args], {
+                env: environment,
+                cwd,
+                killSignal: 'SIGTERM',
+                maxBuffer: PREFLIGHT_OUTPUT_LIMIT_BYTES,
+                encoding: 'utf8',
+            }, (error, _stdout, stderr) => {
+                settle(error ?? undefined, stderr);
+            });
+        }
+        catch (error) {
+            settle(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        timeout = setTimeout(() => {
+            void terminateProcess(child, 'SIGKILL');
+        }, PREFLIGHT_TIMEOUT_MS);
+        if (signal) {
+            if (signal.aborted)
+                onAbort();
+            else
+                signal.addEventListener('abort', onAbort, { once: true });
+        }
     });
 }
 async function requirePath(path, label, expected) {

package/node_modules/@maka/eval/dist/process-termination.js

@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+const WINDOWS_TASKKILL_TIMEOUT_MS = 2_000;
+/**
+ * Terminates a child using the platform's process lifecycle semantics.
+ * Windows does not implement POSIX signals, so every termination request must
+ * include descendants. Otherwise the root can exit before forced escalation
+ * and leave its workers running.
+ */
+export function terminateProcess(child, signal, options = {}) {
+    if (!child || child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve(false);
+    const platform = options.platform ?? process.platform;
+    if (platform === 'win32') {
+        const pid = child.pid;
+        if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0) {
+            return killChild(child);
+        }
+        return (options.runTaskkill ?? killWindowsTree)(pid).then((killed) => killed ? true : killChild(child));
+    }
+    return killChild(child, signal);
+}
+function killChild(child, signal) {
+    try {
+        // Omitting the signal is intentional on Windows: Node uses its native
+        // graceful termination path instead of trying to emulate a POSIX signal.
+        return Promise.resolve(signal === undefined ? child.kill() : child.kill(signal));
+    }
+    catch {
+        return Promise.resolve(false);
+    }
+}
+function killWindowsTree(pid) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let timeout;
+        const finish = (succeeded) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeout)
+                clearTimeout(timeout);
+            resolve(succeeded);
+        };
+        try {
+            const killer = spawn('taskkill.exe', ['/PID', String(pid), '/T', '/F'], {
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+            killer.once('error', () => finish(false));
+            killer.once('close', (code) => finish(code === 0));
+            timeout = setTimeout(() => {
+                try {
+                    killer.kill();
+                }
+                catch {
+                    /* taskkill already exited */
+                }
+                finish(false);
+            }, WINDOWS_TASKKILL_TIMEOUT_MS);
+        }
+        catch {
+            finish(false);
+        }
+    });
+}

package/node_modules/@maka/mcp/dist/sep-2243.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { truncateUtf16Safe } from '@maka/core/text-sanitize';
 import { formatMcpDiagnosticText } from './diagnostic-text.js';
 const X_MCP_HEADER = 'x-mcp-header';
 const RFC_9110_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/u;
@@ -190,9 +191,8 @@ function valueAtPath(root, path) {
 function truncateRenderedWarning(value) {
     if (value.length <= MCP_HEADER_WARNING_LENGTH_LIMIT)
         return value;
-    const end = MCP_HEADER_WARNING_LENGTH_LIMIT - 1;
-    const safeEnd = end > 0 && /[\uD800-\uDBFF]/u.test(value[end - 1] ?? '') ? end - 1 : end;
-    return `${value.slice(0, safeEnd)}\u2026`;
+    // The ellipsis is one BMP code unit, so it fits in the unit it reclaims.
+    return `${truncateUtf16Safe(value, MCP_HEADER_WARNING_LENGTH_LIMIT - 1)}\u2026`;
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);

package/node_modules/@maka/runtime/dist/agent-run.js

@@ -132,12 +132,13 @@ export class AgentRun {
                 : {}),
         };
     }
-    stop(source) {
+    stop(source, workHubActionId) {
+        const abortSource = normalizeStopSessionSource(source, workHubActionId);
         if (this.terminalClaim)
             return false;
         this.terminalClaim = { owner: 'stop' };
         this.stopped = true;
-        this.abortSource = normalizeStopSessionSource(source);
+        this.abortSource = abortSource;
         return true;
     }
     isStopped() {
@@ -1542,7 +1543,9 @@ async function appendUserMessageOnce(store, sessionId, message) {
     }
 }
 function isInteractionResumeAck(event) {
-    return (event.type === 'sandbox_boundary_decision_ack' || event.type === 'user_question_answer_ack');
+    return (event.type === 'sandbox_boundary_decision_ack' ||
+        event.type === 'user_question_answer_ack' ||
+        event.type === 'form_answer_ack');
 }
 /**
  * Non-terminal error content never reaches the ledger: the trailing terminal