sneakoscope 6.4.0 → 6.7.0

package/dist/core/doctor/retired-managed-residue-runtime.js

@@ -29,15 +29,25 @@ export async function reconcileRetiredGitPolicyMode(root, fix, quarantineRoot, c
     const value = await readJson(file, null).catch(() => null);
     if (value?.schema !== 'sks.git-policy.v1')
         return;
-    if (['solo', 'work', 'strict-work', 'ci'].includes(String(value.mode || '')))
+    const mode = String(value.mode || '');
+    if (['solo', 'work', 'strict-work', 'ci'].includes(mode))
         return;
+    const replacement = mode === 'team'
+        ? 'work'
+        : mode === 'strict-team'
+            ? 'strict-work'
+            : null;
+    if (!replacement) {
+        await reconcileKnownRetiredPath(root, file, false, fix, quarantineRoot, counters);
+        return;
+    }
     counters.detected += 1;
     if (!fix) {
         counters.remaining += 1;
         return;
     }
     try {
-        await writeJsonAtomic(file, { ...value, mode: 'work' });
+        await writeJsonAtomic(file, { ...value, mode: replacement });
         counters.removed += 1;
         counters.rewrittenState += 1;
     }

package/dist/core/doctor/retired-managed-residue-state.js

@@ -45,7 +45,7 @@ async function reconcileStateFiles(root, fix, quarantineRoot, counters) {
         const value = await readJson(file, null).catch(() => null);
         if (!value || typeof value !== 'object')
             continue;
-        const stripped = stripRetiredPublicState(value);
+        const stripped = stripRetiredPublicState(value, true);
         if (!stripped.changed)
             continue;
         counters.detected += 1;
@@ -100,12 +100,12 @@ async function reconcileUserStateCollision(root, file, fix, quarantineRoot, coun
         counters.remaining += 1;
     }
 }
-function stripRetiredPublicState(value) {
+function stripRetiredPublicState(value, routeStateRoot) {
     if (Array.isArray(value)) {
         let changed = false;
         const next = [];
         for (const entry of value) {
-            const result = stripRetiredPublicState(entry);
+            const result = stripRetiredPublicState(entry, false);
             changed ||= result.changed;
             next.push(result.value);
         }
@@ -115,16 +115,16 @@ function stripRetiredPublicState(value) {
         return { value, changed: false };
     const next = {};
     let changed = false;
-    const retiredRoute = isRetiredStateObject(value);
+    const retiredRoute = routeStateRoot && isRetiredStateObject(value);
     for (const [key, entry] of Object.entries(value)) {
         if (RETIRED_DB_STATE_KEY_RE.test(key)) {
             changed = true;
             continue;
         }
-        if (key === 'preempted_missions' && Array.isArray(entry)) {
+        if (routeStateRoot && key === 'preempted_missions' && Array.isArray(entry)) {
             const filtered = entry.filter((row) => !row || typeof row !== 'object' || !isRetiredStateObject(row));
             changed ||= filtered.length !== entry.length;
-            const nested = stripRetiredPublicState(filtered);
+            const nested = stripRetiredPublicState(filtered, false);
             changed ||= nested.changed;
             next[key] = nested.value;
             continue;
@@ -137,7 +137,7 @@ function stripRetiredPublicState(value) {
             changed = true;
             continue;
         }
-        const nested = stripRetiredPublicState(entry);
+        const nested = stripRetiredPublicState(entry, false);
         changed ||= nested.changed;
         next[key] = nested.value;
     }

package/dist/core/evaluation.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { nowIso, sha256, writeJsonAtomic } from './fsx.js';
+import { DEFAULT_OFFICIAL_SUBAGENT_JOB_MAX_RUNTIME_SECONDS, DEFAULT_OFFICIAL_SUBAGENT_MAX_DEPTH, DEFAULT_OFFICIAL_SUBAGENT_MAX_THREADS } from './subagents/official-subagent-config.js';
 import { contextCapsule } from './triwiki-attention.js';
 import { validateWikiCoordinateIndex } from './wiki-coordinate.js';
 export const DEFAULT_EVAL_THRESHOLDS = Object.freeze({
@@ -67,9 +68,9 @@ export const PERMISSION_PROFILES = Object.freeze({
     dangerous_full_access: { filesystem: 'full-access', network: 'controlled', purpose: 'Never default. Requires explicit reason and review.' }
 });
 export const DEFAULT_MULTIAGENT_V2 = Object.freeze({
-    max_threads: 4,
-    max_depth: 1,
-    job_max_runtime_seconds: 1800,
+    max_threads: DEFAULT_OFFICIAL_SUBAGENT_MAX_THREADS,
+    max_depth: DEFAULT_OFFICIAL_SUBAGENT_MAX_DEPTH,
+    job_max_runtime_seconds: DEFAULT_OFFICIAL_SUBAGENT_JOB_MAX_RUNTIME_SECONDS,
     wait_control: 'bounded_wait_then_structured_summary',
     subagent_output: 'structured_summary_only'
 });
@@ -88,9 +89,9 @@ export const ZELLIJ_COCKPIT_VIEWS = Object.freeze([
     'Code Structure View',
     'Statusline / Terminal Title Preview'
 ]);
-export function estimateTokens(value) {
+export function serializedSizeBytes(value) {
     const text = typeof value === 'string' ? value : JSON.stringify(value);
-    return Math.max(1, Math.ceil(String(text || '').length / 4));
+    return Buffer.byteLength(String(text ?? ''), 'utf8');
 }
 export function classifyToolError(input = {}) {
     const text = `${input.code || ''} ${input.name || ''} ${input.message || ''} ${input.stderr || ''}`.toLowerCase();
@@ -472,7 +473,19 @@ function scoreSelection(allClaims, selectedIds) {
         accuracy_proxy: Number(accuracy.toFixed(4))
     };
 }
-function metricBlock({ label, context, scenario, msPerRun }) {
+function tokenMeasurementFromEvidence(evidence, label) {
+    const rawCount = evidence?.[`${label}_tokens`];
+    const source = String(evidence?.source || '').trim();
+    if (rawCount === null || rawCount === undefined || !source) {
+        return { token_count: null, token_evidence: null };
+    }
+    const count = Number(rawCount);
+    if (!Number.isInteger(count) || count < 0) {
+        return { token_count: null, token_evidence: null };
+    }
+    return { token_count: count, token_evidence: { source } };
+}
+function metricBlock({ label, context, scenario, msPerRun, tokenMeasurement }) {
     const selectedIds = (context.claims || []).map((claim) => claim.id);
     const wikiValidation = context.wiki ? validateWikiCoordinateIndex(context.wiki) : { ok: false };
     const voxel = context.wiki?.vx || context.wiki?.voxel_overlay || null;
@@ -480,7 +493,14 @@ function metricBlock({ label, context, scenario, msPerRun }) {
     return {
         label,
         context_hash: sha256(JSON.stringify(context)),
-        estimated_tokens: estimateTokens(context),
+        serialized_size_bytes: serializedSizeBytes(context),
+        size_metric: {
+            name: 'serialized_json_bytes',
+            unit: 'bytes',
+            proxy_for_tokens: false
+        },
+        token_count: tokenMeasurement?.token_count ?? null,
+        token_evidence: tokenMeasurement?.token_evidence ?? null,
         context_build_ms_per_run: Number(msPerRun.toFixed(4)),
         wiki: context.wiki ? {
             schema: context.wiki.schema,
@@ -493,16 +513,40 @@ function metricBlock({ label, context, scenario, msPerRun }) {
         quality: scoreSelection(scenario.claims, selectedIds)
     };
 }
+function measuredTokenEvidence(metric) {
+    const count = metric?.token_count;
+    const identity = String(metric?.token_evidence?.source || '').trim();
+    return Number.isInteger(count) && count >= 0 && identity ? { count, identity } : null;
+}
+function serializedSize(metric) {
+    const size = metric?.serialized_size_bytes;
+    return Number.isFinite(size) && size >= 0 ? Number(size) : null;
+}
 export function compareMetricBlocks(baseline, candidate, thresholds = DEFAULT_EVAL_THRESHOLDS) {
-    const tokenSavingsPct = baseline.estimated_tokens
-        ? (baseline.estimated_tokens - candidate.estimated_tokens) / baseline.estimated_tokens
-        : 0;
+    const baselineTokenEvidence = measuredTokenEvidence(baseline);
+    const candidateTokenEvidence = measuredTokenEvidence(candidate);
+    const comparableTokenEvidence = baselineTokenEvidence !== null
+        && baselineTokenEvidence.count > 0
+        && candidateTokenEvidence !== null
+        && baselineTokenEvidence.identity === candidateTokenEvidence.identity
+        ? { baseline: baselineTokenEvidence.count, candidate: candidateTokenEvidence.count, identity: baselineTokenEvidence.identity }
+        : null;
+    const tokenEvidenceAvailable = comparableTokenEvidence !== null;
+    const tokenSavingsPct = comparableTokenEvidence
+        ? (comparableTokenEvidence.baseline - comparableTokenEvidence.candidate) / comparableTokenEvidence.baseline
+        : null;
+    const baselineSize = serializedSize(baseline);
+    const candidateSize = serializedSize(candidate);
+    const serializedSizeSavingsPct = baselineSize !== null && baselineSize > 0 && candidateSize !== null
+        ? (baselineSize - candidateSize) / baselineSize
+        : null;
     const accuracyDelta = candidate.quality.accuracy_proxy - baseline.quality.accuracy_proxy;
     const precisionDelta = candidate.quality.relevance_precision - baseline.quality.relevance_precision;
     const supportDelta = candidate.quality.support_ratio - baseline.quality.support_ratio;
     const buildRuntimeDeltaMs = candidate.context_build_ms_per_run - baseline.context_build_ms_per_run;
     const checks = {
-        token_savings: tokenSavingsPct >= thresholds.min_token_savings_pct,
+        token_evidence: tokenEvidenceAvailable,
+        token_savings: tokenSavingsPct === null ? null : tokenSavingsPct >= thresholds.min_token_savings_pct,
         accuracy_delta: accuracyDelta >= thresholds.min_accuracy_delta,
         required_recall: candidate.quality.required_recall >= thresholds.min_required_recall,
         unsupported_critical: candidate.quality.unsupported_critical_selected <= thresholds.max_unsupported_critical_selected,
@@ -511,13 +555,23 @@ export function compareMetricBlocks(baseline, candidate, thresholds = DEFAULT_EV
     if (candidate.wiki)
         checks.wiki_index = candidate.wiki.valid === true;
     return {
-        token_savings_pct: Number(tokenSavingsPct.toFixed(4)),
+        token_savings_pct: tokenSavingsPct === null ? null : Number(tokenSavingsPct.toFixed(4)),
+        serialized_size_savings_pct: serializedSizeSavingsPct === null ? null : Number(serializedSizeSavingsPct.toFixed(4)),
+        token_measurement: {
+            available: tokenEvidenceAvailable,
+            evidence_identity: comparableTokenEvidence?.identity ?? null,
+            reason: tokenEvidenceAvailable
+                ? null
+                : baselineTokenEvidence && candidateTokenEvidence && baselineTokenEvidence.identity !== candidateTokenEvidence.identity
+                    ? 'matching_token_evidence_identity_required'
+                    : 'actual_token_counts_with_evidence_required'
+        },
         accuracy_delta: Number(accuracyDelta.toFixed(4)),
         precision_delta: Number(precisionDelta.toFixed(4)),
         support_ratio_delta: Number(supportDelta.toFixed(4)),
         build_runtime_delta_ms: Number(buildRuntimeDeltaMs.toFixed(4)),
         checks,
-        meaningful_improvement: Object.values(checks).every(Boolean)
+        meaningful_improvement: Object.values(checks).every((value) => value === true)
     };
 }
 export function runEvaluationBenchmark(opts = {}) {
@@ -536,17 +590,19 @@ export function runEvaluationBenchmark(opts = {}) {
         label: 'uncompressed-all-claims',
         context: baselineTiming.result,
         scenario,
-        msPerRun: baselineTiming.ms_per_run
+        msPerRun: baselineTiming.ms_per_run,
+        tokenMeasurement: tokenMeasurementFromEvidence(opts.tokenEvidence, 'baseline')
     });
     const candidate = metricBlock({
         label: 'triwiki-compressed-capsule',
         context: candidateTiming.result,
         scenario,
-        msPerRun: candidateTiming.ms_per_run
+        msPerRun: candidateTiming.ms_per_run,
+        tokenMeasurement: tokenMeasurementFromEvidence(opts.tokenEvidence, 'candidate')
     });
     const comparison = compareMetricBlocks(baseline, candidate, opts.thresholds || DEFAULT_EVAL_THRESHOLDS);
     return {
-        schema_version: 1,
+        schema_version: 2,
         generated_at: nowIso(),
         scenario: {
             id: scenario.id,
@@ -560,25 +616,31 @@ export function runEvaluationBenchmark(opts = {}) {
         candidate,
         comparison,
         notes: [
-            'estimated_tokens uses a deterministic chars/4 approximation for local regression tracking.',
+            'serialized_size_bytes is a deterministic UTF-8 JSON byte-size metric, not a token estimate.',
+            'Token savings are unavailable unless actual baseline and candidate token counts share the same nonempty token_evidence.source identity.',
             'accuracy_proxy scores evidence-weighted context selection quality; it is not a live model task accuracy measurement.'
         ]
     };
 }
 function reportMetric(report) {
-    if (report?.candidate?.quality && report?.candidate?.estimated_tokens)
+    if (report?.candidate?.quality && hasSizeOrTokenMetric(report.candidate))
         return report.candidate;
-    if (report?.metrics?.quality && report?.metrics?.estimated_tokens)
+    if (report?.metrics?.quality && hasSizeOrTokenMetric(report.metrics))
         return report.metrics;
-    if (report?.quality && report?.estimated_tokens)
+    if (report?.quality && hasSizeOrTokenMetric(report))
         return report;
     throw new Error('Unsupported eval report shape.');
 }
+function hasSizeOrTokenMetric(metric) {
+    return metric?.serialized_size_bytes !== undefined
+        || metric?.token_count !== undefined
+        || metric?.estimated_tokens !== undefined;
+}
 export function compareEvaluationReports(baselineReport, candidateReport, thresholds = DEFAULT_EVAL_THRESHOLDS) {
     const baseline = reportMetric(baselineReport);
     const candidate = reportMetric(candidateReport);
     return {
-        schema_version: 1,
+        schema_version: 2,
         generated_at: nowIso(),
         baseline_label: baseline.label || baselineReport?.scenario?.id || 'baseline',
         candidate_label: candidate.label || candidateReport?.scenario?.id || 'candidate',

package/dist/core/feature-fixtures.js

@@ -40,10 +40,6 @@ const FIXTURES = Object.freeze({
     'cli-check': fixture('execute', 'sks check --tier confidence --sla 5m --plan --json', [], 'pass'),
     'cli-plan': fixture('execute', 'sks plan "fixture" --json', [], 'pass'),
     'cli-review': fixture('execute', 'sks review --diff HEAD --json', [], 'pass'),
-    'cli-ui': fixture('static', 'sks ui [--port 4477] [--mission latest] [--once] [--json]', [], 'pass', {
-        quality: 'static_contract',
-        reason: 'UI command opens a localhost dashboard; release fixture tracks the CLI contract without launching a server.'
-    }),
     'cli-run': fixture('execute_and_validate_artifacts', 'sks run "fixture" --mock --json', ['run-classification.json', 'completion-proof.json', 'evidence-index.json', 'route-completion-contract.json', 'trust-report.json', 'work-order-ledger.json'], 'blocked', { reason: 'finalizeMockRun() in run-command.ts intentionally hardcodes gate.passed=false for every --mock invocation so a mock run can never claim a real completion; it does write all declared artifacts, including a work-order-ledger honestly closed to blocked (18차).' }),
     'cli-status': fixture('execute', 'sks status --json', [], 'pass'),
     'cli-usage': fixture('execute', 'sks usage overview', [], 'pass'),
@@ -66,7 +62,7 @@ const FIXTURES = Object.freeze({
     'cli-selftest': fixture('execute', 'sks selftest --mock', [], 'pass'),
     'cli-git': fixture('execute', 'sks git policy --json', [], 'pass'),
     'cli-uninstall': fixture('execute', 'sks uninstall --dry-run --json', [], 'pass'),
-    'cli-goal': fixture('execute_and_validate_artifacts', 'sks goal create "Fixture smoke: create a minimal Node.js CLI health-check script" --json', ['goal-workflow.json', 'work-order-ledger.json'], 'blocked', { timeout_ms: 300000, reason: 'goal create drives a real loop-graph -> $Naruto multi-agent orchestration pass that requires live agent infrastructure (GPT dispatch, zellij dashboard, verification DAG) unavailable in a fixture/CI sandbox, so loop_result/gate legitimately reports blocked (naruto_*_missing, loop-graph-proof.json_missing) and the command exits 1 by design; goal-workflow.json and a work-order-ledger honestly closed to blocked (18차) are still written.' }),
+    'cli-goal': fixture('execute', 'sks goal create "Fixture smoke: create a minimal Node.js CLI health-check script" --json', [], 'pass', { reason: 'The compatibility command is stateless: it prints a detailed Codex native /goal request and writes no SKS mission, artifact, loop, or fallback state.' }),
     'cli-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode seo --json', ['search-visibility/site-inventory.json', 'search-visibility/seo-findings.json', 'search-visibility/verification-report.json', 'seo-gate.json', 'completion-proof.json'], 'pass'),
     'cli-research': fixture('execute_and_validate_artifacts', 'sks research run latest --mock --json', ['research-gate.json', 'completion-proof.json'], 'blocked', { timeout_ms: 180000, reason: '"run" (not "status") is the command that actually writes research-gate.json/completion-proof.json, but research is a two-step prepare-then-run workflow gated by an active-route-not-closed check between steps that a single fixture command cannot express; on a hermetic run "latest" will not be a properly prepared+closed research mission.' }),
     'cli-qa-loop': fixture('execute_and_validate_artifacts', 'sks qa-loop run latest --mock --json', ['qa-gate.json', 'completion-proof.json'], 'pass', { timeout_ms: 180000 }),
@@ -152,8 +148,9 @@ const FIXTURES = Object.freeze({
         quality: 'wiring_only',
         reason: 'Policy-only route (answer-only conversational mode with no writes); nothing executable to run beyond static contract text.'
     }),
-    'route-goal': fixture('mock', '$Goal bridge route', ['goal-workflow.json', 'completion-proof.json'], 'pass', {
-        reason: 'sks goal create "<prompt>" --json never calls maybeFinalizeRoute, so it does not write completion-proof.json even on success; live-testing it also surfaced a real defect (loop-worker-runtime.ts omitted an explicit `agents` value, so buildAgentRoster() fell back to DEFAULT_AGENT_COUNT=5 while maxAgentCount was capped to the loop\'s smaller worker budget, throwing "Agent count 5 exceeds max N" for any ordinary fixture prompt) which has been fixed in this change, but goal-workflow.json/completion-proof.json parity still requires either wiring maybeFinalizeRoute into goalCreate or relaxing this fixture\'s expected_artifacts, both out of scope here; left as documented mock.'
+    'route-goal': fixture('static', '$Goal Codex-native control route', [], 'pass', {
+        quality: 'wiring_only',
+        reason: 'Goal lifecycle is owned entirely by Codex native /goal. The SKS surface only builds a detailed native objective and command; it creates no mission, proof artifact, compatibility loop, or fallback goal state.'
     }),
     'route-super-search': fixture('execute', 'sks run "$Super-Search doctor" --execute --json', [], 'pass'),
     'route-seo-geo-optimizer': fixture('execute_and_validate_artifacts', 'sks seo-geo-optimizer fixture --mode geo --json', ['search-visibility/site-inventory.json', 'search-visibility/geo-findings.json', 'search-visibility/verification-report.json', 'geo-gate.json', 'completion-proof.json'], 'pass'),

package/dist/core/feature-registry.js

@@ -13,7 +13,6 @@ export const FEATURE_INVENTORY_SCHEMA = 'sks.feature-inventory.v1';
 export const ALL_FEATURES_SELFTEST_SCHEMA = 'sks.all-features-selftest.v1';
 export const ALL_FEATURE_COMPLETION_SCHEMA = 'sks.all-feature-completion.v1';
 const HANDLER_ALIAS_TO_COMMAND = Object.freeze({
-    ui: 'wizard',
     auth: 'codex-lb',
     hook: 'hooks',
     memory: 'gc',

package/dist/core/fsx.js

@@ -446,6 +446,88 @@ export class TailBuffer {
         return this.totalBytes;
     }
 }
+const activeDetachedProcessGroups = new Map();
+let processGroupLifecycleHandlersInstalled = false;
+let relayingParentSignal = false;
+export function registerDetachedProcessGroup(child) {
+    const pid = child.pid;
+    if (process.platform === 'win32' || !pid)
+        return () => { };
+    const group = { pid, child };
+    activeDetachedProcessGroups.set(pid, group);
+    installProcessGroupLifecycleHandlers();
+    return () => {
+        if (activeDetachedProcessGroups.get(pid) !== group)
+            return;
+        activeDetachedProcessGroups.delete(pid);
+        if (activeDetachedProcessGroups.size === 0)
+            uninstallProcessGroupLifecycleHandlers();
+    };
+}
+function installProcessGroupLifecycleHandlers() {
+    if (processGroupLifecycleHandlersInstalled || process.platform === 'win32')
+        return;
+    processGroupLifecycleHandlersInstalled = true;
+    process.on('exit', terminateRegisteredProcessGroups);
+    // Run before existing once listeners remove themselves so rawListeners still
+    // reflects whether Node's default signal termination was already suppressed.
+    process.prependListener('SIGHUP', handleParentSighup);
+    process.prependListener('SIGINT', handleParentSigint);
+    process.prependListener('SIGTERM', handleParentSigterm);
+}
+function uninstallProcessGroupLifecycleHandlers() {
+    if (!processGroupLifecycleHandlersInstalled)
+        return;
+    processGroupLifecycleHandlersInstalled = false;
+    process.off('exit', terminateRegisteredProcessGroups);
+    process.off('SIGHUP', handleParentSighup);
+    process.off('SIGINT', handleParentSigint);
+    process.off('SIGTERM', handleParentSigterm);
+}
+function handleParentSighup() {
+    relayParentSignal('SIGHUP', handleParentSighup);
+}
+function handleParentSigint() {
+    relayParentSignal('SIGINT', handleParentSigint);
+}
+function handleParentSigterm() {
+    relayParentSignal('SIGTERM', handleParentSigterm);
+}
+function relayParentSignal(signal, ownHandler) {
+    if (relayingParentSignal)
+        return;
+    terminateRegisteredProcessGroups();
+    if (process.rawListeners(signal).some((listener) => listener !== ownHandler))
+        return;
+    relayingParentSignal = true;
+    uninstallProcessGroupLifecycleHandlers();
+    try {
+        process.kill(process.pid, signal);
+    }
+    catch {
+        process.exit(signal === 'SIGHUP' ? 129 : signal === 'SIGINT' ? 130 : 143);
+    }
+    setImmediate(() => {
+        relayingParentSignal = false;
+        if (activeDetachedProcessGroups.size > 0)
+            installProcessGroupLifecycleHandlers();
+    });
+}
+function terminateRegisteredProcessGroups() {
+    for (const group of [...activeDetachedProcessGroups.values()]) {
+        if (activeDetachedProcessGroups.get(group.pid) !== group)
+            continue;
+        try {
+            process.kill(-group.pid, 'SIGKILL');
+            continue;
+        }
+        catch { }
+        try {
+            group.child.kill('SIGKILL');
+        }
+        catch { }
+    }
+}
 export function runProcess(command, args, options = {}) {
     return new Promise((resolve) => {
         const tailBytes = options.maxOutputBytes ?? DEFAULT_PROCESS_TAIL_BYTES;
@@ -453,26 +535,36 @@ export function runProcess(command, args, options = {}) {
         const stderrTail = new TailBuffer(tailBytes);
         const timeoutMs = options.timeoutMs ?? DEFAULT_PROCESS_TIMEOUT_MS;
         let killedByTimeout = false;
+        let spawnRegistrationFailed = false;
         let settled = false;
+        let processTreeCleanup = null;
         let stdoutStream = null;
         let stderrStream = null;
         const spawnOptions = {
             cwd: options.cwd || process.cwd(),
             shell: false,
             stdio: [options.input !== undefined ? 'pipe' : 'ignore', 'pipe', 'pipe'],
+            detached: process.platform !== 'win32',
         };
-        if (options.env) {
+        if (options.envMode === 'replace') {
+            spawnOptions.env = { ...(options.env || {}) };
+        }
+        else if (options.env) {
             spawnOptions.env = { ...process.env, ...options.env };
         }
         const child = spawn(command, args, spawnOptions);
-        if (options.input !== undefined && child.stdin) {
-            child.stdin.end(options.input);
-        }
+        const unregisterDetachedProcessGroup = registerDetachedProcessGroup(child);
+        const pausedForSpawnRegistration = Boolean(options.onSpawn
+            && child.pid
+            && process.platform !== 'win32'
+            && child.kill('SIGSTOP'));
         const finish = async (result) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
+            await processTreeCleanup;
+            unregisterDetachedProcessGroup();
             try {
                 await stdoutStream?.end?.();
             }
@@ -493,16 +585,7 @@ export function runProcess(command, args, options = {}) {
         }
         const timer = setTimeout(() => {
             killedByTimeout = true;
-            try {
-                child.kill('SIGTERM');
-            }
-            catch { }
-            setTimeout(() => {
-                try {
-                    child.kill('SIGKILL');
-                }
-                catch { }
-            }, 1500).unref?.();
+            processTreeCleanup = terminateProcessTree(child.pid, child);
         }, timeoutMs);
         timer.unref?.();
         child.stdout?.on('data', (d) => {
@@ -524,6 +607,7 @@ export function runProcess(command, args, options = {}) {
             stderrBytes: stderrTail.totalBytesCounted,
             truncated: stdoutTail.truncated || stderrTail.truncated,
             timedOut: killedByTimeout,
+            ...(spawnRegistrationFailed ? { spawnRegistrationFailed: true } : {}),
         }));
         child.on('close', (code) => void finish({
             code: killedByTimeout ? 124 : code,
@@ -534,9 +618,80 @@ export function runProcess(command, args, options = {}) {
             stderrBytes: stderrTail.totalBytesCounted,
             truncated: stdoutTail.truncated || stderrTail.truncated,
             timedOut: killedByTimeout,
+            ...(spawnRegistrationFailed ? { spawnRegistrationFailed: true } : {}),
         }));
+        void (async () => {
+            if (options.onSpawn) {
+                const pid = child.pid;
+                if (!pid) {
+                    spawnRegistrationFailed = true;
+                    child.kill('SIGKILL');
+                    return;
+                }
+                try {
+                    await options.onSpawn(pid);
+                }
+                catch {
+                    spawnRegistrationFailed = true;
+                    processTreeCleanup = terminateProcessTree(pid, child);
+                    await processTreeCleanup;
+                    return;
+                }
+                if (pausedForSpawnRegistration)
+                    child.kill('SIGCONT');
+            }
+            if (options.input !== undefined && child.stdin)
+                child.stdin.end(options.input);
+        })();
     });
 }
+async function terminateProcessTree(pid, child) {
+    signalProcessTree(pid, 'SIGTERM', child);
+    if (await waitForProcessTreeExit(pid, 1_000))
+        return;
+    signalProcessTree(pid, 'SIGKILL', child);
+    await waitForProcessTreeExit(pid, 1_500);
+}
+function signalProcessTree(pid, signal, child) {
+    if (pid && process.platform !== 'win32') {
+        try {
+            process.kill(-pid, signal);
+            return;
+        }
+        catch { }
+    }
+    try {
+        child.kill(signal);
+    }
+    catch { }
+}
+async function waitForProcessTreeExit(pid, timeoutMs) {
+    if (!pid)
+        return true;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!processTreeIsAlive(pid))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    return !processTreeIsAlive(pid);
+}
+function processTreeIsAlive(pid) {
+    if (process.platform !== 'win32') {
+        try {
+            process.kill(-pid, 0);
+            return true;
+        }
+        catch { }
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function readStdin() {
     let data = '';
     process.stdin.setEncoding('utf8');