@vale-dinap/lucidly 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to Lucidly are listed here. The format follows [Keep a Chang
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-11-11
+
+### Added
+
+- **Optional sound alerts**, with the bell next to keep-awake in the top bar: a short sound when a session finishes, asks you something or runs into trouble, in any of your tabs. Off by default. Each event has its own sound, chosen from a dropdown (17 sounds in three groups: gentle ones, questions, and louder alerts such as Alarm, Siren and Buzzer; or None for no sound) and tried with *Test*, and there is a volume slider. *Only when I'm not looking* (on by default) keeps quiet for the session on screen while the page is visible. The sounds are made in the browser, no files. Browsers only allow sound after you interact with a page: after a reload the bell turns amber until your first click or key press.
+
+## [0.4.0] - 2026-11-11
+
+### Added
+
+- **Session tabs: several sessions open at once.** Picking a session in the list still replaces the one on screen; to keep both, open it in a new tab with `Ctrl`/`⌘`-click, a middle click, the row's **New tab** button, or the **+** at the end of the tab strip. The strip shows from two tabs on, at the very top of the page, above the top bar. Each tab has a dot in the orb's colours (blue working, amber your turn, green finished, red in trouble, grey quiet), and a count of running subagents. When a tab you're not looking at asks you something, finishes or runs into trouble, it flashes a few times, then glows until you open it, and the page title counts those tabs, like "(2) Lucidly". A session already in a tab is never opened twice: picking it switches to its tab. Each tab keeps your place (view, selection, Glance spotlight, scroll) for when you come back. `[` / `]` go to the previous / next tab, and a middle click on a tab closes it. Tabs survive a reload and a server restart, which reopens their sessions.
+- **Glance names the step too, and says how both stand.** Under the orb, the task in the spotlight and, on a second line, the node in the middle of its chain (the step under way by default, "Step 3 of 5"; `←` / `→` move it, and the line follows: your request, a reply, a round's end, the result). Each line has a status mark: a spinning ring while it runs, a tick when done, a cross when in trouble, a balloon when it asked you, a pause when interrupted, an empty ring for what hasn't started.
+- **Running subagents show in Glance.** While any runs, including in the background after the agent's turn ended, a tag beside the orb names the latest one, with "+N" for the others. Click it for the list of all of them (how long each has run, and the task and step that launched it); pick one and the wheel brings that step into the spotlight, and the side panel, if open, shows the subagent.
+
+### Changed
+
+- **Lucidly stops following a session nobody has open.** Closing its tab (or replacing it with another session) stops it at once, unless another page has it too; a session no page has shown for 10 minutes stops by itself. Until now, every session opened kept being followed until the server stopped. A saved snapshot you loaded is kept.
+- **An earlier task in the Glance spotlight centres on its goal**, where it ended up, instead of your request; with the side panel open, the goal is the one selected, and the panel shows the task with its result highlighted.
+- **The System theme has a clearer icon**: the sun and the moon, cut along a diagonal, instead of a monitor. The Dark icon's moon now faces the same way.
+
 ## [0.3.0] - 2026-11-06
 
 ### Added
@@ -54,6 +74,8 @@ All notable changes to Lucidly are listed here. The format follows [Keep a Chang
 
 First public release.
 
+[0.5.0]: https://github.com/vale-dinap/lucidly/compare/v0.4.0...v0.5.0
+[0.4.0]: https://github.com/vale-dinap/lucidly/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/vale-dinap/lucidly/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/vale-dinap/lucidly/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/vale-dinap/lucidly/releases/tag/v0.1.0

package/README.md

@@ -2,9 +2,11 @@
 
 [![CI](https://github.com/vale-dinap/lucidly/actions/workflows/ci.yml/badge.svg)](https://github.com/vale-dinap/lucidly/actions/workflows/ci.yml)
 
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/vale-dinap/lucidly)
+
 *See what your AI agent is doing, at a glance.*
 
-https://github.com/user-attachments/assets/ff9ff898-4317-4e78-99e4-caac09b620ca
+https://github.com/user-attachments/assets/6ceb52e7-eb58-4223-adba-d6a04d61b263
 
 ## Quick start
 
@@ -52,6 +54,14 @@ Every item in the view, whether a planned step, a subtask or a blocker, is linke
 
 All of these show a made-up demo session (`scripts/demo-session.mjs`).
 
+**Glance**, the default view: how the agent is doing, at a glance. The orb says what it is doing now, and the task under way unfolds into its steps, from your request to the goal, with the steps still to come.
+
+![The Glance view while the agent works: the orb running a command, and the current task unfolded into its steps](docs/media/img_04_glance-view-while-the-agent-works.png)
+
+**Glance and the side panel.** Pick any step, here a subagent's, and the panel shows its files, commands and transcript, while Glance stays where it was.
+
+![The Glance view in the light theme, with a subagent step open in the side panel](docs/media/img_05_glance-with-a-subagent-step-open-light-theme.png)
+
 **Drill down.** Open a step in place to see each of its actions, hover one for what it did, and click it for its full output.
 
 https://github.com/user-attachments/assets/a8d20d0e-41c5-4ada-a9d5-b9cf6541714f
@@ -134,7 +144,9 @@ In the browser:
 - Switch views with the buttons at the left of the toolbar under the timeline (it stays on screen while you scroll), or `V` to cycle through *Glance*, *Simple*, *Detailed*, *Files* and **Actions**. In Simple and Detailed, the **filters** next to them narrow the list: *All*, *Failed*, *Recovered*, *Subagents* and *Questions* (the exchanges answered without any work), each with its count. When the toolbar is too narrow (for example with the side panel open), they fold into one menu button showing the current filter, with a red dot if anything is still failed. *Hide Q&A* applies to *All* only, and greys out with the other filters. Search is a magnifier until you click it or press `/`. The flame button (or `H`) turns on **token heat**: tasks and steps glow from green to red by the tokens they used (fresh input, cache writes and output, the way the token meter counts them), relative to the rest of the run, on a log scale so only the real outliers turn red. Tasks and questions are ranked together, steps among steps. It is off by default; hover a glowing node or dot for its tokens. Actions is a flat, chronological list of everything the agent did: commands, edits, reads, searches, subagent calls. Filter by kind, show only *Failed* actions or only *Recovered* ones (each failure is tagged *failed*, or *failed → recovered* in grey), search (`/`), or limit to one task. Each failure shows its actual error line. Select a row to see its full input and output, and *Show in path* to jump back to the step it belongs to. A long shell command is shown in parts: its shell lines, the script it runs (`node - <<'EOF'`, `python -c "…"`, highlighted as JavaScript or Python), and the content it writes to a file (`cat > a.py <<'EOF'`), with *Show the whole command* for the command as recorded. For commands that change files, long lines that wrap continue indented so each real line stands out, and dense JavaScript has *Reformat for reading*: line breaks and indentation for display only, with *Show as written* to go back. *Copy commands* copies the listed shell commands, with failed ones marked. In the side panel, every card has its own **copy button**: your messages, the agent's text, plans and results (as Markdown), thinking, commands and each of their parts (without the `$` prompt; a script as written, even when shown reformatted), inputs, outputs and errors (whole, even when only the first lines are shown), and diffs (as a unified diff). A tick confirms the copy.
 - The **pin** in the overview's top-right corner (or `P`) keeps the overview on screen too while you scroll. It is pinned by default: scrolled down, it tightens into a compact card (about half the height) that still shows everything: the stats on one line, the timeline, the subagents on a single row (parallel ones are counted on a *+N* marker), the navigator and the legend. It unfolds again back at the top, and what you were reading stays put during the transition. Unpin it to let it scroll away; Lucidly remembers the choice. The arrows button at the right of the toolbar (or `E`) expands or collapses everything.
 - **Keep awake** (the cup next to the status in the top bar) stops the device from sleeping, like a no-sleep page. Turn it on, and optionally choose *Only while the agent is working*: the device stays awake while a turn runs and may sleep once the work is done and the session is idle (or has had no news for 30 minutes). The cup steams while it is holding the device awake. It uses the browser's Screen Wake Lock, so it works while the Lucidly tab is visible: a hidden or minimised tab lets the device sleep, and it takes effect again when you come back.
+- **Sounds** (the bell next to keep-awake) plays a short sound when a session finishes, asks you something or runs into trouble, in any of your tabs. It is off by default. Each event has its own sound, chosen from a dropdown (17 sounds in three groups: gentle ones, questions, and louder alerts such as Alarm, Siren and Buzzer; or None for no sound) and tried with *Test*, and the volume can be set. With *Only when I'm not looking* (on by default), the session on screen stays quiet while the page is visible. Browsers only play sound after you interact with a page, so after a reload the bell turns amber until your first click or key press.
 - A session opens at the top, on the overview and its timeline, with the side panel closed until you select something. Whenever you're not at the end of the list, a round **arrow button** floats at the bottom right, with a count of actions that arrived since you scrolled away. Click it (or press `F` or `End`) to jump to the end and follow the agent, keeping the current step in view. If the side panel is closed it stays closed: the list just scrolls along. Scrolling or clicking pauses following. **Open session** (the folder button on the left, the run's title, or `O`) lists the Claude Code sessions of this project or of all projects. All projects are grouped by project folder, each group headed by the folder's name, its session count and when it last changed (a green dot if a session in it is live). This project comes first; groups fold, and the ones open by default are this project's and any with a live session (or all of them, when there are only a few). *Expand all* / *Collapse all* sits at the top, and what you open or close stays that way.
+- **Tabs** let you keep several sessions open. Picking a session replaces the one on screen; `Ctrl`/`⌘`-click it, middle-click it or use its **New tab** button to open it in a new tab instead (the **+** at the end of the tab strip does the same). From two tabs on, a strip at the very top of the page, above the top bar, shows them, each with a dot in the orb's colours and a count of running subagents. A tab you're not looking at that asks you something, finishes or runs into trouble flashes, then glows until you open it, and the page title shows how many do. Picking a session that's already in a tab switches to it. Each tab keeps your place (view, selection, spotlight, scroll). `[` / `]` move between tabs, a middle click closes one, and they come back after a reload. Closing a tab stops following its session; one no page has shown for 10 minutes stops by itself.
 - The download button, next to *Open session* on the left, saves a **snapshot** of the run as a `.lucidly.json` file, and *Open a saved snapshot…* in the session list reopens one. You don't need this for Claude Code sessions, which reopen straight from their transcripts. It's for keeping a run after its transcript is cleaned up, sharing it with someone who doesn't have the transcript, and runs streamed from other agents through stdin, which have no transcript to reopen.
 
 Lucidly only reads. It binds to `127.0.0.1` and never sends anything to the agent.

package/dist/core/summary.js

@@ -0,0 +1,41 @@
+/** Nothing new for this long: a run said to be working has gone quiet (as in the web UI). */
+export const QUIET_MS = 5 * 60 * 1000;
+/** A finished run stays 'done' (rather than 'rest') this long. */
+const RECENT_MS = 30 * 60 * 1000;
+export function runSummary(run, nodes, now = Date.now()) {
+    const get = (id) => id === undefined ? undefined : nodes instanceof Map ? nodes.get(id) : nodes[id];
+    const kids = (n) => (n?.children ?? []).map(get).filter((c) => !!c);
+    // Like the UI's descendants(): children, and inside subtasks, theirs.
+    const below = (n, f, acc = []) => {
+        for (const c of kids(n)) {
+            if (f(c))
+                acc.push(c);
+            if (c.type === 'subtask')
+                below(c, f, acc);
+        }
+        return acc;
+    };
+    const openIssue = (s) => below(s, (c) => c.type === 'blocker' && c.status === 'open').length > 0 || (s.stats?.errors ?? 0) - (s.stats?.recovered ?? 0) > 0;
+    const age = run.updatedAt ? now - Date.parse(run.updatedAt) : Infinity;
+    const stale = age > QUIET_MS;
+    const all = nodes instanceof Map ? [...nodes.values()] : Object.values(nodes);
+    const agents = stale ? 0 : all.filter((n) => n.type === 'subtask' && n.origin === 'subagent' && n.status === 'active').length;
+    const out = (state, question) => ({ state, ...(question !== undefined ? { question } : {}), agents, updatedAt: run.updatedAt });
+    const g = get(run.currentGoal) ?? get(run.goals[run.goals.length - 1]);
+    if (run.status === 'working') {
+        if (stale)
+            return out('quiet');
+        const step = get(run.currentStep);
+        return out(step && openIssue(step) ? 'bad' : 'work');
+    }
+    if (g?.status === 'waiting')
+        return out('paused');
+    const ask = g ? below(g, (c) => c.type === 'activity' && c.kind === 'ask' && c.status === 'active')[0] : undefined;
+    if (ask)
+        return out('you', String(ask.title ?? '').replace(/^Ask:\s*/, ''));
+    if (g?.asked)
+        return out('you', g.question ?? '');
+    return out(age < RECENT_MS ? 'done' : 'rest');
+}
+/** The states that want you: a tab you're not looking at flashes when it turns one of these. */
+export const ATTENTION = new Set(['you', 'bad', 'done']);

package/dist/server/server.js

@@ -42,11 +42,19 @@ const TYPES = {
     '.png': 'image/png',
     '.ico': 'image/x-icon',
 };
+/** How often tab states are refreshed regardless of new events (they change with time too). */
+const TICK_MS = 15_000;
+/** A run no page has shown or listed for this long is closed (when it can be opened again). */
+export const IDLE_CLOSE_MS = 10 * 60 * 1000;
 export class LucidlyServer {
     runs = new Map();
     byKey = new Map();
     seq = 0;
     server = null;
+    watchers = new Set();
+    /** Open event streams per run, ended when the run closes. */
+    streams = new Map();
+    ticker = null;
     port = 0;
     cwd;
     wantPort;
@@ -68,6 +76,8 @@ export class LucidlyServer {
                         s.off('error', fail);
                         this.server = s;
                         this.port = s.address().port;
+                        this.ticker = setInterval(() => this.tick(), TICK_MS);
+                        this.ticker.unref();
                         ok();
                     });
                 });
@@ -81,6 +91,8 @@ export class LucidlyServer {
         throw new Error(`No free port from ${this.wantPort}`);
     }
     async close() {
+        if (this.ticker)
+            clearInterval(this.ticker);
         for (const r of this.runs.values())
             r.close();
         this.server?.closeAllConnections?.();
@@ -110,8 +122,66 @@ export class LucidlyServer {
         r.close();
         this.runs.delete(id);
         this.byKey.delete(r.key);
+        for (const res of this.streams.get(id) ?? [])
+            res.end();
+        this.streams.delete(id);
+        // Tabs holding it hear that it's gone.
+        for (const w of this.watchers)
+            if (w.runs.has(id))
+                this.pushTabs(w);
         return true;
     }
+    /** Whether some page (other than `except`) shows the run, or has it in a tab. */
+    watched(run, except) {
+        if (run.shownBy(except))
+            return true;
+        for (const w of this.watchers)
+            if (w.client !== except && w.runs.has(run.id))
+                return true;
+        return false;
+    }
+    /**
+     * A tab closed (or switched to another session) on page `client`: the run stops, unless another
+     * tab or page still has it.
+     */
+    release(id, client) {
+        const run = this.runs.get(id);
+        if (!run)
+            return { closed: false };
+        if (client)
+            for (const w of this.watchers)
+                if (w.client === client)
+                    w.runs.delete(id);
+        if (this.watched(run, client))
+            return { closed: false };
+        return { closed: this.closeRun(id) };
+    }
+    /** Tells a page's tabs what changed in the states of their runs. */
+    pushTabs(w, now = Date.now()) {
+        const changed = {};
+        for (const id of w.runs) {
+            const run = this.runs.get(id);
+            const s = run ? run.summary(now) : { gone: true };
+            const json = JSON.stringify(s);
+            if (w.last.get(id) === json)
+                continue;
+            w.last.set(id, json);
+            changed[id] = s;
+        }
+        if (Object.keys(changed).length)
+            w.send({ runs: changed });
+    }
+    /** States that change with time alone (working → quiet, done → rest), and closing idle runs. */
+    tick(now = Date.now()) {
+        for (const w of this.watchers)
+            this.pushTabs(w, now);
+        for (const run of [...this.runs.values()]) {
+            if (this.watched(run))
+                run.lastWatched = now;
+            else if (run.reopenable && now - run.lastWatched > IDLE_CLOSE_MS)
+                this.closeRun(run.id);
+        }
+    }
     // ───────────────────────────── HTTP
     hostOk(req) {
         const host = (req.headers.host ?? '').toLowerCase();
@@ -151,10 +221,13 @@ export class LucidlyServer {
             if (!run)
                 return send(res, 404, { error: 'no such run' });
             const [, , action, arg] = m;
-            if (!action && req.method === 'DELETE')
-                return send(res, 200, { closed: this.closeRun(run.id) });
+            // With the page's id: only if no other tab or page has the run (see release).
+            if (!action && req.method === 'DELETE') {
+                const client = url.searchParams.get('client');
+                return send(res, 200, client ? this.release(run.id, client) : { closed: this.closeRun(run.id) });
+            }
             if (action === 'stream')
-                return this.stream(req, res, run);
+                return this.stream(req, res, run, url.searchParams.get('client') ?? undefined);
             if (action === 'raw' && arg) {
                 if (!run.engine.nodes.has(arg))
                     return send(res, 404, { error: 'no such node' });
@@ -182,6 +255,14 @@ export class LucidlyServer {
         if (path === '/api/runs' && req.method === 'GET') {
             return send(res, 200, { runs: [...this.runs.values()].map((r) => r.info()) });
         }
+        // A page's session tabs: the states of the runs they hold, live (event "tabs").
+        if (path === '/api/tabs/stream' && req.method === 'GET') {
+            const client = url.searchParams.get('client');
+            if (!client)
+                return send(res, 400, { error: 'client required' });
+            const ids = (url.searchParams.get('runs') ?? '').split(',').filter(Boolean);
+            return this.tabStream(req, res, client, ids);
+        }
         if (path === '/api/sessions' && req.method === 'GET') {
             const all = url.searchParams.get('scope') === 'all';
             const sessions = await listSessions({ cwd: all ? undefined : this.cwd, limit: all ? 60 : 30 });
@@ -222,21 +303,44 @@ export class LucidlyServer {
         }
         return send(res, 404, { error: 'not found' });
     }
-    stream(req, res, run) {
-        res.writeHead(200, {
-            'content-type': 'text/event-stream; charset=utf-8',
-            'cache-control': 'no-store',
-            connection: 'keep-alive',
-            'x-accel-buffering': 'no',
-        });
-        res.write('retry: 2000\n\n');
+    stream(req, res, run, client) {
+        sseHead(res);
+        let set = this.streams.get(run.id);
+        if (!set)
+            this.streams.set(run.id, (set = new Set()));
+        set.add(res);
         const unsubscribe = run.subscribe((event, data) => {
             res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
-        });
+        }, client);
         const ping = setInterval(() => res.write(': ping\n\n'), 15000);
         req.on('close', () => {
             clearInterval(ping);
             unsubscribe();
+            this.streams.get(run.id)?.delete(res);
+        });
+    }
+    tabStream(req, res, client, ids) {
+        sseHead(res);
+        // A page has one tab stream: a new one (its tabs changed) replaces the old.
+        for (const w of this.watchers)
+            if (w.client === client)
+                this.watchers.delete(w);
+        const w = { client, runs: new Set(ids), last: new Map(), send: (data) => res.write(`event: tabs\ndata: ${JSON.stringify(data)}\n\n`) };
+        this.watchers.add(w);
+        const offs = ids.map((id) => this.runs.get(id)?.onChange(() => this.pushTabs(w))).filter((f) => !!f);
+        this.pushTabs(w);
+        const ping = setInterval(() => res.write(': ping\n\n'), 15000);
+        req.on('close', () => {
+            clearInterval(ping);
+            for (const off of offs)
+                off();
+            this.watchers.delete(w);
+            const now = Date.now();
+            for (const id of ids) {
+                const run = this.runs.get(id);
+                if (run)
+                    run.lastWatched = now;
+            }
         });
     }
     async static(res, path) {
@@ -260,6 +364,15 @@ export class LucidlyServer {
         res.end(body);
     }
 }
+function sseHead(res) {
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-store',
+        connection: 'keep-alive',
+        'x-accel-buffering': 'no',
+    });
+    res.write('retry: 2000\n\n');
+}
 function send(res, status, body) {
     res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
     res.end(JSON.stringify(body));

package/dist/server/session.js

@@ -3,9 +3,12 @@
  * State lives in memory; saving writes the event log, loading replays it.
  */
 import { Engine } from "../core/engine.js";
+import { runSummary } from "../core/summary.js";
 export const SAVE_FORMAT = 'lucidly-run';
 export const SAVE_VERSION = 1;
 const FLUSH_MS = 120;
+/** Listeners to a run's summary (session tabs) hear about changes at most this often. */
+const CHANGE_MS = 250;
 export class RunSession {
     id;
     key;
@@ -14,8 +17,13 @@ export class RunSession {
     engine = new Engine();
     events = [];
     source;
-    subs = new Set();
+    /** Live subscribers, each with the page (client id) it belongs to, when it said. */
+    subs = new Map();
     timer = null;
+    changeTimer = null;
+    changeSubs = new Set();
+    /** When a page last showed or listed this run (for closing runs nobody looks at any more). */
+    lastWatched = Date.now();
     constructor(id, source, opts = {}) {
         this.id = id;
         this.source = source;
@@ -35,16 +43,22 @@ export class RunSession {
         this.engine.applyAll(evs);
         if (this.subs.size && !this.timer)
             this.timer = setTimeout(() => this.flush(), FLUSH_MS);
+        if (this.changeSubs.size && !this.changeTimer)
+            this.changeTimer = setTimeout(() => {
+                this.changeTimer = null;
+                for (const f of this.changeSubs)
+                    f();
+            }, CHANGE_MS);
     }
     flush() {
         this.timer = null;
         const patch = this.engine.takePatch();
         if (!patch)
             return;
-        for (const s of this.subs)
+        for (const s of this.subs.keys())
             s('patch', patch);
     }
-    subscribe(send) {
+    subscribe(send, client) {
         // Bring existing subscribers up to date first, so the new snapshot and their state agree.
         if (this.timer) {
             clearTimeout(this.timer);
@@ -53,9 +67,35 @@ export class RunSession {
         else {
             this.engine.takePatch();
         }
-        this.subs.add(send);
+        this.subs.set(send, client);
+        this.lastWatched = Date.now();
         send('snapshot', this.engine.snapshot());
-        return () => this.subs.delete(send);
+        return () => {
+            this.subs.delete(send);
+            this.lastWatched = Date.now();
+        };
+    }
+    /** Calls `f` (throttled) whenever new events arrive. */
+    onChange(f) {
+        this.changeSubs.add(f);
+        return () => this.changeSubs.delete(f);
+    }
+    /** Whether a page other than `except` has this run open (its full stream). */
+    shownBy(except) {
+        for (const c of this.subs.values())
+            if (c === undefined || c !== except)
+                return true;
+        return false;
+    }
+    /** Whether it can be opened again from its file (so closing it loses nothing). */
+    get reopenable() {
+        return !!this.source?.path;
+    }
+    /** The run's state for its tab, and its name: the session's title, or else its first request. */
+    summary(now = Date.now()) {
+        const r = this.engine.run;
+        const first = r.goals.length ? this.engine.nodes.get(r.goals[0])?.title : undefined;
+        return { ...runSummary(r, this.engine.nodes, now), title: r.title ?? first ?? this.label };
     }
     info() {
         const r = this.engine.run;
@@ -69,6 +109,7 @@ export class RunSession {
             eventCount: r.eventCount,
             updatedAt: r.updatedAt,
             subscribers: this.subs.size,
+            ...(this.source?.path ? { path: this.source.path } : {}),
         };
     }
     save() {
@@ -95,7 +136,10 @@ export class RunSession {
     close() {
         if (this.timer)
             clearTimeout(this.timer);
+        if (this.changeTimer)
+            clearTimeout(this.changeTimer);
         this.source?.stop();
         this.subs.clear();
+        this.changeSubs.clear();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vale-dinap/lucidly",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "See what your AI agent is doing, at a glance.",
   "keywords": [
     "claude",