@ohmaseclaro/fleetwatch 0.1.0

package/dist/server/watcher.js

@@ -0,0 +1,578 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import chokidar from "chokidar";
+import { parseLineMulti, parseTitleLine } from "./jsonl.js";
+import { attachmentStore } from "./attachmentStore.js";
+import { readDelta, readEntireFile, readHeadTail, readTailLines } from "./tail.js";
+import { decodeProjectDir } from "./projectPath.js";
+import { BaseProvider } from "./providers/base.js";
+const HOME = os.homedir();
+/** Default location — most installs use this. */
+export const CLAUDE_PROJECTS_DIR = path.join(HOME, ".claude", "projects");
+export const COWORK_DIR = path.join(HOME, "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+export const HISTORY_FILE = path.join(HOME, ".claude", "history.jsonl");
+/**
+ * Quick-and-cheap predicate: does a JSONL file look like a Claude-family
+ * session log (Claude Code OR Cowork — they share the format but differ in
+ * casing)? Reads at most the first KB and checks for shape markers:
+ *
+ *   - `type: user/assistant/...` (always present)
+ *   - `message: {...}` (the canonical event envelope) OR any of the
+ *     known id fields (camelCase from Claude Code, snake_case from Cowork)
+ *
+ * False negatives (we don't recognize a real Claude file) are rare; false
+ * positives are unlikely because random JSONL files don't carry the exact
+ * type values we look for.
+ */
+async function looksLikeClaudeJsonl(file) {
+    let fh = null;
+    try {
+        fh = await fs.open(file, "r");
+        const buf = Buffer.alloc(1024);
+        await fh.read(buf, 0, buf.length, 0);
+        const text = buf.toString("utf8");
+        const firstLine = text.split(/\r?\n/, 1)[0] ?? "";
+        if (!firstLine.startsWith("{"))
+            return false;
+        const hasKnownType = /"type"\s*:\s*"(user|assistant|summary|tool_use|tool_result)"/.test(firstLine);
+        if (!hasKnownType)
+            return false;
+        // Accept any of the id-shape fields we've seen across Claude Code,
+        // Cowork, and skill subagent variants.
+        const hasIdMarker = /"message"\s*:/.test(firstLine) ||
+            /"parentUuid"/.test(firstLine) ||
+            /"promptId"/.test(firstLine) ||
+            /"sessionId"/.test(firstLine) ||
+            /"session_id"/.test(firstLine) ||
+            /"parent_uuid"/.test(firstLine) ||
+            /"parent_tool_use_id"/.test(firstLine);
+        return hasIdMarker;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await fh?.close();
+    }
+}
+/**
+ * Verify a directory looks like a Claude/Cowork sessions root: contains at
+ * least one *.jsonl file (possibly nested) whose first line passes
+ * looksLikeClaudeJsonl. Walks only 3 levels deep to stay fast.
+ */
+async function verifyClaudeStyleDir(dir, maxDepth = 3) {
+    const found = await findFirstJsonl(dir, maxDepth, 0);
+    if (!found)
+        return false;
+    return looksLikeClaudeJsonl(found);
+}
+async function findFirstJsonl(dir, maxDepth, depth) {
+    if (depth > maxDepth)
+        return null;
+    let entries;
+    try {
+        entries = (await fs.readdir(dir, { withFileTypes: true }));
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            return full;
+        if (entry.isDirectory()) {
+            const sub = await findFirstJsonl(full, maxDepth, depth + 1);
+            if (sub)
+                return sub;
+        }
+    }
+    return null;
+}
+/**
+ * Tails Claude Code (~/.claude/projects) AND Cowork JSONL files. Both share
+ * the same on-disk format so they're handled by one provider — sessions
+ * are emitted with their correct `source` (claude-code | cowork) field.
+ */
+export class Watcher extends BaseProvider {
+    info = {
+        id: "claude-code",
+        displayName: "Claude",
+        description: "Claude Code sessions in ~/.claude/projects (and Cowork sessions if present).",
+        accentColor: "var(--accent)",
+    };
+    files = new Map();
+    projectWatcher = null;
+    coworkWatcher = null;
+    historyWatcher = null;
+    historyState = null;
+    projectByPath = new Map();
+    excludePathPrefixes;
+    constructor(opts) {
+        super(opts);
+        this.excludePathPrefixes = opts.excludePathPrefixes ?? [];
+    }
+    /** Resolved at start() — null when the default isn't there and no fallback exists. */
+    claudeDir = null;
+    coworkDir = null;
+    historyFile = null;
+    async onStart() {
+        // --- Discover Claude Code projects dir ---------------------------------
+        this.claudeDir = await this.discover({
+            label: "Claude projects dir",
+            candidates: [
+                process.env.CLAUDE_PROJECTS_DIR,
+                CLAUDE_PROJECTS_DIR, // ~/.claude/projects (default)
+                path.join(HOME, ".config", "claude", "projects"), // XDG-ish (Linux)
+                path.join(HOME, "Library", "Application Support", "Claude", "projects"),
+            ],
+            searchRoots: [HOME],
+            searchName: "projects",
+            pathMustContain: ".claude",
+            // Generous depth: handle non-standard installs like
+            // ~/Workspaces/something/.claude/projects without being so wide that
+            // we walk huge user trees.
+            searchMaxDepth: 6,
+            verify: async (p) => {
+                // Must be a directory AND look like Claude session data.
+                try {
+                    const st = await fs.stat(p);
+                    if (!st.isDirectory())
+                        return false;
+                }
+                catch {
+                    return false;
+                }
+                return verifyClaudeStyleDir(p);
+            },
+        });
+        if (this.claudeDir) {
+            await fs.mkdir(this.claudeDir, { recursive: true }).catch(() => { });
+            await this.initialScan(this.claudeDir, "claude-code");
+        }
+        else {
+            this.log(`no Claude projects dir found — Claude Code sessions disabled`);
+        }
+        // --- Discover Cowork dir (always optional) -----------------------------
+        this.coworkDir = await this.discover({
+            label: "Cowork sessions dir",
+            candidates: [
+                process.env.COWORK_DIR,
+                COWORK_DIR,
+                path.join(HOME, ".config", "claude", "local-agent-mode-sessions"),
+            ],
+            searchRoots: [
+                path.join(HOME, "Library", "Application Support"),
+                path.join(HOME, ".config"),
+            ],
+            searchName: "local-agent-mode-sessions",
+            pathMustContain: "local-agent-mode-sessions",
+            searchMaxDepth: 5,
+            verify: async (p) => {
+                try {
+                    const st = await fs.stat(p);
+                    if (!st.isDirectory())
+                        return false;
+                }
+                catch {
+                    return false;
+                }
+                // Cowork shares Claude's JSONL format — same verifier. The
+                // pathMustContain constraint above is what keeps us from picking up
+                // Claude Code's dir by mistake. Cowork nests deeper than Claude
+                // (install-id/install-id/local_*/<uuid>.jsonl), so allow more depth.
+                return verifyClaudeStyleDir(p, 5);
+            },
+        });
+        if (this.coworkDir) {
+            await this.initialScan(this.coworkDir, "cowork");
+        }
+        // --- Discover the history.jsonl file (cwd → preview ordering) ----------
+        const defaultHistory = this.claudeDir
+            ? path.join(path.dirname(this.claudeDir), "history.jsonl")
+            : HISTORY_FILE;
+        this.historyFile = await this.discover({
+            label: "Claude history.jsonl",
+            candidates: [
+                process.env.CLAUDE_HISTORY_FILE,
+                defaultHistory,
+                HISTORY_FILE,
+            ],
+            verify: async (p) => {
+                try {
+                    const st = await fs.stat(p);
+                    return st.isFile();
+                }
+                catch {
+                    return false;
+                }
+            },
+        });
+        if (this.historyFile) {
+            await this.primeHistory();
+        }
+        // --- Wire chokidar watchers for everything we discovered ---------------
+        if (this.claudeDir) {
+            this.projectWatcher = chokidar
+                .watch(this.claudeDir, {
+                ignored: (p) => p.endsWith(".tmp") || p.includes("/.DS_Store"),
+                persistent: true,
+                ignoreInitial: true,
+                depth: 10,
+            })
+                .on("add", (p) => this.onFileChange(p, "claude-code", "add"))
+                .on("change", (p) => this.onFileChange(p, "claude-code", "change"))
+                .on("unlink", (p) => this.onFileRemoved(p))
+                .on("error", (err) => this.log(`watcher error: ${err.message}`));
+        }
+        if (this.coworkDir) {
+            this.coworkWatcher = chokidar
+                .watch(this.coworkDir, {
+                ignored: (p) => p.endsWith(".tmp") || p.includes("/.DS_Store"),
+                persistent: true,
+                ignoreInitial: true,
+                depth: 10,
+            })
+                .on("add", (p) => this.onFileChange(p, "cowork", "add"))
+                .on("change", (p) => this.onFileChange(p, "cowork", "change"))
+                .on("error", (err) => this.log(`cowork watch error: ${err.message}`));
+        }
+        if (this.historyFile) {
+            this.historyWatcher = chokidar
+                .watch(this.historyFile, {
+                persistent: true,
+                ignoreInitial: true,
+            })
+                .on("add", () => this.readHistoryDelta())
+                .on("change", () => this.readHistoryDelta())
+                .on("error", (err) => this.log(`history watch error: ${err.message}`));
+        }
+        // 1s tick for status recompute (handles idle / awaiting-user transitions)
+        setInterval(() => this.registry.recomputeAll(), 1000).unref();
+        // If we found absolutely nothing, surface that clearly to the operator.
+        if (!this.claudeDir && !this.coworkDir) {
+            this.skipStartup("no Claude or Cowork data found in any candidate location");
+        }
+    }
+    async onStop() {
+        await this.projectWatcher?.close();
+        await this.coworkWatcher?.close();
+        await this.historyWatcher?.close();
+    }
+    async initialScan(root, source) {
+        const found = [];
+        await walk(root, found);
+        for (const file of found) {
+            if (!file.endsWith(".jsonl"))
+                continue;
+            try {
+                await this.onFileChange(file, source, "initial");
+            }
+            catch (err) {
+                this.log(`[watcher initial] ${file}: ${err.message}`);
+            }
+        }
+    }
+    async primeHistory() {
+        if (!this.historyFile)
+            return;
+        try {
+            const { state, lines } = await readEntireFile(this.historyFile);
+            this.historyState = state;
+            for (const line of lines)
+                this.consumeHistoryLine(line);
+        }
+        catch {
+            // history file may not exist on a fresh machine
+            this.historyState = null;
+        }
+    }
+    async readHistoryDelta() {
+        if (!this.historyFile)
+            return;
+        if (!this.historyState) {
+            await this.primeHistory();
+            return;
+        }
+        try {
+            const { newState, lines, rotated } = await readDelta(this.historyFile, this.historyState);
+            this.historyState = newState;
+            const toConsume = rotated ? lines : lines;
+            for (const line of toConsume)
+                this.consumeHistoryLine(line);
+        }
+        catch (err) {
+            this.log(`history readDelta failed: ${err.message}`);
+        }
+    }
+    consumeHistoryLine(line) {
+        if (!line)
+            return;
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (typeof raw !== "object" || raw === null)
+            return;
+        if (typeof raw.display !== "string" || typeof raw.timestamp !== "number")
+            return;
+        const sessionId = typeof raw.sessionId === "string" ? raw.sessionId : null;
+        const project = typeof raw.project === "string" ? raw.project : null;
+        if (!sessionId || !project)
+            return;
+        // Skip slash commands as user-message-equivalents
+        const display = raw.display.trim();
+        if (display.startsWith("/"))
+            return;
+        const preview = display.length > 120 ? display.slice(0, 117) + "…" : display;
+        this.registry.setUserMessageFromHistory(project, sessionId, raw.timestamp, preview);
+    }
+    async onFileChange(filePath, source, reason) {
+        if (!filePath.endsWith(".jsonl"))
+            return;
+        if (this.shouldExclude(filePath))
+            return;
+        const sessionId = path.basename(filePath, ".jsonl");
+        if (!isUuid(sessionId))
+            return;
+        // Determine project info.
+        const projectInfo = this.projectInfoForFile(filePath, source);
+        if (this.excludePathPrefixes.some((p) => projectInfo.projectPath.startsWith(p)))
+            return;
+        const isSubagent = filePath.includes("/subagents/");
+        const parentSessionId = isSubagent ? extractParentSessionId(filePath) : undefined;
+        this.registry.upsertMeta(sessionId, {
+            filePath,
+            projectPath: projectInfo.projectPath,
+            projectLabel: projectInfo.projectLabel,
+            source,
+            isSubagent,
+            parentSessionId,
+        });
+        let entry = this.files.get(filePath);
+        if (!entry) {
+            entry = {
+                filePath,
+                sessionId,
+                source,
+                projectPath: projectInfo.projectPath,
+                projectLabel: projectInfo.projectLabel,
+                isSubagent,
+                parentSessionId,
+                state: null,
+                pending: false,
+                queued: false,
+            };
+            this.files.set(filePath, entry);
+        }
+        if (entry.pending) {
+            entry.queued = true;
+            return;
+        }
+        entry.pending = true;
+        try {
+            do {
+                entry.queued = false;
+                await this.consumeFile(entry, reason === "initial");
+            } while (entry.queued);
+        }
+        finally {
+            entry.pending = false;
+        }
+    }
+    /**
+     * Fast backfill: read only the last 200 lines of the JSONL file instead of
+     * the whole file. This makes opening a session instant regardless of file size.
+     * The ring buffer holds 800 events so 200 raw lines gives plenty of headroom
+     * for multi-event lines and filtered-out metadata.
+     */
+    async backfillSession(sessionId) {
+        let filePath;
+        for (const [fp, entry] of this.files) {
+            if (entry.sessionId === sessionId) {
+                filePath = fp;
+                break;
+            }
+        }
+        if (!filePath)
+            return;
+        const fileEntry = this.files.get(filePath);
+        if (!fileEntry)
+            return;
+        try {
+            const { lines, state } = await readTailLines(filePath, 200);
+            // Update the tail state so subsequent readDelta calls are correct.
+            fileEntry.state = state;
+            for (const line of lines)
+                this.dispatchLine(fileEntry.sessionId, line);
+        }
+        catch (err) {
+            this.log(`[watcher backfill] ${filePath}: ${err.message}`);
+        }
+    }
+    async consumeFile(entry, initial) {
+        if (entry.state === null) {
+            try {
+                if (initial) {
+                    // Metadata-only scan: just enough lines to derive status + title.
+                    // Avoids loading megabytes from old sessions on startup.
+                    const { headLines, tailLines, state } = await readHeadTail(entry.filePath, 20, 40);
+                    entry.state = state;
+                    // Parse head for title / metadata (no events buffered unless subscribed)
+                    for (const line of headLines)
+                        this.dispatchLine(entry.sessionId, line, true);
+                    // Parse tail for status derivation
+                    for (const line of tailLines)
+                        this.dispatchLine(entry.sessionId, line, true);
+                }
+                else {
+                    const { state, lines } = await readEntireFile(entry.filePath);
+                    entry.state = state;
+                    for (const line of lines)
+                        this.dispatchLine(entry.sessionId, line);
+                }
+            }
+            catch (err) {
+                this.log(`[watcher] failed to read ${entry.filePath}: ${err.message}`);
+            }
+            return;
+        }
+        try {
+            const { newState, lines } = await readDelta(entry.filePath, entry.state);
+            entry.state = newState;
+            for (const line of lines)
+                this.dispatchLine(entry.sessionId, line);
+        }
+        catch (err) {
+            this.log(`[watcher] failed to tail ${entry.filePath}: ${err.message}`);
+        }
+    }
+    dispatchLine(sessionId, line, metaOnly = false) {
+        // Always check for title metadata lines.
+        const titlePatch = parseTitleLine(line);
+        if (titlePatch) {
+            this.registry.setTitle(sessionId, titlePatch);
+            return; // title lines are metadata only, not events
+        }
+        const events = parseLineMulti(line, sessionId, {
+            storeImage: (buf, mediaType) => attachmentStore.put(buf, mediaType),
+        });
+        for (const ev of events) {
+            // Capture cwd / git branch from raw line for richer metadata.
+            try {
+                const raw = JSON.parse(line);
+                if (typeof raw?.cwd === "string" && raw.cwd.length > 0) {
+                    const meta = this.registry.get(sessionId);
+                    const fileEntry = Array.from(this.files.values()).find((e) => e.sessionId === sessionId);
+                    if (meta && meta.projectPath !== raw.cwd) {
+                        const label = labelFromPath(raw.cwd);
+                        this.registry.upsertMeta(sessionId, {
+                            filePath: fileEntry?.filePath ?? "",
+                            projectPath: raw.cwd,
+                            projectLabel: label,
+                            source: meta.source,
+                            isSubagent: meta.isSubagent,
+                            parentSessionId: meta.parentSessionId,
+                            gitBranch: typeof raw.gitBranch === "string" ? raw.gitBranch : undefined,
+                        });
+                    }
+                    else if (meta && typeof raw.gitBranch === "string" && meta.gitBranch !== raw.gitBranch) {
+                        this.registry.upsertMeta(sessionId, {
+                            filePath: fileEntry?.filePath ?? meta.projectPath,
+                            projectPath: meta.projectPath,
+                            projectLabel: meta.projectLabel,
+                            source: meta.source,
+                            isSubagent: meta.isSubagent,
+                            parentSessionId: meta.parentSessionId,
+                            gitBranch: raw.gitBranch,
+                        });
+                    }
+                }
+            }
+            catch { }
+            // appendEvent is a no-op for unsubscribed sessions (no event buffering).
+            this.registry.appendEvent(sessionId, ev);
+        }
+    }
+    onFileRemoved(filePath) {
+        const entry = this.files.get(filePath);
+        if (!entry)
+            return;
+        this.files.delete(filePath);
+        this.registry.remove(entry.sessionId);
+    }
+    projectInfoForFile(filePath, source) {
+        if (source === "claude-code") {
+            // Decode the encoded project segment relative to the discovered Claude
+            // projects dir (or the default constant when discovery hasn't run yet).
+            const root = this.claudeDir ?? CLAUDE_PROJECTS_DIR;
+            const rel = path.relative(root, filePath);
+            const encoded = rel.split(path.sep)[0];
+            if (this.projectByPath.has(encoded))
+                return this.projectByPath.get(encoded);
+            const info = decodeProjectDir(encoded);
+            this.projectByPath.set(encoded, info);
+            return info;
+        }
+        // Cowork: path is e.g. <coworkDir>/<install-id>/<install-id>/local_<id>/<uuid>.jsonl
+        // Use the deepest folder name as label.
+        const dir = path.dirname(filePath);
+        const folder = path.basename(dir);
+        return { projectPath: dir, projectLabel: `cowork / ${folder}` };
+    }
+    shouldExclude(filePath) {
+        if (this.excludePathPrefixes.length === 0)
+            return false;
+        return this.excludePathPrefixes.some((p) => filePath.startsWith(p));
+    }
+}
+function isUuid(s) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s);
+}
+function extractParentSessionId(filePath) {
+    // .../<parentUuid>/subagents/agent-<uuid>.jsonl (heuristic)
+    const parts = filePath.split(path.sep);
+    const idx = parts.lastIndexOf("subagents");
+    if (idx > 0) {
+        const candidate = parts[idx - 1];
+        if (isUuid(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function labelFromPath(p) {
+    const segs = p.split("/").filter(Boolean);
+    if (segs.length >= 2)
+        return `${segs[segs.length - 2]} / ${segs[segs.length - 1]}`;
+    return segs[segs.length - 1] ?? p;
+}
+async function stat(p) {
+    try {
+        return await fs.stat(p);
+    }
+    catch {
+        return null;
+    }
+}
+async function walk(root, out) {
+    let entries;
+    try {
+        entries = (await fs.readdir(root, { withFileTypes: true }));
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = path.join(root, String(entry.name));
+        if (entry.isDirectory()) {
+            await walk(full, out);
+        }
+        else if (entry.isFile()) {
+            out.push(full);
+        }
+    }
+}
+//# sourceMappingURL=watcher.js.map

package/dist/web/assets/index-C2fCiOuu.css

@@ -0,0 +1 @@
+*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:var(--font-sans);font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--font-mono);font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;letter-spacing:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.pointer-events-none{pointer-events:none}.visible{visibility:visible}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.sticky{position:sticky}.inset-0{inset:0}.bottom-0{bottom:0}.bottom-2{bottom:.5rem}.bottom-6{bottom:1.5rem}.left-0{left:0}.left-1{left:.25rem}.right-0{right:0}.right-3{right:.75rem}.right-6{right:1.5rem}.top-0{top:0}.top-1{top:.25rem}.top-3{top:.75rem}.z-20{z-index:20}.z-50{z-index:50}.-mx-1{margin-left:-.25rem;margin-right:-.25rem}.mx-1{margin-left:.25rem;margin-right:.25rem}.my-1{margin-top:.25rem;margin-bottom:.25rem}.my-2{margin-top:.5rem;margin-bottom:.5rem}.my-3{margin-top:.75rem;margin-bottom:.75rem}.mb-1{margin-bottom:.25rem}.mb-2{margin-bottom:.5rem}.mb-2\.5{margin-bottom:.625rem}.mb-3{margin-bottom:.75rem}.mb-4{margin-bottom:1rem}.mb-5{margin-bottom:1.25rem}.ml-1{margin-left:.25rem}.ml-1\.5{margin-left:.375rem}.ml-2{margin-left:.5rem}.ml-4{margin-left:1rem}.ml-5{margin-left:1.25rem}.ml-auto{margin-left:auto}.mt-0\.5{margin-top:.125rem}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.mt-3{margin-top:.75rem}.mt-4{margin-top:1rem}.mt-5{margin-top:1.25rem}.mt-8{margin-top:2rem}.block{display:block}.inline-block{display:inline-block}.inline{display:inline}.flex{display:flex}.inline-flex{display:inline-flex}.grid{display:grid}.hidden{display:none}.h-1{height:.25rem}.h-2{height:.5rem}.h-7{height:1.75rem}.h-8{height:2rem}.h-9{height:2.25rem}.max-h-\[85vh\]{max-height:85vh}.min-h-full{min-height:100%}.w-1{width:.25rem}.w-2{width:.5rem}.w-5{width:1.25rem}.w-7{width:1.75rem}.w-8{width:2rem}.w-9{width:2.25rem}.w-full{width:100%}.min-w-0{min-width:0px}.max-w-\[88\%\]{max-width:88%}.max-w-\[92\%\]{max-width:92%}.max-w-md{max-width:28rem}.max-w-sm{max-width:24rem}.flex-1{flex:1 1 0%}.flex-shrink-0{flex-shrink:0}.cursor-pointer{cursor:pointer}.resize{resize:both}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-start{align-items:flex-start}.items-end{align-items:flex-end}.items-center{align-items:center}.items-baseline{align-items:baseline}.justify-start{justify-content:flex-start}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-0\.5{gap:.125rem}.gap-1{gap:.25rem}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.space-y-1>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.25rem * var(--tw-space-y-reverse))}.space-y-2>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.space-y-3>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.75rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.75rem * var(--tw-space-y-reverse))}.space-y-6>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.5rem * var(--tw-space-y-reverse))}.overflow-auto{overflow:auto}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-y-auto{overflow-y:auto}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.whitespace-pre-wrap{white-space:pre-wrap}.break-words{overflow-wrap:break-word}.break-all{word-break:break-all}.rounded{border-radius:var(--radius)}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:var(--radius-lg)}.rounded-md{border-radius:.375rem}.rounded-t-2xl{border-top-left-radius:1rem;border-top-right-radius:1rem}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-l{border-left-width:1px}.p-5{padding:1.25rem}.px-1{padding-left:.25rem;padding-right:.25rem}.px-1\.5{padding-left:.375rem;padding-right:.375rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-2\.5{padding-left:.625rem;padding-right:.625rem}.px-3{padding-left:.75rem;padding-right:.75rem}.px-3\.5{padding-left:.875rem;padding-right:.875rem}.px-4{padding-left:1rem;padding-right:1rem}.px-5{padding-left:1.25rem;padding-right:1.25rem}.px-6{padding-left:1.5rem;padding-right:1.5rem}.py-0\.5{padding-top:.125rem;padding-bottom:.125rem}.py-1{padding-top:.25rem;padding-bottom:.25rem}.py-1\.5{padding-top:.375rem;padding-bottom:.375rem}.py-2{padding-top:.5rem;padding-bottom:.5rem}.py-2\.5{padding-top:.625rem;padding-bottom:.625rem}.py-3{padding-top:.75rem;padding-bottom:.75rem}.py-4{padding-top:1rem;padding-bottom:1rem}.py-px{padding-top:1px;padding-bottom:1px}.pb-0\.5{padding-bottom:.125rem}.pb-10{padding-bottom:2.5rem}.pb-2{padding-bottom:.5rem}.pb-2\.5{padding-bottom:.625rem}.pb-4{padding-bottom:1rem}.pl-3{padding-left:.75rem}.pr-4{padding-right:1rem}.pt-1{padding-top:.25rem}.pt-16{padding-top:4rem}.pt-2{padding-top:.5rem}.pt-3{padding-top:.75rem}.text-left{text-align:left}.text-center{text-align:center}.font-mono{font-family:var(--font-mono)}.text-4xl{font-size:2.25rem;line-height:2.5rem}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.text-\[8px\]{font-size:8px}.text-\[9px\]{font-size:9px}.text-base{font-size:1rem;line-height:1.5rem}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xs{font-size:.75rem;line-height:1rem}.font-medium{font-weight:500}.font-semibold{font-weight:600}.uppercase{text-transform:uppercase}.italic{font-style:italic}.tabular-nums{--tw-numeric-spacing: tabular-nums;font-variant-numeric:var(--tw-ordinal) var(--tw-slashed-zero) var(--tw-numeric-figure) var(--tw-numeric-spacing) var(--tw-numeric-fraction)}.leading-none{line-height:1}.leading-tight{line-height:1.25}.tracking-tight{letter-spacing:-.025em}.tracking-wider{letter-spacing:.05em}.underline{text-decoration-line:underline}.shadow{--tw-shadow: 0 1px 3px 0 rgb(0 0 0 / .1), 0 1px 2px -1px rgb(0 0 0 / .1);--tw-shadow-colored: 0 1px 3px 0 var(--tw-shadow-color), 0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-opacity{transition-property:opacity;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}:root{--bg: #1F1D18;--bg-elevated: #26241E;--bg-subtle: #2B2922;--text: #F0EEE6;--text-muted: #B5AE9D;--text-faint: #80796A;--accent: #D97757;--accent-soft: #4A2E22;--accent-bg: #3A2A22;--border: #38352D;--border-strong: #4A463C;--status-running: #4ADE80;--status-tool: #FACC15;--status-waiting: #94A3B8;--status-idle: #80796A;--status-error: #F87171;--radius-sm: 8px;--radius: 12px;--radius-lg: 16px;--shadow-sm: 0 1px 3px rgba(0, 0, 0, .3);--shadow: 0 2px 16px rgba(0, 0, 0, .4);--font-sans: "Inter", -apple-system, "SF Pro Text", system-ui, sans-serif;--font-serif: "Tiempos Text", Georgia, serif;--font-mono: "JetBrains Mono", ui-monospace, "SF Mono", monospace}@media (prefers-color-scheme: light){:root{--bg: #FAF9F5;--bg-elevated: #FFFFFF;--bg-subtle: #F0EEE6;--text: #3D3929;--text-muted: #6B6555;--text-faint: #9B9486;--accent: #C96442;--accent-soft: #E7B9A5;--accent-bg: #FBEFE9;--border: #E6E2D6;--border-strong: #C9C3B3;--status-running: #2F855A;--status-tool: #B7791F;--status-waiting: #4A5568;--status-idle: #9B9486;--status-error: #C53030;--shadow-sm: 0 1px 2px rgba(45, 38, 25, .04);--shadow: 0 2px 12px rgba(45, 38, 25, .08)}}*{box-sizing:border-box}html,body,#root{margin:0;padding:0;min-height:100%;height:100%}body{background:var(--bg);color:var(--text);font-family:var(--font-sans);-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;overscroll-behavior-y:contain;-webkit-tap-highlight-color:transparent}#root{display:flex;flex-direction:column}.safe-top{padding-top:max(env(safe-area-inset-top,0px),.5rem)}.safe-bottom{padding-bottom:max(env(safe-area-inset-bottom,0px),.5rem)}.safe-x{padding-left:env(safe-area-inset-left,0px);padding-right:env(safe-area-inset-right,0px)}@keyframes pulse-dot{0%,to{opacity:1;transform:scale(1)}50%{opacity:.55;transform:scale(.8)}}.pulse-dot{animation:pulse-dot 1.4s ease-in-out infinite}@keyframes slide-in{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}.slide-in{animation:slide-in .2s ease-out}button,a{-webkit-touch-callout:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}::-webkit-scrollbar{width:8px;height:8px}::-webkit-scrollbar-thumb{background:var(--border-strong);border-radius:4px}::-webkit-scrollbar-track{background:transparent}.no-scrollbar{scrollbar-width:none;-ms-overflow-style:none}.no-scrollbar::-webkit-scrollbar{display:none}input:focus,textarea:focus,button:focus-visible{outline:none;border-color:var(--accent)!important;box-shadow:0 0 0 2px var(--accent-bg)}.prose-claude{font-family:var(--font-serif);line-height:1.55;font-size:.95rem;white-space:pre-wrap;word-break:break-word}.prose-claude code{font-family:var(--font-mono);font-size:.85em;background:var(--bg-subtle);padding:1px 5px;border-radius:4px}.prose-claude pre{background:var(--bg-subtle);padding:10px 12px;border-radius:var(--radius-sm);overflow-x:auto;font-size:.82rem;margin:6px 0}.hover\:opacity-80:hover{opacity:.8}.focus\:border-accent:focus{border-color:var(--accent)}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.active\:bg-bg-subtle:active{background-color:var(--bg-subtle)}@media (min-width: 640px){.sm\:max-w-md{max-width:28rem}.sm\:items-center{align-items:center}.sm\:rounded-2xl{border-radius:1rem}}