opencode-task-timer 0.0.0-stage → 0.1.9

package/CHANGELOG.md

@@ -0,0 +1,65 @@
+# Changelog
+
+Alle nennenswerten Änderungen an diesem Plugin. Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.1.0/), Versionen nach [Semantic Versioning](https://semver.org/lang/de/). Aufbau und Pflege sind in [docs/changelog.md](docs/changelog.md) beschrieben.
+
+## [Unreleased]
+
+---
+
+## [0.1.9] - 2026-10-28
+
+Patch-Release: **Öffentlich und auf npm**.
+
+### Geändert
+
+- **Open Source:** Repository ist öffentlich unter `emelpe78/opencode-task-timer`; das Paket liegt auf npm als `opencode-task-timer`.
+- **Auffindbarkeit:** Beschreibung und Keywords für GitHub und npm geschärft, damit das Plugin leichter gefunden wird.
+
+## [0.1.8] - 2026-10-26
+
+Patch-Release: **Titel bleiben stehen, der Block spricht Englisch**.
+
+### Behoben
+
+- **Titel fehlte:** `session.inbox.enqueued` kommt vor `session.execution.started`. Der Prompt-Text wird jetzt schon beim Vormerken je Sitzung abgelegt und benennt den startenden Lauf, statt beim Start ins Leere zu greifen.
+- **Zustand überschrieb sich:** Der Store schreibt asynchron und lieferte kurz danach noch den alten Stand. Ereignisse rechnen deshalb auf einem eigenen Stand mit Revision; der Store gilt nur, wenn er nicht älter ist. Zwei Prompts kurz hintereinander verlieren so keinen Titel mehr.
+- **Befehle waren unauffindbar:** Die Tastenebene registrierte kein `mode` und lag damit im Standardmodus `base`, der nur bei leerem Eingabefeld greift. Befehlspalette und Slash-Vervollständigung laufen dagegen im globalen Modus und sahen weder `/laufzeiten-reset` noch `/ott-reset`. Die Ebene ist jetzt `mode: "global"`, beide Befehle erscheinen wieder in Palette und Vervollständigung.
+- Ein abgebrochener Prompt (`session.inbox.cancelled`) wird entfernt und benennt keinen späteren Lauf.
+
+### Geändert
+
+- Der Block in der Seitenleiste ist englisch: Überschrift `Durations`, Status `error`, `aborted`, `superseded`, `ended`, `inactive`, `clock skew`, Hinweis `waiting for you`, Zusatz `20s waiting`, Summenzeile `2 tasks, 1m 57s, Ø 59s` und `untitled`. Befehle, Palettentitel, Dialoge und Toasts bleiben deutsch.
+- Die beiden Befehle heißen jetzt `/ott-reset` und `/ott-reset-all` statt `/laufzeiten-reset` und `/laufzeiten-reset-alle`. Die alten Namen entfallen ersatzlos; Titel, Gruppe, Rückfrage und Toast bleiben deutsch.
+
+## [0.1.7] - 2026-10-26
+
+Patch-Release: **Die veröffentlichte Fassung lädt wieder**.
+
+### Behoben
+
+- Drei Ursachen nacheinander, die das Laden verhinderten:
+  - JSX in `node_modules` wird nicht transformiert, deshalb fehlte ein vorgebautes `dist/` (`Cannot find package 'react'`).
+  - `dist/tui.js` importierte `./laufzeit.ts`, die nicht im Paket lag (`Cannot find module './laufzeit.ts'`).
+  - Ein `build`-Skript löste npms Vorbereitung für Git-Abhängigkeiten aus und ließ die Installation abbrechen (`git dep preparation failed`). Der Build heißt jetzt `bauen`.
+
+### Hinzugefügt
+
+- `scripts/build.mjs` baut `src/tui.tsx` und `src/measurement.ts` nach `dist/`.
+
+## [0.1.0] - 2026-10-26
+
+Minor-Release: **Erste Fassung**. Die Linie bringt den Laufzeiten-Block in der Seitenleiste, die Messung je Agentenlauf samt Wartezeit und die durable Ablage. Die Patches dieser Linie nach `0.1.0` beheben ausschließlich das Laden der veröffentlichten Fassung.
+
+### Hinzugefügt
+
+- Block `Laufzeiten` in der Seitenleiste, neueste Aufgabe oben, höchstens zehn Zeilen, mit Dauer, Titel und Status nur bei Abweichung.
+- Laufender Eintrag mit sekündlichem Takt und Hinweis `wartet auf dich`.
+- Wartezeit auf Freigaben und Rückfragen zählt zur Laufzeit und wird beim Abschluss als `· 20s warten` ausgewiesen.
+- Summenzeile über alle abgeschlossenen Aufgaben der Sitzung.
+- Zustände `Fehler`, `abgebrochen`, `verdrängt`, `beendet`, `inaktiv` und `Zeitsprung`.
+- Messung je Agentenlauf statt je Prompt: `steer` und Fortsetzung nach einer Kompaktierung verlängern, Subagenten zählen nicht separat.
+- Durable Ablage mit Aufbewahrung über 30 Tage und 200 Sitzungen.
+- Liegengebliebene Läufe werden beim Start als `beendet` abgeschlossen.
+- Befehle `/laufzeiten-reset` und `/laufzeiten-reset-alle`.
+- Ausblenden bei sehr schmaler Seitenleiste.
+- Tests für die Messlogik mit `node --test`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marc Lettau-Poelchen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,95 @@
-# Temporary Holding Version
+# opencode-task-timer
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+OpenCode-2-TUI-Plugin: Laufzeiten je Agentenaufgabe in der Seitenleiste.
+
+Misst, wie lange der Agent für jede Aufgabe braucht, und zeigt die Dauern als Block in der TUI-Seitenleiste.
+
+```
+Durations
+    35s Zweite Aufgabe mit Fehler
+    1m 22s Seitenleisten-Probe · 20s waiting
+2 tasks, 1m 57s, Ø 59s
+```
+
+- Die Uhr startet, wenn der Agent mit einer Aufgabe beginnt.
+- Die Uhr stoppt, wenn er fertig ist und du wieder gefragt wirst.
+- Die Zeilen stehen in der Seitenleiste, neueste oben.
+
+## Installation
+
+Über npm:
+
+```
+opencode plugin add opencode-task-timer
+```
+
+Oder direkt vom Repository:
+
+```
+opencode plugin add github:emelpe78/opencode-task-timer#v0.1.9
+```
+
+Danach OpenCode neu starten. Der Block erscheint in der Seitenleiste, sobald in der Sitzung die erste Aufgabe gelaufen ist. Eine Sitzung ohne Aufgaben zeigt nichts.
+
+## Was gemessen wird
+
+Der vollständige Messvertrag steht in [README-Messung](docs/measurement.md). Die Kurzfassung:
+
+- Gemessen wird ein Agentenlauf, nicht ein Prompt.
+- Ein `steer`-Prompt und die Fortsetzung nach einer Kompaktierung verlängern die laufende Aufgabe. Ein `queue`-Prompt gehört zur nächsten.
+- Subagenten werden nicht separat gezählt, ihre Zeit steckt in der Hauptlaufzeit.
+- Warten auf deine Freigabe zählt zur Laufzeit und wird beim Abschluss zusätzlich ausgewiesen.
+- Titel ist die erste Zeile deines Prompts, auf 40 Zeichen gekürzt.
+
+## Befehle
+
+| Befehl           | Wirkung                                     |
+| ---------------- | ------------------------------------------- |
+| `/ott-reset`     | Löscht die Laufzeiten der aktuellen Sitzung |
+| `/ott-reset-all` | Löscht alle gespeicherten Laufzeiten        |
+
+Beide stehen auch in der Befehlspalette und fragen vor dem Löschen nach.
+
+## Anzeige
+
+- Höchstens zehn Zeilen, neueste oben.
+- Dauer als `42s`, `1m 23s`, ab einer Stunde `1h 02m`.
+- Status nur bei Abweichung: `error`, `aborted`, `superseded`, `ended`, `inactive`, `clock skew`.
+- Der laufende Eintrag tickt sekündlich und zeigt `waiting for you`, wenn er auf dich wartet.
+- Summenzeile über alle abgeschlossenen Aufgaben der Sitzung, englisch.
+- Bei sehr schmaler Seitenleiste bleibt der Block aus, statt unleserlich zu werden.
+- Rein lesend, kein Tastenkürzel.
+
+## Speicherung
+
+Der Zustand liegt im durabelen Store des Hosts und überlebt Neustarts. Er enthält je Aufgabe nur den gekürzten Titel und Zeitpunkte, niemals den vollen Prompt. Aufbewahrung: 30 Tage und höchstens 200 Sitzungen. Gelöschte Sitzungen verschwinden sofort.
+
+## Entwicklung
+
+```
+npm install
+npm run bauen   # schreibt dist/tui.js und dist/measurement.js
+npm test
+```
+
+Die Messlogik liegt in `src/measurement.ts` und ist frei von OpenCode-Abhängigkeiten, damit sie mit `node --test` prüfbar bleibt. `src/tui.tsx` verdrahtet nur die Ereignisse und rendert den Block. Was gemessen wird, steht in [README-Messung](docs/measurement.md); wie `CHANGELOG.md` aufgebaut und gepflegt wird, in [Changelog-Regeln](docs/changelog.md).
+
+`dist/` ist eingecheckt, damit die Installation direkt aus dem Repository funktioniert.
+
+## Fallstricke beim Veröffentlichen
+
+- OpenCodes Solid-JSX-Transform überspringt Pfade mit `/node_modules/`. Ein veröffentlichtes Plugin liegt genau dort, deshalb braucht es ein vorgebautes `dist/`. Ohne das wird sein JSX als React-JSX übersetzt und der Ladevorgang scheitert an einem fehlenden `react`.
+- `dist/` muss die Messlogik mitliefern. Ein Import auf `./measurement.ts` schlägt fehl, weil `src/` nicht im Paket liegt.
+- `package.json` darf keines der Skripte `build`, `prepare`, `prepack`, `install`, `preinstall` oder `postinstall` nennen. npms pacote löst sonst bei einer Git-Abhängigkeit eine Vorbereitung aus, die hier scheitert. Der Build heißt deshalb `bauen`.
+- Die Imports auf `@opentui/solid` und `solid-js` werden auf die Laufzeitmodule des Hosts umgeschrieben (`opentui:runtime-module:…`), wie im offiziellen Plugin `oc-tps`.
+- `context.keymap.layer` braucht `mode: "global"`, sonst landet die Ebene im Standardmodus `base`. Der greift nur bei leerem Eingabefeld, während Befehlspalette und Slash-Vervollständigung im globalen Modus laufen. Ohne `mode` sind die Befehle dort unsichtbar, obwohl `palette: true` und `slash` gesetzt sind.
+- Ein Plugin in `~/.config/opencode/plugins/` ist ein Server-Plugin und bekommt keinen TUI-Kontext. `context.keymap` fehlt dort, der Ladevorgang scheitert mit `undefined is not an object`. TUI-Plugins gehören über `cli.json` oder `opencode plugin add` eingebunden.
+
+## Voraussetzungen
+
+- OpenCode 2.0 oder neuer (`@opencode/plugin` 2.x).
+- Node 22.6 oder neuer, nur für die Tests.
+
+## Lizenz
+
+[MIT](LICENSE)

package/dist/measurement.js

@@ -0,0 +1,463 @@
+// Reine Messlogik für opencode-task-timer.
+//
+// Diese Datei kennt weder OpenCode noch Solid noch JSX. Sie ist damit mit
+// `node --test` prüfbar und enthält die eigentliche Wahrheit darüber, was als
+// Laufzeit gezählt wird. Alles Sichtbare und alles Verdrahtete liegt in
+// `tui.tsx`.
+//
+// Messvertrag (kurz):
+// - Gemessen wird ein Agentenlauf, nicht ein Prompt.
+// - Start ist `run-started`, Ende ist `run-ended` oder `run-interrupted`.
+// - Zeitstempel kommen vom Server, nicht von der lokalen Uhr.
+// - Ein `steer`-Prompt und eine automatische Fortsetzung nach Kompaktierung
+//   verlängern den laufenden Eintrag. Ein `queue`-Prompt führt über ein
+//   `superseded`-Ende zu einer neuen Zeile.
+// - Kind-Sitzungen (Subagenten) werden vollständig ignoriert, damit ihre Zeit
+//   nicht doppelt in der Wurzel landet.
+// - Warten auf Freigabe oder Rückfrage zählt zur Laufzeit und wird beim
+//   Abschluss zusätzlich ausgewiesen.
+
+export const MAX_ENTRIES = 10;
+export const MAX_TITLE = 40;
+export const RETENTION_DAYS = 30;
+export const MAX_SESSIONS = 200;
+export const UNTITLED = "untitled";
+export const WAITING_HINT = "waiting for you";
+export const RUNNING_HINT = "running";
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+export function emptyState() {
+  return {
+    rev: 0,
+    entries: [],
+    texts: {},
+    pending: {},
+    lastPrompt: {},
+    sessions: [],
+    heartbeats: {}
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Formatierung
+// ---------------------------------------------------------------------------
+
+/** Dauer als `42s`, `1m 23s` oder `1h 02m`. Sekundengenau, ohne Zehntel. */
+export function formatDuration(ms) {
+  const total = Math.max(0, Math.round(ms / 1000));
+  const hours = Math.floor(total / 3600);
+  const minutes = Math.floor(total % 3600 / 60);
+  const seconds = total % 60;
+  if (hours > 0) return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+  if (minutes > 0) return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+  return `${seconds}s`;
+}
+
+/**
+ * Titel aus dem Prompt: erste nicht leere Zeile, auf `MAX_TITLE` Zeichen
+ * gekürzt. Ohne verwertbaren Text bleibt `untitled`.
+ */
+export function shortenTitle(text) {
+  if (!text) return UNTITLED;
+  const line = text.split(/\r?\n/).map(part => part.trim()).find(part => part.length > 0);
+  if (!line) return UNTITLED;
+  const compact = line.replace(/\s+/g, " ");
+  if (compact.length <= MAX_TITLE) return compact;
+  return `${compact.slice(0, MAX_TITLE - 1).trimEnd()}…`;
+}
+
+/** Anzeigetext eines Status. Erfolgreiche Läufe bleiben schlicht. */
+export function statusLabel(status) {
+  switch (status) {
+    case "running":
+      return RUNNING_HINT;
+    case "error":
+      return "error";
+    case "aborted":
+      return "aborted";
+    case "superseded":
+      return "superseded";
+    case "ended":
+      return "ended";
+    case "inactive":
+      return "inactive";
+    case "clockSkew":
+      return "clock skew";
+    case "done":
+      return undefined;
+  }
+}
+export function statusFromReason(reason) {
+  switch (reason) {
+    case "user":
+      return "aborted";
+    case "shutdown":
+      return "ended";
+    case "superseded":
+      return "superseded";
+    case "inactivity":
+      return "inactive";
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Ableitungen
+// ---------------------------------------------------------------------------
+
+/** Dauer eines Eintrags. Negatives aus einer zurückgestellten Uhr wird zu null. */
+export function durationMs(entry, now) {
+  const end = entry.end ?? now;
+  return Math.max(0, end - entry.start);
+}
+
+/** Wartezeit einschließlich einer noch laufenden Wartezeit. */
+export function waitingMs(entry, now) {
+  const open = entry.waitingSince === undefined ? 0 : Math.max(0, now - entry.waitingSince);
+  return entry.waitingMs + open;
+}
+/**
+ * Kennzahlen über alle abgeschlossenen Einträge, auch die nicht erfolgreichen
+ * und auch die aus der Anzeige gefallenen. Der laufende Eintrag bleibt außen
+ * vor, sonst wäre die Summe bei jedem Takt eine andere.
+ */
+export function stats(entries, now) {
+  const finished = entries.filter(entry => entry.status !== "running");
+  const totalMs = finished.reduce((sum, entry) => sum + durationMs(entry, now), 0);
+  const count = finished.length;
+  return {
+    count,
+    totalMs,
+    averageMs: count > 0 ? Math.round(totalMs / count) : 0
+  };
+}
+export function summaryLine(summary) {
+  if (summary.count === 0) return undefined;
+  const tasks = summary.count === 1 ? "1 task" : `${summary.count} tasks`;
+  return `${tasks}, ${formatDuration(summary.totalMs)}, Ø ${formatDuration(summary.averageMs)}`;
+}
+
+/** Zusatz zur Laufzeit, wenn beim Abschluss Wartezeit angefallen ist. */
+export function waitingNote(entry, now) {
+  if (entry.status === "running") return undefined;
+  const waiting = waitingMs(entry, now);
+  if (waiting < 1000) return undefined;
+  return `${formatDuration(waiting)} waiting`;
+}
+
+/** Einträge einer Sitzung, neueste zuerst, auf `MAX_ENTRIES` begrenzt. */
+export function visibleEntries(state, session, max = MAX_ENTRIES) {
+  return state.entries.filter(entry => entry.session === session).sort((left, right) => right.start - left.start).slice(0, max);
+}
+export function runningEntry(state, session) {
+  return state.entries.find(entry => entry.session === session && entry.status === "running");
+}
+
+// ---------------------------------------------------------------------------
+// Zustandsübergänge
+// ---------------------------------------------------------------------------
+
+export function withEntries(state, entries) {
+  return {
+    ...state,
+    entries
+  };
+}
+function replace(state, id, patch) {
+  return withEntries(state, state.entries.map(entry => entry.id === id ? {
+    ...entry,
+    ...patch
+  } : entry));
+}
+function touchSession(state, session, time) {
+  const rest = state.sessions.filter(entry => entry !== session);
+  return {
+    ...state,
+    sessions: [...rest, session],
+    heartbeats: {
+      ...state.heartbeats,
+      [session]: time
+    }
+  };
+}
+
+/**
+ * Ein `steer`-Prompt verlängert die laufende Aufgabe, deshalb wird der Titel
+ * ergänzt statt ersetzt. Passt die Ergänzung nicht mehr in `MAX_TITLE`, bleibt
+ * der bisherige Titel stehen, damit die Zeile lesbar bleibt.
+ */
+function appendTitle(previous, next) {
+  if (previous === UNTITLED) return next;
+  if (next === UNTITLED) return previous;
+  const combined = `${previous} + ${next}`;
+  return combined.length <= MAX_TITLE ? combined : previous;
+}
+function finish(state, session, time, status) {
+  const running = runningEntry(state, session);
+  if (!running) return state;
+  const openWaiting = running.waitingSince === undefined ? 0 : Math.max(0, time - running.waitingSince);
+  // Eine zurückgestellte Systemuhr darf keine negative Laufzeit erzeugen.
+  const clockSkew = time < running.start;
+  return replace(state, running.id, {
+    end: clockSkew ? running.start : time,
+    status: clockSkew ? "clockSkew" : status,
+    waitingMs: running.waitingMs + openWaiting,
+    waitingSince: undefined
+  });
+}
+
+/** Wendet ein Ereignis auf den Zustand an. Ohne Seiteneffekte. */
+export function apply(state, event) {
+  const next = reduce(state, event);
+  // Jede angenommene Änderung zählt eine Revision weiter.
+  return next === state ? state : {
+    ...next,
+    rev: state.rev + 1
+  };
+}
+function reduce(state, event) {
+  switch (event.kind) {
+    case "run-started":
+      {
+        if (event.isChild) return state;
+        // Doppelte Zustellung, etwa nach Hot Reload oder in einer zweiten TUI.
+        if (state.entries.some(entry => entry.id === event.id)) return state;
+        const touched = touchSession(state, event.session, event.time);
+        const running = runningEntry(touched, event.session);
+        // Fortsetzung, etwa nach einer Kompaktierung: derselbe Auftrag läuft
+        // weiter, es entsteht keine neue Zeile.
+        if (running) return touched;
+        // Der Host meldet den Prompt vor dem Start, die Zustellung aber erst
+        // danach. Deshalb ist der vorgemerkte Prompt die richtige Quelle und der
+        // zuletzt zugestellte nur der Rückfall. `titleFrom` verhindert später,
+        // dass dieselbe Zustellung den Titel ein zweites Mal ergänzt.
+        const queued = touched.pending[event.session]?.[0];
+        const fallback = queued?.text ?? touched.lastPrompt[event.session];
+        const entry = {
+          id: event.id,
+          session: event.session,
+          title: shortenTitle(fallback),
+          ...(queued === undefined ? {} : {
+            titleFrom: queued.id
+          }),
+          start: event.time,
+          status: "running",
+          waitingMs: 0
+        };
+        return withEntries(touched, [...touched.entries, entry]);
+      }
+    case "run-ended":
+      {
+        if (event.isChild) return state;
+        return finish(touchSession(state, event.session, event.time), event.session, event.time, event.result === "done" ? "done" : "error");
+      }
+    case "run-interrupted":
+      {
+        if (event.isChild) return state;
+        return finish(touchSession(state, event.session, event.time), event.session, event.time, statusFromReason(event.reason));
+      }
+    case "prompt-queued":
+      {
+        const queue = state.pending[event.session] ?? [];
+        const known = queue.some(item => item.id === event.deliveryID);
+        return {
+          ...state,
+          texts: {
+            ...state.texts,
+            [event.deliveryID]: event.text
+          },
+          pending: {
+            ...state.pending,
+            [event.session]: known ? queue : [...queue, {
+              id: event.deliveryID,
+              text: event.text,
+              delivery: event.delivery
+            }]
+          }
+        };
+      }
+    case "prompt-delivered":
+      {
+        if (event.isChild) return state;
+        const text = state.texts[event.deliveryID];
+        const title = shortenTitle(text);
+        // Der Prompt ist zugestellt: Text und Vormerkung sind verbraucht.
+        const texts = {
+          ...state.texts
+        };
+        delete texts[event.deliveryID];
+        const queue = (state.pending[event.session] ?? []).filter(item => item.id !== event.deliveryID);
+        const pending = {
+          ...state.pending,
+          [event.session]: queue
+        };
+        if (queue.length === 0) delete pending[event.session];
+        const touched = {
+          ...state,
+          texts,
+          pending,
+          lastPrompt: {
+            ...state.lastPrompt,
+            [event.session]: text ?? title
+          }
+        };
+        const running = runningEntry(touched, event.session);
+        if (!running) return touched;
+        // Hat dieser Prompt den Lauf schon beim Start benannt, steht der Titel
+        // bereits und wird nicht ein zweites Mal ergänzt.
+        if (running.titleFrom === event.deliveryID) return touched;
+        // Ein `steer`-Prompt schiebt sich in die laufende Arbeit und ergänzt
+        // deren Titel.
+        if (event.delivery === "steer") {
+          return replace(touched, running.id, {
+            title: appendTitle(running.title, title)
+          });
+        }
+        // Ein `queue`-Prompt gehört zum naechsten Lauf. Ist noch einer offen, wird
+        // er nicht umbenannt, sonst stuende ein fremder Titel an einer fremden
+        // Laufzeit. Ist der offene Lauf noch ohne Titel, ist das die eigene
+        // Zustellung, die der Host erst nach dem Start meldet.
+        if (running.title === UNTITLED) {
+          return replace(touched, running.id, {
+            title
+          });
+        }
+        return touched;
+      }
+    case "prompt-cancelled":
+      {
+        // Ein verworfener Prompt darf weder den nächsten Lauf benennen noch als
+        // Rückfall liegen bleiben.
+        const texts = {
+          ...state.texts
+        };
+        delete texts[event.deliveryID];
+        const queue = (state.pending[event.session] ?? []).filter(item => item.id !== event.deliveryID);
+        const pending = {
+          ...state.pending,
+          [event.session]: queue
+        };
+        if (queue.length === 0) delete pending[event.session];
+        return {
+          ...state,
+          texts,
+          pending
+        };
+      }
+    case "waiting-started":
+      {
+        const running = runningEntry(state, event.session);
+        if (!running || running.waitingSince !== undefined) return state;
+        return replace(state, running.id, {
+          waitingSince: event.time
+        });
+      }
+    case "waiting-ended":
+      {
+        const running = runningEntry(state, event.session);
+        if (!running || running.waitingSince === undefined) return state;
+        const added = Math.max(0, event.time - running.waitingSince);
+        return replace(state, running.id, {
+          waitingMs: running.waitingMs + added,
+          waitingSince: undefined
+        });
+      }
+    case "session-deleted":
+      {
+        const texts = {
+          ...state.texts
+        };
+        const pending = {
+          ...state.pending
+        };
+        const lastPrompt = {
+          ...state.lastPrompt
+        };
+        const heartbeats = {
+          ...state.heartbeats
+        };
+        delete pending[event.session];
+        delete lastPrompt[event.session];
+        delete heartbeats[event.session];
+        return {
+          entries: state.entries.filter(entry => entry.session !== event.session),
+          texts,
+          pending,
+          lastPrompt,
+          sessions: state.sessions.filter(session => session !== event.session),
+          heartbeats
+        };
+      }
+    case "heartbeat":
+      {
+        if (event.isChild) return state;
+        return touchSession(state, event.session, event.time);
+      }
+  }
+}
+
+/**
+ * Schließt beim Start liegengebliebene Läufe ab. Die Dauer endet beim letzten
+ * Lebenszeichen, nicht bei der aktuellen Uhrzeit, sonst würde eine über Nacht
+ * geschlossene Sitzung eine absurde Laufzeit behaupten.
+ */
+export function closeStaleRuns(state) {
+  const entries = state.entries.map(entry => {
+    if (entry.status !== "running") return entry;
+    const last = state.heartbeats[entry.session] ?? entry.start;
+    const end = Math.max(entry.start, last);
+    return {
+      ...entry,
+      status: "ended",
+      end,
+      waitingSince: undefined
+    };
+  });
+  return withEntries(state, entries);
+}
+
+/**
+ * Räumt nach Alter und Anzahl auf: Einträge älter als `RETENTION_DAYS` verschwinden,
+ * und es bleiben höchstens `MAX_SESSIONS` Sitzungen erhalten.
+ */
+export function prune(state, now) {
+  const cutoff = now - RETENTION_DAYS * MS_PER_DAY;
+  const kept = new Set(state.sessions.slice(Math.max(0, state.sessions.length - MAX_SESSIONS)));
+  const entries = state.entries.filter(entry => entry.start >= cutoff && kept.has(entry.session));
+  const liveSessions = new Set(entries.map(entry => entry.session));
+  const pending = {};
+  const lastPrompt = {};
+  const heartbeats = {};
+  for (const session of liveSessions) {
+    const queue = state.pending[session];
+    if (queue !== undefined && queue.length > 0) pending[session] = queue;
+    const prompt = state.lastPrompt[session];
+    if (prompt !== undefined) lastPrompt[session] = prompt;
+    const beat = state.heartbeats[session];
+    if (beat !== undefined) heartbeats[session] = beat;
+  }
+  // Vorgemerkte Texte ohne noch offene Vormerkung sind nach einem Aufräumen
+  // wertlos: ihre Zustellung kommt nicht mehr.
+  const texts = {};
+  for (const queue of Object.values(pending)) {
+    for (const item of queue) {
+      const text = state.texts[item.id];
+      if (text !== undefined) texts[item.id] = text;
+    }
+  }
+  return {
+    rev: state.rev + 1,
+    entries,
+    texts,
+    pending,
+    lastPrompt,
+    sessions: state.sessions.filter(session => liveSessions.has(session)),
+    heartbeats
+  };
+}
+
+/** Leert die Einträge einer Sitzung, ohne andere Sitzungen anzutasten. */
+export function clearSession(state, session) {
+  return {
+    ...withEntries(state, state.entries.filter(entry => entry.session !== session)),
+    rev: state.rev + 1
+  };
+}

package/dist/tui.js

@@ -0,0 +1,536 @@
+import { use as _$use } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createComponent as _$createComponent } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { effect as _$effect } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { memo as _$memo } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createTextNode as _$createTextNode } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insertNode as _$insertNode } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { insert as _$insert } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { setProp as _$setProp } from "opentui:runtime-module:%40opentui%2Fsolid";
+import { createElement as _$createElement } from "opentui:runtime-module:%40opentui%2Fsolid";
+// OpenCode-2-TUI-Plugin: Laufzeiten je Aufgabe in der Seitenleiste.
+//
+// Diese Datei verdrahtet die OpenCode-Ereignisse mit der reinen Messlogik aus
+// `measurement.ts` und rendert den Block. Die Wahrheit über die Messung liegt in
+// `measurement.ts` und ist dort durch Tests belegt; hier steht nur Übersetzung und
+// Darstellung.
+//
+// Messvertrag siehe README, Abschnitt "Was gemessen wird".
+
+import { Plugin } from "@opencode/plugin/tui";
+import { For, Show, createMemo, createSignal, onCleanup } from "opentui:runtime-module:solid-js";
+import { apply, clearSession, closeStaleRuns, durationMs, emptyState, formatDuration, prune, runningEntry, stats, statusLabel, summaryLine, visibleEntries, waitingNote, WAITING_HINT } from "./measurement.js";
+
+/** Speicherschlüssel im durabelen Host-Store. */
+const STORAGE = "laufzeiten";
+/** Unter dieser Breite wird der Block ausgeblendet statt unleserlich zu werden. */
+const MIN_WIDTH = 22;
+/** Takt der Live-Anzeige. */
+const TICK_MS = 1_000;
+/** Ab hier wird der Titel gekürzt, damit die Zeile in die Spalte passt. */
+const TITLE_SPACE = 12;
+/** Liest einen Textpfad defensiv, weil die Payload-Form zwischen Versionen wechselt. */
+function textAt(value, path) {
+  let current = value;
+  for (const part of path) {
+    if (current === null || typeof current !== "object") return undefined;
+    current = current[part];
+  }
+  return typeof current === "string" ? current : undefined;
+}
+
+/**
+ * Prompt-Text eines Zustellungs-Ereignisses. Die Form ist je nach Version
+ * `{ item: { type, payload: { text } } }` oder `{ item: { text } }`, deshalb
+ * werden beide Wege versucht.
+ */
+function promptText(event) {
+  for (const path of [["data", "item", "payload", "text"], ["data", "item", "text"], ["data", "text"], ["item", "payload", "text"], ["item", "text"]]) {
+    const text = textAt(event, path);
+    if (text !== undefined) return text;
+  }
+  return "";
+}
+function deliveryID(event) {
+  for (const path of [["data", "inboxID"], ["data", "item", "id"], ["data", "item", "payload", "id"], ["inboxID"]]) {
+    const id = textAt(event, path);
+    if (id !== undefined) return id;
+  }
+  return undefined;
+}
+export default Plugin.define({
+  id: "task-timer",
+  async setup(context) {
+    // Beim Start liegengebliebene Läufe abschließen und aufräumen, damit eine
+    // über Nacht geschlossene Sitzung keine absurde Laufzeit behauptet.
+    const [stored, write] = context.storage.store(STORAGE, {
+      initial: {
+        state: emptyState()
+      }
+    });
+    const cleaned = prune(closeStaleRuns(stored.state), Date.now());
+    if (cleaned !== stored.state) {
+      await write(draft => {
+        draft.state = cleaned;
+      });
+    }
+    // Ein Taktzähler stößt die sekündliche Neuberechnung an. Der Zustand selbst
+    // ist der reaktive Store, deshalb genügt ein Zähler ohne Wert.
+    const [tick, setTick] = createSignal(0);
+    const nudge = () => setTick(value => value + 1);
+
+    // Der Store schreibt asynchron und zieht seinen Stand verzögert nach. Würde
+    // jedes Ereignis blind aus dem Store rechnen, überschriebe der alte Stand
+    // das frisch Zugestellte. Genau daran ging der Titel verloren. Deshalb trägt
+    // jeder Zustand eine Revision: der Store gilt nur, wenn er nicht älter ist
+    // als der eigene Stand. So gehen Änderungen einer zweiten TUI nicht
+    // verloren, und der eigene Fortschritt wird nicht zurückgedreht.
+    const [latest, setLatest] = createSignal(cleaned);
+    const advance = next => {
+      setLatest(() => next);
+      return write(draft => {
+        draft.state = next;
+      }).then(() => undefined, () => undefined);
+    };
+
+    /** Der Zustand, auf den das nächste Ereignis trifft. */
+    const currentState = () => stored.state.rev > latest().rev ? stored.state : latest();
+    const accept = event => {
+      const before = currentState();
+      const after = apply(before, event);
+      if (after === before) return;
+      void advance(after);
+      nudge();
+    };
+
+    /** Übersetzt ein OpenCode-Ereignis in unsere Sprache und wendet es an. */
+    const translate = (type, event) => {
+      const data = event.data ?? {};
+      const session = typeof data.sessionID === "string" ? data.sessionID : undefined;
+      const stamp = event.created;
+      const time = typeof stamp === "number" ? stamp : Date.now();
+      const isChild = session !== undefined && session !== context.data.session.root(session);
+      switch (type) {
+        case "session.execution.started":
+          {
+            if (!session) return;
+            const identifier = event.id;
+            const id = typeof identifier === "string" ? identifier : `${session}:${time}`;
+            accept({
+              kind: "run-started",
+              id,
+              session,
+              time,
+              isChild
+            });
+            return;
+          }
+        case "session.execution.succeeded":
+          {
+            if (!session) return;
+            accept({
+              kind: "run-ended",
+              session,
+              time,
+              result: "done",
+              isChild
+            });
+            return;
+          }
+        case "session.execution.failed":
+          {
+            if (!session) return;
+            accept({
+              kind: "run-ended",
+              session,
+              time,
+              result: "error",
+              isChild
+            });
+            return;
+          }
+        case "session.execution.interrupted":
+          {
+            if (!session) return;
+            const raw = data.reason;
+            const known = ["user", "shutdown", "superseded", "inactivity"];
+            const reason = known.find(value => value === raw) ?? "user";
+            accept({
+              kind: "run-interrupted",
+              session,
+              time,
+              reason,
+              isChild
+            });
+            return;
+          }
+        case "session.inbox.enqueued":
+          {
+            // Der Host meldet den Prompt vor dem Lauf. Text und Zustellart werden
+            // vorgemerkt, damit der Eintrag beim Start schon seinen Titel kennt.
+            const id = deliveryID(event);
+            if (!id || !session) return;
+            const item = data.item ?? {};
+            const delivery = item.delivery === "steer" ? "steer" : "queue";
+            accept({
+              kind: "prompt-queued",
+              deliveryID: id,
+              session,
+              text: promptText(event),
+              delivery
+            });
+            return;
+          }
+        case "session.inbox.delivered":
+          {
+            const id = deliveryID(event);
+            if (!session || !id) return;
+            // Die Zustellart vom Vormerken bleibt maßgeblich; das Ereignis selbst
+            // trägt sie nicht.
+            const queued = currentState().pending[session] ?? [];
+            const delivery = queued.find(item => item.id === id)?.delivery ?? "queue";
+            accept({
+              kind: "prompt-delivered",
+              deliveryID: id,
+              session,
+              time,
+              delivery,
+              isChild
+            });
+            return;
+          }
+        case "session.inbox.delivery.changed":
+          {
+            // Nur eine Umstellung auf `steer` verlängert die laufende Aufgabe.
+            const id = deliveryID(event);
+            if (!session || !id || data.delivery !== "steer") return;
+            accept({
+              kind: "prompt-delivered",
+              deliveryID: id,
+              session,
+              time,
+              delivery: "steer",
+              isChild
+            });
+            return;
+          }
+        case "session.inbox.cancelled":
+          {
+            // Ein verworfener Prompt benennt keinen Lauf.
+            const id = deliveryID(event);
+            if (!session || !id) return;
+            accept({
+              kind: "prompt-cancelled",
+              deliveryID: id,
+              session
+            });
+            return;
+          }
+        case "session.permissions":
+          {
+            if (!session) return;
+            const open = Array.isArray(data.permissions) && data.permissions.length > 0;
+            accept({
+              kind: open ? "waiting-started" : "waiting-ended",
+              session,
+              time
+            });
+            return;
+          }
+        case "session.deleted":
+          {
+            if (!session) return;
+            accept({
+              kind: "session-deleted",
+              session
+            });
+            return;
+          }
+        case "session.step.started":
+        case "session.step.ended":
+        case "session.tool.called":
+        case "session.tool.success":
+        case "session.tool.failed":
+        case "session.status":
+        case "session.retry.scheduled":
+          {
+            // Lebenszeichen halten die Dauer eines liegengebliebenen Laufs ehrlich.
+            if (!session) return;
+            accept({
+              kind: "heartbeat",
+              session,
+              time,
+              isChild
+            });
+            return;
+          }
+        default:
+          return;
+      }
+    };
+    const subscription = context.data.listen(event => {
+      const type = event.details?.type;
+      if (!type) return;
+      translate(type, event.details);
+    });
+    const ticker = setInterval(nudge, TICK_MS);
+    onCleanup(() => {
+      clearInterval(ticker);
+      subscription();
+    });
+
+    // ---------------------------------------------------------------------
+    // Darstellung
+    // ---------------------------------------------------------------------
+
+    function Row(props) {
+      const duration = createMemo(() => formatDuration(durationMs(props.entry, props.now)));
+      const running = createMemo(() => props.entry.status === "running");
+      const waiting = createMemo(() => props.entry.waitingSince !== undefined);
+      const status = createMemo(() => statusLabel(props.entry.status));
+      const note = createMemo(() => waitingNote(props.entry, props.now));
+      const title = createMemo(() => {
+        const space = Math.max(6, props.width - TITLE_SPACE);
+        const text = props.entry.title;
+        return text.length <= space ? text : `${text.slice(0, space - 1).trimEnd()}…`;
+      });
+      const color = createMemo(() => {
+        switch (props.entry.status) {
+          case "error":
+            return context.theme.hue.red[500];
+          case "aborted":
+          case "superseded":
+          case "ended":
+          case "inactive":
+          case "clockSkew":
+            return context.theme.hue.orange[500];
+          default:
+            return context.theme.text.muted;
+        }
+      });
+      return (() => {
+        var _el$ = _$createElement("box"),
+          _el$2 = _$createElement("box"),
+          _el$3 = _$createElement("text"),
+          _el$4 = _$createElement("text"),
+          _el$5 = _$createTextNode(` `);
+        _$insertNode(_el$, _el$2);
+        _$setProp(_el$, "flexDirection", "column");
+        _$insertNode(_el$2, _el$3);
+        _$insertNode(_el$2, _el$4);
+        _$setProp(_el$2, "flexDirection", "row");
+        _$insert(_el$3, () => duration().padStart(7));
+        _$insertNode(_el$4, _el$5);
+        _$insert(_el$4, title, null);
+        _$insert(_el$, _$createComponent(Show, {
+          get when() {
+            return waiting() || status() !== undefined || note() !== undefined;
+          },
+          get children() {
+            var _el$6 = _$createElement("box");
+            _$setProp(_el$6, "flexDirection", "row");
+            _$setProp(_el$6, "paddingLeft", 8);
+            _$insert(_el$6, _$createComponent(Show, {
+              get when() {
+                return waiting();
+              },
+              get children() {
+                var _el$7 = _$createElement("text");
+                _$insert(_el$7, WAITING_HINT);
+                _$effect(_$p => _$setProp(_el$7, "fg", context.theme.hue.orange[500], _$p));
+                return _el$7;
+              }
+            }), null);
+            _$insert(_el$6, _$createComponent(Show, {
+              get when() {
+                return _$memo(() => !!!waiting())() && status() !== undefined;
+              },
+              get children() {
+                var _el$8 = _$createElement("text");
+                _$insert(_el$8, status);
+                _$effect(_$p => _$setProp(_el$8, "fg", color(), _$p));
+                return _el$8;
+              }
+            }), null);
+            _$insert(_el$6, _$createComponent(Show, {
+              get when() {
+                return note() !== undefined;
+              },
+              get children() {
+                var _el$9 = _$createElement("text"),
+                  _el$0 = _$createTextNode(` · `);
+                _$insertNode(_el$9, _el$0);
+                _$insert(_el$9, note, null);
+                _$effect(_$p => _$setProp(_el$9, "fg", context.theme.text.muted, _$p));
+                return _el$9;
+              }
+            }), null);
+            return _el$6;
+          }
+        }), null);
+        _$effect(_p$ => {
+          var _v$ = running() ? context.theme.hue.accent[500] : context.theme.text.base,
+            _v$2 = context.theme.text.base;
+          _v$ !== _p$.e && (_p$.e = _$setProp(_el$3, "fg", _v$, _p$.e));
+          _v$2 !== _p$.t && (_p$.t = _$setProp(_el$4, "fg", _v$2, _p$.t));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined
+        });
+        return _el$;
+      })();
+    }
+    function Block(props) {
+      const [width, setWidth] = createSignal(0);
+      const now = createMemo(() => {
+        tick();
+        return Date.now();
+      });
+      const list = createMemo(() => visibleEntries(currentState(), props.sessionID));
+      const running = createMemo(() => runningEntry(currentState(), props.sessionID));
+      const numbers = createMemo(() => stats(currentState().entries, now()));
+      const summary = createMemo(() => summaryLine(numbers()));
+
+      // Eine Kind-Sitzung zeigt nichts: die Liste gehört zur Wurzel-Aufgabe.
+      const visible = createMemo(() => {
+        if (props.sessionID !== context.data.session.root(props.sessionID)) return false;
+        return list().length > 0 && width() >= MIN_WIDTH;
+      });
+      return (() => {
+        var _el$1 = _$createElement("box");
+        _$use(element => {
+          const box = element;
+          const measure = () => setWidth(box.width ?? 0);
+          box.onSizeChange = measure;
+          measure();
+        }, _el$1);
+        _$setProp(_el$1, "flexDirection", "column");
+        _$setProp(_el$1, "paddingTop", 1);
+        _$setProp(_el$1, "flexShrink", 0);
+        _$insert(_el$1, _$createComponent(Show, {
+          get when() {
+            return visible();
+          },
+          get children() {
+            return [(() => {
+              var _el$10 = _$createElement("text");
+              _$insertNode(_el$10, _$createTextNode(`Durations`));
+              _$effect(_$p => _$setProp(_el$10, "fg", context.theme.text.muted, _$p));
+              return _el$10;
+            })(), _$createComponent(Show, {
+              get when() {
+                return running() !== undefined;
+              },
+              get children() {
+                return _$createComponent(Row, {
+                  get entry() {
+                    return running();
+                  },
+                  get now() {
+                    return now();
+                  },
+                  get width() {
+                    return width();
+                  }
+                });
+              }
+            }), _$createComponent(For, {
+              get each() {
+                return list().filter(entry => entry.status !== "running");
+              },
+              children: entry => _$createComponent(Row, {
+                entry: entry,
+                get now() {
+                  return now();
+                },
+                get width() {
+                  return width();
+                }
+              })
+            }), _$createComponent(Show, {
+              get when() {
+                return summary() !== undefined;
+              },
+              get children() {
+                var _el$12 = _$createElement("text");
+                _$insert(_el$12, summary);
+                _$effect(_$p => _$setProp(_el$12, "fg", context.theme.text.muted, _$p));
+                return _el$12;
+              }
+            })];
+          }
+        }));
+        return _el$1;
+      })();
+    }
+    const slot = context.ui.slot({
+      append: "sidebar.content",
+      render: input => _$createComponent(Block, {
+        get sessionID() {
+          return input.sessionID;
+        }
+      })
+    });
+    onCleanup(slot);
+
+    // ---------------------------------------------------------------------
+    // Befehle
+    // ---------------------------------------------------------------------
+
+    const reset = async (all, session) => {
+      if (!all && !session) {
+        context.ui.toast.show({
+          message: "Keine Sitzung geöffnet",
+          variant: "warning"
+        });
+        return;
+      }
+      const confirmed = await context.ui.dialog.confirm({
+        title: "Laufzeiten zurücksetzen",
+        message: all ? "Alle gespeicherten Laufzeiten verwerfen?" : "Laufzeiten dieser Sitzung verwerfen?"
+      });
+      if (!confirmed) return;
+      // Zurücksetzen behält die Revision bei, damit die Anzeige sofort folgt.
+      await advance(all ? emptyState() : clearSession(currentState(), session));
+      nudge();
+      context.ui.toast.show({
+        message: "Laufzeiten zurückgesetzt",
+        variant: "info"
+      });
+    };
+    const currentSession = () => {
+      const route = context.ui.router.current();
+      return route.type === "session" ? route.sessionID : undefined;
+    };
+    context.keymap.layer(() => ({
+      // Ohne `mode` landet die Ebene im Standardmodus `base`, der nur bei
+      // leerem Eingabefeld greift. Palettensuche und Slash-Vervollständigung
+      // laufen dagegen im globalen Modus, deshalb blieben beide Befehle dort
+      // unsichtbar.
+      mode: "global",
+      commands: [{
+        id: "task-timer.reset",
+        title: "Laufzeiten zurücksetzen",
+        group: "Laufzeiten",
+        palette: true,
+        slash: {
+          name: "ott-reset"
+        },
+        run: () => {
+          void reset(false, currentSession());
+        }
+      }, {
+        id: "task-timer.reset-all",
+        title: "Laufzeiten aller Sitzungen zurücksetzen",
+        group: "Laufzeiten",
+        palette: true,
+        slash: {
+          name: "ott-reset-all"
+        },
+        run: () => {
+          void reset(true, currentSession());
+        }
+      }]
+    }));
+  }
+});

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "opencode-task-timer",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.9",
+  "description": "OpenCode 2 TUI plugin: per-task agent durations in the sidebar",
+  "license": "MIT",
+  "author": "Marc Lettau-Poelchen <lettau.poelchen@emelpe.de>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emelpe78/opencode-task-timer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/emelpe78/opencode-task-timer/issues"
+  },
+  "homepage": "https://github.com/emelpe78/opencode-task-timer#readme",
+  "type": "module",
+  "exports": {
+    "./tui": "./dist/tui.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test 'test/*.test.ts'",
+    "bauen": "node scripts/build.mjs"
+  },
+  "engines": {
+    "node": ">=22.6"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "opencode-plugins",
+    "tui",
+    "timer",
+    "duration",
+    "agent",
+    "sidebar",
+    "solid-js",
+    "typescript",
+    "cli",
+    "productivity"
+  ],
+  "devDependencies": {
+    "@babel/core": "^7.29.7",
+    "@babel/preset-typescript": "^7.29.7",
+    "babel-preset-solid": "^1.9.16",
+    "solid-js": "^1.9.17"
+  }
+}