mixdog 0.9.41 → 0.9.44

package/scripts/result-classification-test.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    executeInternalTool,
+    setInternalToolsProvider,
+} from '../src/runtime/agent/orchestrator/internal-tools.mjs';
+import { classifyResultKind } from '../src/runtime/agent/orchestrator/session/result-classification.mjs';
+import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
+import { executeTool } from '../src/runtime/agent/orchestrator/session/loop/tool-exec.mjs';
+
+async function classifyHandlerResult(handlerResult) {
+    setInternalToolsProvider({
+        tools: [{ name: 'result_classification_test' }],
+        executor: async () => handlerResult,
+    });
+    const returned = await executeInternalTool('result_classification_test', {});
+    const normalized = normalizeToolEnvelope(returned);
+    return classifyResultKind(normalized.result, normalized.explicitSuccess);
+}
+
+test('explicit success suppresses Error: text-prefix classification', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'Error: quoted log output' }],
+        isError: false,
+    }), 'normal');
+});
+
+test('explicit isError:true remains an error', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'handler failed' }],
+        isError: true,
+    }), 'error');
+});
+
+test('flag-less Error: text remains an error', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'Error: prefix-only failure' }],
+    }), 'error');
+});
+
+test('flag-less normal text remains normal', async () => {
+    assert.equal(await classifyHandlerResult({
+        content: [{ type: 'text', text: 'ordinary output' }],
+    }), 'normal');
+});
+
+test('afterToolHook receives unwrapped explicit-success text', async () => {
+    setInternalToolsProvider({
+        tools: [{ name: 'result_classification_test' }],
+        executor: async () => ({
+            content: [{ type: 'text', text: 'Error: quoted hook payload' }],
+            isError: false,
+        }),
+    });
+    let hookResult;
+    const returned = await executeTool(
+        'result_classification_test',
+        {},
+        process.cwd(),
+        'result-classification-test-session',
+        {
+            afterToolHook: async (input) => {
+                hookResult = input.result;
+            },
+        },
+        { toolCallId: 'result-classification-hook-call' },
+    );
+    assert.equal(hookResult, 'Error: quoted hook payload');
+    assert.equal(typeof hookResult, 'string');
+
+    const normalized = normalizeToolEnvelope(returned);
+    assert.equal(normalized.result, hookResult);
+    assert.equal(normalized.explicitSuccess, true);
+});

package/scripts/routing-corpus.mjs

@@ -345,7 +345,7 @@ function buildCorpus(rows, { limit, sinceTs, agentFilter }) {
 }
 
 function scoreCorpus(cases) {
-  // A single健全 index: sum of flagged cases per KPI (lower is better).
+  // A single health index: sum of flagged cases per KPI (lower is better).
   const summary = {};
   let flaggedCases = 0;
   for (const k of FLAG_KEYS) summary[k] = cases.filter((c) => c.flags.includes(k)).length;

package/scripts/shell-jobs-windows-hide-test.mjs

@@ -0,0 +1,164 @@
+import assert from 'node:assert/strict';
+import { readFileSync, rmSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import test from 'node:test';
+import {
+    killShellJob,
+    startBackgroundShellJob,
+    waitForShellJob,
+} from '../src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs';
+import { shellJobDetailPath } from '../src/runtime/agent/orchestrator/tools/builtin/shell-job-paths.mjs';
+
+function availablePowerShellHosts() {
+    return ['powershell.exe', 'pwsh.exe'].filter((host) => {
+        const result = spawnSync(host, ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', '$PSVersionTable.PSVersion.Major'], {
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        return !result.error && result.status === 0;
+    });
+}
+
+const windowProbe = String.raw`
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+public delegate bool MixdogEnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+public static class MixdogWindowProbe {
+    [DllImport("user32.dll")] public static extern bool EnumWindows(MixdogEnumWindowsProc callback, IntPtr lParam);
+    [DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetClassName(IntPtr hWnd, StringBuilder text, int maxCount);
+    [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+}
+'@
+$consoleWindowPids = @{}
+$callback = [MixdogEnumWindowsProc] {
+    param([IntPtr] $hWnd, [IntPtr] $lParam)
+    $className = New-Object System.Text.StringBuilder 256
+    [void] [MixdogWindowProbe]::GetClassName($hWnd, $className, $className.Capacity)
+    if ($className.ToString() -eq 'ConsoleWindowClass') {
+        [uint32] $pid = 0
+        [void] [MixdogWindowProbe]::GetWindowThreadProcessId($hWnd, [ref] $pid)
+        $consoleWindowPids[[string] $pid] = $true
+    }
+    return $true
+}
+[void] [MixdogWindowProbe]::EnumWindows($callback, [IntPtr]::Zero)
+Get-CimInstance Win32_Process | ForEach-Object {
+    Write-Output "P|$($_.ProcessId)|$($_.ParentProcessId)|$($_.Name)"
+}
+$consoleWindowPids.Keys | ForEach-Object { Write-Output "W|$_" }
+`;
+
+function processConsoleSnapshot(probeHost) {
+    const result = spawnSync(probeHost, ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', windowProbe], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 10_000,
+    });
+    if (result.error || result.status !== 0) {
+        throw new Error(`Console window probe failed: ${result.error?.message || result.stderr || result.status}`);
+    }
+    const processes = new Map();
+    const consoleWindowPids = new Set();
+    for (const row of result.stdout.split(/\r?\n/)) {
+        const [kind, pid, parentPid, name] = row.split('|');
+        if (kind === 'P') processes.set(Number(pid), { parentPid: Number(parentPid), name });
+        if (kind === 'W') consoleWindowPids.add(Number(pid));
+    }
+    return { processes, consoleWindowPids };
+}
+
+function processTreePids(processes, rootPid) {
+    const tree = new Set([rootPid]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [pid, process] of processes) {
+            if (!tree.has(pid) && tree.has(process.parentPid)) {
+                tree.add(pid);
+                changed = true;
+            }
+        }
+    }
+    return tree;
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function removeJobArtifacts(detail) {
+    for (const file of [
+        shellJobDetailPath(detail.jobId),
+        detail.stdoutPath,
+        detail.stderrPath,
+        detail.exitPath,
+        detail.donePath,
+        `${detail.exitPath}.cmd.ps1`,
+        `${detail.exitPath}.user.ps1`,
+    ]) {
+        try { rmSync(file, { force: true }); } catch {}
+    }
+}
+
+test('Windows PowerShell shell jobs create no conhost or ConsoleWindowClass window', async (t) => {
+    if (process.platform !== 'win32') return t.skip('win32-only');
+    const hosts = availablePowerShellHosts();
+    if (hosts.length === 0) return t.skip('no PowerShell host installed');
+    const workDir = mkdtempSync(join(tmpdir(), 'mixdog-shell-job-window-'));
+    const probeHost = hosts[0];
+
+    try {
+        for (const shell of hosts) {
+            const before = processConsoleSnapshot(probeHost);
+            const job = startBackgroundShellJob({
+                command: "Start-Sleep -Milliseconds 5000; Write-Output 'mixdog-window-probe-out'; [Console]::Error.WriteLine('mixdog-window-probe-err')",
+                timeoutMs: 10_000,
+                workDir,
+                mergeStderr: false,
+                spawnEnv: process.env,
+                shell,
+                shellType: 'powershell',
+            });
+            try {
+                const newConsoleHosts = new Set();
+                for (let i = 0; i < 8; i += 1) {
+                    await sleep(100);
+                    const snapshot = processConsoleSnapshot(probeHost);
+                    const jobTree = processTreePids(snapshot.processes, job.pid);
+                    // windowsHide may give the outer wrapper one hidden console
+                    // (a direct child of job.pid). A second conhost belongs to
+                    // Start-Process only when it is nested below that wrapper.
+                    const isNestedJobConsole = (pid) => {
+                        const process = snapshot.processes.get(pid);
+                        return process && process.parentPid !== job.pid && jobTree.has(process.parentPid);
+                    };
+                    for (const [pid, process] of snapshot.processes) {
+                        if (process.name?.toLowerCase() === 'conhost.exe'
+                            && !before.processes.has(pid) && isNestedJobConsole(pid)) {
+                            newConsoleHosts.add(`${pid}|conhost.exe|parent=${process.parentPid}`);
+                        }
+                    }
+                    for (const pid of snapshot.consoleWindowPids) {
+                        if (!before.consoleWindowPids.has(pid) && isNestedJobConsole(pid)) {
+                            newConsoleHosts.add(`${pid}|ConsoleWindowClass`);
+                        }
+                    }
+                }
+                const detail = await waitForShellJob(job.jobId, { timeoutMs: 10_000, pollMs: 50 });
+                assert.equal(detail?.exitCode, 0, `${shell} preserves the child exit code`);
+                assert.equal(readFileSync(job.stdoutPath, 'utf8').trim(), 'mixdog-window-probe-out', `${shell} preserves stdout redirection`);
+                assert.equal(readFileSync(job.stderrPath, 'utf8').trim(), 'mixdog-window-probe-err', `${shell} preserves stderr redirection`);
+                assert.deepEqual([...newConsoleHosts], [], `${shell} created a console host/window in its process tree: ${[...newConsoleHosts].join(', ')}`);
+            } finally {
+                killShellJob(job.jobId);
+                removeJobArtifacts(job);
+            }
+        }
+    } finally {
+        rmSync(workDir, { recursive: true, force: true });
+    }
+});

package/scripts/smoke.mjs

@@ -95,7 +95,7 @@ runNode(['--input-type=module', '-e', `
     stats: { currentContextTokens: 0 },
     agentJobs: [{ task_id: 'task_statusline_smoke', status: 'running', tag: 'bench-agent', startedAt: new Date().toISOString() }],
   });
-  if (!line.includes('Running') || !line.includes('bench-agent')) throw new Error('statusline must render live agent task state: ' + JSON.stringify(line));
+  if (!line.includes('Running 1 Agent') || line.includes('bench-agent')) throw new Error('statusline must render live agent count without task tags: ' + JSON.stringify(line));
 `], 'statusline live agent task smoke', { env: isolatedStatuslineEnv });
 
 runNode(['--input-type=module', '-e', `

package/scripts/submit-commandbusy-race-test.mjs

@@ -7,12 +7,39 @@ import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
 // command (commandBusy) or an auto-clear. Wires the real session-flow queue
 // (enqueue/drain) + the real submit() against a minimal bag whose set() mirrors
 // engine.mjs's commandBusy-release drain kick.
-function makeEngine({ autoClearBeforeSubmit } = {}) {
+function makeEngine({
+  autoClearBeforeSubmit,
+  autoClearEnabled = false,
+  runtimeClear = async () => true,
+} = {}) {
   let seq = 0;
   const executed = [];
-  let state = { queued: [], busy: false, commandBusy: false };
+  const providerRequests = [];
+  let resolveProviderDispatch;
+  const providerDispatch = new Promise((resolve) => { resolveProviderDispatch = resolve; });
+  let state = {
+    items: [{ kind: 'user', id: 'existing', text: 'existing prompt' }],
+    queued: [],
+    busy: false,
+    commandBusy: false,
+  };
   const bag = {
-    runtime: { id: null, consumePendingSessionReset: () => null },
+    runtime: {
+      id: 'session_1',
+      session: {
+        id: 'session_1',
+        messages: [{ role: 'user', content: 'existing prompt' }],
+        lastUsedAt: Date.now() - 1000,
+      },
+      getCompactionSettings: () => ({}),
+      clear: runtimeClear,
+      consumePendingSessionReset: () => null,
+      ask: async (text) => {
+        providerRequests.push(text);
+        resolveProviderDispatch(text);
+        return { result: { content: 'ok' }, session: bag.runtime.session };
+      },
+    },
     nextId: () => `id_${++seq}`,
     tuiDebug: () => {},
     flags: {},
@@ -30,12 +57,15 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
       if (released) queueMicrotask(() => { void bag.drain?.(); });
       return true;
     },
-    pushItem: () => {},
+    pushItem: (item) => { state = { ...state, items: [...state.items, item] }; },
     patchItem: () => {},
     replaceItems: (x) => x,
     pushNotice: () => {},
-    pushUserOrSyntheticItem: (text) => { executed.push(text); },
-    autoClearState: () => ({ enabled: false }),
+    pushUserOrSyntheticItem: (text, id) => {
+      executed.push(text);
+      state = { ...state, items: [...state.items, { kind: 'user', id, text }] };
+    },
+    autoClearState: () => ({ enabled: autoClearEnabled, idleMs: 0, minContextPercent: 0 }),
     agentStatusState: () => ({}),
     routeState: () => ({}),
     syncContextStats: () => {},
@@ -44,7 +74,10 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
     requeueEntriesFront: () => {},
     resetStatsAndSyncContext: () => {},
     flushDeferredExecutionPendingResumeKick: () => {},
-    runTurn: async () => 'ok',
+    runTurn: async (text) => {
+      await bag.runtime.ask(text);
+      return 'ok';
+    },
   };
   Object.assign(bag, createSessionFlow(bag));
   if (autoClearBeforeSubmit) bag.autoClearBeforeSubmit = autoClearBeforeSubmit;
@@ -53,6 +86,14 @@ function makeEngine({ autoClearBeforeSubmit } = {}) {
     api,
     bag,
     getExecuted: () => executed,
+    getProviderRequests: () => providerRequests,
+    waitForProviderDispatch: (timeoutMs = 250) => new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`provider dispatch timed out after ${timeoutMs}ms`)), timeoutMs);
+      providerDispatch.then((text) => {
+        clearTimeout(timer);
+        resolve(text);
+      }, reject);
+    }),
     getState: () => bag.getState(),
     mutateState: (mutator) => { mutator(state); },
   };
@@ -107,6 +148,57 @@ test('submit still enqueues when autoClearBeforeSubmit rejects', async () => {
   assert.deepEqual(getExecuted(), ['survives rejection'], 'rejected auto-clear must not lose the prompt');
 });
 
+test('runtime clear false skips auto-clear and sends the first post-failure prompt to the provider', async () => {
+  const {
+    api, bag, getExecuted, getProviderRequests, getState,
+  } = makeEngine({ autoClearEnabled: true, runtimeClear: async () => false });
+
+  assert.equal(api.submit('first after failed auto-clear'), true);
+  await tick(); await tick();
+
+  assert.deepEqual(getExecuted(), ['first after failed auto-clear'], 'user card remains visible');
+  assert.deepEqual(getProviderRequests(), ['first after failed auto-clear'], 'first post-failure input reaches provider');
+  assert.equal(getState().items.some((item) => item.label === 'Auto-clear skipped'), true);
+  assert.equal(getState().items.some((item) => item.label === 'Auto-clear complete'), false);
+  assert.equal(getState().items.some((item) => item.id === 'existing'), true, 'failed clear preserves the existing session UI');
+  assert.equal(bag.runtime.session.messages[0].content, 'existing prompt', 'failed clear preserves the runtime session');
+});
+
+test('late runtime clear false keeps the UI skipped and sends the first post-timeout prompt', async () => {
+  let resolveClear;
+  let harness;
+  const autoClearBeforeSubmit = () => harness.bag.performSessionClear({
+    verb: 'Auto-clearing idle conversation',
+    doneLabel: 'Auto-clear complete',
+    skipLabel: 'Auto-clear skipped',
+    surface: 'auto-clear',
+    useCompaction: true,
+    compactTimeoutMs: 5,
+  });
+  harness = makeEngine({
+    autoClearBeforeSubmit,
+    runtimeClear: () => new Promise((resolve) => { resolveClear = resolve; }),
+  });
+  harness.bag.runtime.getCompactionSettings = () => ({ compactType: 'summary' });
+
+  assert.equal(harness.api.submit('first after timed-out auto-clear'), true);
+  await harness.waitForProviderDispatch();
+  assert.equal(typeof resolveClear, 'function', 'compacting clear started');
+  assert.deepEqual(
+    harness.getProviderRequests(),
+    ['first after timed-out auto-clear'],
+    'first post-timeout input reaches provider before late clear settles',
+  );
+
+  resolveClear(false);
+  await tick(); await tick();
+
+  assert.equal(harness.getState().items.some((item) => item.label === 'Auto-clear skipped'), true);
+  assert.equal(harness.getState().items.some((item) => item.label === 'Auto-clear complete'), false);
+  assert.equal(harness.getState().items.some((item) => item.id === 'existing'), true, 'late false preserves the existing session UI');
+  assert.equal(harness.bag.runtime.session.messages[0].content, 'existing prompt', 'late false preserves the runtime session');
+});
+
 test('empty and whitespace submits are still rejected', () => {
   const { api, bag } = makeEngine();
   assert.equal(api.submit('   '), false);