dsh-workspace-status 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+## 0.1.0 — 2026-10-25
+
+### Added
+
+- First public release: coloured status marks on workspace rows (waiting, running,
+  recently finished) with locale-aware labels and a settings toggle.
+- Declares `dsh.catalog` so plugin markets place it under UI with a real summary.
+
+All notable changes to this package are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-25
+
+### Added
+
+- Workspace rows in the sidebar show a status mark aggregated from their
+  sessions: amber dot while a session waits for the user (approval, plan
+  review, answer), blue spinning ring while a session or subagent runs, green
+  dot for a recently finished unread session (one-hour notice window).
+- One mark per workspace with the shipped session-row precedence: waiting
+  outranks running, which outranks the finished reminder.
+- Hidden screen-reader description with per-state counts and workspace names.
+- Archived sessions ignored; ungrouped sessions mark the Ungrouped bucket.
+- Zero-fork implementation: an additive `sidebar.footer.action` entry that
+  publishes row CSS keyed on `data-row-key="workspace:<id>"`, with no DOM
+  writes, observers or host services.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-workspace-status contributors
+
+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,157 @@
-# Temporary Holding Version
+# dsh-workspace-status
 
-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.
+Colored status marks on the **workspace rows** of the DeepSeek Harness sidebar:
+waiting for you, running, and just finished.
+
+Harness draws a status dot on every conversation row, but nothing on the
+workspace (folder) row above it. Collapse a group, or scroll it out of view, and
+the folder row cannot tell you that an agent inside is stuck waiting for an
+approval or still working. This plugin gives the folder row the same kind of
+mark, aggregated from its sessions:
+
+| Mark | Meaning | Color |
+|---|---|---|
+| solid dot | at least one session is waiting for you — approval, plan review, or an answer | amber (`--dsw-alias-state-warn-primary`) |
+| stroked ring, spinning | at least one session is running, including a running subagent | blue (`--dsw-static-deepseek-450`) |
+| solid dot | at least one session finished recently and has not been opened since | green (`--dsw-alias-state-success-primary`) |
+
+The mark sits in the empty right-hand end of the workspace row — the same place
+a session row puts its timestamp — and does not displace the title. It appears
+for expanded and collapsed groups alike, and its state is described to
+screen-reader users in a hidden sentence ("Workspace activity: 2 running, 1
+waiting for you — api, web").
+
+## Preview
+
+![Four sidebar rows: api waiting (amber dot), web running (blue ring), docs recently finished (green dot), sandbox idle (no mark)](docs/preview-mock.png)
+
+This is the plugin's own stylesheet rendered over a local reproduction of the
+sidebar row DOM and theme tokens — a design preview, not a live screenshot. The
+shipped app draws the same marks on the real rows.
+
+## Rules
+
+- **Precedence matches the shipped session row:** waiting for the user beats
+  running, which beats the finished reminder. A workspace therefore shows one
+  mark at a time; the hidden description still reports every count.
+- **Subagents count as their parent's activity.** A running subagent keeps the
+  parent session's workspace marked even when the parent turn has settled.
+  Subagent rows never produce a mark of their own — they are not workspace
+  members.
+- **Archived sessions are ignored**, the same way the default browser view
+  hides them.
+- **The finished mark is a notice, not a flag.** It lapses one hour after the
+  session's last update, or one hour after the plugin watched it stop if that
+  is later. The shipped per-row green dot persists until opened; a folder row
+  has no timestamp to contradict it, so a permanent green dot would outlive the
+  news. A finished session that was never seen running is judged by its own
+  updated time only.
+- **Ungrouped sessions** mark the "Ungrouped" bucket row, which behaves like a
+  workspace row in the sidebar.
+- **No mark when everything is idle.** The plugin renders nothing at all in
+  that case — no stylesheet, no hidden text.
+
+The active workspace (the one containing the open conversation) is already
+marked natively: Harness paints the folder icon of the active chain blue. This
+plugin does not duplicate that.
+
+## Install
+
+From npm:
+
+```sh
+dsh plugin --profile <profile> add dsh-workspace-status
+```
+
+From a local checkout (development):
+
+```sh
+dsh plugin --profile desktop add /absolute/path/to/dsh-workspace-status
+```
+
+`dsh plugin add` links the checkout and appends this package to
+`dsh.profile.bundles` because it declares `dsh.bundle`. Use the profile that
+runs your client — `desktop` for the macOS/Windows app, `web` for `dsh web`.
+Or use sidebar → **Plugins** → **Add plugin** and pass the absolute path to this
+directory. The host half contributes nothing, but the profile composition still
+changes, so **restart the profile's Host** (quit and reopen the desktop app, or
+restart `dsh web`) after installing. Then reload the page if the client half
+does not appear.
+
+Manual mount without the CLI: copy the package into the profile's
+`node_modules`, add `"dsh-workspace-status"` to `dsh.profile.bundles` in the
+profile's `package.json`, and insert the row from `cordis.patch.yml` into the
+profile's patch layer.
+
+## Verify
+
+1. Start a session in a workspace and collapse that group while it runs — a
+   blue ring appears at the end of the folder row.
+2. Trigger an approval (or a plan review / question) in a session of another
+   workspace — that folder row shows an amber dot even while expanded.
+3. Let a session finish without opening it — a green dot appears, and lapses an
+   hour later.
+4. Expand the group: the mark stays on the folder row; the session rows keep
+   their own dots unchanged.
+5. With every session idle, no extra element appears in the sidebar.
+
+The client half writes nothing into the sidebar DOM — it reacts to the public
+Workspace/Session feeds and emits CSS keyed on the row the browser already
+renders. If the mark is missing, check the browser console for a failed client
+bundle load first; nothing else in the sidebar is affected.
+
+## How it works
+
+- The mount is an entry in the additive `sidebar.footer.action` seat. It renders
+  only a `<style>` element and a visually hidden `<span>`; it is not a control
+  and adds nothing visible at the foot.
+- Aggregation reads the same public data the browser uses: `useWorkspaces`
+  (`items`, `archivedSessionIds`), `useSessions` (`byId`) and
+  `useSessionStatus` (`running`, `pendingInteraction`, `completionUnread`).
+- The visible mark is the workspace row's trailing pseudo-element, emitted as a
+  rule targeting `[data-row-key="workspace:<id>"]::after`.
+- Removing the plugin removes the mount, which removes the stylesheet; no state
+  is written anywhere.
+
+### The one internal dependency
+
+`data-row-key="workspace:<id>"` is an internal detail of
+`@deepseek-ai/dsh-client-ui-workspace`, not a public slot contract. A future
+Harness release could rename it, in which case the marks would silently stop
+appearing until this package is updated. The failure mode is deliberately
+**"no indicator"**, not "broken sidebar": the plugin never touches the DOM, so a
+stale selector can only produce a missing dot.
+
+## Compatibility
+
+- DeepSeek Harness `>=0.2.1-rc.2 <0.3.0-0` (developed and verified against
+  `0.2.1-rc.3`); Web and Desktop clients.
+- Node `>=22.18.0` for the build-free package and its tests.
+- No runtime dependencies, no host services, no settings, no model-visible
+  tools or prompt changes.
+
+## Development
+
+```sh
+npm test
+```
+
+The suite loads the classic-script client envelope in a sandbox, drives the slot
+component with fake standard hooks, and asserts the emitted stylesheet and
+hidden description across waiting/running/finished, subagent, archived,
+ungrouped, expiry and selector-escaping cases. A manifest test checks the bundle
+patch, export map, locale parity and the loader envelope.
+
+There is no build step: `index.js` and `client.js` are the published artifacts.
+
+## Remove
+
+```sh
+dsh plugin --profile <profile> remove dsh-workspace-status
+```
+
+Restart the Host. The sidebar returns to stock; nothing else is left behind.
+
+## License
+
+MIT

package/client.js

@@ -0,0 +1,510 @@
+/**
+ * Browser half of workspace-status.
+ *
+ * The sidebar draws a status dot on every Session row but nothing on the
+ * Workspace (folder) row above it, so a collapsed group — or a group scrolled
+ * out of view — hides whether any agent inside it is waiting, running, or
+ * just finished. Workspace rows declare no slot, so this package does not
+ * render markup into them: it publishes one stylesheet aimed at the row the
+ * Workspace browser already renders (`data-row-key="workspace:<id>"`) and
+ * draws the mark as that row's trailing pseudo-element. React keeps owning
+ * the row; nothing is written to the document and nothing is observed.
+ *
+ * The entry mounts in the additive `sidebar.footer.action` seat, which is
+ * mounted for the whole browsing region even when no Session exists. It shows
+ * no control of its own: it publishes the row rules plus a visually hidden
+ * description of the same state for readers who cannot see the mark.
+ *
+ * Data comes from the same public feeds the browser itself reads:
+ * `useWorkspaces` (items + archive set), `useSessions` (summaries, including
+ * subagent rows) and `useSessionStatus` (running / pendingInteraction /
+ * completionUnread). The precedence mirrors the shipped Session row:
+ * waiting for the user outranks running, which outranks the finished
+ * reminder; a subagent keeps its parent's workspace busy.
+ */
+
+window.__ModuleLoader__.load({
+  id: 'dsh-workspace-status',
+  factory(require) {
+    const React = require('react')
+
+    /** Additive seat beside Settings at the sidebar foot. */
+    const SLOT = 'sidebar.footer.action'
+    /** Stable list id; reusing it would shadow this entry rather than add one. */
+    const ENTRY_ID = 'workspace-status'
+    /** The stylesheet this mount owns; unmounting the entry removes it. */
+    const STYLE_ID = 'dsh-workspace-status/rows.css'
+    /** Last among the shipped footer actions. */
+    const ENTRY_ORDER = 950
+
+    /**
+     * How long a finished-but-unread Session keeps its Workspace marked.
+     *
+     * The browser's finished reminder persists until the Session is opened.
+     * A folder row owns no timestamp that could age it out, so it would keep a
+     * green dot on a workspace whose work stopped days ago. This mark is a
+     * notice: it lapses once the Session's last update stops reading in
+     * minutes. A Session watched stopping keeps the mark for the same window
+     * even when its last prompt is older than that.
+     */
+    const FINISHED_WINDOW_MS = 60 * 60 * 1000
+
+    /** How many workspace names the hidden description lists. */
+    const MAX_NAMES = 4
+
+    /** The visually hidden description's class. */
+    const SR_CLASS = 'dsws-sr'
+
+    /**
+     * The hidden description's own rule. The visible mark carries no markup of
+     * its own (the generated row rules draw it), so this sheet only has to
+     * keep the description out of the layout.
+     */
+    const BASE_CSS = [
+      `.${SR_CLASS}{position:absolute;width:1px;height:1px;margin:-1px;padding:0;`,
+      'overflow:hidden;clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0}',
+    ].join('')
+
+    /**
+     * Every user-facing string lives here rather than in a locale service: the
+     * only copy this package produces is a hidden description, so the built-in
+     * dictionaries are enough and the plugin keeps working without the locale
+     * face. The `locale/*.json` files mirror them for tooling.
+     */
+    const DICTIONARIES = {
+      en: {
+        'activity.summary': 'Workspace activity: {clauses} — {names}',
+        'activity.waiting': '{n} waiting for you',
+        'activity.running': '{n} running',
+        'activity.done': '{n} recently finished',
+        'activity.unnamed': 'Ungrouped',
+        'activity.more': 'and {n} more',
+        'activity.listSeparator': ', ',
+      },
+      zh: {
+        'activity.summary': '工作区状态：{clauses} — {names}',
+        'activity.waiting': '{n} 个等待你处理',
+        'activity.running': '{n} 个运行中',
+        'activity.done': '{n} 个刚刚完成',
+        'activity.unnamed': '未分组',
+        'activity.more': '等 {n} 个',
+        'activity.listSeparator': '、',
+      },
+    }
+
+    /**
+     * Resolve the host's language without assuming the locale service exists.
+     * @returns 'zh' for Chinese hosts, otherwise 'en'.
+     */
+    function currentLanguage() {
+      const candidates = []
+      if (typeof document !== 'undefined') {
+        const lang = document?.documentElement?.lang
+        if (typeof lang === 'string' && lang !== '') candidates.push(lang)
+      }
+      if (typeof navigator !== 'undefined' && typeof navigator.language === 'string') {
+        candidates.push(navigator.language)
+      }
+      for (const value of candidates) {
+        if (/^zh/i.test(value)) return 'zh'
+      }
+      return 'en'
+    }
+
+    /** Interpolate `{name}` placeholders in one template. */
+    function format(template, params) {
+      return template.replace(/\{(\w+)\}/g, (match, name) => (
+        params !== undefined && Object.prototype.hasOwnProperty.call(params, name)
+          ? String(params[name])
+          : match
+      ))
+    }
+
+    /** One localized message, falling back to English and then the key. */
+    function message(key, params) {
+      const language = currentLanguage()
+      const dictionary = DICTIONARIES[language] ?? DICTIONARIES.en
+      const template = dictionary[key] ?? DICTIONARIES.en[key] ?? key
+      return format(template, params)
+    }
+
+    /**
+     * Escape one group key for a double-quoted CSS attribute selector.
+     *
+     * A control character has no literal form inside a CSS string: an unescaped
+     * newline ends the string token and the whole rule is dropped as invalid,
+     * so the row would lose its mark silently. Each one is written as a hex
+     * escape with a trailing space, which stops a following hex digit being
+     * absorbed. Host Workspace ids are UUIDs, so this is a correctness guard,
+     * not a path expected in practice.
+     * @param value - raw group key.
+     * @returns the key escaped for use inside quotes.
+     */
+    function quote(value) {
+      let escaped = ''
+      for (const char of String(value)) {
+        const code = char.codePointAt(0) ?? 0
+        if (char === '\\' || char === '"') escaped += `\\${char}`
+        else if (code < 0x20 || code === 0x7f) escaped += `\\${code.toString(16)} `
+        else escaped += char
+      }
+      return escaped
+    }
+
+    /**
+     * The running mark, carried as an alpha mask rather than a border.
+     *
+     * A CSS border ring cannot read as a circle at this size: its corners are
+     * mitred, so the gap between the two ends looks like a clipped square. The
+     * mask keeps a round 2px-equivalent stroke with round caps and a faint
+     * track, matching the geometry of the product's own running indicator.
+     */
+    const RING = "url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 10 10'%3E%3Ccircle cx='5' cy='5' r='4' fill='none' stroke='%23000' stroke-width='1.5' stroke-linecap='round' stroke-opacity='.25'/%3E%3Ccircle cx='5' cy='5' r='4' fill='none' stroke='%23000' stroke-width='1.5' stroke-linecap='round' stroke-dasharray='5 20'/%3E%3C/svg%3E\")"
+
+    /**
+     * One Workspace's tally before the states are split.
+     * @typedef {{ key: string, title: string, waiting: number, running: number, done: number }} GroupTally
+     */
+
+    /**
+     * Whether a Session's own timestamp is recent enough to still deserve a
+     * finished mark. A missing or zero timestamp cannot be corroborated, so it
+     * never earns one (subagent rows carry a zero timestamp).
+     * @param updatedAt - the Session summary's epoch-millisecond timestamp.
+     * @param now - render-time clock.
+     * @returns true while the timestamp reads within the notice window.
+     */
+    function isFresh(updatedAt, now) {
+      if (typeof updatedAt !== 'number' || !Number.isFinite(updatedAt) || updatedAt <= 0) return false
+      return now - updatedAt <= FINISHED_WINDOW_MS
+    }
+
+    /**
+     * What this mount has watched happen, keyed by Session id.
+     *
+     * `running` holds every Session seen running since the mount; `stoppedAt`
+     * holds the time a Session was watched stop while still carrying the unread
+     * mark, and only for Sessions first seen running. Together they let the
+     * finished mark expire on its own rather than wait for the browser to clear
+     * it — and they cover a Session that ran for hours, whose `updatedAt` is
+     * the time of its last prompt, not the time it stopped.
+     * @typedef {{ running: Set<string>, stoppedAt: Map<string, number> }} Watch
+     */
+
+    /** Drop one Session from the watch (archived or gone). */
+    function forget(watch, sessionId) {
+      watch.running.delete(sessionId)
+      watch.stoppedAt.delete(sessionId)
+    }
+
+    /** Whether any direct subagent child of one Session is currently running. */
+    function runsChild(sessionId, children, sessions, statuses) {
+      const kids = children.get(sessionId)
+      if (kids === undefined) return false
+      for (const childId of kids) {
+        const status = statuses?.get?.(childId)
+        // The status feed is authoritative where it knows the child; the
+        // summary's own running flag is the fallback, matching the browser's
+        // precedence.
+        const running = status?.running === undefined
+          ? sessions[childId]?.running === true
+          : status.running === true
+        if (running) return true
+      }
+      return false
+    }
+
+    /**
+     * Which Workspace groups own a waiting, running, or just-finished Session.
+     *
+     * Precedence matches the shipped Session row: waiting for the user outranks
+     * running, which outranks the finished reminder. Each Session therefore
+     * lands in exactly one tally, so the counts in the hidden description add
+     * up to the number of marked Sessions. Archived Sessions are skipped, the
+     * same way the default browser view hides them. A running subagent keeps
+     * its parent's Workspace busy even when the parent turn already settled;
+     * subagent rows are not workspace members, so they never create a mark of
+     * their own.
+     *
+     * @param items - Workspace rows from the Workspace snapshot.
+     * @param byId - Session summaries keyed by id.
+     * @param statuses - Session UI status map (running / pendingInteraction / completionUnread).
+     * @param archivedSessionIds - registry-global archive set.
+     * @param now - render-time clock, epoch milliseconds.
+     * @param watch - this mount's running/stopped observations.
+     * @returns marked group keys by state, counts, and display titles.
+     */
+    function deriveActivity(items, byId, statuses, archivedSessionIds, now, watch) {
+      const sessions = byId !== null && typeof byId === 'object' ? byId : {}
+      const archived = new Set(Array.isArray(archivedSessionIds) ? archivedSessionIds : [])
+      const statusMap = statuses !== null && typeof statuses?.get === 'function' ? statuses : undefined
+
+      /** Session id → owning Workspace key (ungrouped bucket is `''`). */
+      const workspaceOf = new Map()
+      /** Workspace key → display title. */
+      const titles = new Map()
+      for (const workspace of Array.isArray(items) ? items : []) {
+        if (workspace === null || typeof workspace !== 'object') continue
+        const key = typeof workspace.workspaceId === 'string' ? workspace.workspaceId : ''
+        titles.set(key, typeof workspace.title === 'string' ? workspace.title : '')
+        for (const sessionId of Array.isArray(workspace.sessionIds) ? workspace.sessionIds : []) {
+          workspaceOf.set(sessionId, key)
+        }
+      }
+
+      /** Parent Session id → direct subagent child ids. */
+      const children = new Map()
+      for (const sessionId of Object.keys(sessions)) {
+        const row = sessions[sessionId]
+        if (row?.origin !== 'subagent' || typeof row.parentId !== 'string') continue
+        const list = children.get(row.parentId)
+        if (list === undefined) children.set(row.parentId, [sessionId])
+        else list.push(sessionId)
+      }
+
+      /** @type {Map<string, GroupTally>} */
+      const groups = new Map()
+      const tally = (key) => {
+        let group = groups.get(key)
+        if (group === undefined) {
+          group = { key, title: titles.get(key) ?? '', waiting: 0, running: 0, done: 0 }
+          groups.set(key, group)
+        }
+        return group
+      }
+
+      for (const sessionId of Object.keys(sessions).sort()) {
+        const row = sessions[sessionId]
+        if (row === null || row === undefined) continue
+        if (row.origin === 'subagent') continue
+        if (archived.has(sessionId)) {
+          forget(watch, sessionId)
+          continue
+        }
+
+        const status = statusMap?.get?.(sessionId)
+        const running = status?.running === true
+          || (status?.running === undefined && row.running === true)
+          || runsChild(sessionId, children, sessions, statusMap)
+        const waiting = status?.pendingInteraction !== undefined && status?.pendingInteraction !== null
+
+        if (running) {
+          watch.running.add(sessionId)
+          watch.stoppedAt.delete(sessionId)
+        } else if (watch.running.delete(sessionId) && status?.completionUnread === true) {
+          watch.stoppedAt.set(sessionId, now)
+        }
+
+        const recent = isFresh(row.updatedAt, now)
+          || (watch.stoppedAt.get(sessionId) !== undefined
+            && now - watch.stoppedAt.get(sessionId) <= FINISHED_WINDOW_MS)
+        const key = workspaceOf.has(sessionId) ? workspaceOf.get(sessionId) : ''
+
+        if (waiting) {
+          tally(key).waiting += 1
+        } else if (running) {
+          tally(key).running += 1
+        } else if (status?.completionUnread === true && recent) {
+          tally(key).done += 1
+        }
+      }
+
+      // Prune observations that can no longer produce a mark.
+      for (const sessionId of watch.running) {
+        if (sessions[sessionId] === undefined) watch.running.delete(sessionId)
+      }
+      for (const [sessionId, stoppedAt] of watch.stoppedAt) {
+        if (sessions[sessionId] === undefined || now - stoppedAt > FINISHED_WINDOW_MS) {
+          watch.stoppedAt.delete(sessionId)
+        }
+      }
+
+      const waitingKeys = []
+      const runningKeys = []
+      const doneKeys = []
+      const names = new Map()
+      const totals = { waiting: 0, running: 0, done: 0 }
+      let marked = 0
+      for (const group of groups.values()) {
+        const total = group.waiting + group.running + group.done
+        if (total === 0) continue
+        if (group.waiting > 0) waitingKeys.push(group.key)
+        else if (group.running > 0) runningKeys.push(group.key)
+        else doneKeys.push(group.key)
+        totals.waiting += group.waiting
+        totals.running += group.running
+        totals.done += group.done
+        marked += total
+        names.set(group.key, group.title)
+      }
+      waitingKeys.sort()
+      runningKeys.sort()
+      doneKeys.sort()
+
+      return { waiting: waitingKeys, running: runningKeys, done: doneKeys, totals, marked, names }
+    }
+
+    /**
+     * The selectors for one state's rows, each carrying its own pseudo-element.
+     *
+     * Every rule repeats the whole selector list. A comma-joined list applies
+     * the trailing `::after` to its last member only, so sharing one prefix
+     * would leave every row but one undecorated once two Workspaces share a
+     * state.
+     */
+    function selectors(keys, suffix) {
+      return keys.map((key) => `[data-row-key="workspace:${quote(key)}"]${suffix}`).join(',')
+    }
+
+    /**
+     * The stylesheet that draws each marked row's trailing mark.
+     *
+     * The mark is the row's `::after`, a flex child at the empty right-hand end
+     * beside the row actions, so it never displaces the title and needs no
+     * positioning. Waiting is a solid amber dot, running is the product's blue
+     * as a stroked ring, finished is the product's green dot. Colors come from
+     * the same theme tokens the Session rows use, so both levels agree and both
+     * themes are covered.
+     * @param activity - derived activity for the current render.
+     * @returns CSS text (no base rules).
+     */
+    function rowCss(activity) {
+      const parts = []
+
+      if (activity.waiting.length > 0) {
+        const waiting = selectors(activity.waiting, '::after')
+        parts.push(
+          `${waiting}{content:"";flex:none;box-sizing:border-box;width:6px;height:6px;`,
+          'margin-inline-start:2px;border-radius:50%;',
+          'background:var(--dsw-alias-state-warn-primary);',
+          'box-shadow:0 0 0 2px color-mix(in srgb, var(--dsw-alias-state-warn-primary) 16%, transparent)}',
+        )
+      }
+
+      if (activity.running.length > 0) {
+        const running = selectors(activity.running, '::after')
+        parts.push(
+          '@keyframes dsws-spin{to{transform:rotate(360deg)}}',
+          `${running}{content:"";flex:none;box-sizing:border-box;width:10px;height:10px;`,
+          'margin-inline-start:2px;background-color:var(--dsw-static-deepseek-450);',
+          `-webkit-mask-image:${RING};mask-image:${RING};`,
+          '-webkit-mask-size:100% 100%;mask-size:100% 100%;',
+          '-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat;',
+          'animation:dsws-spin 1.5s linear infinite}',
+          `@media (prefers-reduced-motion:reduce){${running}{animation:none;opacity:.7}}`,
+        )
+      }
+
+      if (activity.done.length > 0) {
+        const done = selectors(activity.done, '::after')
+        parts.push(
+          `${done}{content:"";flex:none;box-sizing:border-box;width:6px;height:6px;`,
+          'margin-inline-start:2px;border-radius:50%;',
+          'background:var(--dsw-alias-state-success-primary);',
+          'box-shadow:0 0 0 2px color-mix(in srgb, var(--dsw-alias-state-success-primary) 14%, transparent)}',
+        )
+      }
+
+      return parts.join('')
+    }
+
+    /**
+     * The hidden description of the same state.
+     *
+     * Pseudo-elements are not reliably announced, so the aggregate travels as
+     * text: counts by state followed by the Workspace names, bounded so a large
+     * fleet does not turn into a paragraph.
+     * @param activity - derived activity for the current render.
+     * @returns one localized sentence.
+     */
+    function describe(activity) {
+      const separator = message('activity.listSeparator')
+      const clauses = []
+      if (activity.totals.waiting > 0) {
+        clauses.push(message('activity.waiting', { n: activity.totals.waiting }))
+      }
+      if (activity.totals.running > 0) {
+        clauses.push(message('activity.running', { n: activity.totals.running }))
+      }
+      if (activity.totals.done > 0) {
+        clauses.push(message('activity.done', { n: activity.totals.done }))
+      }
+      const orderedKeys = [...activity.waiting, ...activity.running, ...activity.done]
+      const names = orderedKeys.map((key) => {
+        const title = activity.names.get(key)
+        return title !== undefined && title !== '' ? title : message('activity.unnamed')
+      })
+      const listed = names.slice(0, MAX_NAMES)
+      const rest = names.length - listed.length
+      if (rest > 0) listed.push(message('activity.more', { n: rest }))
+      return message('activity.summary', {
+        clauses: clauses.join(separator),
+        names: listed.join(separator),
+      })
+    }
+
+    /**
+     * Read one standard selector hook, tolerating an assembly without it.
+     * @param hook - the standard hook, possibly absent.
+     * @param selector - projection over the hook's snapshot.
+     * @param fallback - snapshot used when the hook is absent.
+     * @returns the selected value.
+     */
+    function useStandard(hook, selector, fallback) {
+      return typeof hook === 'function' ? hook(selector) : selector(fallback)
+    }
+
+    const EMPTY_WORKSPACES = { items: [], archivedSessionIds: [] }
+    const EMPTY_SESSIONS = { byId: {} }
+    const EMPTY_STATUSES = new Map()
+
+    /**
+     * The slot entry. It shows no control of its own: it publishes the row
+     * rules, plus a description of the same state for readers who cannot see
+     * the mark.
+     * @param props - standard selector hooks.
+     * @returns the style + hidden description, or null when nothing is marked.
+     */
+    function WorkspaceStatus({ useWorkspaces, useSessions, useSessionStatus }) {
+      const items = useStandard(useWorkspaces, (state) => state?.items, EMPTY_WORKSPACES)
+      const archived = useStandard(useWorkspaces, (state) => state?.archivedSessionIds, EMPTY_WORKSPACES)
+      const byId = useStandard(useSessions, (state) => state?.byId, EMPTY_SESSIONS)
+      const statuses = useStandard(useSessionStatus, (state) => state, EMPTY_STATUSES)
+
+      const watchRef = React.useRef(undefined)
+      if (watchRef.current === undefined) {
+        watchRef.current = { running: new Set(), stoppedAt: new Map() }
+      }
+
+      const activity = React.useMemo(
+        // The window is measured at render time, the same way the browser reads
+        // its own clock: no timer, because any feed change re-renders anyway.
+        // Advancing the watch is idempotent, so a repeated render costs nothing.
+        () => deriveActivity(items, byId, statuses, archived, Date.now(), watchRef.current),
+        [items, byId, statuses, archived, watchRef],
+      )
+
+      if (activity.marked === 0) return null
+
+      return React.createElement(
+        React.Fragment,
+        null,
+        React.createElement('style', { 'data-plugin-css': STYLE_ID }, BASE_CSS + rowCss(activity)),
+        React.createElement('span', { className: SR_CLASS }, describe(activity)),
+      )
+    }
+
+    return {
+      name: 'workspace-status',
+      inject: ['slots'],
+      apply(ctx) {
+        ctx.slots.inject(SLOT, () => ctx.slots.register(
+          { name: SLOT, id: ENTRY_ID, order: ENTRY_ORDER },
+          WorkspaceStatus,
+        ))
+      },
+      /** Exposed for the package's own tests; the Loader ignores it. */
+      __test: { deriveActivity, rowCss, describe, quote, WorkspaceStatus, FINISHED_WINDOW_MS },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# The bundle layer this package contributes to a dsh profile.
+# Rows inserted here become Loader entries once the profile lists this package
+# in package.json -> dsh.profile.bundles (the Plugins page does both steps).
+- insert:
+    - id: workspace-status
+      name: dsh-workspace-status

package/icon.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" role="img" aria-label="Workspace Status">
+  <rect x="2.25" y="2.25" width="19.5" height="19.5" rx="4.25" fill="#151A22"/>
+  <rect x="5" y="5.5" width="5" height="5" rx="1.3" fill="#3B4A5A"/>
+  <rect x="12.5" y="5.5" width="5" height="5" rx="1.3" fill="#3B4A5A"/>
+  <circle cx="7.5" cy="15.75" r="2.4" fill="none" stroke="#4D8DFF" stroke-width="1.5" stroke-linecap="round" stroke-dasharray="4 9"/>
+  <circle cx="15" cy="15.75" r="1.8" fill="#F59E0B"/>
+  <circle cx="19.4" cy="15.75" r="1.8" fill="#22C55E"/>
+</svg>

package/index.js

@@ -0,0 +1,18 @@
+/**
+ * Host half of workspace-status.
+ *
+ * The Client module owns the indicator: it reads Workspace and Session state
+ * through the slot's standard hooks and publishes the row rules from its own
+ * component, so the Host has no service to provide and no resource to register.
+ * This empty `apply` exists only to give the Loader a host-side row, exactly
+ * like any other bundle that is purely a browser feature.
+ */
+
+/** Loader entry name; matches the patch row in `cordis.patch.yml`. */
+export const name = 'workspace-status'
+
+/** No Host services are required. */
+export const inject = []
+
+/** No Host-side behavior. */
+export function apply() {}

package/locale/en.json

@@ -0,0 +1,13 @@
+{
+  "meta": {
+    "title": "Workspace Status",
+    "description": "Marks each workspace in the sidebar while one of its sessions is waiting for you, running, or recently finished."
+  },
+  "activity.summary": "Workspace activity: {clauses} — {names}",
+  "activity.waiting": "{n} waiting for you",
+  "activity.running": "{n} running",
+  "activity.done": "{n} recently finished",
+  "activity.unnamed": "Ungrouped",
+  "activity.more": "and {n} more",
+  "activity.listSeparator": ", "
+}

package/locale/zh.json

@@ -0,0 +1,13 @@
+{
+  "meta": {
+    "title": "工作区状态",
+    "description": "侧边栏里，某个工作区有会话等待你处理、正在运行或刚刚完成时，在该工作区行上显示状态标记。"
+  },
+  "activity.summary": "工作区状态：{clauses} — {names}",
+  "activity.waiting": "{n} 个等待你处理",
+  "activity.running": "{n} 个运行中",
+  "activity.done": "{n} 个刚刚完成",
+  "activity.unnamed": "未分组",
+  "activity.more": "等 {n} 个",
+  "activity.listSeparator": "、"
+}

package/package.json

@@ -1,6 +1,77 @@
 {
   "name": "dsh-workspace-status",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Colored status marks on DeepSeek Harness sidebar workspaces: waiting for you, running, and recently finished.",
+  "type": "module",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "sidebar",
+    "workspace",
+    "status",
+    "indicator"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-ui-workspace",
+        "@deepseek-ai/dsh-client-ui-session"
+      ]
+    },
+    "compatibility": {
+      "dsh": ">=0.2.1-rc.2 <0.3.0-0"
+    },
+    "catalog": {
+      "summary": {
+        "en": "Colored status marks on sidebar workspace rows: waiting for you, running, and recently finished, so the next workspace to open is obvious.",
+        "zh": "在侧边栏工作区行上显示彩色状态：等待你处理、运行中、刚刚完成，一眼看出下一个该打开的工作区。"
+      },
+      "category": "ui"
+    }
+  },
+  "engines": {
+    "dsh": ">=0.2.1-rc.2 <0.3.0-0",
+    "node": ">=22.18.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Stijnus/dsh-workspace-status.git"
+  },
+  "homepage": "https://github.com/Stijnus/dsh-workspace-status#readme",
+  "bugs": {
+    "url": "https://github.com/Stijnus/dsh-workspace-status/issues"
+  }
+}