@poolzin/pool-bot 2026.2.17 → 2026.2.19

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+## v2026.2.19 (2026-02-17)
+
+### Fixes
+- **Build:** `pnpm build` now succeeds cleanly — added tsconfig excludes for `*.e2e-harness.ts`, `*-test-helpers.ts`, and `*.e2e-test-helpers.ts` patterns that caused TS6059 rootDir errors
+- **Audit:** verified all 37 extensions have `poolbot.plugin.json` manifests and supporting files (package.json, skills, READMEs) — no gaps found
+
+---
+
+## v2026.2.18 (2026-02-17)
+
+### Features
+- Upstream bulk port — 394 new production files + 52 modified files aligned with upstream:
+  - **Archive security hardening:** path traversal guards, symlink/hardlink blocking, entry count + byte budget limits, `preservePaths: false` + `strict: true` for tar extraction
+  - **Agent workspace:** `loadExtraBootstrapFiles()` with full security (path traversal guards, symlink resolution, basename allowlist)
+  - **Gateway channels:** `ChannelManager` restart tracking with `restartAttempts` map, `manuallyStopped` set, exponential backoff
+  - **Config CLI:** `runConfigGet`/`runConfigUnset` now accept injectable `RuntimeEnv`; `runConfigUnset` uses `snapshot.resolved` with `structuredClone` to prevent runtime defaults leaking into config file
+  - **Gateway auth:** rate limiting support (`rateLimited`, `retryAfterMs`), `"none" | "trusted-proxy"` auth modes
+  - **Mesh networking:** protocol schemas, validators, and server methods for mesh gateway federation
+  - **Subagent registry:** complete rewrite with announcement queue
+  - **Memory:** QMD search mode fallback, hybrid search backend config
+  - **Exec approvals:** normalized path signature for approval checks
+  - Plus 375+ new source files covering agents, CLI, config, cron, daemon, gateway, hooks, infra, media, routing, and more
+
+---
+
 ## v2026.2.17 (2026-02-17)
 
 ### Features

package/dist/agents/agent-scope.js

@@ -2,6 +2,7 @@ import os from "node:os";
 import path from "node:path";
 import { resolveStateDir } from "../config/paths.js";
 import { DEFAULT_AGENT_ID, normalizeAgentId, parseAgentSessionKey, } from "../routing/session-key.js";
+import { normalizeSkillFilter } from "./skills/filter.js";
 import { resolveUserPath } from "../utils.js";
 import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
 export { resolveAgentIdFromSessionKey } from "../routing/session-key.js";
@@ -76,6 +77,9 @@ export function resolveAgentConfig(cfg, agentId) {
         tools: entry.tools,
     };
 }
+export function resolveAgentSkillsFilter(cfg, agentId) {
+    return normalizeSkillFilter(resolveAgentConfig(cfg, agentId)?.skills);
+}
 export function resolveAgentModelPrimary(cfg, agentId) {
     const raw = resolveAgentConfig(cfg, agentId)?.model;
     if (!raw)

package/dist/agents/announce-idempotency.js

@@ -0,0 +1,14 @@
+export function buildAnnounceIdFromChildRun(params) {
+    return `v1:${params.childSessionKey}:${params.childRunId}`;
+}
+export function buildAnnounceIdempotencyKey(announceId) {
+    return `announce:${announceId}`;
+}
+export function resolveQueueAnnounceId(params) {
+    const announceId = params.announceId?.trim();
+    if (announceId) {
+        return announceId;
+    }
+    // Backward-compatible fallback for queue items that predate announceId.
+    return `legacy:${params.sessionKey}:${params.enqueuedAt}`;
+}

package/dist/agents/auth-profiles.resolve-auth-profile-order.fixtures.js

@@ -0,0 +1,23 @@
+export const ANTHROPIC_STORE = {
+    version: 1,
+    profiles: {
+        "anthropic:default": {
+            type: "api_key",
+            provider: "anthropic",
+            key: "sk-default",
+        },
+        "anthropic:work": {
+            type: "api_key",
+            provider: "anthropic",
+            key: "sk-work",
+        },
+    },
+};
+export const ANTHROPIC_CFG = {
+    auth: {
+        profiles: {
+            "anthropic:default": { provider: "anthropic", mode: "api_key" },
+            "anthropic:work": { provider: "anthropic", mode: "api_key" },
+        },
+    },
+};

package/dist/agents/bash-tools.exec-runtime.js

@@ -0,0 +1,438 @@
+import path from "node:path";
+import { Type } from "@sinclair/typebox";
+import { requestHeartbeatNow } from "../infra/heartbeat-wake.js";
+import { mergePathPrepend } from "../infra/path-prepend.js";
+import { enqueueSystemEvent } from "../infra/system-events.js";
+export { applyPathPrepend, normalizePathPrepend } from "../infra/path-prepend.js";
+import { logWarn } from "../logger.js";
+import { getProcessSupervisor } from "../process/supervisor/index.js";
+import { addSession, appendOutput, createSessionSlug, markExited, tail, } from "./bash-process-registry.js";
+import { buildDockerExecArgs, chunkString, clampWithDefault, readEnvInt, } from "./bash-tools.shared.js";
+import { buildCursorPositionResponse, stripDsrRequests } from "./pty-dsr.js";
+import { getShellConfig, sanitizeBinaryOutput } from "./shell-utils.js";
+// Security: Blocklist of environment variables that could alter execution flow
+// or inject code when running on non-sandboxed hosts (Gateway/Node).
+const DANGEROUS_HOST_ENV_VARS = new Set([
+    "LD_PRELOAD",
+    "LD_LIBRARY_PATH",
+    "LD_AUDIT",
+    "DYLD_INSERT_LIBRARIES",
+    "DYLD_LIBRARY_PATH",
+    "NODE_OPTIONS",
+    "NODE_PATH",
+    "PYTHONPATH",
+    "PYTHONHOME",
+    "RUBYLIB",
+    "PERL5LIB",
+    "BASH_ENV",
+    "ENV",
+    "GCONV_PATH",
+    "IFS",
+    "SSLKEYLOGFILE",
+]);
+const DANGEROUS_HOST_ENV_PREFIXES = ["DYLD_", "LD_"];
+// Centralized sanitization helper.
+// Throws an error if dangerous variables or PATH modifications are detected on the host.
+export function validateHostEnv(env) {
+    for (const key of Object.keys(env)) {
+        const upperKey = key.toUpperCase();
+        // 1. Block known dangerous variables (Fail Closed)
+        if (DANGEROUS_HOST_ENV_PREFIXES.some((prefix) => upperKey.startsWith(prefix))) {
+            throw new Error(`Security Violation: Environment variable '${key}' is forbidden during host execution.`);
+        }
+        if (DANGEROUS_HOST_ENV_VARS.has(upperKey)) {
+            throw new Error(`Security Violation: Environment variable '${key}' is forbidden during host execution.`);
+        }
+        // 2. Strictly block PATH modification on host
+        // Allowing custom PATH on the gateway/node can lead to binary hijacking.
+        if (upperKey === "PATH") {
+            throw new Error("Security Violation: Custom 'PATH' variable is forbidden during host execution.");
+        }
+    }
+}
+export const DEFAULT_MAX_OUTPUT = clampWithDefault(readEnvInt("PI_BASH_MAX_OUTPUT_CHARS"), 200_000, 1_000, 200_000);
+export const DEFAULT_PENDING_MAX_OUTPUT = clampWithDefault(readEnvInt("POOLBOT_BASH_PENDING_MAX_OUTPUT_CHARS"), 30_000, 1_000, 200_000);
+export const DEFAULT_PATH = process.env.PATH ?? "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+export const DEFAULT_NOTIFY_TAIL_CHARS = 400;
+const DEFAULT_NOTIFY_SNIPPET_CHARS = 180;
+export const DEFAULT_APPROVAL_TIMEOUT_MS = 120_000;
+export const DEFAULT_APPROVAL_REQUEST_TIMEOUT_MS = 130_000;
+const DEFAULT_APPROVAL_RUNNING_NOTICE_MS = 10_000;
+const APPROVAL_SLUG_LENGTH = 8;
+export const execSchema = Type.Object({
+    command: Type.String({ description: "Shell command to execute" }),
+    workdir: Type.Optional(Type.String({ description: "Working directory (defaults to cwd)" })),
+    env: Type.Optional(Type.Record(Type.String(), Type.String())),
+    yieldMs: Type.Optional(Type.Number({
+        description: "Milliseconds to wait before backgrounding (default 10000)",
+    })),
+    background: Type.Optional(Type.Boolean({ description: "Run in background immediately" })),
+    timeout: Type.Optional(Type.Number({
+        description: "Timeout in seconds (optional, kills process on expiry)",
+    })),
+    pty: Type.Optional(Type.Boolean({
+        description: "Run in a pseudo-terminal (PTY) when available (TTY-required CLIs, coding agents)",
+    })),
+    elevated: Type.Optional(Type.Boolean({
+        description: "Run on the host with elevated permissions (if allowed)",
+    })),
+    host: Type.Optional(Type.String({
+        description: "Exec host (sandbox|gateway|node).",
+    })),
+    security: Type.Optional(Type.String({
+        description: "Exec security mode (deny|allowlist|full).",
+    })),
+    ask: Type.Optional(Type.String({
+        description: "Exec ask mode (off|on-miss|always).",
+    })),
+    node: Type.Optional(Type.String({
+        description: "Node id/name for host=node.",
+    })),
+});
+export function normalizeExecHost(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "sandbox" || normalized === "gateway" || normalized === "node") {
+        return normalized;
+    }
+    return null;
+}
+export function normalizeExecSecurity(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "deny" || normalized === "allowlist" || normalized === "full") {
+        return normalized;
+    }
+    return null;
+}
+export function normalizeExecAsk(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "off" || normalized === "on-miss" || normalized === "always") {
+        return normalized;
+    }
+    return null;
+}
+export function renderExecHostLabel(host) {
+    return host === "sandbox" ? "sandbox" : host === "gateway" ? "gateway" : "node";
+}
+export function normalizeNotifyOutput(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function compactNotifyOutput(value, maxChars = DEFAULT_NOTIFY_SNIPPET_CHARS) {
+    const normalized = normalizeNotifyOutput(value);
+    if (!normalized) {
+        return "";
+    }
+    if (normalized.length <= maxChars) {
+        return normalized;
+    }
+    const safe = Math.max(1, maxChars - 1);
+    return `${normalized.slice(0, safe)}…`;
+}
+export function applyShellPath(env, shellPath) {
+    if (!shellPath) {
+        return;
+    }
+    const entries = shellPath
+        .split(path.delimiter)
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (entries.length === 0) {
+        return;
+    }
+    const merged = mergePathPrepend(env.PATH, entries);
+    if (merged) {
+        env.PATH = merged;
+    }
+}
+function maybeNotifyOnExit(session, status) {
+    if (!session.backgrounded || !session.notifyOnExit || session.exitNotified) {
+        return;
+    }
+    const sessionKey = session.sessionKey?.trim();
+    if (!sessionKey) {
+        return;
+    }
+    session.exitNotified = true;
+    const exitLabel = session.exitSignal
+        ? `signal ${session.exitSignal}`
+        : `code ${session.exitCode ?? 0}`;
+    const output = compactNotifyOutput(tail(session.tail || session.aggregated || "", DEFAULT_NOTIFY_TAIL_CHARS));
+    if (status === "completed" && !output && session.notifyOnExitEmptySuccess !== true) {
+        return;
+    }
+    const summary = output
+        ? `Exec ${status} (${session.id.slice(0, 8)}, ${exitLabel}) :: ${output}`
+        : `Exec ${status} (${session.id.slice(0, 8)}, ${exitLabel})`;
+    enqueueSystemEvent(summary, { sessionKey });
+    requestHeartbeatNow({ reason: `exec:${session.id}:exit` });
+}
+export function createApprovalSlug(id) {
+    return id.slice(0, APPROVAL_SLUG_LENGTH);
+}
+export function resolveApprovalRunningNoticeMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return DEFAULT_APPROVAL_RUNNING_NOTICE_MS;
+    }
+    if (value <= 0) {
+        return 0;
+    }
+    return Math.floor(value);
+}
+export function emitExecSystemEvent(text, opts) {
+    const sessionKey = opts.sessionKey?.trim();
+    if (!sessionKey) {
+        return;
+    }
+    enqueueSystemEvent(text, { sessionKey, contextKey: opts.contextKey });
+    requestHeartbeatNow({ reason: "exec-event" });
+}
+export async function runExecProcess(opts) {
+    const startedAt = Date.now();
+    const sessionId = createSessionSlug();
+    const execCommand = opts.execCommand ?? opts.command;
+    const supervisor = getProcessSupervisor();
+    const session = {
+        id: sessionId,
+        command: opts.command,
+        scopeKey: opts.scopeKey,
+        sessionKey: opts.sessionKey,
+        notifyOnExit: opts.notifyOnExit,
+        notifyOnExitEmptySuccess: opts.notifyOnExitEmptySuccess === true,
+        exitNotified: false,
+        child: undefined,
+        stdin: undefined,
+        pid: undefined,
+        startedAt,
+        cwd: opts.workdir,
+        maxOutputChars: opts.maxOutput,
+        pendingMaxOutputChars: opts.pendingMaxOutput,
+        totalOutputChars: 0,
+        pendingStdout: [],
+        pendingStderr: [],
+        pendingStdoutChars: 0,
+        pendingStderrChars: 0,
+        aggregated: "",
+        tail: "",
+        exited: false,
+        exitCode: undefined,
+        exitSignal: undefined,
+        truncated: false,
+        backgrounded: false,
+    };
+    addSession(session);
+    const emitUpdate = () => {
+        if (!opts.onUpdate) {
+            return;
+        }
+        const tailText = session.tail || session.aggregated;
+        const warningText = opts.warnings.length ? `${opts.warnings.join("\n")}\n\n` : "";
+        opts.onUpdate({
+            content: [{ type: "text", text: warningText + (tailText || "") }],
+            details: {
+                status: "running",
+                sessionId,
+                pid: session.pid ?? undefined,
+                startedAt,
+                cwd: session.cwd,
+                tail: session.tail,
+            },
+        });
+    };
+    const handleStdout = (data) => {
+        const str = sanitizeBinaryOutput(data.toString());
+        for (const chunk of chunkString(str)) {
+            appendOutput(session, "stdout", chunk);
+            emitUpdate();
+        }
+    };
+    const handleStderr = (data) => {
+        const str = sanitizeBinaryOutput(data.toString());
+        for (const chunk of chunkString(str)) {
+            appendOutput(session, "stderr", chunk);
+            emitUpdate();
+        }
+    };
+    const timeoutMs = typeof opts.timeoutSec === "number" && opts.timeoutSec > 0
+        ? Math.floor(opts.timeoutSec * 1000)
+        : undefined;
+    const spawnSpec = (() => {
+        if (opts.sandbox) {
+            return {
+                mode: "child",
+                argv: [
+                    "docker",
+                    ...buildDockerExecArgs({
+                        containerName: opts.sandbox.containerName,
+                        command: execCommand,
+                        workdir: opts.containerWorkdir ?? opts.sandbox.containerWorkdir,
+                        env: opts.env,
+                        tty: opts.usePty,
+                    }),
+                ],
+                env: process.env,
+                stdinMode: opts.usePty ? "pipe-open" : "pipe-closed",
+            };
+        }
+        const { shell, args: shellArgs } = getShellConfig();
+        const childArgv = [shell, ...shellArgs, execCommand];
+        if (opts.usePty) {
+            return {
+                mode: "pty",
+                ptyCommand: execCommand,
+                childFallbackArgv: childArgv,
+                env: opts.env,
+                stdinMode: "pipe-open",
+            };
+        }
+        return {
+            mode: "child",
+            argv: childArgv,
+            env: opts.env,
+            stdinMode: "pipe-closed",
+        };
+    })();
+    let managedRun = null;
+    let usingPty = spawnSpec.mode === "pty";
+    const cursorResponse = buildCursorPositionResponse();
+    const onSupervisorStdout = (chunk) => {
+        if (usingPty) {
+            const { cleaned, requests } = stripDsrRequests(chunk);
+            if (requests > 0 && managedRun?.stdin) {
+                for (let i = 0; i < requests; i += 1) {
+                    managedRun.stdin.write(cursorResponse);
+                }
+            }
+            handleStdout(cleaned);
+            return;
+        }
+        handleStdout(chunk);
+    };
+    try {
+        const spawnBase = {
+            runId: sessionId,
+            sessionId: opts.sessionKey?.trim() || sessionId,
+            backendId: opts.sandbox ? "exec-sandbox" : "exec-host",
+            scopeKey: opts.scopeKey,
+            cwd: opts.workdir,
+            env: spawnSpec.env,
+            timeoutMs,
+            captureOutput: false,
+            onStdout: onSupervisorStdout,
+            onStderr: handleStderr,
+        };
+        managedRun =
+            spawnSpec.mode === "pty"
+                ? await supervisor.spawn({
+                    ...spawnBase,
+                    mode: "pty",
+                    ptyCommand: spawnSpec.ptyCommand,
+                })
+                : await supervisor.spawn({
+                    ...spawnBase,
+                    mode: "child",
+                    argv: spawnSpec.argv,
+                    stdinMode: spawnSpec.stdinMode,
+                });
+    }
+    catch (err) {
+        if (spawnSpec.mode === "pty") {
+            const warning = `Warning: PTY spawn failed (${String(err)}); retrying without PTY for \`${opts.command}\`.`;
+            logWarn(`exec: PTY spawn failed (${String(err)}); retrying without PTY for "${opts.command}".`);
+            opts.warnings.push(warning);
+            usingPty = false;
+            try {
+                managedRun = await supervisor.spawn({
+                    runId: sessionId,
+                    sessionId: opts.sessionKey?.trim() || sessionId,
+                    backendId: "exec-host",
+                    scopeKey: opts.scopeKey,
+                    mode: "child",
+                    argv: spawnSpec.childFallbackArgv,
+                    cwd: opts.workdir,
+                    env: spawnSpec.env,
+                    stdinMode: "pipe-open",
+                    timeoutMs,
+                    captureOutput: false,
+                    onStdout: handleStdout,
+                    onStderr: handleStderr,
+                });
+            }
+            catch (retryErr) {
+                markExited(session, null, null, "failed");
+                maybeNotifyOnExit(session, "failed");
+                throw retryErr;
+            }
+        }
+        else {
+            markExited(session, null, null, "failed");
+            maybeNotifyOnExit(session, "failed");
+            throw err;
+        }
+    }
+    session.stdin = managedRun.stdin;
+    session.pid = managedRun.pid;
+    const promise = managedRun
+        .wait()
+        .then((exit) => {
+        const durationMs = Date.now() - startedAt;
+        const isNormalExit = exit.reason === "exit";
+        const status = isNormalExit ? "completed" : "failed";
+        markExited(session, exit.exitCode, exit.exitSignal, status);
+        maybeNotifyOnExit(session, status);
+        if (!session.child && session.stdin) {
+            session.stdin.destroyed = true;
+        }
+        const aggregated = session.aggregated.trim();
+        if (status === "completed") {
+            const exitCode = exit.exitCode ?? 0;
+            const exitMsg = exitCode !== 0 ? `\n\n(Command exited with code ${exitCode})` : "";
+            return {
+                status: "completed",
+                exitCode,
+                exitSignal: exit.exitSignal,
+                durationMs,
+                aggregated: aggregated + exitMsg,
+                timedOut: false,
+            };
+        }
+        const reason = exit.reason === "overall-timeout"
+            ? `Command timed out after ${opts.timeoutSec} seconds`
+            : exit.reason === "no-output-timeout"
+                ? "Command timed out waiting for output"
+                : exit.exitSignal != null
+                    ? `Command aborted by signal ${exit.exitSignal}`
+                    : "Command aborted before exit code was captured";
+        return {
+            status: "failed",
+            exitCode: exit.exitCode,
+            exitSignal: exit.exitSignal,
+            durationMs,
+            aggregated,
+            timedOut: exit.timedOut,
+            reason: aggregated ? `${aggregated}\n\n${reason}` : reason,
+        };
+    })
+        .catch((err) => {
+        markExited(session, null, null, "failed");
+        maybeNotifyOnExit(session, "failed");
+        const aggregated = session.aggregated.trim();
+        const message = aggregated ? `${aggregated}\n\n${String(err)}` : String(err);
+        return {
+            status: "failed",
+            exitCode: null,
+            exitSignal: null,
+            durationMs: Date.now() - startedAt,
+            aggregated,
+            timedOut: false,
+            reason: message,
+        };
+    });
+    return {
+        session,
+        startedAt,
+        pid: session.pid ?? undefined,
+        promise,
+        kill: () => {
+            managedRun?.cancel("manual-cancel");
+        },
+    };
+}

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

@@ -197,3 +197,9 @@ export function pad(str, width) {
         return str;
     return str + " ".repeat(width - str.length);
 }
+export function clampWithDefault(value, defaultValue, min, max) {
+    if (value === undefined || Number.isNaN(value)) {
+        return defaultValue;
+    }
+    return Math.min(Math.max(value, min), max);
+}

package/dist/agents/cli-runner/reliability.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import { CLI_FRESH_WATCHDOG_DEFAULTS, CLI_RESUME_WATCHDOG_DEFAULTS, CLI_WATCHDOG_MIN_TIMEOUT_MS, } from "../cli-watchdog-defaults.js";
+function pickWatchdogProfile(backend, useResume) {
+    const defaults = useResume ? CLI_RESUME_WATCHDOG_DEFAULTS : CLI_FRESH_WATCHDOG_DEFAULTS;
+    const configured = useResume
+        ? backend.reliability?.watchdog?.resume
+        : backend.reliability?.watchdog?.fresh;
+    const ratio = (() => {
+        const value = configured?.noOutputTimeoutRatio;
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+            return defaults.noOutputTimeoutRatio;
+        }
+        return Math.max(0.05, Math.min(0.95, value));
+    })();
+    const minMs = (() => {
+        const value = configured?.minMs;
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+            return defaults.minMs;
+        }
+        return Math.max(CLI_WATCHDOG_MIN_TIMEOUT_MS, Math.floor(value));
+    })();
+    const maxMs = (() => {
+        const value = configured?.maxMs;
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+            return defaults.maxMs;
+        }
+        return Math.max(CLI_WATCHDOG_MIN_TIMEOUT_MS, Math.floor(value));
+    })();
+    return {
+        noOutputTimeoutMs: typeof configured?.noOutputTimeoutMs === "number" &&
+            Number.isFinite(configured.noOutputTimeoutMs)
+            ? Math.max(CLI_WATCHDOG_MIN_TIMEOUT_MS, Math.floor(configured.noOutputTimeoutMs))
+            : undefined,
+        noOutputTimeoutRatio: ratio,
+        minMs: Math.min(minMs, maxMs),
+        maxMs: Math.max(minMs, maxMs),
+    };
+}
+export function resolveCliNoOutputTimeoutMs(params) {
+    const profile = pickWatchdogProfile(params.backend, params.useResume);
+    // Keep watchdog below global timeout in normal cases.
+    const cap = Math.max(CLI_WATCHDOG_MIN_TIMEOUT_MS, params.timeoutMs - 1_000);
+    if (profile.noOutputTimeoutMs !== undefined) {
+        return Math.min(profile.noOutputTimeoutMs, cap);
+    }
+    const computed = Math.floor(params.timeoutMs * profile.noOutputTimeoutRatio);
+    const bounded = Math.min(profile.maxMs, Math.max(profile.minMs, computed));
+    return Math.min(bounded, cap);
+}
+export function buildCliSupervisorScopeKey(params) {
+    const commandToken = path
+        .basename(params.backend.command ?? "")
+        .trim()
+        .toLowerCase();
+    const backendToken = params.backendId.trim().toLowerCase();
+    const sessionToken = params.cliSessionId?.trim();
+    if (!sessionToken) {
+        return undefined;
+    }
+    return `cli:${backendToken}:${commandToken}:${sessionToken}`;
+}

package/dist/agents/cli-watchdog-defaults.js

@@ -0,0 +1,11 @@
+export const CLI_WATCHDOG_MIN_TIMEOUT_MS = 1_000;
+export const CLI_FRESH_WATCHDOG_DEFAULTS = {
+    noOutputTimeoutRatio: 0.8,
+    minMs: 180_000,
+    maxMs: 600_000,
+};
+export const CLI_RESUME_WATCHDOG_DEFAULTS = {
+    noOutputTimeoutRatio: 0.3,
+    minMs: 60_000,
+    maxMs: 180_000,
+};

package/dist/agents/command-poll-backoff.js

@@ -0,0 +1,63 @@
+// Exponential backoff schedule for command polling
+const BACKOFF_SCHEDULE_MS = [5000, 10000, 30000, 60000];
+/**
+ * Calculate suggested retry delay based on consecutive no-output poll count.
+ * Implements exponential backoff schedule: 5s → 10s → 30s → 60s (capped).
+ */
+export function calculateBackoffMs(consecutiveNoOutputPolls) {
+    const index = Math.min(consecutiveNoOutputPolls, BACKOFF_SCHEDULE_MS.length - 1);
+    return BACKOFF_SCHEDULE_MS[index] ?? 60000;
+}
+/**
+ * Record a command poll and return suggested retry delay.
+ * @param state Session state to track polling in
+ * @param commandId Unique identifier for the command being polled
+ * @param hasNewOutput Whether this poll returned new output
+ * @returns Suggested delay in milliseconds before next poll
+ */
+export function recordCommandPoll(state, commandId, hasNewOutput) {
+    if (!state.commandPollCounts) {
+        state.commandPollCounts = new Map();
+    }
+    const existing = state.commandPollCounts.get(commandId);
+    const now = Date.now();
+    if (hasNewOutput) {
+        state.commandPollCounts.set(commandId, { count: 0, lastPollAt: now });
+        return BACKOFF_SCHEDULE_MS[0] ?? 5000;
+    }
+    const newCount = (existing?.count ?? -1) + 1;
+    state.commandPollCounts.set(commandId, { count: newCount, lastPollAt: now });
+    return calculateBackoffMs(newCount);
+}
+/**
+ * Get current suggested backoff for a command without modifying state.
+ * Useful for checking current backoff level.
+ */
+export function getCommandPollSuggestion(state, commandId) {
+    const pollData = state.commandPollCounts?.get(commandId);
+    if (!pollData) {
+        return undefined;
+    }
+    return calculateBackoffMs(pollData.count);
+}
+/**
+ * Reset poll count for a command (e.g., when command completes).
+ */
+export function resetCommandPollCount(state, commandId) {
+    state.commandPollCounts?.delete(commandId);
+}
+/**
+ * Prune stale command poll records (older than 1 hour).
+ * Call periodically to prevent memory bloat.
+ */
+export function pruneStaleCommandPolls(state, maxAgeMs = 3600000) {
+    if (!state.commandPollCounts) {
+        return;
+    }
+    const now = Date.now();
+    for (const [commandId, data] of state.commandPollCounts.entries()) {
+        if (now - data.lastPollAt > maxAgeMs) {
+            state.commandPollCounts.delete(commandId);
+        }
+    }
+}

package/dist/agents/current-time.js

@@ -0,0 +1,16 @@
+import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone, } from "./date-time.js";
+export function resolveCronStyleNow(cfg, nowMs) {
+    const userTimezone = resolveUserTimezone(cfg.agents?.defaults?.userTimezone);
+    const userTimeFormat = resolveUserTimeFormat(cfg.agents?.defaults?.timeFormat);
+    const formattedTime = formatUserTime(new Date(nowMs), userTimezone, userTimeFormat) ?? new Date(nowMs).toISOString();
+    const timeLine = `Current time: ${formattedTime} (${userTimezone})`;
+    return { userTimezone, formattedTime, timeLine };
+}
+export function appendCronStyleCurrentTimeLine(text, cfg, nowMs) {
+    const base = text.trimEnd();
+    if (!base || base.includes("Current time:")) {
+        return base;
+    }
+    const { timeLine } = resolveCronStyleNow(cfg, nowMs);
+    return `${base}\n${timeLine}`;
+}