@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/agents/bash-tools.process.js

@@ -1,7 +1,28 @@
 import { Type } from "@sinclair/typebox";
+import { formatDurationCompact } from "../infra/format-time/format-duration.js";
+import { getDiagnosticSessionState } from "../logging/diagnostic-session-state.js";
+import { killProcessTree } from "../process/kill-tree.js";
+import { getProcessSupervisor } from "../process/supervisor/index.js";
 import { deleteSession, drainSession, getFinishedSession, getSession, listFinishedSessions, listRunningSessions, markExited, setJobTtlMs, } from "./bash-process-registry.js";
-import { deriveSessionName, formatDuration, killSession, pad, sliceLogLines, truncateMiddle, } from "./bash-tools.shared.js";
+import { deriveSessionName, pad, sliceLogLines, truncateMiddle } from "./bash-tools.shared.js";
+import { recordCommandPoll, resetCommandPollCount } from "./command-poll-backoff.js";
 import { encodeKeySequence, encodePaste } from "./pty-keys.js";
+const DEFAULT_LOG_TAIL_LINES = 200;
+function resolveLogSliceWindow(offset, limit) {
+    const usingDefaultTail = offset === undefined && limit === undefined;
+    const effectiveLimit = typeof limit === "number" && Number.isFinite(limit)
+        ? limit
+        : usingDefaultTail
+            ? DEFAULT_LOG_TAIL_LINES
+            : undefined;
+    return { effectiveOffset: offset, effectiveLimit, usingDefaultTail };
+}
+function defaultTailNote(totalLines, usingDefaultTail) {
+    if (!usingDefaultTail || totalLines <= DEFAULT_LOG_TAIL_LINES) {
+        return "";
+    }
+    return `\n\n[showing last ${DEFAULT_LOG_TAIL_LINES} of ${totalLines} lines; pass offset/limit to page]`;
+}
 const processSchema = Type.Object({
     action: Type.String({ description: "Process action" }),
     sessionId: Type.Optional(Type.String({ description: "Session id for actions other than list" })),
@@ -14,13 +35,76 @@ const processSchema = Type.Object({
     eof: Type.Optional(Type.Boolean({ description: "Close stdin after write" })),
     offset: Type.Optional(Type.Number({ description: "Log offset" })),
     limit: Type.Optional(Type.Number({ description: "Log length" })),
+    timeout: Type.Optional(Type.Number({
+        description: "For poll: wait up to this many milliseconds before returning",
+        minimum: 0,
+    })),
 });
+const MAX_POLL_WAIT_MS = 120_000;
+function resolvePollWaitMs(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return Math.max(0, Math.min(MAX_POLL_WAIT_MS, Math.floor(value)));
+    }
+    if (typeof value === "string") {
+        const parsed = Number.parseInt(value.trim(), 10);
+        if (Number.isFinite(parsed)) {
+            return Math.max(0, Math.min(MAX_POLL_WAIT_MS, parsed));
+        }
+    }
+    return 0;
+}
+function failText(text) {
+    return {
+        content: [
+            {
+                type: "text",
+                text,
+            },
+        ],
+        details: { status: "failed" },
+    };
+}
+function recordPollRetrySuggestion(sessionId, hasNewOutput) {
+    try {
+        const sessionState = getDiagnosticSessionState({ sessionId });
+        return recordCommandPoll(sessionState, sessionId, hasNewOutput);
+    }
+    catch {
+        return undefined;
+    }
+}
+function resetPollRetrySuggestion(sessionId) {
+    try {
+        const sessionState = getDiagnosticSessionState({ sessionId });
+        resetCommandPollCount(sessionState, sessionId);
+    }
+    catch {
+        // Ignore diagnostics state failures for process tool behavior.
+    }
+}
 export function createProcessTool(defaults) {
     if (defaults?.cleanupMs !== undefined) {
         setJobTtlMs(defaults.cleanupMs);
     }
     const scopeKey = defaults?.scopeKey;
+    const supervisor = getProcessSupervisor();
     const isInScope = (session) => !scopeKey || session?.scopeKey === scopeKey;
+    const cancelManagedSession = (sessionId) => {
+        const record = supervisor.getRecord(sessionId);
+        if (!record || record.state === "exited") {
+            return false;
+        }
+        supervisor.cancel(sessionId, "manual-cancel");
+        return true;
+    };
+    const terminateSessionFallback = (session) => {
+        const pid = session.pid ?? session.child?.pid;
+        if (typeof pid !== "number" || !Number.isFinite(pid) || pid <= 0) {
+            return false;
+        }
+        killProcessTree(pid);
+        return true;
+    };
     return {
         name: "process",
         label: "process",
@@ -60,10 +144,10 @@ export function createProcessTool(defaults) {
                     exitSignal: s.exitSignal ?? undefined,
                 }));
                 const lines = [...running, ...finished]
-                    .sort((a, b) => b.startedAt - a.startedAt)
+                    .toSorted((a, b) => b.startedAt - a.startedAt)
                     .map((s) => {
                     const label = s.name ? truncateMiddle(s.name, 80) : truncateMiddle(s.command, 120);
-                    return `${s.sessionId} ${pad(s.status, 9)} ${formatDuration(s.runtimeMs)} :: ${label}`;
+                    return `${s.sessionId} ${pad(s.status, 9)} ${formatDurationCompact(s.runtimeMs) ?? "n/a"} :: ${label}`;
                 });
                 return {
                     content: [
@@ -85,10 +169,49 @@ export function createProcessTool(defaults) {
             const finished = getFinishedSession(params.sessionId);
             const scopedSession = isInScope(session) ? session : undefined;
             const scopedFinished = isInScope(finished) ? finished : undefined;
+            const failedResult = (text) => ({
+                content: [{ type: "text", text }],
+                details: { status: "failed" },
+            });
+            const resolveBackgroundedWritableStdin = () => {
+                if (!scopedSession) {
+                    return {
+                        ok: false,
+                        result: failedResult(`No active session found for ${params.sessionId}`),
+                    };
+                }
+                if (!scopedSession.backgrounded) {
+                    return {
+                        ok: false,
+                        result: failedResult(`Session ${params.sessionId} is not backgrounded.`),
+                    };
+                }
+                const stdin = scopedSession.stdin ?? scopedSession.child?.stdin;
+                if (!stdin || stdin.destroyed) {
+                    return {
+                        ok: false,
+                        result: failedResult(`Session ${params.sessionId} stdin is not writable.`),
+                    };
+                }
+                return { ok: true, session: scopedSession, stdin: stdin };
+            };
+            const writeToStdin = async (stdin, data) => {
+                await new Promise((resolve, reject) => {
+                    stdin.write(data, (err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            };
             switch (params.action) {
                 case "poll": {
                     if (!scopedSession) {
                         if (scopedFinished) {
+                            resetPollRetrySuggestion(params.sessionId);
                             return {
                                 content: [
                                     {
@@ -109,26 +232,18 @@ export function createProcessTool(defaults) {
                                 },
                             };
                         }
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `No session found for ${params.sessionId}`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
+                        resetPollRetrySuggestion(params.sessionId);
+                        return failText(`No session found for ${params.sessionId}`);
                     }
                     if (!scopedSession.backgrounded) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} is not backgrounded.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
+                        return failText(`Session ${params.sessionId} is not backgrounded.`);
+                    }
+                    const pollWaitMs = resolvePollWaitMs(params.timeout);
+                    if (pollWaitMs > 0 && !scopedSession.exited) {
+                        const deadline = Date.now() + pollWaitMs;
+                        while (!scopedSession.exited && Date.now() < deadline) {
+                            await new Promise((resolve) => setTimeout(resolve, Math.min(250, deadline - Date.now())));
+                        }
                     }
                     const { stdout, stderr } = drainSession(scopedSession);
                     const exited = scopedSession.exited;
@@ -144,6 +259,13 @@ export function createProcessTool(defaults) {
                             : "failed"
                         : "running";
                     const output = [stdout.trimEnd(), stderr.trimEnd()].filter(Boolean).join("\n").trim();
+                    const hasNewOutput = output.length > 0;
+                    const retryInMs = exited
+                        ? undefined
+                        : recordPollRetrySuggestion(params.sessionId, hasNewOutput);
+                    if (exited) {
+                        resetPollRetrySuggestion(params.sessionId);
+                    }
                     return {
                         content: [
                             {
@@ -160,6 +282,7 @@ export function createProcessTool(defaults) {
                             exitCode: exited ? exitCode : undefined,
                             aggregated: scopedSession.aggregated,
                             name: deriveSessionName(scopedSession.command),
+                            ...(typeof retryInMs === "number" ? { retryInMs } : {}),
                         },
                     };
                 }
@@ -176,9 +299,13 @@ export function createProcessTool(defaults) {
                                 details: { status: "failed" },
                             };
                         }
-                        const { slice, totalLines, totalChars } = sliceLogLines(scopedSession.aggregated, params.offset, params.limit);
+                        const window = resolveLogSliceWindow(params.offset, params.limit);
+                        const { slice, totalLines, totalChars } = sliceLogLines(scopedSession.aggregated, window.effectiveOffset, window.effectiveLimit);
+                        const logDefaultTailNote = defaultTailNote(totalLines, window.usingDefaultTail);
                         return {
-                            content: [{ type: "text", text: slice || "(no output yet)" }],
+                            content: [
+                                { type: "text", text: (slice || "(no output yet)") + logDefaultTailNote },
+                            ],
                             details: {
                                 status: scopedSession.exited ? "completed" : "running",
                                 sessionId: params.sessionId,
@@ -191,10 +318,17 @@ export function createProcessTool(defaults) {
                         };
                     }
                     if (scopedFinished) {
-                        const { slice, totalLines, totalChars } = sliceLogLines(scopedFinished.aggregated, params.offset, params.limit);
+                        const window = resolveLogSliceWindow(params.offset, params.limit);
+                        const { slice, totalLines, totalChars } = sliceLogLines(scopedFinished.aggregated, window.effectiveOffset, window.effectiveLimit);
                         const status = scopedFinished.status === "completed" ? "completed" : "failed";
+                        const logDefaultTailNote = defaultTailNote(totalLines, window.usingDefaultTail);
                         return {
-                            content: [{ type: "text", text: slice || "(no output recorded)" }],
+                            content: [
+                                {
+                                    type: "text",
+                                    text: (slice || "(no output recorded)") + logDefaultTailNote,
+                                },
+                            ],
                             details: {
                                 status,
                                 sessionId: params.sessionId,
@@ -219,50 +353,13 @@ export function createProcessTool(defaults) {
                     };
                 }
                 case "write": {
-                    if (!scopedSession) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `No active session found for ${params.sessionId}`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
+                    const resolved = resolveBackgroundedWritableStdin();
+                    if (!resolved.ok) {
+                        return resolved.result;
                     }
-                    if (!scopedSession.backgrounded) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} is not backgrounded.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
-                    }
-                    const stdin = scopedSession.stdin ?? scopedSession.child?.stdin;
-                    if (!stdin || stdin.destroyed) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} stdin is not writable.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
-                    }
-                    await new Promise((resolve, reject) => {
-                        stdin.write(params.data ?? "", (err) => {
-                            if (err)
-                                reject(err);
-                            else
-                                resolve();
-                        });
-                    });
+                    await writeToStdin(resolved.stdin, params.data ?? "");
                     if (params.eof) {
-                        stdin.end();
+                        resolved.stdin.end();
                     }
                     return {
                         content: [
@@ -274,44 +371,14 @@ export function createProcessTool(defaults) {
                         details: {
                             status: "running",
                             sessionId: params.sessionId,
-                            name: scopedSession ? deriveSessionName(scopedSession.command) : undefined,
+                            name: deriveSessionName(resolved.session.command),
                         },
                     };
                 }
                 case "send-keys": {
-                    if (!scopedSession) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `No active session found for ${params.sessionId}`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
-                    }
-                    if (!scopedSession.backgrounded) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} is not backgrounded.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
-                    }
-                    const stdin = scopedSession.stdin ?? scopedSession.child?.stdin;
-                    if (!stdin || stdin.destroyed) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} stdin is not writable.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
+                    const resolved = resolveBackgroundedWritableStdin();
+                    if (!resolved.ok) {
+                        return resolved.result;
                     }
                     const { data, warnings } = encodeKeySequence({
                         keys: params.keys,
@@ -329,14 +396,7 @@ export function createProcessTool(defaults) {
                             details: { status: "failed" },
                         };
                     }
-                    await new Promise((resolve, reject) => {
-                        stdin.write(data, (err) => {
-                            if (err)
-                                reject(err);
-                            else
-                                resolve();
-                        });
-                    });
+                    await writeToStdin(resolved.stdin, data);
                     return {
                         content: [
                             {
@@ -348,53 +408,16 @@ export function createProcessTool(defaults) {
                         details: {
                             status: "running",
                             sessionId: params.sessionId,
-                            name: scopedSession ? deriveSessionName(scopedSession.command) : undefined,
+                            name: deriveSessionName(resolved.session.command),
                         },
                     };
                 }
                 case "submit": {
-                    if (!scopedSession) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `No active session found for ${params.sessionId}`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
+                    const resolved = resolveBackgroundedWritableStdin();
+                    if (!resolved.ok) {
+                        return resolved.result;
                     }
-                    if (!scopedSession.backgrounded) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} is not backgrounded.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
-                    }
-                    const stdin = scopedSession.stdin ?? scopedSession.child?.stdin;
-                    if (!stdin || stdin.destroyed) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} stdin is not writable.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
-                    }
-                    await new Promise((resolve, reject) => {
-                        stdin.write("\r", (err) => {
-                            if (err)
-                                reject(err);
-                            else
-                                resolve();
-                        });
-                    });
+                    await writeToStdin(resolved.stdin, "\r");
                     return {
                         content: [
                             {
@@ -405,44 +428,14 @@ export function createProcessTool(defaults) {
                         details: {
                             status: "running",
                             sessionId: params.sessionId,
-                            name: scopedSession ? deriveSessionName(scopedSession.command) : undefined,
+                            name: deriveSessionName(resolved.session.command),
                         },
                     };
                 }
                 case "paste": {
-                    if (!scopedSession) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `No active session found for ${params.sessionId}`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
-                    }
-                    if (!scopedSession.backgrounded) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} is not backgrounded.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
-                    }
-                    const stdin = scopedSession.stdin ?? scopedSession.child?.stdin;
-                    if (!stdin || stdin.destroyed) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} stdin is not writable.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
+                    const resolved = resolveBackgroundedWritableStdin();
+                    if (!resolved.ok) {
+                        return resolved.result;
                     }
                     const payload = encodePaste(params.text ?? "", params.bracketed !== false);
                     if (!payload) {
@@ -456,14 +449,7 @@ export function createProcessTool(defaults) {
                             details: { status: "failed" },
                         };
                     }
-                    await new Promise((resolve, reject) => {
-                        stdin.write(payload, (err) => {
-                            if (err)
-                                reject(err);
-                            else
-                                resolve();
-                        });
-                    });
+                    await writeToStdin(resolved.stdin, payload);
                     return {
                         content: [
                             {
@@ -474,37 +460,35 @@ export function createProcessTool(defaults) {
                         details: {
                             status: "running",
                             sessionId: params.sessionId,
-                            name: scopedSession ? deriveSessionName(scopedSession.command) : undefined,
+                            name: deriveSessionName(resolved.session.command),
                         },
                     };
                 }
                 case "kill": {
                     if (!scopedSession) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `No active session found for ${params.sessionId}`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
+                        return failText(`No active session found for ${params.sessionId}`);
                     }
                     if (!scopedSession.backgrounded) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Session ${params.sessionId} is not backgrounded.`,
-                                },
-                            ],
-                            details: { status: "failed" },
-                        };
+                        return failText(`Session ${params.sessionId} is not backgrounded.`);
+                    }
+                    const canceled = cancelManagedSession(scopedSession.id);
+                    if (!canceled) {
+                        const terminated = terminateSessionFallback(scopedSession);
+                        if (!terminated) {
+                            return failText(`Unable to terminate session ${params.sessionId}: no active supervisor run or process id.`);
+                        }
+                        markExited(scopedSession, null, "SIGKILL", "failed");
                     }
-                    killSession(scopedSession);
-                    markExited(scopedSession, null, "SIGKILL", "failed");
+                    resetPollRetrySuggestion(params.sessionId);
                     return {
-                        content: [{ type: "text", text: `Killed session ${params.sessionId}.` }],
+                        content: [
+                            {
+                                type: "text",
+                                text: canceled
+                                    ? `Termination requested for session ${params.sessionId}.`
+                                    : `Killed session ${params.sessionId}.`,
+                            },
+                        ],
                         details: {
                             status: "failed",
                             name: scopedSession ? deriveSessionName(scopedSession.command) : undefined,
@@ -513,6 +497,7 @@ export function createProcessTool(defaults) {
                 }
                 case "clear": {
                     if (scopedFinished) {
+                        resetPollRetrySuggestion(params.sessionId);
                         deleteSession(params.sessionId);
                         return {
                             content: [{ type: "text", text: `Cleared session ${params.sessionId}.` }],
@@ -531,10 +516,30 @@ export function createProcessTool(defaults) {
                 }
                 case "remove": {
                     if (scopedSession) {
-                        killSession(scopedSession);
-                        markExited(scopedSession, null, "SIGKILL", "failed");
+                        const canceled = cancelManagedSession(scopedSession.id);
+                        if (canceled) {
+                            // Keep remove semantics deterministic: drop from process registry now.
+                            scopedSession.backgrounded = false;
+                            deleteSession(params.sessionId);
+                        }
+                        else {
+                            const terminated = terminateSessionFallback(scopedSession);
+                            if (!terminated) {
+                                return failText(`Unable to remove session ${params.sessionId}: no active supervisor run or process id.`);
+                            }
+                            markExited(scopedSession, null, "SIGKILL", "failed");
+                            deleteSession(params.sessionId);
+                        }
+                        resetPollRetrySuggestion(params.sessionId);
                         return {
-                            content: [{ type: "text", text: `Removed session ${params.sessionId}.` }],
+                            content: [
+                                {
+                                    type: "text",
+                                    text: canceled
+                                        ? `Removed session ${params.sessionId} (termination requested).`
+                                        : `Removed session ${params.sessionId}.`,
+                                },
+                            ],
                             details: {
                                 status: "failed",
                                 name: scopedSession ? deriveSessionName(scopedSession.command) : undefined,
@@ -542,6 +547,7 @@ export function createProcessTool(defaults) {
                         };
                     }
                     if (scopedFinished) {
+                        resetPollRetrySuggestion(params.sessionId);
                         deleteSession(params.sessionId);
                         return {
                             content: [{ type: "text", text: `Removed session ${params.sessionId}.` }],

package/dist/agents/bedrock-discovery.js

@@ -1,4 +1,6 @@
 import { BedrockClient, ListFoundationModelsCommand, } from "@aws-sdk/client-bedrock";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("bedrock-discovery");
 const DEFAULT_REFRESH_INTERVAL_SECONDS = 3600;
 const DEFAULT_CONTEXT_WINDOW = 32000;
 const DEFAULT_MAX_TOKENS = 4096;
@@ -150,7 +152,7 @@ export async function discoverBedrockModels(params) {
         }
         if (!hasLoggedBedrockError) {
             hasLoggedBedrockError = true;
-            console.warn(`[bedrock-discovery] Failed to list models: ${String(error)}`);
+            log.warn(`Failed to list models: ${String(error)}`);
         }
         return [];
     }