teapot-coding-agent 0.1.0

package/dist/master.js

@@ -0,0 +1,219 @@
+/**
+ * Master server: owns all agents and one low-frequency scheduler tick.
+ * Agents are in-process async loops (I/O bound only); all CPU-heavy work is
+ * delegated to subprocesses managed by the bash tool with hard timeouts.
+ */
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { Agent } from "./agent/agent.js";
+import { parseSchedule, matches } from "./scheduler/cron.js";
+const CONFIG_DIR = process.env.TEAPOT_CONFIG_DIR ??
+    path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), "teapot-coding-agent");
+const DATA_DIR = process.env.TEAPOT_DATA_DIR ??
+    process.env.XDG_DATA_HOME ??
+    path.join(os.homedir(), ".local", "share", "teapot-coding-agent");
+const DEFAULT_CONFIG = {
+    port: Number(process.env.TEAPOT_PORT ?? 7788),
+    dataDir: DATA_DIR,
+    llm: {
+        baseUrl: process.env.TEAPOT_BASE_URL ?? "https://openrouter.ai/api/v1",
+        apiKey: process.env.TEAPOT_API_KEY ?? "",
+        model: process.env.TEAPOT_MODEL ?? "",
+    },
+    providers: {},
+    agents: [],
+    tasks: [],
+};
+/** Where config is looked up / stored. */
+export function configDir() {
+    return CONFIG_DIR;
+}
+/**
+ * Resolution order:
+ *   1. explicit path argument (CLI)
+ *   2. $TEAPOT_CONFIG
+ *   3. ~/.config/teapot-coding-agent/config.json
+ *   4. ./teapot.config.json (legacy project-local)
+ */
+export function resolveConfigPath(explicitPath) {
+    if (explicitPath)
+        return path.resolve(explicitPath);
+    if (process.env.TEAPOT_CONFIG)
+        return path.resolve(process.env.TEAPOT_CONFIG);
+    const xdg = path.join(CONFIG_DIR, "config.json");
+    if (existsSync(xdg))
+        return xdg;
+    return path.resolve("teapot.config.json");
+}
+let masterRawConfig = {};
+export function loadConfig(configPath) {
+    if (!existsSync(configPath))
+        return DEFAULT_CONFIG;
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    const user = JSON.parse(readFileSync(configPath, "utf8"));
+    masterRawConfig = user;
+    return {
+        ...DEFAULT_CONFIG,
+        ...user,
+        dataDir: user.dataDir ? path.resolve(user.dataDir.replace(/^~/, os.homedir())) : DEFAULT_CONFIG.dataDir,
+        llm: { ...DEFAULT_CONFIG.llm, ...user.llm },
+        providers: { ...user.providers },
+    };
+}
+/** Raw parsed user config (for lossless persistence of web edits). */
+export function loadedRaw() {
+    return masterRawConfig;
+}
+export class Master {
+    config;
+    configPath;
+    agents = new Map();
+    tasks = [];
+    startedAt = Date.now();
+    constructor(config, configPath) {
+        this.config = config;
+        this.configPath = configPath;
+    }
+    /** Persist current logical config back to disk (lossless via raw user config). */
+    saveConfig() {
+        this.raw.agents = this.config.agents;
+        this.raw.providers = this.config.providers;
+        this.raw.defaultProvider = this.config.defaultProvider;
+        this.raw.tasks = this.config.tasks;
+        if (this.raw.progressIntervalMs === undefined && this.config.progressIntervalMs !== undefined)
+            this.raw.progressIntervalMs = this.config.progressIntervalMs;
+        writeFileSync(this.configPath, JSON.stringify(this.raw, null, 2) + "\n");
+    }
+    raw = loadedRaw();
+    /** Apply partial config edits from the web UI and persist them. */
+    updateConfig(patch) {
+        if (patch.providers)
+            this.config.providers = patch.providers;
+        if (patch.defaultProvider !== undefined)
+            this.config.defaultProvider = patch.defaultProvider;
+        if (patch.progressIntervalMs !== undefined) {
+            this.config.progressIntervalMs = patch.progressIntervalMs;
+            for (const a of this.agents.values())
+                a.opts.progressIntervalMs =
+                    patch.progressIntervalMs;
+        }
+        if (patch.tasks) {
+            this.config.tasks = patch.tasks;
+            // rebuild schedule table live
+            this.tasks = patch.tasks.map((t) => ({
+                task: t,
+                schedule: parseSchedule(t.schedule),
+                lastRunMin: -1,
+            }));
+        }
+        this.saveConfig();
+    }
+    async start() {
+        mkdirSync(this.config.dataDir, { recursive: true });
+        for (const ac of this.config.agents) {
+            await this.addAgent(ac);
+        }
+        for (const t of this.config.tasks ?? []) {
+            this.tasks.push({
+                task: t,
+                schedule: parseSchedule(t.schedule),
+                lastRunMin: -1,
+            });
+        }
+        // single low-frequency tick for everything periodic (idle cost ≈ 0)
+        setInterval(() => void this.tick(), 15_000).unref();
+    }
+    /** Create an agent; optionally persist it to the config file. */
+    async addAgent(ac, persist = false) {
+        if (this.agents.has(ac.id))
+            throw new Error(`agent id already exists: ${ac.id}`);
+        // provider resolution: inline overrides > named provider > legacy llm block
+        const provName = ac.provider ?? this.config.defaultProvider ?? "openrouter";
+        const prov = this.config.providers?.[provName];
+        if (!prov && !ac.baseUrl && !this.config.llm.baseUrl) {
+            throw new Error(`agent ${ac.id}: unknown provider "${provName}" and no fallback`);
+        }
+        const llm = {
+            baseUrl: ac.baseUrl ?? prov?.baseUrl ?? this.config.llm.baseUrl,
+            apiKey: ac.apiKey ?? prov?.apiKey ?? this.config.llm.apiKey,
+            model: ac.model ?? prov?.model ?? this.config.llm.model,
+            timeoutMs: 120_000,
+        };
+        if (!llm.model)
+            throw new Error(`agent ${ac.id}: no model configured (set model on the agent or on its provider)`);
+        const logFile = path.join(this.config.dataDir, `${ac.id}.jsonl`);
+        const agent = new Agent({
+            id: ac.id,
+            workspace: path.resolve(ac.workspace),
+            llm,
+            logFile,
+            progressIntervalMs: this.config.progressIntervalMs,
+            autoContinue: true,
+            ...(this.config.contextTokenBudget ? { contextTokenBudget: this.config.contextTokenBudget } : {}),
+            globalSkillsDir: path.join(CONFIG_DIR, "skills"),
+        });
+        await agent.init();
+        this.agents.set(ac.id, agent);
+        if (persist) {
+            this.config.agents.push(ac);
+            this.saveConfig();
+        }
+        return agent;
+    }
+    async removeAgent(id) {
+        const agent = this.agents.get(id);
+        if (!agent)
+            throw new Error(`no such agent: ${id}`);
+        this.agents.delete(id);
+        await agent.dispose();
+        this.config.agents = this.config.agents.filter((a) => a.id !== id);
+        this.saveConfig();
+    }
+    /** 4 ticks/min; each tick is a few integer compares per task. */
+    tick() {
+        const now = new Date();
+        const minuteKey = Math.floor(now.getTime() / 60_000);
+        for (const t of this.tasks) {
+            try {
+                if (!matches(t.schedule, now))
+                    continue;
+                if (t.lastRunMin === minuteKey)
+                    continue; // dedupe within the same minute
+                t.lastRunMin = minuteKey;
+                const agent = this.agents.get(t.task.agent);
+                if (!agent)
+                    continue;
+                console.log(`[teapot] scheduled task "${t.task.id}" -> agent ${t.task.agent}`);
+                void (async () => {
+                    if (t.task.forked)
+                        await agent.fork();
+                    await agent.enqueuePrompt(t.task.prompt, `scheduler:${t.task.id}`);
+                    if (agent.status !== "running")
+                        agent.start(`scheduled:${t.task.id}`);
+                })();
+            }
+            catch (err) {
+                console.error(`[teapot] scheduler error (${t.task.id}):`, err.message);
+            }
+        }
+    }
+    metrics() {
+        const mu = process.memoryUsage();
+        const cu = process.cpuUsage();
+        return {
+            uptimeSec: Math.floor((Date.now() - this.startedAt) / 1000),
+            rssMb: +(mu.rss / 1048576).toFixed(1),
+            heapUsedMb: +(mu.heapUsed / 1048576).toFixed(1),
+            cpuMsTotal: cu.user + cu.system,
+            loadavg1: +(os.loadavg()[0]).toFixed(2),
+            agents: [...this.agents.values()].map((a) => ({
+                id: a.opts_id(),
+                turns: a.stats.turns,
+                toolCalls: a.stats.toolCalls,
+                inputTokens: a.stats.inputTokens,
+                outputTokens: a.stats.outputTokens,
+            })),
+        };
+    }
+}

package/dist/scheduler/cron.js

@@ -0,0 +1,81 @@
+/**
+ * Minimal 5-field cron matcher (minute hour day-of-month month day-of-week).
+ * Also supports shorthand "every <n>s|m|h".
+ * The master ticks once every 15s; matching is a handful of integer compares.
+ */
+const BOUNDS = [
+    [0, 59],
+    [0, 23],
+    [1, 31],
+    [1, 12],
+    [0, 7], // 0 and 7 are both Sunday
+];
+function parseField(part, min, max) {
+    const out = new Set();
+    for (const piece of part.split(",")) {
+        const [range, stepStr] = piece.split("/");
+        const step = Math.max(1, Number(stepStr ?? 1) || 1);
+        if (range === "*" || range === "*/" + step) {
+            for (let i = min; i <= max; i += step)
+                out.add(i);
+        }
+        else if (range.includes("-")) {
+            const [a, b] = range.split("-").map(Number);
+            if (Number.isNaN(a) || Number.isNaN(b))
+                throw new Error(`bad cron field: ${part}`);
+            for (let i = a; i <= b; i += step)
+                out.add(i);
+        }
+        else {
+            const v = Number(range);
+            if (Number.isNaN(v))
+                throw new Error(`bad cron field: ${part}`);
+            if (!stepStr || step === 1) {
+                out.add(v);
+            }
+            else {
+                for (let i = v; i <= max; i += step)
+                    out.add(i);
+            }
+        }
+    }
+    return out;
+}
+export function parseSchedule(spec) {
+    const every = spec.trim().match(/^every\s+(\d+)\s*(s|m|h)$/i);
+    let effective = spec.trim();
+    if (every) {
+        const n = Number(every[1]);
+        const unit = every[2].toLowerCase();
+        if (unit === "s") {
+            const m = Math.max(1, Math.round(n / 60));
+            effective = `*/${m} * * * *`;
+        }
+        else if (unit === "m") {
+            effective = `*/${n} * * * *`;
+        }
+        else {
+            effective = `0 */${n} * * *`;
+        }
+    }
+    const parts = effective.split(/\s+/);
+    if (parts.length !== 5)
+        throw new Error(`bad schedule: ${spec}`);
+    return {
+        raw: spec,
+        fields: parts.map((p, i) => parseField(p, BOUNDS[i][0], BOUNDS[i][1])),
+    };
+}
+/** Does this schedule fire at the given Date? */
+export function matches(schedule, d) {
+    const values = [d.getMinutes(), d.getHours(), d.getDate(), d.getMonth() + 1, d.getDay()];
+    for (let i = 0; i < 5; i++) {
+        if (!schedule.fields[i].has(values[i])) {
+            // Sunday alias: field 5 with 7 should also match day=0
+            if (i === 4 && values[i] === 0 && schedule.fields[i].has(7))
+                continue;
+            return false;
+        }
+    }
+    return true;
+}

package/dist/server/api.js

@@ -0,0 +1,267 @@
+/**
+ * REST + SSE API on Hono, plus static file serving for the web UI.
+ */
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { readFileSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { parseSchedule } from "../scheduler/cron.js";
+import path from "node:path";
+import { bus } from "../bus.js";
+import { readEvents } from "../log/events.js";
+export function buildApp(master) {
+    const app = new Hono();
+    // ---- agents ----
+    app.get("/api/agents", (c) => c.json({ agents: [...master.agents.values()].map((a) => a.snapshot()) }));
+    // create + start an agent on an arbitrary directory
+    app.post("/api/agents", async (c) => {
+        const body = await c.req.json();
+        if (!body.workspace?.trim())
+            return c.json({ error: "workspace required" }, 400);
+        const ws = path.resolve(body.workspace.replace(/^~/, process.env.HOME ?? "~"));
+        try {
+            const st = await fs.stat(ws);
+            if (!st.isDirectory())
+                return c.json({ error: "not a directory" }, 400);
+        }
+        catch {
+            return c.json({ error: `directory not found: ${ws}` }, 400);
+        }
+        const id = (body.id?.trim() || path.basename(ws)).replace(/[^\w.-]/g, "-").slice(0, 40);
+        try {
+            const agent = await master.addAgent({ id, workspace: ws, provider: body.provider, model: body.model }, true);
+            if (body.start !== false)
+                agent.start("created via web");
+            return c.json({ ok: true, agent: agent.snapshot() });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
+    // remove agent (log file is kept)
+    app.delete("/api/agents/:id", async (c) => {
+        try {
+            await master.removeAgent(c.req.param("id"));
+            return c.json({ ok: true });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 404);
+        }
+    });
+    // ---- filesystem browsing (read-only, for the workspace picker) ----
+    app.get("/api/fs", async (c) => {
+        let p = c.req.query("path") || process.env.HOME || "/";
+        p = path.resolve(p.replace(/^~/, process.env.HOME ?? "~"));
+        try {
+            const entries = await fs.readdir(p, { withFileTypes: true });
+            return c.json({
+                path: p,
+                parent: path.dirname(p),
+                entries: entries
+                    .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+                    .slice(0, 500)
+                    .map((e) => e.name)
+                    .sort(),
+            });
+        }
+        catch {
+            return c.json({ error: "cannot read" }, 400);
+        }
+    });
+    // ---- config (view/edit from the web UI) ----
+    app.get("/api/config", (c) => {
+        const mask = (p) => Object.fromEntries(Object.entries(p ?? {}).map(([k, v]) => [
+            k,
+            { ...v, apiKey: v.apiKey ? "•••" + String(v.apiKey).slice(-4) : undefined },
+        ]));
+        return c.json({
+            configPath: master.configPath,
+            providers: mask(master.config.providers),
+            defaultProvider: master.config.defaultProvider,
+            progressIntervalMs: master.config.progressIntervalMs,
+            tasks: master.config.tasks,
+            agents: master.config.agents.map((a) => ({ id: a.id, workspace: a.workspace, provider: a.provider, model: a.model })),
+        });
+    });
+    app.put("/api/config", async (c) => {
+        const body = await c.req.json().catch(() => null);
+        if (!body)
+            return c.json({ error: "invalid JSON" }, 400);
+        try {
+            // validate schedules before applying anything
+            for (const t of body.tasks ?? [])
+                parseSchedule(t.schedule);
+            // keep masked keys intact: "•••1234" means "unchanged"
+            const prev = master.config.providers ?? {};
+            const providers = {};
+            for (const [name, p] of Object.entries(body.providers ?? {})) {
+                const masked = !p.apiKey || p.apiKey.startsWith("•••");
+                providers[name] = {
+                    baseUrl: p.baseUrl,
+                    apiKey: masked ? prev[name]?.apiKey : p.apiKey,
+                    ...(p.model ? { model: p.model } : {}),
+                };
+            }
+            master.updateConfig({
+                providers,
+                defaultProvider: body.defaultProvider,
+                progressIntervalMs: body.progressIntervalMs,
+                tasks: body.tasks,
+            });
+            return c.json({ ok: true });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
+    app.get("/api/agents/:id", (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        return a ? c.json(a.snapshot()) : c.json({ error: "not found" }, 404);
+    });
+    app.post("/api/agents/:id/prompt", async (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        const body = await c.req.json();
+        if (!body.text?.trim())
+            return c.json({ error: "text required" }, 400);
+        await a.enqueuePrompt(body.text, "user");
+        if (body.start !== false && a.status !== "running")
+            a.start("prompt");
+        return c.json({ ok: true });
+    });
+    app.post("/api/agents/:id/start", (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        a.start("api start");
+        return c.json({ ok: true });
+    });
+    app.post("/api/agents/:id/stop", (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        a.stop("stopped via api");
+        return c.json({ ok: true });
+    });
+    app.post("/api/agents/:id/goal", async (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        const body = await c.req.json();
+        if (body.text)
+            await a.setGoal(body.text);
+        else if (body.status)
+            await a.setGoalStatus(body.status);
+        else
+            return c.json({ error: "text or status required" }, 400);
+        return c.json({ ok: true });
+    });
+    app.post("/api/agents/:id/fork", async (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        const body = await c.req.json().catch(() => ({ fromEvent: null }));
+        const r = await a.fork(body.fromEvent ?? null);
+        return c.json({ ok: true, ...r });
+    });
+    // ---- event log access (human/inspect friendly) ----
+    app.get("/api/agents/:id/events", async (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        const limit = Math.min(Number(c.req.query("limit") ?? 200), 5000);
+        let events = await readEvents(a.log.filePath);
+        const branch = c.req.query("branch");
+        const session = c.req.query("session");
+        if (branch)
+            events = events.filter((e) => e.branch === branch);
+        if (session)
+            events = events.filter((e) => e.session === session);
+        return c.json({ events: events.slice(-limit), total: events.length });
+    });
+    app.get("/api/agents/:id/branches", async (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        const events = await readEvents(a.log.filePath);
+        const branches = new Map();
+        for (const e of events) {
+            const b = branches.get(e.branch) ?? { branch: e.branch, events: 0 };
+            b.events++;
+            if (e.type === "fork")
+                b.forkedFrom = e.data;
+            branches.set(e.branch, b);
+        }
+        return c.json({ branches: [...branches.values()] });
+    });
+    // ---- metrics / SSE ----
+    app.get("/api/metrics", (c) => c.json(master.metrics()));
+    app.get("/api/events", (c) => {
+        c.header("content-type", "text/event-stream");
+        c.header("cache-control", "no-cache");
+        c.header("connection", "keep-alive");
+        const stream = new ReadableStream({
+            start(controller) {
+                const enc = new TextEncoder();
+                const send = (data) => controller.enqueue(enc.encode(`data: ${JSON.stringify(data)}\n\n`));
+                send({ kind: "hello", agents: [...master.agents.values()].map((a) => a.snapshot()) });
+                const onUpdate = (ev) => send(ev);
+                bus.on("update", onUpdate);
+                // keep-alive comment every 30s so proxies don't close the stream
+                const ka = setInterval(() => controller.enqueue(enc.encode(": ping\n\n")), 30_000);
+                ;
+                controller._cleanup = () => {
+                    clearInterval(ka);
+                    bus.off("update", onUpdate);
+                };
+            },
+            cancel() {
+                /* handled in _cleanup via abort signal below */
+            },
+        });
+        c.req.raw.signal.addEventListener("abort", () => {
+            /* node-server closes the stream; cleanup runs on cancel */
+        });
+        return c.body(stream);
+    });
+    // RFC 2324 / HTCPCP compliance
+    app.on(["GET", "POST", "BREW"], "/brew", (c) => c.text("418 I'm a teapot \u{1FAD6}", 418));
+    app.on(["GET", "POST", "BREW"], "/brew/coffee", (c) => c.text("418 I'm a teapot — coffee not supported (see RFC 2324 §2.3.2)", 418));
+    // ---- web ui (built by vite into ./public; no bundler needed to serve) ----
+    const webRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), import.meta.url.includes("/dist/") ? "../../public" : "../../public");
+    const mime = {
+        ".html": "text/html",
+        ".js": "text/javascript",
+        ".css": "text/css",
+        ".svg": "image/svg+xml",
+        ".ico": "image/x-icon",
+    };
+    app.get("/", (c) => {
+        try {
+            return c.html(readFileSync(path.join(webRoot, "index.html"), "utf8"));
+        }
+        catch {
+            return c.text("web UI not built — run: pnpm build-web", 404);
+        }
+    });
+    app.get("/assets/*", (c) => {
+        const rel = c.req.path.replace("/assets/", "");
+        const file = path.resolve(webRoot, "assets", path.basename(rel)); // basename: no traversal
+        try {
+            return c.body(readFileSync(file), 200, {
+                "content-type": mime[path.extname(file)] ?? "application/octet-stream",
+            });
+        }
+        catch {
+            return c.notFound();
+        }
+    });
+    return app;
+}
+export function serveApp(app, port) {
+    serve({ fetch: app.fetch, port }, (info) => {
+        console.log(`[teapot] master listening on http://localhost:${info.port}`);
+    });
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "teapot-coding-agent",
+  "version": "0.1.0",
+  "description": "A lightweight, always-on multi-agent harness for AI coding agents",
+  "type": "module",
+  "license": "AGPL-3.0-or-later",
+  "keywords": [
+    "ai",
+    "agent",
+    "coding-agent",
+    "llm",
+    "harness",
+    "autonomous-agents"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/akku1139/teapot.git"
+  },
+  "packageManager": "pnpm@11.3.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "teapot": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "public",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && vite build",
+    "build-server": "tsc -p tsconfig.json",
+    "build-web": "vite build",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "dev-web": "vite",
+    "test": "node --import tsx --test test/*.test.ts"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.14.0",
+    "hono": "^4.7.0",
+    "openai": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "solid-js": "^1.9.15",
+    "tsx": "^4.20.0",
+    "typescript": "^5.8.0",
+    "vite": "^8.2.2",
+    "vite-plugin-solid": "^2.11.14"
+  }
+}

package/public/assets/index-CxlAQ_0i.css

@@ -0,0 +1 @@
+:root{--bg-darkest:#1a1c22;--bg-dark:#232630;--bg-mid:#2b2e39;--bg-light:#343845;--fg:#dcdee4;--dim:#9298a5;--line:#1d2027;--acc:#5865f2;--ok:#3ba55d;--warn:#faa81a;--err:#ed4245;--tool:#3ba0c9;font-family:gg sans,ui-sans-serif,system-ui,-apple-system,Segoe UI,sans-serif}*{box-sizing:border-box}html,body,#root{height:100%;margin:0}body{background:var(--bg-dark);color:var(--fg);font-size:15px}.layout{grid-template-columns:250px 1fr 300px;height:100vh;display:grid}@media (width<=1100px){.layout{grid-template-columns:220px 1fr}.rightbar{display:none}}.sidebar{background:var(--bg-darkest);padding:10px 8px;overflow-y:auto}.sidebar h1{color:var(--fg);margin:0;padding:4px 8px 10px;font-size:14px}.agent-item{cursor:pointer;color:var(--dim);border-radius:6px;align-items:center;gap:8px;margin-bottom:2px;padding:7px 10px;display:flex}.agent-item:hover{background:var(--bg-mid)}.agent-item.sel{background:var(--bg-mid);color:var(--fg)}.dot{border-radius:50%;flex-shrink:0;width:9px;height:9px}.dot.running{background:var(--ok);box-shadow:0 0 6px var(--ok)}.dot.idle{background:var(--warn)}.dot.stopped{background:var(--dim)}.dot.error{background:var(--err);box-shadow:0 0 6px var(--err)}.sidebar .metrics{color:var(--dim);border-top:1px solid var(--line);margin-top:12px;padding:8px 10px;font-size:11px;line-height:1.7}.channel{flex-direction:column;min-width:0;display:flex}.chan-head{border-bottom:2px solid var(--line);background:var(--bg-dark);align-items:center;gap:10px;padding:10px 16px;display:flex}.chan-head .hash{color:var(--dim);font-size:20px}.chan-head .title{font-weight:700}.chan-head .sub{color:var(--dim);text-overflow:ellipsis;white-space:nowrap;margin-left:8px;font-size:12px;overflow:hidden}.badge{background:var(--bg-light);vertical-align:middle;border-radius:10px;padding:1px 8px;font-size:11px}.badge.running{color:var(--ok)}.badge.error{color:var(--err)}.badge.idle{color:var(--warn)}.badge.done{color:var(--acc)}.feed{flex:1;padding:14px 0 8px;overflow-y:auto}.msg{gap:14px;padding:3px 18px;display:flex}.msg:hover{background:#ffffff08}.msg.grouped{padding-top:0}.avatar{border-radius:50%;flex-shrink:0;justify-content:center;align-items:center;width:38px;height:38px;margin-top:2px;font-size:17px;display:flex}.msg-body{flex:1;min-width:0}.msg-head{align-items:baseline;gap:8px;display:flex}.author{font-size:14.5px;font-weight:600}.ts{color:var(--dim);font-size:11px}.content{white-space:pre-wrap;word-break:break-word;line-height:1.45}.content p{margin:2px 0}.content pre{background:var(--bg-darkest);border-radius:6px;padding:8px;overflow-x:auto}.content code{background:var(--bg-darkest);border-radius:4px;padding:1px 4px;font-size:13px}.content h1,.content h2,.content h3,.content h4{margin:8px 0 2px;font-size:15px}.embed{border-left:3px solid var(--tool);background:var(--bg-darkest);border-radius:4px;margin-top:3px;padding:6px 10px;font-size:13.5px}.embed.fail{border-color:var(--err)}.embed .mono{white-space:pre-wrap;word-break:break-word;font-family:ui-monospace,Menlo,monospace;font-size:12.5px}.embed .meta{color:var(--dim);margin-top:3px;font-size:11px}.divider-msg{color:var(--dim);align-items:center;gap:10px;padding:4px 18px;font-size:11.5px;display:flex}.divider-msg:before,.divider-msg:after{content:"";background:var(--line);flex:1;height:1px}.divider-msg.err{color:var(--err)}.day-divider{align-items:center;gap:10px;padding:14px 18px 6px;display:flex}.day-divider:before,.day-divider:after{content:"";background:var(--bg-light);flex:1;height:1px}.day-divider span{color:var(--dim);font-size:11px}.composer{padding:0 16px 18px}.composer form{background:var(--bg-light);border-radius:10px;align-items:center;gap:8px;padding:10px 12px;display:flex}.composer input[type=text]{color:var(--fg);font:inherit;background:0 0;border:none;outline:none;flex:1}.composer button{background:var(--acc);color:#fff;cursor:pointer;border:none;border-radius:8px;padding:7px 14px;font-weight:600}.composer button:hover{opacity:.9}.composer label{color:var(--dim);white-space:nowrap;align-items:center;gap:4px;font-size:12px;display:flex}.hint{color:var(--dim);margin-top:5px;font-size:11px}.rightbar{background:var(--bg-dark);border-left:2px solid var(--line);padding:14px;font-size:13px;overflow-y:auto}.rightbar h3{text-transform:uppercase;letter-spacing:.04em;color:var(--dim);margin:14px 0 6px;font-size:11px}.rightbar h3:first-child{margin-top:0}.card{background:var(--bg-darkest);white-space:pre-wrap;word-break:break-word;border-radius:8px;max-height:200px;padding:10px;overflow-y:auto}.muted{color:var(--dim)}.branch-row{color:var(--dim);cursor:pointer;justify-content:space-between;padding:3px 0;font-size:12px;display:flex}.branch-row:hover,.branch-row.cur{color:var(--fg)}.btnrow{gap:6px;margin:8px 0;display:flex}.btnrow button{background:var(--bg-light);color:var(--fg);cursor:pointer;border:none;border-radius:6px;padding:6px 10px;font-size:13px}.btnrow button:hover{filter:brightness(1.2)}.iconbtn{background:var(--bg-light);color:var(--fg);cursor:pointer;border:none;border-radius:6px;width:26px;height:24px;font-size:13px}.iconbtn:hover{filter:brightness(1.3)}.overlay{z-index:10;background:#0009;place-items:center;display:grid;position:fixed;inset:0}.modal{background:var(--bg-mid);border-radius:10px;width:min(620px,92vw);max-height:88vh;padding:16px 18px;overflow-y:auto}.modal-head{justify-content:space-between;align-items:center;margin-bottom:12px;font-size:16px;display:flex}.modal label{color:var(--dim);flex-direction:column;gap:4px;font-size:12.5px;display:flex}.modal input[type=text],.modal input[type=number],.modal select,.modal textarea{background:var(--bg-darkest);color:var(--fg);font:inherit;border:none;border-radius:6px;outline:none;padding:7px 9px}.modal textarea{resize:vertical}.w100{width:100%}.mono{font-family:ui-monospace,Menlo,monospace;font-size:13px}.dirlist{background:var(--bg-darkest);border-radius:6px;max-height:160px;padding:4px;overflow-y:auto}.direntry{cursor:pointer;border-radius:4px;padding:4px 8px;font-size:14px}.direntry:hover{background:var(--bg-light)}