@openduo/duoduo 0.3.7 → 0.4.0

package/bootstrap/dashboard.html

@@ -658,8 +658,8 @@ body{
     if (cortex.length > 0) {
       var h = '<span class="sig-label">cortex</span>';
       cortex.forEach(function(s){
-        var color = s.status==="active"?"running":s.status==="error"?"alert":s.status==="ended"?"off":"standby";
-        var tip = s.session_key+"\n"+s.status+" \u2022 "+(s.health||"ok")+"\nlast: "+timeAgo(s.last_event_at)+"\ncreated: "+timeAgo(s.created_at)+(s.cwd?"\ncwd: "+s.cwd:"");
+        var color = s.last_error?"alert":s.status==="active"?"running":s.status==="error"?"alert":s.status==="ended"?"off":"standby";
+        var tip = s.session_key+"\n"+s.status+" \u2022 "+(s.health||"ok")+"\nlast: "+timeAgo(s.last_event_at)+"\ncreated: "+timeAgo(s.created_at)+(s.cwd?"\ncwd: "+s.cwd:"")+(s.last_error?"\n\u26A0 error: "+s.last_error.message+" ("+timeAgo(s.last_error.at)+")":"");
         h+='<div class="ind circle '+color+'" data-key="'+esc(s.session_key)+'" data-tip="'+esc(tip)+'"></div>';
       });
       groups.push(h);
@@ -706,7 +706,36 @@ body{
       var tip = "last tick: "+timeAgo(status.cadence.last_tick)+"\ninterval: "+(status.cadence.interval_ms/1000)+"s";
       groups.push('<span class="sig-label" data-tip="'+esc(tip)+'">\u23F1 '+timeAgo(status.cadence.last_tick)+'</span>');
     }
-    signalEl.innerHTML = groups.map(function(g){return'<div class="sig-group">'+g+'</div>'}).join('<div class="sig-sep"></div>');
+    var newHtml = groups.map(function(g){return'<div class="sig-group">'+g+'</div>'}).join('<div class="sig-sep"></div>');
+    // Diff-update: preserve existing DOM nodes to keep blink animations alive.
+    // Only replace innerHTML when the structural content (ignoring blink class) changes.
+    var stripped = function(html) { return html.replace(/ blink/g, ""); };
+    if (stripped(signalEl.innerHTML) !== stripped(newHtml)) {
+      // Save active blink keys before rebuild
+      var blinking = new Set();
+      signalEl.querySelectorAll(".blink").forEach(function(el) { if (el.dataset.key) blinking.add(el.dataset.key); });
+      signalEl.innerHTML = newHtml;
+      // Restore blink on rebuilt nodes
+      blinking.forEach(function(key) {
+        var dot = signalEl.querySelector('[data-key="' + CSS.escape(key) + '"]');
+        if (dot) dot.classList.add("blink");
+      });
+    } else {
+      // Structure unchanged — patch individual dot colors/tips in-place
+      signalEl.querySelectorAll("[data-key]").forEach(function(dot) {
+        var key = dot.dataset.key;
+        var tmp = document.createElement("div");
+        tmp.innerHTML = newHtml;
+        var newDot = tmp.querySelector('[data-key="' + CSS.escape(key) + '"]');
+        if (newDot) {
+          // Update color class without touching blink
+          var hadBlink = dot.classList.contains("blink");
+          dot.className = newDot.className;
+          if (hadBlink) dot.classList.add("blink");
+          dot.dataset.tip = newDot.dataset.tip || "";
+        }
+      });
+    }
   }
 
   // --- Tooltip ---

package/bootstrap/var/DUODUO.md

@@ -10,9 +10,9 @@ Look for `DUODUO.md` in subdirectories to learn how each part works.
 - `cadence/` — background task queue and rhythm system
 - `channels/` — per-channel instance config, inbox, outbox, sessions
 - `jobs/` — scheduled recurring tasks (cron-based)
-- `sessions/` — per-session mailboxes and state
+- `sessions/` — per-session state, mailboxes, and metadata (see sessions/DUODUO.md)
 - `events/` — Spine (append-only event log, my history)
-- `registry/` — runtime status snapshots
+- `registry/` — session status snapshots for dashboard and external tools
 - `outbox/` — pending egress messages
 - `ingress/` — raw channel inputs before normalization
 - `telemetry/` — structured runtime latency samples for offline aggregation

package/bootstrap/var/sessions/DUODUO.md

@@ -0,0 +1,54 @@
+# Sessions — Per-Session Runtime State
+
+Each session gets a directory under `var/sessions/` named by the SHA-256
+hash of its session key. This is where my per-session persistent state lives.
+
+## Directory Layout
+
+```
+var/sessions/{sha256-hash}/
+├── state.json       ← persistent session state (source of truth)
+├── meta.md          ← session metadata (routes, display name, kind)
+├── inbox/           ← raw incoming items (*.pending files)
+└── mailbox/
+    ├── mailbox.md   ← rendered mailbox for SDK consumption
+    ├── pending/     ← merged items awaiting drain (*.item.json)
+    └── notes.jsonl  ← append-only drain notes
+```
+
+## state.json
+
+The single source of truth for persistent session data:
+
+- **Identity** (immutable after creation): `session_key`, `cwd`, `plane`,
+  `permission_profile`, `created_at`
+- **SDK session**: `sdk_session_id` — the Claude Agent SDK session ID for
+  conversation resume. Written when SDK confirms a new session, cleared on
+  `/clear` or `/reset`.
+- **Drain watermark**: `last_event_id`, `last_event_at` — crash recovery
+  markers. Ensures the `outbox write → watermark → mailbox finalize`
+  ordering survives process crashes.
+- **Channel capabilities**: declared by `channel.pull` consumers.
+- **Pending injections**: gateway notices, interrupted context, skip rewind,
+  outbound attachments — drain-scoped data consumed on the next turn.
+- **Last error**: `last_error` — most recent drain failure. Cleared on next
+  successful drain. Used by dashboard for error observability.
+
+## Mailbox Pipeline
+
+Messages flow through two stages:
+
+1. `inbox/*.pending` → raw items from ingress (one file per message)
+2. `mailbox/pending/*.item.json` → merged items ready for SDK consumption
+
+The drain loop merges inbox into mailbox, processes items, then deletes
+completed files. A crash at any stage is recoverable: the watermark in
+state.json tells the runner which items were already processed.
+
+## meta.md
+
+YAML frontmatter with session metadata:
+
+- `session_key`, `display_name`, `kind` (channel/job/meta/system)
+- `routes` — delivery routes for job result notifications
+- `owner_session` — parent session for job sessions