@phren/agent 0.0.1

package/dist/commands.js

@@ -0,0 +1,292 @@
+import { estimateMessageTokens } from "./context/token-counter.js";
+import { pruneMessages } from "./context/pruner.js";
+import { listPresets, loadPreset, savePreset, deletePreset, formatPreset } from "./multi/presets.js";
+import { renderMarkdown } from "./multi/markdown.js";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+const HISTORY_MAX_LINES = 5;
+export function createCommandContext(session, contextLimit) {
+    return {
+        session,
+        contextLimit,
+        undoStack: [],
+    };
+}
+/** Truncate text to N lines, appending [+M lines] if overflow. */
+function truncateText(text, maxLines) {
+    const lines = text.split("\n");
+    if (lines.length <= maxLines)
+        return text;
+    const overflow = lines.length - maxLines;
+    return lines.slice(0, maxLines).join("\n") + `\n${DIM}[+${overflow} lines]${RESET}`;
+}
+/**
+ * Try to handle a slash command. Returns true if the input was a command.
+ */
+export function handleCommand(input, ctx) {
+    const parts = input.trim().split(/\s+/);
+    const name = parts[0];
+    switch (name) {
+        case "/help":
+            process.stderr.write(`${DIM}Commands:
+  /help       Show this help
+  /turns      Show turn and tool call counts
+  /clear      Clear conversation history
+  /cost       Show token usage and estimated cost
+  /plan       Show conversation plan (tool calls so far)
+  /undo       Undo last user message and response
+  /history [n|full]  Show last N messages (default 10) with rich formatting
+  /compact    Compact conversation to save context space
+  /mode       Toggle input mode (steering ↔ queue)
+  /spawn <name> <task>  Spawn a background agent
+  /agents     List running agents
+  /preset [name|save|delete|list]  Config presets
+  /exit       Exit the REPL${RESET}\n`);
+            return true;
+        case "/turns": {
+            const tokens = estimateMessageTokens(ctx.session.messages);
+            const pct = ctx.contextLimit > 0 ? ((tokens / ctx.contextLimit) * 100).toFixed(1) : "?";
+            const costLine = ctx.costTracker ? `  Cost: $${ctx.costTracker.totalCost.toFixed(4)}` : "";
+            process.stderr.write(`${DIM}Turns: ${ctx.session.turns}  Tool calls: ${ctx.session.toolCalls}  ` +
+                `Messages: ${ctx.session.messages.length}  Tokens: ~${tokens} (${pct}%)${costLine}${RESET}\n`);
+            return true;
+        }
+        case "/clear":
+            ctx.session.messages.length = 0;
+            ctx.session.turns = 0;
+            ctx.session.toolCalls = 0;
+            ctx.undoStack.length = 0;
+            process.stderr.write(`${DIM}Conversation cleared.${RESET}\n`);
+            return true;
+        case "/cost": {
+            const ct = ctx.costTracker;
+            if (ct) {
+                process.stderr.write(`${DIM}Tokens — input: ${ct.inputTokens}  output: ${ct.outputTokens}  est. cost: $${ct.totalCost.toFixed(4)}${RESET}\n`);
+            }
+            else {
+                process.stderr.write(`${DIM}Cost tracking not available.${RESET}\n`);
+            }
+            return true;
+        }
+        case "/plan": {
+            const tools = [];
+            for (const msg of ctx.session.messages) {
+                if (typeof msg.content !== "string") {
+                    for (const block of msg.content) {
+                        if (block.type === "tool_use") {
+                            tools.push(block.name);
+                        }
+                    }
+                }
+            }
+            if (tools.length === 0) {
+                process.stderr.write(`${DIM}No tool calls yet.${RESET}\n`);
+            }
+            else {
+                process.stderr.write(`${DIM}Tool calls (${tools.length}): ${tools.join(" → ")}${RESET}\n`);
+            }
+            return true;
+        }
+        case "/undo": {
+            if (ctx.session.messages.length < 2) {
+                process.stderr.write(`${DIM}Nothing to undo.${RESET}\n`);
+                return true;
+            }
+            // Remove messages back to the previous user message
+            let removed = 0;
+            while (ctx.session.messages.length > 0) {
+                const last = ctx.session.messages.pop();
+                removed++;
+                if (last?.role === "user" && typeof last.content === "string")
+                    break;
+            }
+            process.stderr.write(`${DIM}Undid ${removed} messages.${RESET}\n`);
+            return true;
+        }
+        case "/history": {
+            const msgs = ctx.session.messages;
+            if (msgs.length === 0) {
+                process.stderr.write(`${DIM}No messages yet.${RESET}\n`);
+                return true;
+            }
+            const arg = parts[1];
+            const isFull = arg === "full";
+            const count = isFull ? msgs.length : Math.min(parseInt(arg, 10) || 10, msgs.length);
+            const slice = msgs.slice(-count);
+            const tokens = estimateMessageTokens(msgs);
+            const pct = ctx.contextLimit > 0 ? ((tokens / ctx.contextLimit) * 100).toFixed(1) : "?";
+            process.stderr.write(`${DIM}── History (${slice.length}/${msgs.length} messages, ~${tokens} tokens, ${pct}% context) ──${RESET}\n`);
+            for (const msg of slice) {
+                if (msg.role === "user") {
+                    if (typeof msg.content === "string") {
+                        const truncated = truncateText(msg.content, isFull ? Infinity : HISTORY_MAX_LINES);
+                        process.stderr.write(`\n${CYAN}${BOLD}You:${RESET} ${truncated}\n`);
+                    }
+                    else {
+                        // Tool results
+                        for (const block of msg.content) {
+                            if (block.type === "tool_result") {
+                                const icon = block.is_error ? `${RED}✗${RESET}` : `${GREEN}✓${RESET}`;
+                                const preview = (block.content ?? "").slice(0, 80).replace(/\n/g, " ");
+                                process.stderr.write(`${DIM}  ${icon} tool_result ${preview}${preview.length >= 80 ? "..." : ""}${RESET}\n`);
+                            }
+                            else if (block.type === "text") {
+                                process.stderr.write(`${DIM}  ${block.text.slice(0, 100)}${RESET}\n`);
+                            }
+                        }
+                    }
+                }
+                else if (msg.role === "assistant") {
+                    if (typeof msg.content === "string") {
+                        const rendered = isFull ? renderMarkdown(msg.content) : truncateText(msg.content, HISTORY_MAX_LINES);
+                        process.stderr.write(`\n${GREEN}${BOLD}Agent:${RESET}\n${rendered}\n`);
+                    }
+                    else {
+                        for (const block of msg.content) {
+                            if (block.type === "text") {
+                                const text = block.text;
+                                const rendered = isFull ? renderMarkdown(text) : truncateText(text, HISTORY_MAX_LINES);
+                                process.stderr.write(`\n${GREEN}${BOLD}Agent:${RESET}\n${rendered}\n`);
+                            }
+                            else if (block.type === "tool_use") {
+                                const tb = block;
+                                const inputPreview = JSON.stringify(tb.input).slice(0, 60);
+                                process.stderr.write(`${YELLOW}  ⚡ ${tb.name}${RESET}${DIM}(${inputPreview})${RESET}\n`);
+                            }
+                        }
+                    }
+                }
+            }
+            process.stderr.write(`${DIM}── end ──${RESET}\n`);
+            return true;
+        }
+        case "/compact": {
+            const before = ctx.session.messages.length;
+            ctx.session.messages = pruneMessages(ctx.session.messages, { contextLimit: ctx.contextLimit, keepRecentTurns: 4 });
+            const after = ctx.session.messages.length;
+            process.stderr.write(`${DIM}Compacted: ${before} → ${after} messages.${RESET}\n`);
+            return true;
+        }
+        case "/spawn": {
+            if (!ctx.spawner) {
+                process.stderr.write(`${DIM}Spawner not available. Start with --multi or --team to enable.${RESET}\n`);
+                return true;
+            }
+            const spawnName = parts[1];
+            const spawnTask = parts.slice(2).join(" ");
+            if (!spawnName || !spawnTask) {
+                process.stderr.write(`${DIM}Usage: /spawn <name> <task>${RESET}\n`);
+                return true;
+            }
+            const agentId = ctx.spawner.spawn({ task: spawnTask, cwd: process.cwd() });
+            process.stderr.write(`${DIM}Spawned agent "${spawnName}" (${agentId}): ${spawnTask}${RESET}\n`);
+            return true;
+        }
+        case "/agents": {
+            if (!ctx.spawner) {
+                process.stderr.write(`${DIM}No spawner available. Start with --multi or --team to enable.${RESET}\n`);
+                return true;
+            }
+            const agents = ctx.spawner.listAgents();
+            if (agents.length === 0) {
+                process.stderr.write(`${DIM}No agents running.${RESET}\n`);
+            }
+            else {
+                const lines = agents.map((a) => {
+                    const elapsed = a.finishedAt
+                        ? `${((a.finishedAt - a.startedAt) / 1000).toFixed(1)}s`
+                        : `${((Date.now() - a.startedAt) / 1000).toFixed(0)}s`;
+                    return `  ${a.id} [${a.status}] ${elapsed} — ${a.task.slice(0, 60)}`;
+                });
+                process.stderr.write(`${DIM}Agents (${agents.length}):\n${lines.join("\n")}${RESET}\n`);
+            }
+            return true;
+        }
+        case "/preset": {
+            const sub = parts[1]?.toLowerCase();
+            if (!sub || sub === "list") {
+                const all = listPresets();
+                if (all.length === 0) {
+                    process.stderr.write(`${DIM}No presets.${RESET}\n`);
+                }
+                else {
+                    const lines = all.map((p) => `  ${formatPreset(p.name, p.preset, p.builtin)}`);
+                    process.stderr.write(`${DIM}Presets:\n${lines.join("\n")}${RESET}\n`);
+                }
+                return true;
+            }
+            if (sub === "save") {
+                // /preset save <name> [provider=X] [model=X] [permissions=X] [max-turns=N] [budget=N] [plan]
+                const presetName = parts[2];
+                if (!presetName) {
+                    process.stderr.write(`${DIM}Usage: /preset save <name> [provider=X] [model=X] [permissions=X] [max-turns=N] [budget=N] [plan]${RESET}\n`);
+                    return true;
+                }
+                const preset = {};
+                for (const arg of parts.slice(3)) {
+                    const [k, v] = arg.split("=", 2);
+                    if (k === "provider")
+                        preset.provider = v;
+                    else if (k === "model")
+                        preset.model = v;
+                    else if (k === "permissions")
+                        preset.permissions = v;
+                    else if (k === "max-turns")
+                        preset.maxTurns = parseInt(v, 10) || undefined;
+                    else if (k === "budget")
+                        preset.budget = v === "none" ? null : parseFloat(v) || undefined;
+                    else if (k === "plan")
+                        preset.plan = true;
+                }
+                try {
+                    savePreset(presetName, preset);
+                    process.stderr.write(`${DIM}Saved preset "${presetName}".${RESET}\n`);
+                }
+                catch (err) {
+                    process.stderr.write(`${DIM}${err instanceof Error ? err.message : String(err)}${RESET}\n`);
+                }
+                return true;
+            }
+            if (sub === "delete") {
+                const presetName = parts[2];
+                if (!presetName) {
+                    process.stderr.write(`${DIM}Usage: /preset delete <name>${RESET}\n`);
+                    return true;
+                }
+                try {
+                    const ok = deletePreset(presetName);
+                    process.stderr.write(`${DIM}${ok ? `Deleted "${presetName}".` : `Preset "${presetName}" not found.`}${RESET}\n`);
+                }
+                catch (err) {
+                    process.stderr.write(`${DIM}${err instanceof Error ? err.message : String(err)}${RESET}\n`);
+                }
+                return true;
+            }
+            // /preset <name> — show preset details (use --preset <name> on CLI to apply at startup)
+            const preset = loadPreset(sub);
+            if (!preset) {
+                process.stderr.write(`${DIM}Preset "${sub}" not found. Use /preset list to see available presets.${RESET}\n`);
+            }
+            else {
+                const isBuiltin = ["fast", "careful", "yolo"].includes(sub);
+                process.stderr.write(`${DIM}${formatPreset(sub, preset, isBuiltin)}\nUse: phren-agent --preset ${sub} <task>${RESET}\n`);
+            }
+            return true;
+        }
+        case "/exit":
+        case "/quit":
+        case "/q":
+            process.exit(0);
+        default:
+            if (input.startsWith("/")) {
+                process.stderr.write(`${DIM}Unknown command: ${name}. Type /help for commands.${RESET}\n`);
+                return true;
+            }
+            return false;
+    }
+}

package/dist/config.js

@@ -0,0 +1,139 @@
+const HELP = `
+phren-agent — coding agent with persistent memory
+
+Usage: phren-agent [options] <task>
+
+Options:
+  --provider <name>    Force provider: openrouter, anthropic, openai, codex, ollama
+  --model <model>      Override LLM model
+  --project <name>     Force phren project context
+  --max-turns <n>      Max tool-use turns (default: 50)
+  --budget <dollars>   Max spend in USD (aborts when exceeded)
+  --plan               Plan mode: show plan before executing tools
+  --permissions <mode> Permission mode: suggest, auto-confirm, full-auto (default: auto-confirm)
+  --interactive, -i    Interactive REPL mode (multi-turn conversation)
+  --resume             Resume last session's conversation
+  --lint-cmd <cmd>     Override auto-detected lint command
+  --test-cmd <cmd>     Override auto-detected test command
+  --mcp <command>      Connect to an MCP server via stdio (repeatable)
+  --mcp-config <path>  Load MCP server config from JSON file
+  --team <name>        Start in team mode with named team coordination
+  --multi              Start in multi-agent TUI mode
+  --dry-run            Show system prompt and exit
+  --verbose            Show tool calls as they execute
+  --version            Show version
+  --help               Show this help
+
+Providers (auto-detected from env, or use --provider):
+  openrouter           OPENROUTER_API_KEY — routes to any model (default)
+  anthropic            ANTHROPIC_API_KEY — Claude direct
+  openai               OPENAI_API_KEY — OpenAI direct
+  codex                Uses your ChatGPT/Codex subscription directly
+                       (no API key needed, flat rate via your subscription)
+                       Setup: phren-agent auth login
+  ollama               PHREN_OLLAMA_URL — local models (default: localhost:11434)
+
+Environment:
+  PHREN_AGENT_PROVIDER Force provider via env
+  PHREN_AGENT_MODEL    Override model via env
+
+Examples:
+  phren-agent "fix the login bug"
+  phren-agent --provider codex "add input validation"
+  phren-agent --provider anthropic --verbose "refactor the database layer"
+`.trim();
+export function parseArgs(argv) {
+    const args = {
+        task: "",
+        permissions: "auto-confirm",
+        maxTurns: 50,
+        budget: null,
+        plan: false,
+        dryRun: false,
+        verbose: false,
+        interactive: false,
+        resume: false,
+        mcp: [],
+        multi: false,
+        help: false,
+        version: false,
+    };
+    const positional = [];
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg === "--help" || arg === "-h") {
+            args.help = true;
+        }
+        else if (arg === "--version" || arg === "-v") {
+            args.version = true;
+        }
+        else if (arg === "--dry-run") {
+            args.dryRun = true;
+        }
+        else if (arg === "--verbose") {
+            args.verbose = true;
+        }
+        else if (arg === "--interactive" || arg === "-i") {
+            args.interactive = true;
+        }
+        else if (arg === "--plan") {
+            args.plan = true;
+        }
+        else if (arg === "--resume") {
+            args.resume = true;
+        }
+        else if (arg === "--lint-cmd" && argv[i + 1]) {
+            args.lintCmd = argv[++i];
+        }
+        else if (arg === "--test-cmd" && argv[i + 1]) {
+            args.testCmd = argv[++i];
+        }
+        else if (arg === "--mcp" && argv[i + 1]) {
+            args.mcp.push(argv[++i]);
+        }
+        else if (arg === "--mcp-config" && argv[i + 1]) {
+            args.mcpConfig = argv[++i];
+        }
+        else if (arg === "--team" && argv[i + 1]) {
+            args.team = argv[++i];
+        }
+        else if (arg === "--multi") {
+            args.multi = true;
+        }
+        else if (arg === "--provider" && argv[i + 1]) {
+            args.provider = argv[++i];
+        }
+        else if (arg === "--model" && argv[i + 1]) {
+            args.model = argv[++i];
+        }
+        else if (arg === "--project" && argv[i + 1]) {
+            args.project = argv[++i];
+        }
+        else if (arg === "--max-turns" && argv[i + 1]) {
+            args.maxTurns = parseInt(argv[++i], 10) || 50;
+        }
+        else if (arg === "--budget" && argv[i + 1]) {
+            args.budget = parseFloat(argv[++i]) || null;
+        }
+        else if (arg === "--permissions" && argv[i + 1]) {
+            const mode = argv[++i];
+            if (mode === "suggest" || mode === "auto-confirm" || mode === "full-auto") {
+                args.permissions = mode;
+            }
+        }
+        else if (!arg.startsWith("-")) {
+            positional.push(arg);
+        }
+        i++;
+    }
+    args.task = positional.join(" ");
+    // Also check env for model override
+    if (!args.model && process.env.PHREN_AGENT_MODEL) {
+        args.model = process.env.PHREN_AGENT_MODEL;
+    }
+    return args;
+}
+export function printHelp() {
+    console.log(HELP);
+}

package/dist/context/pruner.js

@@ -0,0 +1,62 @@
+import { estimateTokens, estimateMessageTokens } from "./token-counter.js";
+const DEFAULT_CONFIG = {
+    contextLimit: 200_000,
+    keepRecentTurns: 6,
+};
+/** Returns true when the conversation is approaching context limits. */
+export function shouldPrune(systemPrompt, messages, config) {
+    const limit = config?.contextLimit ?? DEFAULT_CONFIG.contextLimit;
+    const systemTokens = estimateTokens(systemPrompt);
+    const msgTokens = estimateMessageTokens(messages);
+    return (systemTokens + msgTokens) > limit * 0.75;
+}
+/** Prune messages, keeping the first (original task) and last N turn pairs. */
+export function pruneMessages(messages, config) {
+    const keepRecent = config?.keepRecentTurns ?? DEFAULT_CONFIG.keepRecentTurns;
+    const keepRecentMessages = keepRecent * 2; // each turn = user + assistant
+    // Not enough messages to prune
+    if (messages.length <= keepRecentMessages + 1) {
+        return messages;
+    }
+    const first = messages[0]; // original task
+    // Walk backwards from split point to ensure tail starts with a user text message,
+    // not a tool_result-only message (which would be orphaned without its tool_use).
+    let splitIdx = messages.length - keepRecentMessages;
+    while (splitIdx > 1) {
+        const msg = messages[splitIdx];
+        if (msg.role === "user") {
+            // Check if this is a text message (not just tool_results)
+            if (typeof msg.content === "string")
+                break;
+            const hasText = msg.content.some((b) => b.type === "text");
+            if (hasText)
+                break;
+        }
+        splitIdx--;
+    }
+    const middle = messages.slice(1, splitIdx);
+    const tail = messages.slice(splitIdx);
+    // Collect tool names used in the pruned middle section
+    const toolsUsed = new Set();
+    for (const msg of middle) {
+        if (typeof msg.content !== "string") {
+            for (const block of msg.content) {
+                if (block.type === "tool_use") {
+                    toolsUsed.add(block.name);
+                }
+            }
+        }
+    }
+    const summaryText = [
+        `[Context compacted: ${middle.length} messages removed]`,
+        toolsUsed.size > 0 ? `Tools used: ${[...toolsUsed].join(", ")}` : null,
+        `Key points: ${middle.length} intermediate turns were compacted to fit context window.`,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const summaryMessage = {
+        role: "user",
+        content: summaryText,
+    };
+    return [first, summaryMessage, ...tail];
+}

package/dist/context/token-counter.js

@@ -0,0 +1,28 @@
+/** Rough token estimate: ~4 chars per token. */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/** Estimate total tokens across a message array. */
+export function estimateMessageTokens(messages) {
+    let total = 0;
+    for (const msg of messages) {
+        total += 4; // per-message overhead
+        if (typeof msg.content === "string") {
+            total += estimateTokens(msg.content);
+        }
+        else {
+            for (const block of msg.content) {
+                if (block.type === "text") {
+                    total += estimateTokens(block.text);
+                }
+                else if (block.type === "tool_result") {
+                    total += estimateTokens(block.content);
+                }
+                else if (block.type === "tool_use") {
+                    total += estimateTokens(JSON.stringify(block.input));
+                }
+            }
+        }
+    }
+    return total;
+}

package/dist/cost.js

@@ -0,0 +1,71 @@
+/** Cost tracking for LLM API usage. */
+// Pricing table — prefix match (most specific wins)
+const PRICING = [
+    // Anthropic
+    ["claude-opus-4", { inputPer1M: 15, outputPer1M: 75 }],
+    ["claude-sonnet-4", { inputPer1M: 3, outputPer1M: 15 }],
+    ["claude-haiku-4", { inputPer1M: 0.80, outputPer1M: 4 }],
+    ["claude-3-5-sonnet", { inputPer1M: 3, outputPer1M: 15 }],
+    ["claude-3-5-haiku", { inputPer1M: 0.80, outputPer1M: 4 }],
+    ["claude-3-opus", { inputPer1M: 15, outputPer1M: 75 }],
+    // OpenAI
+    ["gpt-5", { inputPer1M: 2.50, outputPer1M: 10 }],
+    ["gpt-4.1", { inputPer1M: 2, outputPer1M: 8 }],
+    ["gpt-4o", { inputPer1M: 2.50, outputPer1M: 10 }],
+    ["gpt-4-turbo", { inputPer1M: 10, outputPer1M: 30 }],
+    ["gpt-4", { inputPer1M: 30, outputPer1M: 60 }],
+    ["o3", { inputPer1M: 2, outputPer1M: 8 }],
+    ["o4-mini", { inputPer1M: 1.10, outputPer1M: 4.40 }],
+    // OpenRouter prefixed
+    ["anthropic/claude-opus-4", { inputPer1M: 15, outputPer1M: 75 }],
+    ["anthropic/claude-sonnet-4", { inputPer1M: 3, outputPer1M: 15 }],
+    ["anthropic/claude-haiku-4", { inputPer1M: 0.80, outputPer1M: 4 }],
+    ["openai/gpt-4o", { inputPer1M: 2.50, outputPer1M: 10 }],
+    // Local (free)
+    ["ollama", { inputPer1M: 0, outputPer1M: 0 }],
+];
+PRICING.sort((a, b) => b[0].length - a[0].length); // longest prefix first
+function lookupPricing(model) {
+    const lower = model.toLowerCase();
+    for (const [prefix, pricing] of PRICING) {
+        if (lower.startsWith(prefix))
+            return pricing;
+    }
+    // Default fallback — assume mid-tier pricing
+    return { inputPer1M: 3, outputPer1M: 15 };
+}
+export function createCostTracker(model, budget = null) {
+    const pricing = lookupPricing(model);
+    const tracker = {
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCost: 0,
+        budget,
+        recordUsage(inputTokens, outputTokens) {
+            tracker.totalInputTokens += inputTokens;
+            tracker.totalOutputTokens += outputTokens;
+            tracker.totalCost +=
+                (inputTokens / 1_000_000) * pricing.inputPer1M +
+                    (outputTokens / 1_000_000) * pricing.outputPer1M;
+        },
+        isOverBudget() {
+            return budget !== null && tracker.totalCost >= budget;
+        },
+        formatCost() {
+            const cost = tracker.totalCost < 0.01
+                ? `$${tracker.totalCost.toFixed(4)}`
+                : `$${tracker.totalCost.toFixed(2)}`;
+            const tokens = `${tracker.totalInputTokens + tracker.totalOutputTokens} tokens`;
+            const budgetStr = budget !== null ? ` / $${budget.toFixed(2)} budget` : "";
+            return `${cost} (${tokens}${budgetStr})`;
+        },
+        formatTurnCost(inputTokens, outputTokens) {
+            const turnCost = (inputTokens / 1_000_000) * pricing.inputPer1M +
+                (outputTokens / 1_000_000) * pricing.outputPer1M;
+            return turnCost < 0.01
+                ? `$${turnCost.toFixed(4)}`
+                : `$${turnCost.toFixed(2)}`;
+        },
+    };
+    return tracker;
+}