npm - @pasko70/pibo - Versions diffs - 3.6.2 → 3.6.4 - Mend

@pasko70/pibo 3.6.2 → 3.6.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/dist/apps/chat-vscode-web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<meta name="theme-color" content="#101d22" />
 		<title>Pibo</title>
-		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-l2TxPbpk.js"></script>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-CtaeZkpG.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-b18ZkEo0.css">
 	</head>
 	<body>

package/dist/core/session-router.js CHANGED Viewed

@@ -7,6 +7,7 @@ import { InitialSessionContext, } from "./profiles.js";
 import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault, selectDefaultPiboProfileName } from "../plugins/builtin.js";
 import { RUN_REMINDER_MAX_DURATION_MS, RuntimeRoutedSession as RoutedSession, } from "../agent-runtime/routed-session.js";
 import { runtimeSessionErrorDetails } from "./session-errors.js";
+import { PiboSteeringUnavailableError, } from "./events.js";
 import { OutputRenderSequencer, outputRenderHighWaterStore } from "./output-render-sequence.js";
 import { normalizePiboAgentSessionName, } from "../subagents/tool.js";
 import { piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationSourceFromEvent, piboAgentObservationText, } from "../subagents/observations.js";
@@ -1100,8 +1101,98 @@ export class PiboSessionRouter {
     subscribeSignalStatuses(listener) {
         return this.signalRegistry.subscribeAll(listener);
     }
+    async emitSteeringMessageAndWaitForReply(event, timeoutMs, signal) {
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            let steeringAccepted = false;
+            let targetEventId = this.sessions.get(event.piboSessionId)?.getStatus().activeEventId;
+            let dispatchPromise;
+            let timeout;
+            const assistantMessages = new Map();
+            const finishedEventIds = new Set();
+            const sessionErrors = new Map();
+            const claimSettlement = () => {
+                if (settled)
+                    return false;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                signal?.removeEventListener("abort", onAbort);
+                unsubscribe();
+                return true;
+            };
+            const finish = (result) => {
+                if (!claimSettlement())
+                    return;
+                if (result instanceof Error)
+                    reject(result);
+                else
+                    resolve(result);
+            };
+            const finishTargetIfReady = () => {
+                if (!steeringAccepted || !targetEventId)
+                    return;
+                const error = sessionErrors.get(targetEventId);
+                if (error) {
+                    finish(error);
+                    return;
+                }
+                if (!finishedEventIds.has(targetEventId))
+                    return;
+                finish(assistantMessages.get(targetEventId)
+                    ?? new Error(`Pibo session "${event.piboSessionId}" finished without an assistant reply`));
+            };
+            const rejectAfterSteeringCancellation = (error) => {
+                if (!claimSettlement())
+                    return;
+                void Promise.resolve(dispatchPromise).then(() => reject(error), (dispatchError) => reject(dispatchError instanceof Error ? dispatchError : new Error(String(dispatchError))));
+            };
+            const onAbort = () => {
+                rejectAfterSteeringCancellation(subagentAbortError());
+            };
+            const unsubscribe = this.subscribe((output) => {
+                if (output.piboSessionId !== event.piboSessionId || !("eventId" in output) || !output.eventId)
+                    return;
+                if (output.type === "assistant_message") {
+                    assistantMessages.set(output.eventId, output);
+                }
+                else if (output.type === "message_finished") {
+                    finishedEventIds.add(output.eventId);
+                }
+                else if (output.type === "session_error") {
+                    sessionErrors.set(output.eventId, new Error(output.error));
+                }
+                finishTargetIfReady();
+            });
+            if (signal?.aborted) {
+                finish(subagentAbortError());
+                return;
+            }
+            signal?.addEventListener("abort", onAbort, { once: true });
+            if (timeoutMs !== undefined) {
+                timeout = setTimeout(() => {
+                    rejectAfterSteeringCancellation(new PiboRunExecutionTimeoutError(`Timed out waiting for assistant reply from Pibo session "${event.piboSessionId}"`, "lifetime"));
+                }, timeoutMs);
+            }
+            dispatchPromise = this.emit(event);
+            dispatchPromise.then((output) => {
+                if (output.type !== "message_steered" || !output.activeEventId) {
+                    finish(new Error(`Pibo session "${event.piboSessionId}" did not identify the active turn for steering`));
+                    return;
+                }
+                targetEventId = output.activeEventId;
+                steeringAccepted = true;
+                finishTargetIfReady();
+            }).catch((error) => {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            });
+        });
+    }
     async emitMessageAndWaitForReply(event, timeoutMs, signal) {
         const eventWithId = { ...event, id: event.id ?? randomUUID() };
+        if (eventWithId.delivery === "steer") {
+            return await this.emitSteeringMessageAndWaitForReply(eventWithId, timeoutMs, signal);
+        }
         return await new Promise((resolve, reject) => {
             let settled = false;
             let dispatchPromise;
@@ -2121,7 +2212,7 @@ export class PiboSessionRouter {
     }
     createAgentsController(parentPiboSessionId) {
         return {
-            sendMessage: async ({ subagent, sessionName, message, threadKey, toolCallId, requestId, parentProvenance, signal }) => {
+            sendMessage: async ({ subagent, sessionName, message, threadKey, queue, toolCallId, requestId, parentProvenance, signal }) => {
                 if (signal?.aborted)
                     throw subagentAbortError();
                 if (typeof requestId !== "string" || !requestId.trim())
@@ -2140,10 +2231,14 @@ export class PiboSessionRouter {
                     : parentProvenance?.kind === "subagent-request"
                         ? parentProvenance.loopRunId
                         : undefined;
-                const event = {
+                let delivery = queue === true || !this.sessions.get(child.id)?.canSteerMessage()
+                    ? "queue"
+                    : "steer";
+                let event = {
                     type: "message",
                     piboSessionId: child.id,
                     text: message,
+                    delivery,
                     source: "actor",
                     id: randomUUID(),
                     provenance: {
@@ -2181,7 +2276,19 @@ export class PiboSessionRouter {
                 });
                 let settlement = { status: "fulfilled" };
                 try {
-                    const reply = await this.emitMessageAndWaitForReply(event, undefined, requestSignal);
+                    let reply;
+                    try {
+                        reply = await this.emitMessageAndWaitForReply(event, undefined, requestSignal);
+                    }
+                    catch (error) {
+                        if (delivery !== "steer" || !(error instanceof PiboSteeringUnavailableError) || requestSignal.aborted)
+                            throw error;
+                        this.subagentRequestIdsByEvent.delete(subagentRequestEventKey(child.id, event.id));
+                        delivery = "queue";
+                        event = { ...event, id: randomUUID(), delivery };
+                        this.subagentRequestIdsByEvent.set(subagentRequestEventKey(child.id, event.id), requestId);
+                        reply = await this.emitMessageAndWaitForReply(event, undefined, requestSignal);
+                    }
                     return {
                         requestId,
                         agentId: child.id,
@@ -2189,6 +2296,8 @@ export class PiboSessionRouter {
                         profile: child.profile,
                         threadKey: resolvedThreadKey,
                         eventId: event.id,
+                        delivery,
+                        ...(delivery === "steer" && reply.eventId ? { activeEventId: reply.eventId } : {}),
                         finalMessage: reply.text,
                         reply,
                     };

package/dist/data/chat-read-projections.js CHANGED Viewed

@@ -85,10 +85,18 @@ export class ChatReadProjectionStore {
         this.db = db;
     }
     status() {
-        const r = this.db.prepare("SELECT cursor,target,event_cursor,event_target,paused FROM chat_read_backfill WHERE id=1").get();
-        return { ...r, paused: Boolean(r.paused), historyComplete: r.cursor >= r.target, unreadComplete: r.event_cursor >= r.event_target, complete: r.cursor >= r.target && r.event_cursor >= r.event_target };
+        const row = this.db.prepare("SELECT cursor,target,event_cursor,event_target,paused FROM chat_read_backfill WHERE id=1").get();
+        return {
+            ...row,
+            paused: Boolean(row.paused),
+            historyComplete: row.cursor >= row.target,
+            unreadComplete: row.event_cursor >= row.event_target,
+            complete: row.cursor >= row.target && row.event_cursor >= row.event_target,
+        };
+    }
+    setPaused(paused) {
+        this.db.prepare("UPDATE chat_read_backfill SET paused=? WHERE id=1").run(paused ? 1 : 0);
     }
-    setPaused(paused) { this.db.prepare("UPDATE chat_read_backfill SET paused=? WHERE id=1").run(paused ? 1 : 0); }
     step(limit = 128, maxMs = 4) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 512)
             throw Error("Backfill row budget must be 1..512");
@@ -102,36 +110,9 @@ export class ChatReadProjectionStore {
                 this.db.exec("COMMIT");
                 return { ...current, processed: 0 };
             }
-            if (current.historyComplete) {
-                const rows = this.db.prepare("SELECT stream_id,session_id FROM event_log INDEXED BY idx_event_log_unread_stream WHERE stream_id>? AND stream_id<=? AND type='message_finished' ORDER BY stream_id LIMIT ?").all(current.event_cursor, current.event_target, limit);
-                const insert = this.db.prepare("INSERT OR IGNORE INTO chat_unread_index VALUES(?,?)");
-                let processed = 0;
-                const started = performance.now();
-                for (const row of rows) {
-                    if (row.session_id)
-                        insert.run(row.stream_id, row.session_id);
-                    processed++;
-                    if (performance.now() - started >= maxMs)
-                        break;
-                }
-                const cursor = processed === rows.length && rows.length < limit ? current.event_target : rows[processed - 1].stream_id;
-                this.db.prepare("UPDATE chat_read_backfill SET event_cursor=? WHERE id=1").run(cursor);
-                this.db.exec("COMMIT");
-                return { ...this.status(), processed };
-            }
-            const rows = this.db.prepare("SELECT rowid AS cursor,id FROM chat_messages WHERE rowid>? AND rowid<=? ORDER BY rowid LIMIT ?").all(current.cursor, current.target, limit);
-            const insert = this.db.prepare(`INSERT OR IGNORE INTO chat_history_index(message_id,session_id,event_sequence,source_stream_id,role,created_at)
-    SELECT m.id,m.session_id,COALESCE(e.session_sequence,m.sequence),m.source_stream_id,m.role,m.created_at FROM chat_messages m LEFT JOIN event_log e ON e.stream_id=m.source_stream_id WHERE m.id=?`);
-            let processed = 0;
-            const started = performance.now();
-            for (const row of rows) {
-                insert.run(row.id);
-                processed++;
-                if (performance.now() - started >= maxMs)
-                    break;
-            }
-            const cursor = processed === rows.length && rows.length < limit ? current.target : rows[processed - 1].cursor;
-            this.db.prepare("UPDATE chat_read_backfill SET cursor=? WHERE id=1").run(cursor);
+            const processed = current.historyComplete
+                ? this.backfillUnread(current.event_cursor, current.event_target, limit, maxMs)
+                : this.backfillHistory(current.cursor, current.target, limit, maxMs);
             this.db.exec("COMMIT");
             return { ...this.status(), processed };
         }
@@ -140,6 +121,38 @@ export class ChatReadProjectionStore {
             throw error;
         }
     }
+    backfillUnread(cursor, target, limit, maxMs) {
+        const rows = this.db.prepare("SELECT stream_id,session_id FROM event_log INDEXED BY idx_event_log_unread_stream WHERE stream_id>? AND stream_id<=? AND type='message_finished' ORDER BY stream_id LIMIT ?").all(cursor, target, limit);
+        const insert = this.db.prepare("INSERT OR IGNORE INTO chat_unread_index VALUES(?,?)");
+        let processed = 0;
+        const started = performance.now();
+        for (const row of rows) {
+            if (row.session_id)
+                insert.run(row.stream_id, row.session_id);
+            processed++;
+            if (performance.now() - started >= maxMs)
+                break;
+        }
+        const nextCursor = processed === rows.length && rows.length < limit ? target : rows[processed - 1].stream_id;
+        this.db.prepare("UPDATE chat_read_backfill SET event_cursor=? WHERE id=1").run(nextCursor);
+        return processed;
+    }
+    backfillHistory(cursor, target, limit, maxMs) {
+        const rows = this.db.prepare("SELECT rowid AS cursor,id FROM chat_messages WHERE rowid>? AND rowid<=? ORDER BY rowid LIMIT ?").all(cursor, target, limit);
+        const insert = this.db.prepare(`INSERT OR IGNORE INTO chat_history_index(message_id,session_id,event_sequence,source_stream_id,role,created_at)
+    SELECT m.id,m.session_id,COALESCE(e.session_sequence,m.sequence),m.source_stream_id,m.role,m.created_at FROM chat_messages m LEFT JOIN event_log e ON e.stream_id=m.source_stream_id WHERE m.id=?`);
+        let processed = 0;
+        const started = performance.now();
+        for (const row of rows) {
+            insert.run(row.id);
+            processed++;
+            if (performance.now() - started >= maxMs)
+                break;
+        }
+        const nextCursor = processed === rows.length && rows.length < limit ? target : rows[processed - 1].cursor;
+        this.db.prepare("UPDATE chat_read_backfill SET cursor=? WHERE id=1").run(nextCursor);
+        return processed;
+    }
 }
 export const CHAT_NAVIGATION_REVISION_SCHEMA = `
 CREATE INDEX IF NOT EXISTS idx_sessions_navigation_cursor ON sessions(room_id,id) WHERE deleted_at IS NULL;

package/dist/mcp/config.js CHANGED Viewed

@@ -113,61 +113,40 @@ export function debug(message) {
         console.error(`[pibo mcp] ${message}`);
     }
 }
+function readIntegerEnv(name, fallback, minimum = 1) {
+    const value = process.env[name];
+    if (!value)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return !Number.isNaN(parsed) && parsed >= minimum ? parsed : fallback;
+}
 /**
  * Get configured timeout in milliseconds
  * @env MCP_TIMEOUT - timeout in seconds (default: 1800 = 30 minutes)
  */
 export function getTimeoutMs() {
-    const envTimeout = process.env.MCP_TIMEOUT;
-    if (envTimeout) {
-        const seconds = Number.parseInt(envTimeout, 10);
-        if (!Number.isNaN(seconds) && seconds > 0) {
-            return seconds * 1000;
-        }
-    }
-    return DEFAULT_TIMEOUT_MS;
+    return readIntegerEnv('MCP_TIMEOUT', DEFAULT_TIMEOUT_SECONDS) * 1000;
 }
 /**
  * Get concurrency limit for parallel server connections
  * @env MCP_CONCURRENCY - max parallel connections (default: 5)
  */
 export function getConcurrencyLimit() {
-    const envConcurrency = process.env.MCP_CONCURRENCY;
-    if (envConcurrency) {
-        const limit = Number.parseInt(envConcurrency, 10);
-        if (!Number.isNaN(limit) && limit > 0) {
-            return limit;
-        }
-    }
-    return DEFAULT_CONCURRENCY;
+    return readIntegerEnv('MCP_CONCURRENCY', DEFAULT_CONCURRENCY);
 }
 /**
  * Get max retry attempts for transient failures
  * @env MCP_MAX_RETRIES - max retry attempts (default: 3, use 0 to disable retries)
  */
 export function getMaxRetries() {
-    const envRetries = process.env.MCP_MAX_RETRIES;
-    if (envRetries) {
-        const retries = Number.parseInt(envRetries, 10);
-        if (!Number.isNaN(retries) && retries >= 0) {
-            return retries;
-        }
-    }
-    return DEFAULT_MAX_RETRIES;
+    return readIntegerEnv('MCP_MAX_RETRIES', DEFAULT_MAX_RETRIES, 0);
 }
 /**
  * Get base delay for retry backoff in milliseconds
  * @env MCP_RETRY_DELAY - base delay in milliseconds (default: 1000)
  */
 export function getRetryDelayMs() {
-    const envDelay = process.env.MCP_RETRY_DELAY;
-    if (envDelay) {
-        const delay = Number.parseInt(envDelay, 10);
-        if (!Number.isNaN(delay) && delay > 0) {
-            return delay;
-        }
-    }
-    return DEFAULT_RETRY_DELAY_MS;
+    return readIntegerEnv('MCP_RETRY_DELAY', DEFAULT_RETRY_DELAY_MS);
 }
 // ============================================================================
 // Daemon Configuration
@@ -184,28 +163,14 @@ export function isDaemonEnabled() {
  * @env MCP_DAEMON_TIMEOUT - timeout in seconds (default: 60)
  */
 export function getDaemonTimeoutMs() {
-    const envTimeout = process.env.MCP_DAEMON_TIMEOUT;
-    if (envTimeout) {
-        const seconds = Number.parseInt(envTimeout, 10);
-        if (!Number.isNaN(seconds) && seconds > 0) {
-            return seconds * 1000;
-        }
-    }
-    return DEFAULT_DAEMON_TIMEOUT_SECONDS * 1000;
+    return readIntegerEnv('MCP_DAEMON_TIMEOUT', DEFAULT_DAEMON_TIMEOUT_SECONDS) * 1000;
 }
 /**
  * Get daemon request timeout in milliseconds
  * @env MCP_DAEMON_REQUEST_TIMEOUT - timeout in seconds (default: 60)
  */
 export function getDaemonRequestTimeoutMs() {
-    const envTimeout = process.env.MCP_DAEMON_REQUEST_TIMEOUT;
-    if (envTimeout) {
-        const seconds = Number.parseInt(envTimeout, 10);
-        if (!Number.isNaN(seconds) && seconds > 0) {
-            return seconds * 1000;
-        }
-    }
-    return DEFAULT_DAEMON_REQUEST_TIMEOUT_SECONDS * 1000;
+    return readIntegerEnv('MCP_DAEMON_REQUEST_TIMEOUT', DEFAULT_DAEMON_REQUEST_TIMEOUT_SECONDS) * 1000;
 }
 function getDaemonUserKey(platform) {
     const uid = process.getuid?.();

package/dist/providers/meta-muse.js ADDED Viewed

@@ -0,0 +1,51 @@
+import { registerOpenAiCompatProvider, } from "./openai-compat.js";
+export const META_MUSE_PROVIDER_ID = "meta-muse";
+export const META_MUSE_PROVIDER_NAME = "Meta Muse";
+export const META_MUSE_DEFAULT_BASE_URL = "https://api.meta.ai/v1";
+export const META_MUSE_API_KEY_ENV = "META_API_KEY";
+const COMPAT = {
+    supportsStore: false,
+    maxTokensField: "max_tokens",
+};
+const REASONING_LEVELS = {
+    off: null,
+    minimal: "minimal",
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: "xhigh",
+    max: "max",
+};
+export const META_MUSE_MODELS = [
+    {
+        id: "muse-spark-1.3",
+        name: "Muse Spark 1.3",
+        reasoning: true,
+        thinkingLevelMap: REASONING_LEVELS,
+        compat: COMPAT,
+        contextWindow: 1_000_000,
+        maxTokens: 131_072,
+        cost: { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 },
+        input: ["text", "image"],
+    },
+    {
+        id: "muse-spark-1.3-contributor",
+        name: "Muse Spark 1.3 Contributor",
+        reasoning: true,
+        thinkingLevelMap: { ...REASONING_LEVELS, max: null },
+        compat: COMPAT,
+        contextWindow: 1_000_000,
+        maxTokens: 131_072,
+        cost: { input: 0.10, output: 0.20, cacheRead: 0.002, cacheWrite: 0 },
+        input: ["text", "image"],
+    },
+];
+export function registerMetaMuseProvider(modelRegistry) {
+    return registerOpenAiCompatProvider(modelRegistry, {
+        id: META_MUSE_PROVIDER_ID,
+        name: META_MUSE_PROVIDER_NAME,
+        baseUrl: process.env.PIBO_META_MUSE_BASE_URL || META_MUSE_DEFAULT_BASE_URL,
+        apiKeyEnv: META_MUSE_API_KEY_ENV,
+        models: META_MUSE_MODELS,
+    });
+}

package/dist/runs/resource-isolation.js CHANGED Viewed

@@ -4,6 +4,8 @@ import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
+import { removeWindowsProcessIdentity, terminateWindowsProcessTree, windowsProcessTreeCommand } from "./windows-process-tree.js";
+export { windowsProcessTreeCommand } from "./windows-process-tree.js";
 const execFileAsync = promisify(execFile);
 export class PiboRunResourceLimitError extends Error {
     resources;
@@ -112,7 +114,7 @@ export function prepareYieldedRunExecution(toolName, params, options = {}) {
                     return await operation();
                 }
                 finally {
-                    unlinkOptional(windowsPidPath);
+                    removeWindowsProcessIdentity(windowsPidPath);
                 }
             }
             if (!shouldUseSystemd || !unitName)
@@ -145,130 +147,6 @@ export function prepareYieldedRunExecution(toolName, params, options = {}) {
         },
     };
 }
-export function windowsProcessTreeCommand(command, pidPath) {
-    const portablePidPath = pidPath.replaceAll("\\", "/");
-    return [
-        "__pibo_win_pid=\"$(ps -W | awk -v p=$$ 'NR > 1 && $1 == p { print $4; exit }')\"",
-        "if [ -z \"$__pibo_win_pid\" ]; then printf '%s\\n' 'Pibo could not identify the Windows Bash process.' >&2; exit 125; fi",
-        `printf '%s %s' "$$" "$__pibo_win_pid" > ${bashSingleQuote(portablePidPath)}`,
-        "unset __pibo_win_pid",
-        command,
-    ].join("\n");
-}
-async function terminateWindowsProcessTree(pidPath) {
-    const identity = await waitForWindowsProcessIdentity(pidPath);
-    if (!identity)
-        return;
-    try {
-        const rows = await listWindowsProcessTree(identity.msysPid);
-        for (const row of rows) {
-            try {
-                process.kill(row.windowsPid, "SIGKILL");
-            }
-            catch {
-                // The process may have exited between the snapshot and termination.
-            }
-        }
-        for (let attempt = 0; attempt < 100 && processIsAlive(identity.windowsPid); attempt += 1) {
-            await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-        }
-        if (processIsAlive(identity.windowsPid)) {
-            throw new Error(`Windows yielded-run process tree rooted at PID ${identity.windowsPid} is still active after termination.`);
-        }
-    }
-    finally {
-        unlinkOptional(pidPath);
-    }
-}
-async function waitForWindowsProcessIdentity(pidPath) {
-    for (let attempt = 0; attempt < 80; attempt += 1) {
-        try {
-            const match = readFileSync(pidPath, "utf8").trim().match(/^([1-9]\d*)\s+([1-9]\d*)$/);
-            if (match)
-                return { msysPid: Number(match[1]), windowsPid: Number(match[2]) };
-        }
-        catch {
-            // The Bash wrapper may still be starting.
-        }
-        await new Promise((resolveWait) => setTimeout(resolveWait, 25));
-    }
-    return undefined;
-}
-async function listWindowsProcessTree(rootMsysPid) {
-    const { stdout } = await execFileAsync(windowsBashExecutable(), ["-lc", "ps -W"], {
-        encoding: "utf8",
-        timeout: 5_000,
-        windowsHide: true,
-    });
-    const rows = stdout.split(/\r?\n/).flatMap((line) => {
-        const fields = line.trim().split(/\s+/);
-        if (fields.length < 4 || !fields.slice(0, 4).every((field) => /^\d+$/.test(field)))
-            return [];
-        return [{
-                msysPid: Number(fields[0]),
-                parentMsysPid: Number(fields[1]),
-                processGroupId: Number(fields[2]),
-                windowsPid: Number(fields[3]),
-            }];
-    });
-    const selected = new Set([rootMsysPid]);
-    for (let changed = true; changed;) {
-        changed = false;
-        for (const row of rows) {
-            if (selected.has(row.msysPid))
-                continue;
-            if (row.processGroupId === rootMsysPid || selected.has(row.parentMsysPid)) {
-                selected.add(row.msysPid);
-                changed = true;
-            }
-        }
-    }
-    return rows
-        .filter((row) => selected.has(row.msysPid) && row.windowsPid > 0)
-        .sort((left, right) => processTreeDepth(right, rows) - processTreeDepth(left, rows));
-}
-function processTreeDepth(row, rows) {
-    const byPid = new Map(rows.map((candidate) => [candidate.msysPid, candidate]));
-    let depth = 0;
-    let current = row;
-    const seen = new Set();
-    while (!seen.has(current.msysPid)) {
-        seen.add(current.msysPid);
-        const parent = byPid.get(current.parentMsysPid);
-        if (!parent)
-            break;
-        depth += 1;
-        current = parent;
-    }
-    return depth;
-}
-function windowsBashExecutable() {
-    const candidates = [
-        process.env.ProgramFiles ? join(process.env.ProgramFiles, "Git", "bin", "bash.exe") : undefined,
-        process.env["ProgramFiles(x86)"] ? join(process.env["ProgramFiles(x86)"], "Git", "bin", "bash.exe") : undefined,
-    ].filter((candidate) => Boolean(candidate));
-    return candidates.find((candidate) => existsSync(candidate)) ?? "bash.exe";
-}
-function processIsAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function unlinkOptional(path) {
-    try {
-        unlinkSync(path);
-    }
-    catch {
-        // Best-effort transient process metadata cleanup.
-    }
-}
-function bashSingleQuote(value) {
-    return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
 export function systemdRunCommand(command, unitName, policy, metricsPath = `/tmp/${unitName}.metrics`) {
     const captureScript = [
         '/bin/bash -c "$1"',