@poolzin/pool-bot 2026.2.17 → 2026.2.18

package/dist/agents/workspace.js

@@ -227,6 +227,76 @@ export async function loadWorkspaceBootstrapFiles(dir) {
     return result;
 }
 const SUBAGENT_BOOTSTRAP_ALLOWLIST = new Set([DEFAULT_AGENTS_FILENAME, DEFAULT_TOOLS_FILENAME]);
+const VALID_BOOTSTRAP_NAMES = new Set([
+    DEFAULT_AGENTS_FILENAME,
+    DEFAULT_SOUL_FILENAME,
+    DEFAULT_TOOLS_FILENAME,
+    DEFAULT_IDENTITY_FILENAME,
+    DEFAULT_USER_FILENAME,
+    DEFAULT_HEARTBEAT_FILENAME,
+    DEFAULT_BOOTSTRAP_FILENAME,
+    DEFAULT_MEMORY_FILENAME,
+    DEFAULT_MEMORY_ALT_FILENAME,
+]);
+export async function loadExtraBootstrapFiles(dir, extraPatterns) {
+    if (!extraPatterns.length) {
+        return [];
+    }
+    const resolvedDir = resolveUserPath(dir);
+    let realResolvedDir = resolvedDir;
+    try {
+        realResolvedDir = await fs.realpath(resolvedDir);
+    }
+    catch {
+        // Keep lexical root if realpath fails.
+    }
+    const resolvedPaths = new Set();
+    for (const pattern of extraPatterns) {
+        if (pattern.includes("*") || pattern.includes("?") || pattern.includes("{")) {
+            try {
+                const matches = fs.glob(pattern, { cwd: resolvedDir });
+                for await (const m of matches) {
+                    resolvedPaths.add(m);
+                }
+            }
+            catch {
+                resolvedPaths.add(pattern);
+            }
+        }
+        else {
+            resolvedPaths.add(pattern);
+        }
+    }
+    const result = [];
+    for (const relPath of resolvedPaths) {
+        const filePath = path.resolve(resolvedDir, relPath);
+        if (!filePath.startsWith(resolvedDir + path.sep) && filePath !== resolvedDir) {
+            continue;
+        }
+        try {
+            const realFilePath = await fs.realpath(filePath);
+            if (!realFilePath.startsWith(realResolvedDir + path.sep) &&
+                realFilePath !== realResolvedDir) {
+                continue;
+            }
+            const baseName = path.basename(relPath);
+            if (!VALID_BOOTSTRAP_NAMES.has(baseName)) {
+                continue;
+            }
+            const content = await fs.readFile(realFilePath, "utf-8");
+            result.push({
+                name: baseName,
+                path: filePath,
+                content,
+                missing: false,
+            });
+        }
+        catch {
+            // Silently skip missing extra files
+        }
+    }
+    return result;
+}
 export function filterBootstrapFilesForSession(files, sessionKey) {
     if (!sessionKey || !isSubagentSessionKey(sessionKey))
         return files;

package/dist/auto-reply/heartbeat-reply-payload.js

@@ -0,0 +1,18 @@
+export function resolveHeartbeatReplyPayload(replyResult) {
+    if (!replyResult) {
+        return undefined;
+    }
+    if (!Array.isArray(replyResult)) {
+        return replyResult;
+    }
+    for (let idx = replyResult.length - 1; idx >= 0; idx -= 1) {
+        const payload = replyResult[idx];
+        if (!payload) {
+            continue;
+        }
+        if (payload.text || payload.mediaUrl || (payload.mediaUrls && payload.mediaUrls.length > 0)) {
+            return payload;
+        }
+    }
+    return undefined;
+}

package/dist/auto-reply/reply/commands-export-session.js

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { SessionManager } from "@mariozechner/pi-coding-agent";
+import { resolveDefaultSessionStorePath, resolveSessionFilePath, } from "../../config/sessions/paths.js";
+import { loadSessionStore } from "../../config/sessions/store.js";
+import { resolveCommandsSystemPromptBundle } from "./commands-system-prompt.js";
+// Export HTML templates are bundled with this module
+const EXPORT_HTML_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), "export-html");
+function loadTemplate(fileName) {
+    return fs.readFileSync(path.join(EXPORT_HTML_DIR, fileName), "utf-8");
+}
+function generateHtml(sessionData) {
+    const template = loadTemplate("template.html");
+    const templateCss = loadTemplate("template.css");
+    const templateJs = loadTemplate("template.js");
+    const markedJs = loadTemplate(path.join("vendor", "marked.min.js"));
+    const hljsJs = loadTemplate(path.join("vendor", "highlight.min.js"));
+    // Use pi-mono dark theme colors (matching their theme/dark.json)
+    const themeVars = `
+    --cyan: #00d7ff;
+    --blue: #5f87ff;
+    --green: #b5bd68;
+    --red: #cc6666;
+    --yellow: #ffff00;
+    --gray: #808080;
+    --dimGray: #666666;
+    --darkGray: #505050;
+    --accent: #8abeb7;
+    --selectedBg: #3a3a4a;
+    --userMsgBg: #343541;
+    --toolPendingBg: #282832;
+    --toolSuccessBg: #283228;
+    --toolErrorBg: #3c2828;
+    --customMsgBg: #2d2838;
+    --text: #e0e0e0;
+    --dim: #666666;
+    --muted: #808080;
+    --border: #5f87ff;
+    --borderAccent: #00d7ff;
+    --borderMuted: #505050;
+    --success: #b5bd68;
+    --error: #cc6666;
+    --warning: #ffff00;
+    --thinkingText: #808080;
+    --userMessageBg: #343541;
+    --userMessageText: #e0e0e0;
+    --customMessageBg: #2d2838;
+    --customMessageText: #e0e0e0;
+    --customMessageLabel: #9575cd;
+    --toolTitle: #e0e0e0;
+    --toolOutput: #808080;
+    --mdHeading: #f0c674;
+    --mdLink: #81a2be;
+    --mdLinkUrl: #666666;
+    --mdCode: #8abeb7;
+    --mdCodeBlock: #b5bd68;
+  `;
+    const bodyBg = "#1e1e28";
+    const containerBg = "#282832";
+    const infoBg = "#343541";
+    // Base64 encode session data
+    const sessionDataBase64 = Buffer.from(JSON.stringify(sessionData)).toString("base64");
+    // Build CSS with theme variables
+    const css = templateCss
+        .replace("/* {{THEME_VARS}} */", themeVars.trim())
+        .replace("/* {{BODY_BG_DECL}} */", `--body-bg: ${bodyBg};`)
+        .replace("/* {{CONTAINER_BG_DECL}} */", `--container-bg: ${containerBg};`)
+        .replace("/* {{INFO_BG_DECL}} */", `--info-bg: ${infoBg};`);
+    return template
+        .replace("{{CSS}}", css)
+        .replace("{{JS}}", templateJs)
+        .replace("{{SESSION_DATA}}", sessionDataBase64)
+        .replace("{{MARKED_JS}}", markedJs)
+        .replace("{{HIGHLIGHT_JS}}", hljsJs);
+}
+function parseExportArgs(commandBodyNormalized) {
+    const normalized = commandBodyNormalized.trim();
+    if (normalized === "/export-session" || normalized === "/export") {
+        return {};
+    }
+    const args = normalized.replace(/^\/(export-session|export)\s*/, "").trim();
+    // First non-flag argument is the output path
+    const outputPath = args.split(/\s+/).find((part) => !part.startsWith("-"));
+    return { outputPath };
+}
+export async function buildExportSessionReply(params) {
+    const args = parseExportArgs(params.command.commandBodyNormalized);
+    // 1. Resolve session file
+    const sessionEntry = params.sessionEntry;
+    if (!sessionEntry?.sessionId) {
+        return { text: "❌ No active session found." };
+    }
+    const storePath = resolveDefaultSessionStorePath(params.agentId);
+    const store = loadSessionStore(storePath, { skipCache: true });
+    const entry = store[params.sessionKey];
+    if (!entry?.sessionId) {
+        return { text: `❌ Session not found: ${params.sessionKey}` };
+    }
+    let sessionFile;
+    try {
+        sessionFile = resolveSessionFilePath(entry.sessionId, entry, {
+            agentId: params.agentId,
+            sessionsDir: path.dirname(storePath),
+        });
+    }
+    catch (err) {
+        return {
+            text: `❌ Failed to resolve session file: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!fs.existsSync(sessionFile)) {
+        return { text: `❌ Session file not found: ${sessionFile}` };
+    }
+    // 2. Load session entries
+    const sessionManager = SessionManager.open(sessionFile);
+    const entries = sessionManager.getEntries();
+    const header = sessionManager.getHeader();
+    const leafId = sessionManager.getLeafId();
+    // 3. Build full system prompt
+    const { systemPrompt, tools } = await resolveCommandsSystemPromptBundle(params);
+    // 4. Prepare session data
+    const sessionData = {
+        header,
+        entries,
+        leafId,
+        systemPrompt,
+        tools: tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        })),
+    };
+    // 5. Generate HTML
+    const html = generateHtml(sessionData);
+    // 6. Determine output path
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const defaultFileName = `openclaw-session-${entry.sessionId.slice(0, 8)}-${timestamp}.html`;
+    const outputPath = args.outputPath
+        ? path.resolve(args.outputPath.startsWith("~")
+            ? args.outputPath.replace("~", process.env.HOME ?? "")
+            : args.outputPath)
+        : path.join(params.workspaceDir, defaultFileName);
+    // Ensure directory exists
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // 7. Write file
+    fs.writeFileSync(outputPath, html, "utf-8");
+    const relativePath = path.relative(params.workspaceDir, outputPath);
+    const displayPath = relativePath.startsWith("..") ? outputPath : relativePath;
+    return {
+        text: [
+            "✅ Session exported!",
+            "",
+            `📄 File: ${displayPath}`,
+            `📊 Entries: ${entries.length}`,
+            `🧠 System prompt: ${systemPrompt.length.toLocaleString()} chars`,
+            `🔧 Tools: ${tools.length}`,
+        ].join("\n"),
+    };
+}

package/dist/auto-reply/reply/commands-mesh.js

@@ -0,0 +1,245 @@
+import { callGateway } from "../../gateway/call.js";
+import { logVerbose } from "../../globals.js";
+import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../../utils/message-channel.js";
+const meshPlanCache = new Map();
+const MAX_CACHED_MESH_PLANS = 200;
+function trimMeshPlanCache() {
+    if (meshPlanCache.size <= MAX_CACHED_MESH_PLANS) {
+        return;
+    }
+    const oldest = [...meshPlanCache.entries()]
+        .toSorted((a, b) => a[1].createdAt - b[1].createdAt)
+        .slice(0, meshPlanCache.size - MAX_CACHED_MESH_PLANS);
+    for (const [key] of oldest) {
+        meshPlanCache.delete(key);
+    }
+}
+function parseMeshCommand(commandBody) {
+    const trimmed = commandBody.trim();
+    if (!/^\/mesh\b/i.test(trimmed)) {
+        return null;
+    }
+    const rest = trimmed.replace(/^\/mesh\b:?/i, "").trim();
+    if (!rest || /^help$/i.test(rest)) {
+        return { ok: true, action: "help" };
+    }
+    const tokens = rest.split(/\s+/).filter(Boolean);
+    if (tokens.length === 0) {
+        return { ok: true, action: "help" };
+    }
+    const actionCandidate = tokens[0]?.toLowerCase() ?? "";
+    const explicitAction = actionCandidate === "run" ||
+        actionCandidate === "plan" ||
+        actionCandidate === "status" ||
+        actionCandidate === "retry"
+        ? actionCandidate
+        : null;
+    if (!explicitAction) {
+        // Shorthand: `/mesh <goal>` => auto plan + run
+        return { ok: true, action: "run", target: rest };
+    }
+    const actionArgs = rest.slice(tokens[0]?.length ?? 0).trim();
+    if (explicitAction === "plan" || explicitAction === "run") {
+        if (!actionArgs) {
+            return { ok: false, message: `Usage: /mesh ${explicitAction} <goal>` };
+        }
+        return { ok: true, action: explicitAction, target: actionArgs };
+    }
+    if (explicitAction === "status") {
+        if (!actionArgs) {
+            return { ok: false, message: "Usage: /mesh status <runId>" };
+        }
+        return { ok: true, action: "status", runId: actionArgs.split(/\s+/)[0] };
+    }
+    // retry
+    const argsTokens = actionArgs.split(/\s+/).filter(Boolean);
+    if (argsTokens.length === 0) {
+        return { ok: false, message: "Usage: /mesh retry <runId> [step1,step2,...]" };
+    }
+    const runId = argsTokens[0];
+    const stepArg = argsTokens.slice(1).join(" ").trim();
+    const stepIds = stepArg.length > 0
+        ? stepArg
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter(Boolean)
+        : undefined;
+    return { ok: true, action: "retry", runId, stepIds };
+}
+function cacheKeyForPlan(params, planId) {
+    const sender = params.command.senderId ?? "unknown";
+    const channel = params.command.channel || "unknown";
+    return `${channel}:${sender}:${planId}`;
+}
+function putCachedPlan(params, plan) {
+    meshPlanCache.set(cacheKeyForPlan(params, plan.planId), { plan, createdAt: Date.now() });
+    trimMeshPlanCache();
+}
+function getCachedPlan(params, planId) {
+    return meshPlanCache.get(cacheKeyForPlan(params, planId))?.plan ?? null;
+}
+function looksLikeMeshPlanId(value) {
+    return /^mesh-plan-[a-z0-9-]+$/i.test(value.trim());
+}
+function resolveMeshCommandBody(params) {
+    return (params.ctx.BodyForCommands ??
+        params.ctx.CommandBody ??
+        params.ctx.RawBody ??
+        params.ctx.Body ??
+        params.command.commandBodyNormalized);
+}
+function formatPlanSummary(plan) {
+    const lines = [`🕸️ Mesh Plan`, `Goal: ${plan.goal}`, "", `Steps (${plan.steps.length}):`];
+    for (const step of plan.steps) {
+        const dependsOn = Array.isArray(step.dependsOn) && step.dependsOn.length > 0;
+        const depLine = dependsOn ? ` (depends on: ${step.dependsOn?.join(", ")})` : "";
+        lines.push(`- ${step.id}${step.name ? ` — ${step.name}` : ""}${depLine}`);
+        lines.push(`  ${step.prompt}`);
+    }
+    return lines.join("\n");
+}
+function formatRunSummary(payload) {
+    const stats = payload.stats ?? {};
+    return [
+        `🕸️ Mesh Run`,
+        `Run: ${payload.runId}`,
+        `Status: ${payload.status}`,
+        `Steps: total=${stats.total ?? 0}, ok=${stats.succeeded ?? 0}, failed=${stats.failed ?? 0}, skipped=${stats.skipped ?? 0}, running=${stats.running ?? 0}, pending=${stats.pending ?? 0}`,
+    ].join("\n");
+}
+function meshUsageText() {
+    return [
+        "🕸️ Mesh command",
+        "Usage:",
+        "- /mesh <goal>  (auto plan + run)",
+        "- /mesh plan <goal>",
+        "- /mesh run <goal|mesh-plan-id>",
+        "- /mesh status <runId>",
+        "- /mesh retry <runId> [step1,step2,...]",
+    ].join("\n");
+}
+function resolveMeshClientLabel(params) {
+    const channel = params.command.channel;
+    const sender = params.command.senderId ?? "unknown";
+    return `Chat mesh (${channel}:${sender})`;
+}
+export const handleMeshCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const parsed = parseMeshCommand(resolveMeshCommandBody(params));
+    if (!parsed) {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /mesh from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    if (!parsed.ok) {
+        return { shouldContinue: false, reply: { text: parsed.message } };
+    }
+    if (parsed.action === "help") {
+        return { shouldContinue: false, reply: { text: meshUsageText() } };
+    }
+    const clientDisplayName = resolveMeshClientLabel(params);
+    const commonGateway = {
+        clientName: GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT,
+        clientDisplayName,
+        mode: GATEWAY_CLIENT_MODES.BACKEND,
+    };
+    try {
+        if (parsed.action === "plan") {
+            const planResp = await callGateway({
+                method: "mesh.plan.auto",
+                params: {
+                    goal: parsed.target,
+                    agentId: params.agentId ?? "main",
+                },
+                ...commonGateway,
+            });
+            putCachedPlan(params, planResp.plan);
+            const sourceLine = planResp.source ? `\nPlanner source: ${planResp.source}` : "";
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `${formatPlanSummary(planResp.plan)}${sourceLine}\n\nRun exact plan: /mesh run ${planResp.plan.planId}`,
+                },
+            };
+        }
+        if (parsed.action === "run") {
+            let runPlan;
+            if (looksLikeMeshPlanId(parsed.target)) {
+                const cached = getCachedPlan(params, parsed.target.trim());
+                if (!cached) {
+                    return {
+                        shouldContinue: false,
+                        reply: {
+                            text: `Plan ${parsed.target.trim()} not found in this chat.\nCreate one first: /mesh plan <goal>`,
+                        },
+                    };
+                }
+                runPlan = cached;
+            }
+            else {
+                const planResp = await callGateway({
+                    method: "mesh.plan.auto",
+                    params: {
+                        goal: parsed.target,
+                        agentId: params.agentId ?? "main",
+                    },
+                    ...commonGateway,
+                });
+                putCachedPlan(params, planResp.plan);
+                runPlan = planResp.plan;
+            }
+            const runResp = await callGateway({
+                method: "mesh.run",
+                params: {
+                    plan: runPlan,
+                },
+                ...commonGateway,
+            });
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `${formatPlanSummary(runPlan)}\n\n${formatRunSummary(runResp)}`,
+                },
+            };
+        }
+        if (parsed.action === "status") {
+            const statusResp = await callGateway({
+                method: "mesh.status",
+                params: { runId: parsed.runId },
+                ...commonGateway,
+            });
+            return {
+                shouldContinue: false,
+                reply: { text: formatRunSummary(statusResp) },
+            };
+        }
+        if (parsed.action === "retry") {
+            const retryResp = await callGateway({
+                method: "mesh.retry",
+                params: {
+                    runId: parsed.runId,
+                    ...(parsed.stepIds && parsed.stepIds.length > 0 ? { stepIds: parsed.stepIds } : {}),
+                },
+                ...commonGateway,
+            });
+            return {
+                shouldContinue: false,
+                reply: { text: `🔁 Retry submitted\n${formatRunSummary(retryResp)}` },
+            };
+        }
+        return null;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            shouldContinue: false,
+            reply: {
+                text: `❌ Mesh command failed: ${message}`,
+            },
+        };
+    }
+};

package/dist/auto-reply/reply/commands-setunset.js

@@ -0,0 +1,28 @@
+import { parseConfigValue } from "./config-value.js";
+export function parseSetUnsetCommand(params) {
+    const action = params.action;
+    const args = params.args.trim();
+    if (action === "unset") {
+        if (!args) {
+            return { kind: "error", message: `Usage: ${params.slash} unset path` };
+        }
+        return { kind: "unset", path: args };
+    }
+    if (!args) {
+        return { kind: "error", message: `Usage: ${params.slash} set path=value` };
+    }
+    const eqIndex = args.indexOf("=");
+    if (eqIndex <= 0) {
+        return { kind: "error", message: `Usage: ${params.slash} set path=value` };
+    }
+    const path = args.slice(0, eqIndex).trim();
+    const rawValue = args.slice(eqIndex + 1);
+    if (!path) {
+        return { kind: "error", message: `Usage: ${params.slash} set path=value` };
+    }
+    const parsed = parseConfigValue(rawValue);
+    if (parsed.error) {
+        return { kind: "error", message: parsed.error };
+    }
+    return { kind: "set", path, value: parsed.value };
+}

package/dist/auto-reply/reply/commands-slash-parse.js

@@ -0,0 +1,31 @@
+export function parseSlashCommandActionArgs(raw, slash) {
+    const trimmed = raw.trim();
+    const slashLower = slash.toLowerCase();
+    if (!trimmed.toLowerCase().startsWith(slashLower)) {
+        return { kind: "no-match" };
+    }
+    const rest = trimmed.slice(slash.length).trim();
+    if (!rest) {
+        return { kind: "empty" };
+    }
+    const match = rest.match(/^(\S+)(?:\s+([\s\S]+))?$/);
+    if (!match) {
+        return { kind: "invalid" };
+    }
+    const action = match[1]?.toLowerCase() ?? "";
+    const args = (match[2] ?? "").trim();
+    return { kind: "parsed", action, args };
+}
+export function parseSlashCommandOrNull(raw, slash, opts) {
+    const parsed = parseSlashCommandActionArgs(raw, slash);
+    if (parsed.kind === "no-match") {
+        return null;
+    }
+    if (parsed.kind === "invalid") {
+        return { ok: false, message: opts.invalidMessage };
+    }
+    if (parsed.kind === "empty") {
+        return { ok: true, action: opts.defaultAction ?? "show", args: "" };
+    }
+    return { ok: true, action: parsed.action, args: parsed.args };
+}

package/dist/auto-reply/reply/commands-system-prompt.js

@@ -0,0 +1,117 @@
+import { resolveSessionAgentIds } from "../../agents/agent-scope.js";
+import { resolveBootstrapContextForRun } from "../../agents/bootstrap-files.js";
+import { resolveDefaultModelForAgent } from "../../agents/model-selection.js";
+import { createOpenClawCodingTools } from "../../agents/pi-tools.js";
+import { resolveSandboxRuntimeStatus } from "../../agents/sandbox.js";
+import { buildWorkspaceSkillSnapshot } from "../../agents/skills.js";
+import { getSkillsSnapshotVersion } from "../../agents/skills/refresh.js";
+import { buildSystemPromptParams } from "../../agents/system-prompt-params.js";
+import { buildAgentSystemPrompt } from "../../agents/system-prompt.js";
+import { buildToolSummaryMap } from "../../agents/tool-summaries.js";
+import { getRemoteSkillEligibility } from "../../infra/skills-remote.js";
+import { buildTtsSystemPromptHint } from "../../tts/tts.js";
+export async function resolveCommandsSystemPromptBundle(params) {
+    const workspaceDir = params.workspaceDir;
+    const { bootstrapFiles, contextFiles: injectedFiles } = await resolveBootstrapContextForRun({
+        workspaceDir,
+        config: params.cfg,
+        sessionKey: params.sessionKey,
+        sessionId: params.sessionEntry?.sessionId,
+    });
+    const skillsSnapshot = (() => {
+        try {
+            return buildWorkspaceSkillSnapshot(workspaceDir, {
+                config: params.cfg,
+                eligibility: { remote: getRemoteSkillEligibility() },
+                snapshotVersion: getSkillsSnapshotVersion(workspaceDir),
+            });
+        }
+        catch {
+            return { prompt: "", skills: [], resolvedSkills: [] };
+        }
+    })();
+    const skillsPrompt = skillsSnapshot.prompt ?? "";
+    const sandboxRuntime = resolveSandboxRuntimeStatus({
+        cfg: params.cfg,
+        sessionKey: params.ctx.SessionKey ?? params.sessionKey,
+    });
+    const tools = (() => {
+        try {
+            return createOpenClawCodingTools({
+                config: params.cfg,
+                workspaceDir,
+                sessionKey: params.sessionKey,
+                messageProvider: params.command.channel,
+                groupId: params.sessionEntry?.groupId ?? undefined,
+                groupChannel: params.sessionEntry?.groupChannel ?? undefined,
+                groupSpace: params.sessionEntry?.space ?? undefined,
+                spawnedBy: params.sessionEntry?.spawnedBy ?? undefined,
+                senderIsOwner: params.command.senderIsOwner,
+                modelProvider: params.provider,
+                modelId: params.model,
+            });
+        }
+        catch {
+            return [];
+        }
+    })();
+    const toolSummaries = buildToolSummaryMap(tools);
+    const toolNames = tools.map((t) => t.name);
+    const { sessionAgentId } = resolveSessionAgentIds({
+        sessionKey: params.sessionKey,
+        config: params.cfg,
+    });
+    const defaultModelRef = resolveDefaultModelForAgent({
+        cfg: params.cfg,
+        agentId: sessionAgentId,
+    });
+    const defaultModelLabel = `${defaultModelRef.provider}/${defaultModelRef.model}`;
+    const { runtimeInfo, userTimezone, userTime, userTimeFormat } = buildSystemPromptParams({
+        config: params.cfg,
+        agentId: sessionAgentId,
+        workspaceDir,
+        cwd: process.cwd(),
+        runtime: {
+            host: "unknown",
+            os: "unknown",
+            arch: "unknown",
+            node: process.version,
+            model: `${params.provider}/${params.model}`,
+            defaultModel: defaultModelLabel,
+        },
+    });
+    const sandboxInfo = sandboxRuntime.sandboxed
+        ? {
+            enabled: true,
+            workspaceDir,
+            workspaceAccess: "rw",
+            elevated: {
+                allowed: params.elevated.allowed,
+                defaultLevel: (params.resolvedElevatedLevel ?? "off"),
+            },
+        }
+        : { enabled: false };
+    const ttsHint = params.cfg ? buildTtsSystemPromptHint(params.cfg) : undefined;
+    const systemPrompt = buildAgentSystemPrompt({
+        workspaceDir,
+        defaultThinkLevel: params.resolvedThinkLevel,
+        reasoningLevel: params.resolvedReasoningLevel,
+        extraSystemPrompt: undefined,
+        ownerNumbers: undefined,
+        reasoningTagHint: false,
+        toolNames,
+        toolSummaries,
+        modelAliasLines: [],
+        userTimezone,
+        userTime,
+        userTimeFormat,
+        contextFiles: injectedFiles,
+        skillsPrompt,
+        heartbeatPrompt: undefined,
+        ttsHint,
+        runtimeInfo,
+        sandboxInfo,
+        memoryCitationsMode: params.cfg?.memory?.citations,
+    });
+    return { systemPrompt, tools, skillsPrompt, bootstrapFiles, injectedFiles, sandboxRuntime };
+}