dsh-checklists 0.5.1 → 0.7.0

package/README.md

@@ -30,6 +30,7 @@ If the agent forgets to mark something, you say so in chat and it fixes it.
 | `checklist_delete` | Deletes a list (by id or exact title) |
 | `checklist_remove_item` | Removes one item and everything nested under it |
 | `checklist_rename` | Renames a list; titles stay unique within the session |
+| `checklist_workspace` | Lists checklists from other sessions in the same workspace (read-only) |
 | `checklist_template_save` | Saves a list as a reusable template for future sessions |
 
 Items are plain strings. **Two leading spaces per level** nest them:
@@ -50,7 +51,7 @@ From a local build or tarball:
 npm install
 npm run build
 npm pack
-dsh plugin --profile dev add ./dsh-checklists-0.4.0.tgz
+dsh plugin --profile dev add ./dsh-checklists-0.7.0.tgz
 dsh --profile dev --dump-config        # the tool-checklist row should appear
 ```
 
@@ -68,6 +69,9 @@ Override the defaults on the plugin's entry in the profile's `cordis.patch.yml`:
     maxDigestLines: 12      # lines of the injected digest
     maxItemsPerList: 200    # per-list item cap
     pruneDays: 14           # prune untouched sessions after N days (0 = never)
+    nudge: steer            # steer | observe | off — see "Turn-end gate"
+    workspaceView: on-demand   # off | on-demand | always — see "Workspace lens"
+    workspaceViewLimit: 10     # sibling checklists returned
     # storageRoot: "D:/data/dsh-checklists"
     # templates:
     #   my-flow: ["Step 1", "  Sub-step", "Step 2"]
@@ -113,8 +117,67 @@ the agent's edit.
 |---|---|---|
 | `/dsh-checklist/state` | GET | One session's state (read-only, `no-store`) |
 | `/dsh-checklist/item` | POST | Edit an item's text, with a conflict guard |
+| `/dsh-checklist/nudge` | GET | Recent turn-end gate decisions |
+| `/dsh-checklist/workspace` | GET | Checklists of sibling sessions in the same workspace |
 | `/dsh-checklist/client-probe` | GET | Client load diagnostics |
 
+## Turn-end gate
+
+A checklist only helps while it is true. The gate closes the most common gap:
+a turn does real work, forgets to mark it, and the list is stale by the time you
+look at it.
+
+When a turn is about to close, the plugin checks exactly three things:
+
+1. Did the turn run a tool that changes the workspace (`bash`, `edit`, `write`, …)?
+2. Did it skip every checklist write?
+3. Is anything still marked `doing`?
+
+If all three hold, the agent gets one short steering message before the turn ends:
+
+> Before you finish: N checklist item(s) are still marked "doing". If you
+> completed any of them this turn, update them with checklist_check and say what
+> proves it. If not, leave them as they are — do not mark work you did not do.
+
+It never guesses **what** was completed — only that the bookkeeping was skipped.
+At most one nudge per turn, and none when the turn was pure conversation or the
+checklist already changed.
+
+Inspect recent decisions at `GET /dsh-checklist/nudge`:
+
+```jsonc
+{ "mode": "steer", "entries": [
+  { "source": "turn-stopping", "nudge": true, "steered": true,
+    "reason": "1 item(s) still doing after workspace changes", "doing": 1 }
+] }
+```
+
+`nudge: observe` records without interrupting; `nudge: off` disables the gate.
+
+## Workspace lens
+
+Checklists stay per session. The lens is a **read-only** way to see the
+checklists of other sessions in the same project — available on request, and
+never part of the prompt.
+
+| Mode | Behaviour |
+|---|---|
+| `on-demand` (default) | The tool works; the sidebar section starts collapsed |
+| `always` | The sidebar section starts expanded |
+| `off` | No tool, no route |
+
+Clicking an entry expands it into a read-only tree, fetched once from that
+session's own state route. Nothing there is editable — the lens can look, not
+touch.
+
+Membership comes from disk: a session belongs to the workspace directory that
+contains it under `$DSH_HOME/sessions/<workspace>/<sessionId>/`. The host's
+`workspace.json` is only used for a friendly title, because it is not always
+complete — on the machine this was written on it was missing a workspace.
+
+Nothing here is writable. To change another session's checklist, open that
+session: two writers on one list would give the list two truths.
+
 ## Language
 
 The panel follows the harness locale: **Spanish** when `locale` starts with `es`,

package/client/index.js

@@ -28,6 +28,8 @@ window.__ModuleLoader__.load({
     const COLOR = { done: '#3fb950', doing: '#d29922', blocked: '#f85149', todo: 'inherit' }
 
     const MUTED = { opacity: 0.72, fontSize: 13, padding: '10px 12px', lineHeight: 1.5 }
+    /** Stable empty map: read-only trees never collapse, so one shared object is enough. */
+    const EMPTY_COLLAPSED = {}
     const BUTTON = {
       background: 'transparent',
       border: 'none',
@@ -61,6 +63,9 @@ window.__ModuleLoader__.load({
         hideDoneHint: 'Hide or show completed items',
         copy: 'Copy',
         copyHint: 'Copy the checklist as markdown',
+        workspace: 'Workspace',
+        workspaceEmpty: 'No other session in this workspace has a checklist.',
+        loadingShort: 'Loading…',
         copied: '✓ Copied',
         copyFailed: 'Could not copy',
         noClipboard: 'Clipboard unavailable',
@@ -86,6 +91,9 @@ window.__ModuleLoader__.load({
         hideDoneHint: 'Ocultar o mostrar los ítems hechos',
         copy: 'Copiar',
         copyHint: 'Copiar el checklist como markdown',
+        workspace: 'Proyecto',
+        workspaceEmpty: 'Ninguna otra sesión de este proyecto tiene checklist.',
+        loadingShort: 'Cargando…',
         copied: '✓ Copiado',
         copyFailed: 'No se pudo copiar',
         noClipboard: 'Portapapeles no disponible',
@@ -293,6 +301,7 @@ window.__ModuleLoader__.load({
       const nodeKey = `${props.listId}/${item.id}`
       const isCollapsed = Boolean(props.collapsed[nodeKey])
       const counts = countTree(children)
+      const readOnly = Boolean(props.readOnly)
 
       const label = isEditing
         ? h('input', {
@@ -324,19 +333,19 @@ window.__ModuleLoader__.load({
         : h(
             'span',
             {
-              onDoubleClick: () => props.onStartEdit(item),
-              title: props.t('editHint'),
+              onDoubleClick: readOnly ? undefined : () => props.onStartEdit(item),
+              title: readOnly ? undefined : props.t('editHint'),
               style: {
                 textDecoration: done ? 'line-through' : 'none',
                 wordBreak: 'break-word',
-                cursor: 'text',
+                cursor: readOnly ? 'default' : 'text',
               },
             },
             item.text,
           )
 
       const chevron =
-        children.length > 0
+        children.length > 0 && !readOnly
           ? h(
               'button',
               {
@@ -480,6 +489,172 @@ window.__ModuleLoader__.load({
       return h('section', { style: { marginBottom: 12 } }, header, body)
     }
 
+    /**
+     * The workspace lens, below the session's own lists.
+     *
+     * Collapsed by default and lazy: nothing is fetched until the section is
+     * opened, so a session that never looks costs nothing. A 403 from the host
+     * means the profile disabled the lens, and the section disappears.
+     */
+    /**
+     * One sibling session's tree, read-only.
+     *
+     * No editing, no collapse state, no handlers: that list belongs to another
+     * session, and two writers would give it two truths.
+     */
+    function ReadOnlyTree(props) {
+      const state = props.state
+
+      if (!state || state.phase === 'loading') {
+        return h('div', { style: { opacity: 0.6, fontSize: 11, paddingLeft: 18 } }, props.t('loadingShort'))
+      }
+      if (state.phase === 'error') {
+        return h('div', { style: { opacity: 0.7, fontSize: 11, paddingLeft: 18 } }, state.message)
+      }
+
+      const lists = (state.data && state.data.lists) || []
+      if (lists.length === 0) {
+        return h('div', { style: { opacity: 0.55, fontSize: 11, paddingLeft: 18 } }, props.t('workspaceEmpty'))
+      }
+
+      const noop = () => {}
+      // One list: the entry header already carries its title, so repeating it
+      // inside the tree would say the same thing twice.
+      const showListTitles = lists.length > 1
+
+      return h(
+        'div',
+        { style: { paddingLeft: 18, paddingBottom: 4 } },
+        lists.map((list) =>
+          h(
+            'div',
+            { key: list.id },
+            showListTitles
+              ? h('div', { style: { fontSize: 11, opacity: 0.6, marginTop: 4 } }, list.title)
+              : null,
+            h(
+              'ul',
+              { style: { margin: 0, padding: 0 } },
+              (list.items || []).map((item) =>
+                h(Item, {
+                  key: item.id,
+                  item,
+                  depth: 0,
+                  t: props.t,
+                  readOnly: true,
+                  listId: `${props.sessionId}/${list.id}`,
+                  collapsed: EMPTY_COLLAPSED,
+                  onToggleNode: noop,
+                  editing: null,
+                  onStartEdit: noop,
+                  onDraft: noop,
+                  onCommit: noop,
+                  onCancel: noop,
+                }),
+              ),
+            ),
+          ),
+        ),
+      )
+    }
+
+    function WorkspaceSection(props) {
+      if (!props || props.state.phase === 'disabled') return null
+
+      const open = props.open
+      const state = props.state
+      const entries = state.phase === 'ready' ? state.data.checklists || [] : []
+
+      const header = h(
+        'button',
+        {
+          onClick: props.onToggle,
+          title: open ? props.t('collapse') : props.t('expand'),
+          style: {
+            ...BUTTON,
+            opacity: 0.75,
+            fontSize: 12,
+            display: 'flex',
+            alignItems: 'baseline',
+            gap: 5,
+            width: '100%',
+            textAlign: 'left',
+            padding: '4px 0',
+          },
+        },
+        h('span', { style: { fontSize: 10, opacity: 0.55 } }, open ? '▾' : '▸'),
+        h('span', null, props.t('workspace')),
+        state.phase === 'ready'
+          ? h('span', { style: { opacity: 0.55 } }, String(entries.length))
+          : null,
+      )
+
+      let body = null
+      if (open) {
+        if (state.phase === 'loading') {
+          body = h('div', { style: { opacity: 0.6, fontSize: 12 } }, props.t('loadingShort'))
+        } else if (state.phase === 'error') {
+          body = h('div', { style: { opacity: 0.7, fontSize: 12 } }, state.message)
+        } else if (state.phase === 'ready') {
+          body = entries.length === 0
+            ? h('div', { style: { opacity: 0.55, fontSize: 12 } }, props.t('workspaceEmpty'))
+            : h(
+                'ul',
+                { style: { margin: 0, padding: 0 } },
+                entries.map((entry) => {
+                  const treeOpen = Boolean(props.openTrees && props.openTrees[entry.sessionId])
+                  return h(
+                    'li',
+                    { key: entry.sessionId, style: { listStyle: 'none', margin: 0, padding: 0 } },
+                    h(
+                      'button',
+                      {
+                        onClick: () => props.onToggleTree(entry.sessionId),
+                        title: treeOpen ? props.t('collapse') : props.t('expand'),
+                        style: {
+                          ...BUTTON,
+                          opacity: 0.8,
+                          fontSize: 12,
+                          display: 'flex',
+                          gap: 6,
+                          width: '100%',
+                          textAlign: 'left',
+                          padding: '1px 0',
+                        },
+                      },
+                      h('span', { style: { fontSize: 9, opacity: 0.55 } }, treeOpen ? '▾' : '▸'),
+                      h(
+                        'span',
+                        { style: { flex: 1, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } },
+                        entry.title,
+                      ),
+                      h(
+                        'span',
+                        { style: { opacity: 0.6, fontVariantNumeric: 'tabular-nums' } },
+                        `${entry.done}/${entry.total}`,
+                      ),
+                    ),
+                    treeOpen
+                      ? h(ReadOnlyTree, {
+                          state: props.trees ? props.trees[entry.sessionId] : undefined,
+                          t: props.t,
+                          sessionId: entry.sessionId,
+                        })
+                      : null,
+                  )
+                }),
+              )
+        }
+      }
+
+      return h(
+        'section',
+        { style: { marginTop: 10, borderTop: '1px solid rgba(127,127,127,0.2)', paddingTop: 6 } },
+        header,
+        body,
+      )
+    }
+
     function ChecklistBody(props) {
       const sessionId = props && props.sessionId
       const snapshot = useChecklistState(sessionId)
@@ -525,6 +700,49 @@ window.__ModuleLoader__.load({
         return () => clearTimeout(timer)
       }, [notice])
 
+      const [workspaceOpen, setWorkspaceOpen] = React.useState(false)
+      const [workspace, setWorkspace] = React.useState({ phase: 'idle' })
+      const [openTrees, setOpenTrees] = React.useState({})
+      const [trees, setTrees] = React.useState({})
+
+      // Lazy on purpose: fetched the first time the section is opened, never on
+      // load, so the panel costs nothing until someone asks for the lens.
+      const toggleWorkspace = () => {
+        const next = !workspaceOpen
+        setWorkspaceOpen(next)
+        if (!next || workspace.phase !== 'idle' || !sessionId) return
+
+        setWorkspace({ phase: 'loading' })
+        fetch(`/dsh-checklist/workspace?session=${encodeURIComponent(sessionId)}`, { cache: 'no-store' })
+          .then((response) => {
+            if (response.status === 403) return { disabled: true }
+            if (!response.ok) throw new Error(`HTTP ${response.status}`)
+            return response.json()
+          })
+          .then((data) => setWorkspace(data && data.disabled ? { phase: 'disabled' } : { phase: 'ready', data }))
+          .catch((error) => setWorkspace({ phase: 'error', message: String((error && error.message) || error) }))
+      }
+
+      // Expanding one entry fetches that session's tree once. Nothing to
+      // invalidate: the lens never writes, so a cached tree stays true.
+      const toggleTree = (targetSessionId) => {
+        const next = !openTrees[targetSessionId]
+        setOpenTrees((current) => ({ ...current, [targetSessionId]: next }))
+        if (!next || trees[targetSessionId]) return
+
+        setTrees((current) => ({ ...current, [targetSessionId]: { phase: 'loading' } }))
+        fetch(`/dsh-checklist/state?session=${encodeURIComponent(targetSessionId)}`, { cache: 'no-store' })
+          .then((response) => {
+            if (!response.ok) throw new Error(`HTTP ${response.status}`)
+            return response.json()
+          })
+          .then((data) => setTrees((current) => ({ ...current, [targetSessionId]: { phase: 'ready', data } })))
+          .catch((error) => setTrees((current) => ({
+            ...current,
+            [targetSessionId]: { phase: 'error', message: String((error && error.message) || error) },
+          })))
+      }
+
       const startEdit = (item) => {
         const next = { id: item.id, original: item.text, draft: item.text }
         editingRef.current = next
@@ -594,6 +812,15 @@ window.__ModuleLoader__.load({
           { style: MUTED },
           h('div', { style: { fontWeight: 600, marginBottom: 4 } }, t('emptyTitle')),
           h('div', null, t('emptyHint')),
+          h(WorkspaceSection, {
+            t,
+            open: workspaceOpen,
+            state: workspace,
+            onToggle: toggleWorkspace,
+            trees,
+            openTrees,
+            onToggleTree: toggleTree,
+          }),
         )
       }
 
@@ -663,6 +890,15 @@ window.__ModuleLoader__.load({
             onCancel: cancelEdit,
           }),
         ),
+        h(WorkspaceSection, {
+          t,
+          open: workspaceOpen,
+          state: workspace,
+          onToggle: toggleWorkspace,
+          trees,
+          openTrees,
+          onToggleTree: toggleTree,
+        }),
       )
     }
 

package/lib/index.js

@@ -10,15 +10,36 @@
  * The agent is the only writer. There is no client write path: the session
  * document is the single source of truth.
  */
+import { randomUUID } from 'node:crypto';
 import { renderDigest } from './digest.js';
 import { decideNudge, isChecklistWrite, MUTATING_TOOLS, NUDGE_ROUTE } from './gate.js';
 import { countState } from './model.js';
 import { serveProbe, PROBE_ROUTE } from './probe.js';
-import { serveItemUpdate, serveState, ITEM_ROUTE, STATE_ROUTE } from './route.js';
+import { serveItemUpdate, serveState, serveWorkspace, ITEM_ROUTE, STATE_ROUTE, WORKSPACE_ROUTE } from './route.js';
 import { ChecklistStore } from './store.js';
 import { registerChecklistTools } from './tools.js';
 export const name = 'dsh-checklist';
 export const inject = ['tools'];
+/**
+ * Build the steering message.
+ *
+ * Model-facing, so English. It states the observation, asks for evidence, and
+ * explicitly allows leaving an item untouched — a gate that demanded progress
+ * would push the model into marking work it never did.
+ */
+function buildSteerMessage(doing) {
+    return {
+        id: randomUUID(),
+        role: 'user',
+        content: [{
+                type: 'text',
+                text: `Before you finish: ${doing} checklist item(s) are still marked "doing". `
+                    + 'If you completed any of them this turn, update them with checklist_check and say what '
+                    + 'proves it. If not, leave them as they are — do not mark work you did not do.',
+            }],
+        source: { kind: 'user' },
+    };
+}
 /**
  * Resolve which session this prompt assembly belongs to.
  *
@@ -41,16 +62,18 @@ export function apply(ctx, config = {}) {
     registerChecklistTools(ctx, store, {
         maxItemsPerList: config.maxItemsPerList,
         templates: config.templates,
+        workspaceView: config.workspaceView,
+        workspaceViewLimit: config.workspaceViewLimit,
     });
     // Opportunistic housekeeping: never blocks startup, never fails the plugin.
     if (config.pruneDays !== 0) {
         void store.prune(config.pruneDays ?? 14).catch(() => undefined);
     }
-    // --- Turn-end gate (observation mode) ------------------------------------
-    // Watches one turn's tool activity and decides, as the turn closes, whether
-    // the checklist was left stale. This release only records the decision — the
-    // event is not exercised yet — so enabling `steer` is a one-line follow-up
-    // once the log shows it fires when it should.
+    // --- Turn-end gate --------------------------------------------------------
+    // Watches one turn's tool activity and, as the turn closes, decides whether
+    // the checklist was left stale. In `steer` mode the agent gets a message
+    // before the turn is allowed to end; `observe` only records the decision.
+    const nudgeMode = config.nudge ?? 'steer';
     const activity = new Map();
     const gateLog = [];
     const events = ctx;
@@ -69,7 +92,8 @@ export function apply(ctx, config = {}) {
             current.checklistWrite = true;
         activity.set(agentId, current);
     }));
-    const evaluate = (agentId, source) => {
+    const evaluate = (agent, source) => {
+        const agentId = agent.id;
         const current = activity.get(agentId) ?? { mutated: false, checklistWrite: false };
         activity.set(agentId, { mutated: false, checklistWrite: false });
         const doc = store.peek(agentId);
@@ -78,34 +102,55 @@ export function apply(ctx, config = {}) {
             for (const list of doc.lists)
                 doing += countState(list.items, 'doing');
         const decision = decideNudge(current, doing);
-        // Log every decision while the gate is in observe mode: an empty log must
-        // mean "the event never fired", never "the answer was no".
+        let steered = false;
+        let reason = decision.reason;
+        if (decision.nudge && nudgeMode === 'steer') {
+            try {
+                agent.steer?.(buildSteerMessage(doing));
+                steered = true;
+            }
+            catch (error) {
+                reason = `${reason}; steer failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        }
+        // Log every decision: an empty log must mean "the event never fired",
+        // never "the answer was no".
         gateLog.push({
             at: new Date().toISOString(),
             sessionId: agentId,
             source,
+            mode: nudgeMode,
             nudge: decision.nudge,
-            reason: decision.reason,
+            steered,
+            reason,
             doing,
         });
         if (gateLog.length > 20)
             gateLog.shift();
     };
     ctx.effect(() => events.on('agent/turn-stopping', (payload) => {
+        if (nudgeMode === 'off')
+            return;
         const event = payload;
         if (typeof event.agent?.id === 'string')
-            evaluate(event.agent.id, 'turn-stopping');
+            evaluate(event.agent, 'turn-stopping');
     }));
-    // Second observation point. `agent/status` → idle also marks a turn end, so
-    // keeping both in the log tells us which one the runtime actually delivers —
-    // and leaves the gate working if `turn-stopping` turns out not to reach a
-    // root listener.
+    // Fallback close signal. It evaluates only when `turn-stopping` left activity
+    // unconsumed, so it never duplicates a decision — but it still catches the
+    // turn if the primary event is ever missing.
     ctx.effect(() => events.on('agent/status', (payload) => {
+        if (nudgeMode === 'off')
+            return;
         const event = payload;
         if (event.status !== 'idle')
             return;
-        if (typeof event.agent?.id === 'string')
-            evaluate(event.agent.id, 'status');
+        const agent = event.agent;
+        if (!agent || typeof agent.id !== 'string')
+            return;
+        const current = activity.get(agent.id);
+        if (!current || (!current.mutated && !current.checklistWrite))
+            return;
+        evaluate(agent, 'status');
     }));
     let loggedScope = false;
     ctx.inject(['systemPrompt'], (promptCtx) => {
@@ -148,6 +193,15 @@ export function apply(ctx, config = {}) {
                 void serveItemUpdate(req, res, store);
             },
         }), 'dsh-checklist: item route');
+        // Workspace lens: other sessions' checklists. Read-only, and never part of
+        // the prompt unless the agent explicitly asks for it.
+        webCtx.effect(() => webCtx.webServer.register({
+            kind: 'exact',
+            path: WORKSPACE_ROUTE,
+            handler: (req, res) => {
+                void serveWorkspace(req, res, store, config.workspaceViewLimit ?? 10, (config.workspaceView ?? 'on-demand') !== 'off');
+            },
+        }), 'dsh-checklist: workspace route');
         // Diagnostics channel for the browser half; see src/probe.ts.
         webCtx.effect(() => webCtx.webServer.register({
             kind: 'exact',
@@ -161,7 +215,7 @@ export function apply(ctx, config = {}) {
             kind: 'exact',
             path: NUDGE_ROUTE,
             handler: (req, res) => {
-                const body = Buffer.from(`${JSON.stringify({ mode: 'observe', entries: gateLog }, null, 2)}\n`, 'utf8');
+                const body = Buffer.from(`${JSON.stringify({ mode: nudgeMode, entries: gateLog }, null, 2)}\n`, 'utf8');
                 res.writeHead(200, {
                     'content-type': 'application/json; charset=utf-8',
                     'content-length': String(body.byteLength),

package/lib/route.js

@@ -7,14 +7,58 @@
  */
 import { findItemById } from './model.js';
 import { toPublicState } from './state.js';
+import { listWorkspaceChecklists } from './workspace.js';
 export const STATE_ROUTE = '/dsh-checklist/state';
 export const ITEM_ROUTE = '/dsh-checklist/item';
+export const WORKSPACE_ROUTE = '/dsh-checklist/workspace';
 /** Longest session id we will even look at; real ones are UUIDs. */
 const MAX_SESSION_ID = 200;
 /** Request body cap for the one write endpoint. */
 const MAX_BODY_BYTES = 16 * 1024;
 /** Item text cap, matching `checklist_edit`. */
 const MAX_TEXT = 500;
+/**
+ * Serve the workspace lens: checklists from other sessions in the same workspace.
+ *
+ * Deliberately separate from the session state route: this data never enters the
+ * agent's context unless a tool explicitly asks for it.
+ *
+ * @param req - the incoming request; must be GET.
+ * @param res - the response to write.
+ * @param store - the checklist store.
+ * @param limit - maximum entries returned, newest first.
+ * @param enabled - false when the profile turned the lens off.
+ */
+export async function serveWorkspace(req, res, store, limit, enabled) {
+    if (req.method !== 'GET') {
+        res.writeHead(405, { allow: 'GET' });
+        res.end();
+        return;
+    }
+    if (!enabled) {
+        sendJson(res, 403, { error: 'workspace view is disabled in this profile' });
+        return;
+    }
+    let session;
+    try {
+        const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+        session = url.searchParams.get('session');
+    }
+    catch {
+        sendJson(res, 400, { error: 'malformed request url' });
+        return;
+    }
+    if (!session || session.length === 0 || session.length > MAX_SESSION_ID) {
+        sendJson(res, 400, { error: 'the session query parameter is required' });
+        return;
+    }
+    try {
+        sendJson(res, 200, await listWorkspaceChecklists(store, session, limit));
+    }
+    catch {
+        sendJson(res, 400, { error: 'invalid session id' });
+    }
+}
 function sendJson(res, status, body) {
     const payload = Buffer.from(`${JSON.stringify(body)}\n`, 'utf8');
     res.writeHead(status, {

package/lib/store.js

@@ -38,6 +38,22 @@ export class ChecklistStore {
     peek(sessionId) {
         return this.cache.get(sessionId);
     }
+    /**
+     * Last modification time of one session's checklist file.
+     *
+     * @param sessionId - the session to inspect.
+     * @returns epoch milliseconds, or undefined when that session has no file.
+     */
+    async modifiedAt(sessionId) {
+        try {
+            const info = await stat(this.fileFor(sessionId));
+            // Rounded: mtimeMs is a float, and the lens output declares it integer.
+            return Math.round(info.mtimeMs);
+        }
+        catch {
+            return undefined;
+        }
+    }
     /** Load one session (cache first, then disk). */
     async prime(sessionId) {
         const cached = this.cache.get(sessionId);

package/lib/tools.js

@@ -6,6 +6,7 @@
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { buildItems, checkRename, countItems, findList, flatten, ITEM_STATES, isItemState, mintId, nextItem, removeItemById, resolveRef, toLines, } from './model.js';
+import { listWorkspaceChecklists } from './workspace.js';
 /** Ships with the plugin so a first run has something to instantiate. */
 const DEFAULT_TEMPLATES = {
     release: [
@@ -614,6 +615,69 @@ export function registerChecklistTools(ctx, store, config = {}) {
             });
         },
     })));
+    ctx.effect(() => ctx.tools.register(defineTool({
+        name: 'checklist_workspace',
+        description: 'List the checklists of OTHER sessions in the same workspace. Read-only; the current session is '
+            + 'excluded, and these lists never enter the prompt on their own. Use it when the user asks what '
+            + 'is pending in this project across sessions.',
+        parameters: {
+            limit: {
+                type: 'integer',
+                description: 'Maximum checklists to return, newest first (default 10).',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    workspaceTitle: { type: 'string' },
+                    workspacePath: { type: 'string' },
+                    checklists: {
+                        type: 'array',
+                        required: true,
+                        items: {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                sessionId: { type: 'string', required: true },
+                                title: { type: 'string', required: true },
+                                total: { type: 'integer', required: true },
+                                done: { type: 'integer', required: true },
+                                updatedAt: { type: 'integer', required: true },
+                            },
+                        },
+                    },
+                },
+            },
+            render: (_args, value) => {
+                const view = value;
+                if (view.checklists.length === 0) {
+                    return [{ type: 'text', text: 'No other session in this workspace has a checklist.' }];
+                }
+                const lines = view.checklists.map((entry) => `· ${entry.title} — ${entry.done}/${entry.total}`);
+                return [{ type: 'text', text: lines.join('\n') }];
+            },
+        },
+        timeoutMs: 10_000,
+        async execute(args, exec) {
+            if ((config.workspaceView ?? 'on-demand') === 'off') {
+                throw new Error('checklist_workspace: the workspace lens is disabled in this profile');
+            }
+            const sessionId = sessionOf(exec);
+            const input = args;
+            const requested = typeof input.limit === 'number' && Number.isFinite(input.limit)
+                ? Math.trunc(input.limit)
+                : undefined;
+            const limit = Math.min(Math.max(1, requested ?? config.workspaceViewLimit ?? 10), 50);
+            const view = await listWorkspaceChecklists(store, sessionId, limit);
+            return {
+                ...(view.workspace?.title ? { workspaceTitle: view.workspace.title } : {}),
+                ...(view.workspace?.path ? { workspacePath: view.workspace.path } : {}),
+                checklists: view.checklists,
+            };
+        },
+    })));
     ctx.effect(() => ctx.tools.register(defineTool({
         name: 'checklist_delete',
         description: 'Delete one checklist from the CURRENT session. The list and its items are gone; there is no archive. '

package/lib/types/index.d.ts

@@ -24,5 +24,21 @@ export interface Config {
     pruneDays?: number;
     /** Extra templates merged over the built-in ones. */
     templates?: Record<string, string[]>;
+    /**
+     * What the turn-end gate does when it finds a stale checklist.
+     * - `steer` (default): put a message in front of the agent before the turn ends.
+     * - `observe`: record the decision, never interrupt.
+     * - `off`: do not evaluate at all.
+     */
+    nudge?: 'steer' | 'observe' | 'off';
+    /**
+     * Workspace lens: viewing checklists from other sessions of the same project.
+     * - `on-demand` (default): available, but nothing is shown unless asked.
+     * - `always`: the sidebar section starts expanded.
+     * - `off`: no route, no tool.
+     */
+    workspaceView?: 'off' | 'on-demand' | 'always';
+    /** Maximum sibling checklists the lens returns (default 10). */
+    workspaceViewLimit?: number;
 }
 export declare function apply(ctx: Context, config?: Config): void;

package/lib/types/route.d.ts

@@ -9,6 +9,20 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { ChecklistStore } from './store.js';
 export declare const STATE_ROUTE = "/dsh-checklist/state";
 export declare const ITEM_ROUTE = "/dsh-checklist/item";
+export declare const WORKSPACE_ROUTE = "/dsh-checklist/workspace";
+/**
+ * Serve the workspace lens: checklists from other sessions in the same workspace.
+ *
+ * Deliberately separate from the session state route: this data never enters the
+ * agent's context unless a tool explicitly asks for it.
+ *
+ * @param req - the incoming request; must be GET.
+ * @param res - the response to write.
+ * @param store - the checklist store.
+ * @param limit - maximum entries returned, newest first.
+ * @param enabled - false when the profile turned the lens off.
+ */
+export declare function serveWorkspace(req: IncomingMessage, res: ServerResponse, store: ChecklistStore, limit: number, enabled: boolean): Promise<void>;
 /**
  * Serve one session's checklist state.
  *

package/lib/types/store.d.ts

@@ -23,6 +23,13 @@ export declare class ChecklistStore {
     constructor(root?: string);
     /** The synchronous view used by the prompt digest; `undefined` until primed. */
     peek(sessionId: string): SessionDoc | undefined;
+    /**
+     * Last modification time of one session's checklist file.
+     *
+     * @param sessionId - the session to inspect.
+     * @returns epoch milliseconds, or undefined when that session has no file.
+     */
+    modifiedAt(sessionId: string): Promise<number | undefined>;
     /** Load one session (cache first, then disk). */
     prime(sessionId: string): Promise<SessionDoc>;
     /**

package/lib/types/tools.d.ts

@@ -9,5 +9,9 @@ import type { ChecklistStore } from './store.js';
 export interface ToolsConfig {
     maxItemsPerList?: number;
     templates?: Record<string, string[]>;
+    /** `off` removes the workspace lens entirely; the other modes expose the tool. */
+    workspaceView?: 'off' | 'on-demand' | 'always';
+    /** Maximum sibling checklists the lens returns. */
+    workspaceViewLimit?: number;
 }
 export declare function registerChecklistTools(ctx: Context, store: ChecklistStore, config?: ToolsConfig): void;

package/lib/types/workspace.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Workspace lens: a read-only view of checklists from sibling sessions.
+ *
+ * Two independent facts drive this module, and keeping them apart is what makes
+ * it survive host changes:
+ *
+ *   1. **Membership comes from disk.** A session lives in
+ *      `$DSH_HOME/sessions/<encoded-workspace>/<sessionId>/`. The host's
+ *      `storages/workspace.json` was missing a workspace on the machine this was
+ *      written on, so it is only consulted for a friendly title/path — never to
+ *      decide which sessions belong together.
+ *   2. **Content comes from our own store.** Session logs are never decoded;
+ *      titles and counts are already in the checklist document.
+ */
+import { type ChecklistStore } from './store.js';
+export interface WorkspaceInfo {
+    /** Encoded directory name the host uses under `$DSH_HOME/sessions`. */
+    key: string;
+    /** Friendly workspace title, when the host metadata knows it. */
+    title?: string;
+    /** Absolute workspace path, when the host metadata knows it. */
+    path?: string;
+}
+export interface WorkspaceListSummary {
+    sessionId: string;
+    title: string;
+    total: number;
+    done: number;
+    /** Last write to that session's checklist file, in epoch milliseconds. */
+    updatedAt: number;
+}
+export interface WorkspaceView {
+    workspace?: WorkspaceInfo;
+    checklists: WorkspaceListSummary[];
+}
+/**
+ * Find the workspace directory that contains a session.
+ *
+ * @param sessionId - the session to locate.
+ * @returns the encoded workspace key, or undefined when the session has no dir.
+ */
+export declare function workspaceKeyOf(sessionId: string): Promise<string | undefined>;
+/** Session ids that share one workspace directory. */
+export declare function siblingSessionIds(key: string): Promise<string[]>;
+/**
+ * List the checklists of every *other* session in the caller's workspace.
+ *
+ * @param store - the checklist store.
+ * @param sessionId - the calling session, excluded from the result.
+ * @param limit - maximum entries returned, newest first.
+ * @returns the workspace description plus one summary per sibling checklist.
+ */
+export declare function listWorkspaceChecklists(store: ChecklistStore, sessionId: string, limit: number): Promise<WorkspaceView>;

package/lib/workspace.js

@@ -0,0 +1,134 @@
+/**
+ * Workspace lens: a read-only view of checklists from sibling sessions.
+ *
+ * Two independent facts drive this module, and keeping them apart is what makes
+ * it survive host changes:
+ *
+ *   1. **Membership comes from disk.** A session lives in
+ *      `$DSH_HOME/sessions/<encoded-workspace>/<sessionId>/`. The host's
+ *      `storages/workspace.json` was missing a workspace on the machine this was
+ *      written on, so it is only consulted for a friendly title/path — never to
+ *      decide which sessions belong together.
+ *   2. **Content comes from our own store.** Session logs are never decoded;
+ *      titles and counts are already in the checklist document.
+ */
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { countItems } from './model.js';
+import { resolveDshHome } from './store.js';
+const SESSION_DIR = /^session-/;
+function sessionsRoot() {
+    return join(resolveDshHome(), 'sessions');
+}
+/**
+ * Find the workspace directory that contains a session.
+ *
+ * @param sessionId - the session to locate.
+ * @returns the encoded workspace key, or undefined when the session has no dir.
+ */
+export async function workspaceKeyOf(sessionId) {
+    let entries;
+    try {
+        entries = await readdir(sessionsRoot());
+    }
+    catch {
+        return undefined;
+    }
+    for (const entry of entries) {
+        if (!entry.startsWith('--'))
+            continue;
+        try {
+            const info = await stat(join(sessionsRoot(), entry, sessionId));
+            if (info.isDirectory())
+                return entry;
+        }
+        catch {
+            // Not this workspace; keep looking.
+        }
+    }
+    return undefined;
+}
+/** Session ids that share one workspace directory. */
+export async function siblingSessionIds(key) {
+    try {
+        const entries = await readdir(join(sessionsRoot(), key), { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && SESSION_DIR.test(entry.name))
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Read the host's workspace table.
+ *
+ * Best effort: any parse problem yields no records, and the lens still works
+ * with the encoded directory name.
+ */
+async function hostWorkspaces() {
+    try {
+        const raw = await readFile(join(resolveDshHome(), 'storages', 'workspace.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        const table = parsed.tables?.workspaces;
+        if (table === null || typeof table !== 'object')
+            return [];
+        return Object.values(table)
+            .filter((value) => value !== null && typeof value === 'object');
+    }
+    catch {
+        return [];
+    }
+}
+/** Describe a workspace by matching host records on session membership. */
+async function describeWorkspace(key, siblings) {
+    const wanted = new Set(siblings);
+    const records = await hostWorkspaces();
+    const match = records.find((record) => {
+        const ids = record.sessionIds;
+        return Array.isArray(ids) && ids.some((id) => typeof id === 'string' && wanted.has(id));
+    });
+    return {
+        key,
+        ...(typeof match?.title === 'string' ? { title: match.title } : {}),
+        ...(typeof match?.path === 'string' ? { path: match.path } : {}),
+    };
+}
+/**
+ * List the checklists of every *other* session in the caller's workspace.
+ *
+ * @param store - the checklist store.
+ * @param sessionId - the calling session, excluded from the result.
+ * @param limit - maximum entries returned, newest first.
+ * @returns the workspace description plus one summary per sibling checklist.
+ */
+export async function listWorkspaceChecklists(store, sessionId, limit) {
+    const key = await workspaceKeyOf(sessionId);
+    if (!key)
+        return { checklists: [] };
+    const siblings = (await siblingSessionIds(key)).filter((id) => id !== sessionId);
+    const workspace = await describeWorkspace(key, siblings);
+    const checklists = [];
+    for (const id of siblings) {
+        const updatedAt = await store.modifiedAt(id);
+        if (updatedAt === undefined)
+            continue; // That session never used the plugin.
+        const doc = await store.prime(id);
+        const first = doc.lists[0];
+        if (!first)
+            continue;
+        const totals = doc.lists.reduce((acc, list) => {
+            const counts = countItems(list.items);
+            return { total: acc.total + counts.total, done: acc.done + counts.done };
+        }, { total: 0, done: 0 });
+        checklists.push({
+            sessionId: id,
+            title: doc.lists.length === 1 ? first.title : `${first.title} (+${doc.lists.length - 1})`,
+            total: totals.total,
+            done: totals.done,
+            updatedAt,
+        });
+    }
+    checklists.sort((a, b) => b.updatedAt - a.updatedAt);
+    return { workspace, checklists: checklists.slice(0, Math.max(1, limit)) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-checklists",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Session-scoped checklists for DeepSeek Harness: the agent tracks work as a tree, the model always sees a compact digest, and a read-only sidebar tab mirrors it.",
   "type": "module",
   "main": "lib/index.js",