pulseed 0.4.13 → 0.4.15

package/dist/interface/chat/chat-runner.js

@@ -3,6 +3,11 @@
 // Central coordinator for 1-shot chat execution (Tier 1).
 // Bypasses TaskLifecycle — calls adapter.execute() directly.
 import { execFile } from "node:child_process";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import { getPulseedDirPath } from "../../base/utils/paths.js";
+import { loadProviderConfig } from "../../base/llm/provider-config.js";
+import { TaskSchema } from "../../base/types/task.js";
 import { ChatHistory } from "./chat-history.js";
 import { ChatSessionCatalog, ChatSessionSelectorError, } from "./chat-session-store.js";
 import { buildChatContext, resolveGitRoot } from "../../platform/observation/context-provider.js";
@@ -11,6 +16,7 @@ import { verifyChatAction } from "./chat-verifier.js";
 import { toToolDefinitionsFiltered } from "../../tools/tool-definition-adapter.js";
 import { TendCommand } from "./tend-command.js";
 import { EventSubscriber } from "./event-subscriber.js";
+import { buildPromptedToolProtocolSystemPrompt, extractPromptedToolCalls, } from "../../orchestrator/execution/agent-loop/prompted-tool-protocol.js";
 import { recognizeRuntimeControlIntent } from "../../runtime/control/index.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_VERIFY_RETRIES = 2;
@@ -19,6 +25,7 @@ const ACTIVITY_PREVIEW_CHARS = 40;
 const DIRECT_ANSWER_MAX_TOKENS = 256;
 // ─── Command help text ───
 const COMMAND_HELP = `Available commands:
+Session
   /help                 Show this help message
   /clear                Clear conversation history
   /sessions             List prior chat sessions
@@ -26,9 +33,25 @@ const COMMAND_HELP = `Available commands:
   /title <title>        Rename the current session
   /resume [id|title]    Resume native agentloop state for the current or selected session
   /cleanup [--dry-run]  Clean up stale chat sessions
+  /compact              Summarize older chat turns and keep the latest turns
   /exit                 Exit chat mode
+
+Goals and tasks
+  /status [goal-id]     Show active goal status, or one goal when an id is provided
+  /goals                List goals
+  /tasks [goal-id]      List tasks for a goal; uses the only active goal when unambiguous
+  /task <task-id> [goal-id]
+                        Show one task; searches goals when no goal id is provided
   /track                Promote session to Tier 2 goal pursuit (not yet implemented)
-  /tend                 Generate a goal from chat history and start autonomous daemon execution`;
+  /tend                 Generate a goal from chat history and start autonomous daemon execution
+
+Configuration
+  /config               Show provider configuration with secrets masked
+  /model                Show the active provider/model/adapter
+  /plugins              List installed plugins when plugin metadata is available
+
+Deferred
+  /retry, /undo, and /usage are intentionally not supported yet.`;
 // ─── Helpers ───
 function checkGitChanges(cwd) {
     return new Promise((resolve) => {
@@ -164,6 +187,352 @@ export class ChatRunner {
         });
         return `Session ${session.id}${title} (${session.cwd})\n${lines.join("\n")}`;
     }
+    async loadGoals() {
+        const goalIds = await this.deps.stateManager.listGoalIds();
+        const goals = await Promise.all(goalIds.map((id) => this.deps.stateManager.loadGoal(id)));
+        return goals.filter((goal) => goal !== null);
+    }
+    async listAllGoalIds() {
+        const activeIds = await this.deps.stateManager.listGoalIds();
+        const archivedIds = await this.deps.stateManager.listArchivedGoals();
+        const recoverableArchivedIds = await this.listRecoverableArchivedGoalIds();
+        return [...new Set([...activeIds, ...archivedIds, ...recoverableArchivedIds])];
+    }
+    resolveStatePath(baseDir, ...segments) {
+        const base = path.resolve(baseDir);
+        const resolved = path.resolve(base, ...segments);
+        if (!resolved.startsWith(base + path.sep))
+            return null;
+        return resolved;
+    }
+    async listRecoverableArchivedGoalIds() {
+        const stateManager = this.deps.stateManager;
+        if (typeof stateManager.getBaseDir !== "function")
+            return [];
+        const archiveDir = this.resolveStatePath(stateManager.getBaseDir(), "archive");
+        if (archiveDir === null)
+            return [];
+        let entries = [];
+        try {
+            entries = await fsp.readdir(archiveDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const goalIds = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === ".staging")
+                continue;
+            try {
+                await fsp.access(path.join(archiveDir, entry.name, "goal", "goal.json"));
+                goalIds.push(entry.name);
+            }
+            catch {
+                continue;
+            }
+        }
+        return goalIds;
+    }
+    activeGoals(goals) {
+        return goals.filter((goal) => goal.status === "active" || goal.status === "waiting" || goal.loop_status === "running");
+    }
+    formatGoalLine(goal) {
+        const dimensions = goal.dimensions.length === 0
+            ? "no dimensions"
+            : goal.dimensions
+                .slice(0, 3)
+                .map((dimension) => `${dimension.name}: ${String(dimension.current_value)} target ${JSON.stringify(dimension.threshold)}`)
+                .join("; ");
+        return `${goal.id} - ${goal.title} [${goal.status}, loop ${goal.loop_status}] ${dimensions}`;
+    }
+    async handleStatus(args, start) {
+        if (args) {
+            const goal = await this.deps.stateManager.loadGoal(args);
+            if (!goal) {
+                return { success: false, output: `Goal not found: ${args}`, elapsed_ms: Date.now() - start };
+            }
+            const lines = [
+                `Goal status: ${goal.title}`,
+                `ID: ${goal.id}`,
+                `Status: ${goal.status}`,
+                `Loop: ${goal.loop_status}`,
+                `Updated: ${goal.updated_at}`,
+                `Children: ${goal.children_ids.length}`,
+                `Dimensions:`,
+                ...goal.dimensions.map((dimension) => `- ${dimension.name}: current=${String(dimension.current_value)}, threshold=${JSON.stringify(dimension.threshold)}, confidence=${dimension.confidence}`),
+            ];
+            return { success: true, output: lines.join("\n"), elapsed_ms: Date.now() - start };
+        }
+        const goals = await this.loadGoals();
+        const active = this.activeGoals(goals);
+        if (active.length === 0) {
+            return { success: true, output: "No active goals found.", elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Active goals:\n${active.map((goal) => this.formatGoalLine(goal)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleGoals(start) {
+        const goals = await this.loadGoals();
+        if (goals.length === 0) {
+            return { success: true, output: "No goals found.", elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Goals:\n${goals.map((goal) => this.formatGoalLine(goal)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async readTasksFromDir(tasksDir) {
+        let entries = [];
+        try {
+            entries = await fsp.readdir(tasksDir);
+        }
+        catch {
+            return [];
+        }
+        const tasks = [];
+        for (const entry of entries) {
+            if (!entry.endsWith(".json") || entry === "task-history.json" || entry === "last-failure-context.json")
+                continue;
+            let raw;
+            try {
+                raw = JSON.parse(await fsp.readFile(path.join(tasksDir, entry), "utf-8"));
+            }
+            catch {
+                continue;
+            }
+            const parsed = TaskSchema.safeParse(raw);
+            if (parsed.success)
+                tasks.push(parsed.data);
+        }
+        return tasks.sort((a, b) => (a.created_at < b.created_at ? 1 : -1));
+    }
+    async readTasksForGoal(goalId) {
+        const stateManager = this.deps.stateManager;
+        if (typeof stateManager.getBaseDir !== "function")
+            return [];
+        const baseDir = stateManager.getBaseDir();
+        const activeTasksDir = this.resolveStatePath(baseDir, "tasks", goalId);
+        const archiveTasksDir = this.resolveStatePath(baseDir, "archive", goalId, "tasks");
+        if (activeTasksDir === null || archiveTasksDir === null)
+            return [];
+        const activeTasks = await this.readTasksFromDir(activeTasksDir);
+        if (activeTasks.length > 0)
+            return activeTasks;
+        return this.readTasksFromDir(archiveTasksDir);
+    }
+    async resolveGoalForTasks(selector) {
+        if (selector)
+            return { goalId: selector };
+        const active = this.activeGoals(await this.loadGoals());
+        if (active.length === 1)
+            return { goalId: active[0].id };
+        if (active.length === 0)
+            return { error: "No active goals found. Use /tasks <goal-id>." };
+        return { error: "Multiple active goals found. Use /tasks <goal-id>." };
+    }
+    formatTaskLine(task) {
+        const verdict = task.verification_verdict ? `, verdict ${task.verification_verdict}` : "";
+        return `${task.id} - ${task.status}${verdict}: ${task.work_description}`;
+    }
+    async handleTasks(args, start) {
+        const resolved = await this.resolveGoalForTasks(args);
+        if (resolved.error || !resolved.goalId) {
+            return { success: false, output: resolved.error ?? "Usage: /tasks <goal-id>", elapsed_ms: Date.now() - start };
+        }
+        const tasks = await this.readTasksForGoal(resolved.goalId);
+        if (tasks.length === 0) {
+            return { success: true, output: `No tasks found for goal "${resolved.goalId}".`, elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Tasks for goal ${resolved.goalId}:\n${tasks.map((task) => this.formatTaskLine(task)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    parseTaskArgs(args) {
+        const parts = args.split(/\s+/).filter(Boolean);
+        const goalFlagIndex = parts.indexOf("--goal");
+        if (goalFlagIndex >= 0) {
+            const goalId = parts[goalFlagIndex + 1];
+            parts.splice(goalFlagIndex, goalId ? 2 : 1);
+            return { taskId: parts[0], goalId };
+        }
+        return { taskId: parts[0], goalId: parts[1] };
+    }
+    async findTask(taskId, goalId) {
+        const goalIds = goalId ? [goalId] : await this.listAllGoalIds();
+        const matches = [];
+        for (const candidateGoalId of goalIds) {
+            let raw = null;
+            try {
+                raw = await this.deps.stateManager.readRaw(`tasks/${candidateGoalId}/${taskId}.json`);
+            }
+            catch {
+                raw = null;
+            }
+            if (!raw) {
+                const tasks = await this.readTasksForGoal(candidateGoalId);
+                const matched = tasks.find((task) => task.id === taskId || task.id.startsWith(taskId));
+                if (matched)
+                    matches.push({ goalId: candidateGoalId, task: matched });
+                continue;
+            }
+            const parsed = TaskSchema.safeParse(raw);
+            if (parsed.success)
+                matches.push({ goalId: candidateGoalId, task: parsed.data });
+        }
+        return { task: matches.length === 1 ? matches[0].task : undefined, matches };
+    }
+    formatTask(task) {
+        const lines = [
+            `Task: ${task.id}`,
+            `Goal: ${task.goal_id}`,
+            `Status: ${task.status}`,
+            `Category: ${task.task_category}`,
+            `Created: ${task.created_at}`,
+            `Work: ${task.work_description}`,
+            `Approach: ${task.approach}`,
+        ];
+        if (task.started_at)
+            lines.push(`Started: ${task.started_at}`);
+        if (task.completed_at)
+            lines.push(`Completed: ${task.completed_at}`);
+        if (task.verification_verdict)
+            lines.push(`Verification: ${task.verification_verdict}`);
+        if (task.verification_evidence?.length)
+            lines.push(`Evidence: ${task.verification_evidence.join("; ")}`);
+        if (task.success_criteria.length > 0) {
+            lines.push("Success criteria:");
+            lines.push(...task.success_criteria.map((criterion) => `- ${criterion.description}`));
+        }
+        return lines.join("\n");
+    }
+    async handleTask(args, start) {
+        const { taskId, goalId } = this.parseTaskArgs(args);
+        if (!taskId) {
+            return { success: false, output: "Usage: /task <task-id> [goal-id]", elapsed_ms: Date.now() - start };
+        }
+        const found = await this.findTask(taskId, goalId);
+        if (found.matches.length > 1) {
+            return {
+                success: false,
+                output: `Task selector "${taskId}" matched multiple goals. Use /task ${taskId} <goal-id>.\n${found.matches.map((match) => `- ${match.goalId}`).join("\n")}`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (!found.task) {
+            const suffix = goalId ? ` for goal "${goalId}"` : "";
+            return { success: false, output: `Task not found: ${taskId}${suffix}`, elapsed_ms: Date.now() - start };
+        }
+        return { success: true, output: this.formatTask(found.task), elapsed_ms: Date.now() - start };
+    }
+    providerConfigBaseDir() {
+        const stateManager = this.deps.stateManager;
+        return typeof stateManager.getBaseDir === "function" ? stateManager.getBaseDir() : getPulseedDirPath();
+    }
+    async readProviderConfigSummary() {
+        const config = await loadProviderConfig({
+            baseDir: this.providerConfigBaseDir(),
+            saveMigration: false,
+        });
+        return {
+            provider: config.provider,
+            model: config.model,
+            adapter: config.adapter,
+            light_model: config.light_model,
+            base_url: config.base_url,
+            codex_cli_path: config.codex_cli_path,
+            has_api_key: Boolean(config.api_key),
+        };
+    }
+    formatConfig(config) {
+        return Object.entries(config)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => `${key}: ${typeof value === "string" && /key|token|secret/i.test(key) ? "[masked]" : String(value)}`)
+            .join("\n");
+    }
+    async handleConfig(start) {
+        const config = await this.readProviderConfigSummary();
+        return { success: true, output: `Provider configuration:\n${this.formatConfig(config)}`, elapsed_ms: Date.now() - start };
+    }
+    async handleModel(start) {
+        const config = await this.readProviderConfigSummary();
+        return {
+            success: true,
+            output: `Model: ${config.model}\nProvider: ${config.provider}\nAdapter: ${config.adapter}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handlePlugins(start) {
+        if (!this.deps.pluginLoader) {
+            return { success: true, output: "Plugin information is not available in this chat session.", elapsed_ms: Date.now() - start };
+        }
+        try {
+            const plugins = await this.deps.pluginLoader.loadAll();
+            if (plugins.length === 0) {
+                return { success: true, output: "No plugins found.", elapsed_ms: Date.now() - start };
+            }
+            return {
+                success: true,
+                output: `Plugins:\n${plugins.map((plugin) => `${plugin.name} - ${plugin.type ?? "unknown"} - ${plugin.enabled === false ? "disabled" : "enabled"}`).join("\n")}`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { success: true, output: `Plugin information is unavailable: ${message}`, elapsed_ms: Date.now() - start };
+        }
+    }
+    deterministicChatSummary(messages) {
+        const lines = messages.map((message) => `${message.role}: ${message.content.replace(/\s+/g, " ").trim()}`);
+        return lines.join("\n").slice(0, 4_000);
+    }
+    async summarizeChatForCompaction(messages, existingSummary) {
+        const content = [
+            existingSummary ? `Previous summary:\n${existingSummary}` : "",
+            `Messages to summarize:\n${messages.map((message) => `${message.role}: ${message.content}`).join("\n")}`,
+        ].filter(Boolean).join("\n\n");
+        if (this.deps.llmClient) {
+            try {
+                const response = await this.deps.llmClient.sendMessage([
+                    { role: "user", content: `Summarize this chat history for later continuation. Preserve decisions, open tasks, constraints, and user preferences. Keep it concise.\n\n${content}` },
+                ], { max_tokens: 700, model_tier: "light" });
+                if (response.content.trim())
+                    return { summary: response.content.trim(), usedLlm: true };
+            }
+            catch {
+                // Fall back to deterministic summary below.
+            }
+        }
+        const fallback = [
+            existingSummary ? `Previous summary:\n${existingSummary}` : "",
+            "Extractive summary:",
+            this.deterministicChatSummary(messages),
+        ].filter(Boolean).join("\n\n");
+        return { summary: fallback, usedLlm: false };
+    }
+    async handleCompact(start) {
+        if (!this.history) {
+            return { success: false, output: "No active chat session to compact.", elapsed_ms: Date.now() - start };
+        }
+        const session = this.history.getSessionData();
+        if (session.messages.length <= 4) {
+            return { success: true, output: "Chat history is already compact. No messages were removed.", elapsed_ms: Date.now() - start };
+        }
+        const olderMessages = session.messages.slice(0, -4);
+        const { summary, usedLlm } = await this.summarizeChatForCompaction(olderMessages, session.compactionSummary);
+        const { before, after } = await this.history.compact(summary, 4);
+        const method = usedLlm ? "LLM summary" : "deterministic summary";
+        return {
+            success: true,
+            output: `Compacted chat history with ${method}. Persisted ${before} message(s) down to ${after}; the latest user/assistant turns were kept.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
     async handleCommand(input) {
         const trimmed = input.trim();
         if (!trimmed.startsWith("/"))
@@ -174,7 +543,7 @@ export class ChatRunner {
             return { success: true, output: COMMAND_HELP, elapsed_ms: Date.now() - start };
         }
         if (cmd === "/clear") {
-            this.history?.clear();
+            await this.history?.clear();
             return { success: true, output: "Conversation history cleared.", elapsed_ms: Date.now() - start };
         }
         if (cmd === "/sessions") {
@@ -223,6 +592,30 @@ export class ChatRunner {
                 elapsed_ms: Date.now() - start,
             };
         }
+        if (cmd === "/compact") {
+            return this.handleCompact(start);
+        }
+        if (cmd === "/status") {
+            return this.handleStatus(trimmed.slice("/status".length).trim(), start);
+        }
+        if (cmd === "/goals") {
+            return this.handleGoals(start);
+        }
+        if (cmd === "/tasks") {
+            return this.handleTasks(trimmed.slice("/tasks".length).trim(), start);
+        }
+        if (cmd === "/task") {
+            return this.handleTask(trimmed.slice("/task".length).trim(), start);
+        }
+        if (cmd === "/config") {
+            return this.handleConfig(start);
+        }
+        if (cmd === "/model") {
+            return this.handleModel(start);
+        }
+        if (cmd === "/plugins") {
+            return this.handlePlugins(start);
+        }
         if (cmd === "/exit") {
             return { success: true, output: "Exiting chat mode.", elapsed_ms: Date.now() - start };
         }
@@ -495,15 +888,23 @@ export class ChatRunner {
                 this.cachedStaticSystemPrompt = "";
             }
         }
-        // Build conversation history from prior turns (last 10)
+        // Build conversation history from prior turns (last 10), including any manual compaction summary.
         const messages = history.getMessages();
+        const compactionSummary = history.getSessionData().compactionSummary;
         const priorTurns = resumeOnly ? messages.slice(-10) : messages.slice(0, -1).slice(-10);
         let historyBlock = "";
+        const historySections = [];
+        if (compactionSummary) {
+            historySections.push(`Compacted previous conversation summary:\n${compactionSummary}`);
+        }
         if (priorTurns.length > 0) {
             const lines = priorTurns.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n");
-            historyBlock = `Previous conversation:\n${lines}\n\nCurrent message:\n`;
+            historySections.push(`Previous conversation:\n${lines}`);
         }
-        const directAnswerRoute = !resumeOnly && this.deps.llmClient !== undefined && shouldUseDirectAnswerRoute(input);
+        if (historySections.length > 0) {
+            historyBlock = `${historySections.join("\n\n")}\n\nCurrent message:\n`;
+        }
+        const directAnswerRoute = !resumeOnly && !this.deps.chatAgentLoopRunner && this.deps.llmClient !== undefined && shouldUseDirectAnswerRoute(input);
         const directPrompt = historyBlock ? `${historyBlock}${input}` : input;
         const start = Date.now();
         const assistantBuffer = { text: "" };
@@ -569,6 +970,13 @@ export class ChatRunner {
             .filter((section) => section && section.trim().length > 0)
             .join("\n\n")
             .trim();
+        const agentLoopSystemPrompt = [
+            systemPrompt,
+            compactionSummary ? `## Compacted Chat Summary\n${compactionSummary}` : "",
+        ]
+            .filter((section) => section && section.trim().length > 0)
+            .join("\n\n")
+            .trim();
         const context = resumeOnly ? "" : await buildChatContext(input, gitRoot);
         const basePrompt = resumeOnly ? "" : (context ? `${context}\n\n${input}` : input);
         const prompt = historyBlock ? `${historyBlock}${basePrompt}` : basePrompt;
@@ -626,7 +1034,7 @@ export class ChatRunner {
                     ...(this.nativeAgentLoopStatePath ? { resumeStatePath: this.nativeAgentLoopStatePath } : {}),
                     ...(resumeState ? { resumeState } : {}),
                     ...(resumeOnly ? { resumeOnly: true } : {}),
-                    ...(systemPrompt ? { systemPrompt } : {}),
+                    ...(agentLoopSystemPrompt ? { systemPrompt: agentLoopSystemPrompt } : {}),
                 });
                 const elapsed_ms = Date.now() - start;
                 if (result.output) {
@@ -666,9 +1074,8 @@ export class ChatRunner {
                 };
             }
         }
-        // Use llmClient with self-knowledge tools when available (function calling path)
-        // Skip executeWithTools for clients that don't support tool calling (e.g. CodexLLMClient)
-        if (this.deps.llmClient && this.deps.llmClient.supportsToolCalling?.() !== false) {
+        // Prefer the local LLM/tool loop over the external adapter fallback whenever a client is available.
+        if (this.deps.llmClient) {
             try {
                 const toolResult = await this.executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt || undefined);
                 const elapsed_ms = Date.now() - start;
@@ -812,12 +1219,14 @@ export class ChatRunner {
             const tools = this.deps.registry
                 ? toToolDefinitionsFiltered(this.deps.registry.listAll(), { activatedTools: this.activatedTools })
                 : [];
+            const supportsNativeToolCalling = llmClient.supportsToolCalling?.() !== false;
             let response;
             try {
                 this.emitActivity("lifecycle", "Calling model...", eventContext, "lifecycle:model");
                 response = await this.sendLLMMessage(llmClient, messages, {
-                    tools,
-                    ...(systemPrompt ? { system: systemPrompt } : {}),
+                    ...(supportsNativeToolCalling
+                        ? { tools, ...(systemPrompt ? { system: systemPrompt } : {}) }
+                        : { system: buildPromptedToolProtocolSystemPrompt({ systemPrompt, tools }) }),
                 }, assistantBuffer, eventContext);
             }
             catch (err) {
@@ -825,13 +1234,32 @@ export class ChatRunner {
                 const hint = err instanceof Error ? `: ${err.message}` : "";
                 throw new Error(`Sorry, I encountered an error processing your request${hint}.`);
             }
+            const toolCalls = response.tool_calls?.length
+                ? response.tool_calls
+                : supportsNativeToolCalling
+                    ? []
+                    : extractPromptedToolCalls({
+                        content: response.content,
+                        tools,
+                        createId: () => `prompted-${loop}-${crypto.randomUUID()}`,
+                    }).map((call) => ({
+                        id: call.id,
+                        type: "function",
+                        function: {
+                            name: call.name,
+                            arguments: JSON.stringify(call.input ?? {}),
+                        },
+                    }));
+            if (!supportsNativeToolCalling && toolCalls.length > 0) {
+                assistantBuffer.text = "";
+            }
             // No tool calls — return the text content
-            if (!response.tool_calls || response.tool_calls.length === 0) {
+            if (toolCalls.length === 0) {
                 return assistantBuffer.text || response.content || "(no response)";
             }
             // Append assistant message, then process tool calls
             messages.push({ role: "assistant", content: response.content || "" });
-            for (const tc of response.tool_calls) {
+            for (const tc of toolCalls) {
                 let args = {};
                 try {
                     args = JSON.parse(tc.function.arguments || "{}");