dsh-caveman 0.1.2 → 0.1.3

package/lib/client.js

@@ -7,10 +7,10 @@ window.__ModuleLoader__.load({
     const React = require("react");
 
     // Badge display is centralized in dsh-badges: this plugin only registers
-    // a badge descriptor (projection key + pure appearance renderer). The
-    // renderer maps the 'caveman' projection value to badge appearance, or
-    // null when the mode is off. Functionality (projection unit, /caveman
-    // command, prompt-section injection) lives in the host half.
+    // a badge descriptor (fetch-mode: initial GET + toggle-response self-
+    // update + 5s re-sync). No session projection is involved; per-session
+    // mode lives in the host sidecar. Functionality (/caveman command,
+    // directive parsing, prompt-section injection) lives in the host half.
     const inject = ["slots"];
 
     function apply(ctx) {
@@ -24,18 +24,30 @@ window.__ModuleLoader__.load({
         if (registry === undefined) return false;
         registry.register({
           key: "caveman",
-          projection: "caveman",
+          fetch: (sessionId) =>
+            sessionId
+              ? fetch("/caveman/state?sessionId=" + encodeURIComponent(sessionId))
+                  .then((r) => (r.ok ? r.json() : null))
+                  .catch(() => null)
+              : Promise.resolve(null),
+          pollMs: 5000,
           title: "Click to cycle caveman mode: off -> lite -> full -> ultra",
           onClick: (sessionId) => {
-            if (!sessionId) return;
+            // Cycles through the host sidecar (POST /caveman/toggle). The
+            // resolved value updates the badge immediately (no waiting for
+            // the next poll). Failures are silent (badge stays as-is).
+            if (!sessionId) return Promise.resolve(null);
             try {
-              fetch("/caveman/toggle", {
+              return fetch("/caveman/toggle", {
                 method: "POST",
                 headers: { "content-type": "application/json" },
                 body: JSON.stringify({ sessionId }),
-              }).catch(() => {});
+              })
+                .then((r) => (r.ok ? r.json() : null))
+                .then((data) => (data && data.ok ? { mode: data.mode } : null))
+                .catch(() => null);
             } catch (e) {
-              /* fetch unavailable: no-op */
+              return Promise.resolve(null);
             }
           },
           render: (value) => {

package/lib/index.js

@@ -1,24 +1,41 @@
 // dsh-caveman: per-session caveman communication mode.
-// - sessionProjections unit 'caveman' folds `caveman/change` session events
-//   (default 'full'; per-session by construction, no cross-agent sharing)
-// - /caveman command and plain-text "caveman <mode>" directive (agent/pre-step)
-//   append the change event; directive-only user messages are consumed
+// - per-session mode state lives in a sidecar JSON keyed by session id
+//   (unseen sessions use the settings default 'full'; no cross-agent sharing)
+// - /caveman command, plain-text "caveman <mode>" directive (agent/pre-step),
+//   and POST /caveman/toggle all flip the sidecar state; directive-only user
+//   messages are still consumed
 // - system-prompt section injects the current mode as an overriding directive
-// - composer dock badge (client half, lib/client.js) renders via
-//   useProjection('caveman')
+// - composer dock badge (client half, lib/client.js) renders in fetch mode
+//   (GET /caveman/state + toggle response self-update + 5s re-sync)
 //
-// OUT-OF-REPO EVENT VOCABULARY:
-// `caveman/change` is not in the harness's static KNOWN_SESSION_EVENT_TYPES
-// (generated in @deepseek-ai/dsh-session), so a session log containing it is
-// refused on load unless the type is registered or the event carries
-// `ignorable: true` (append() cannot set that flag). We register the type at
-// apply() time on the SAME module instance the persistence loader imports
-// (both resolve to <workspace>/node_modules/@deepseek-ai/dsh-session), so
-// every boot WITH this plugin can read back its events. Logs written before
-// this fix were repaired in place by .dsh/scripts/repair-caveman-events.py /
-// fix-d8b43aa8.py (ignorable: true injected, 2-frame zstd layout).
-import { z } from 'zod'
+// NO-SESSION-EVENT DESIGN (a' refactor 2026-09-08):
+// this plugin WRITES zero session events. The KNOWN registration (dual-path,
+// below) is KEPT as read-side legacy compat only: rc.2 persistence refuses to
+// load logs containing unregistered, non-ignorable event types
+// (dsh-session-persistence L1120), and historic sessions contain
+// `caveman/change` (实撞 2026-09-08 via rtk: dropping the registration breaks
+// legacy log loading). Logs written before the old fix were repaired in place
+// by .dsh/scripts/repair-caveman-events.py / fix-d8b43aa8.py.
+import { createRequire } from 'node:module'
+import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
 import { KNOWN_SESSION_EVENT_TYPES } from '@deepseek-ai/dsh-session'
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths'
+import { settingsNamespace } from '@deepseek-ai/dsh-settings'
+import zs from '@deepseek-ai/schemastery'
+
+const require = createRequire(import.meta.url)
+
+function registerKnownEventType(type) {
+  KNOWN_SESSION_EVENT_TYPES.add(type)
+  try {
+    const persistencePath = require.resolve('@deepseek-ai/dsh-session-persistence')
+    const hostSessionPath = require.resolve('@deepseek-ai/dsh-session', { paths: [persistencePath] })
+    require(hostSessionPath).KNOWN_SESSION_EVENT_TYPES.add(type)
+  } catch (err) {
+    console.warn('[caveman] could not register host session event type:', err && err.message)
+  }
+}
 
 export const name = 'caveman'
 // Hard dependency on the HTTP route registry for the badge-click toggle
@@ -29,8 +46,6 @@ const VALID = ['off', 'lite', 'full', 'ultra', 'wenyan-lite', 'wenyan-full', 'we
 const DIRECTIVE_RE = /^\/?caveman\s+(off|lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra)$/i
 const OFF_RE = /^(stop\s+caveman|normal\s+mode)$/i
 
-const schema = z.object({ mode: z.enum(VALID) })
-
 function parseDirective(text) {
   if (typeof text !== 'string') return null
   const t = text.trim()
@@ -50,36 +65,81 @@ function directiveOf(message) {
 }
 
 export function apply(ctx) {
-  // Register our event type on the shared KNOWN set so session logs
-  // containing `caveman/change` load in any boot that mounts this plugin.
+  // READ-SIDE LEGACY COMPAT ONLY (do not remove): keeps session logs
+  // containing historic `caveman/change` loadable; this plugin no longer
+  // WRITES session events (see header). Drop only after SOP §8 injection.
   try {
-    KNOWN_SESSION_EVENT_TYPES.add('caveman/change')
+    registerKnownEventType('caveman/change')
   } catch (err) {
     console.warn('[caveman] could not register event type:', err && err.message)
   }
 
-  const projections = ctx.get('sessionProjections')
+  // ---- global default mode (settings document, 'caveman' namespace) ------
+  // Sessions WITHOUT a sidecar entry follow this live default (full).
+  let defaultMode = 'full'
+  let cavemanScope = null
+  const settings = ctx.get('settings')
+  if (settings !== undefined) {
+    try {
+      cavemanScope = settings.register(
+        settingsNamespace('caveman'),
+        zs.object({ defaultMode: zs.union(VALID.map((v) => zs.const(v))).default('full') }),
+        { applies: 'live' },
+      )
+      const value = cavemanScope.get()
+      defaultMode = value && VALID.includes(value.defaultMode) ? value.defaultMode : 'full'
+      cavemanScope.watch((next) => {
+        defaultMode = next && VALID.includes(next.defaultMode) ? next.defaultMode : 'full'
+      })
+    } catch (err) {
+      console.warn('[caveman] settings namespace registration failed:', err && err.message)
+    }
+  }
 
-  if (projections !== undefined) {
-    // rc.7+: client visibility requires wire (viewSchema + view); the bare
-    // top-level schema/view fields are ignored by the rc.2 registry.
-    projections.register({
-      key: 'caveman',
-      stateSchema: schema,
-      stateVersion: 1,
-      init: () => ({ mode: 'full' }),
-      apply: (state, event) => {
-        if (!event || event.type !== 'caveman/change') return state
-        const mode = event.data && typeof event.data.mode === 'string' ? event.data.mode : ''
-        if (!VALID.includes(mode) || state.mode === mode) return state
-        return { mode }
-      },
-      wire: {
-        viewSchema: schema,
-        view: (state) => ({ mode: state.mode }),
-      },
-    })
+  // ---- per-session mode state: sidecar JSON keyed by session id ----------
+  // Truth source for the mode. Sessions WITHOUT an entry use the live
+  // settings default. Atomic tmp+rename persist; lives outside node_modules
+  // (survives restarts and plugin reinstalls).
+  const SIDECAR_PATH = (() => {
+    try {
+      return join(dshHomePath('plugin-state'), 'caveman-state.json')
+    } catch (e) {
+      console.warn('[caveman] dshHomePath unavailable, sidecar persistence disabled:', e && e.message)
+      return null
+    }
+  })()
+  const sessionMode = new Map()
+  const loadSidecar = () => {
+    if (SIDECAR_PATH === null) return
+    try {
+      const data = JSON.parse(readFileSync(SIDECAR_PATH, 'utf8'))
+      const sessions = data && data.sessions
+      if (sessions && typeof sessions === 'object') {
+        for (const [id, mode] of Object.entries(sessions)) {
+          if (typeof mode === 'string' && VALID.includes(mode)) sessionMode.set(id, mode)
+        }
+      }
+    } catch (e) {
+      // missing or corrupt sidecar: start from an empty map (defaults apply)
+    }
+  }
+  const persistSidecar = () => {
+    if (SIDECAR_PATH === null) return
+    try {
+      mkdirSync(dirname(SIDECAR_PATH), { recursive: true })
+      const tmp = SIDECAR_PATH + '.tmp'
+      writeFileSync(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(sessionMode) }), 'utf8')
+      renameSync(tmp, SIDECAR_PATH)
+    } catch (e) {
+      console.warn('[caveman] sidecar persist failed:', e && e.message)
+    }
+  }
+  const readMode = (sessionId) => (sessionMode.has(sessionId) ? sessionMode.get(sessionId) : defaultMode)
+  const writeMode = (sessionId, mode) => {
+    sessionMode.set(sessionId, mode)
+    persistSidecar()
   }
+  loadSidecar()
 
   const commands = ctx.get('commands')
   if (commands !== undefined) {
@@ -92,7 +152,8 @@ export function apply(ctx) {
         if (!VALID.includes(mode)) {
           return { kind: 'error', text: 'Invalid mode: "' + invocation.rawInput.trim() + '". Valid: ' + VALID.join('|') }
         }
-        invocation.agent.session.append('caveman/change', { mode })
+        const sid = invocation.agent && invocation.agent.session && invocation.agent.session.id
+        if (typeof sid === 'string' && sid.length > 0) writeMode(sid, mode)
         return { kind: 'success', text: mode === 'off' ? 'Caveman mode: off' : 'Caveman mode: ' + mode }
       },
     })
@@ -108,17 +169,48 @@ export function apply(ctx) {
       else kept.push(m)
     }
     if (mode === null) return next()
-    payload.agent.session.append('caveman/change', { mode })
+    const sid = payload.agent && payload.agent.session && payload.agent.session.id
+    if (typeof sid === 'string' && sid.length > 0) writeMode(sid, mode)
     if (kept.length === 0) return { kind: 'reject' }
     return { kind: 'enter', messages: kept }
   })
 
-  // ---- badge click toggle: POST /caveman/toggle { sessionId } -------------
-  // The composer badge's onClick cycles the mode off -> lite -> full -> ultra
-  // -> off through the same caveman/change event path as /caveman on|off, so
-  // UI, projection, and prompt-section all agree via the session log.
+  // ---- badge state read: GET /caveman/state?sessionId=... ----------------
+  // Fetch-mode badge client reads the per-session mode here (initial load
+  // plus a periodic re-sync). Exact route; the matcher strips the query.
   const CYCLE = ['off', 'lite', 'full', 'ultra']
   const webServer = ctx.get('webServer')
+  if (webServer !== undefined) {
+    try {
+      webServer.register({
+        kind: 'exact',
+        path: '/caveman/state',
+        handler: async (req, res) => {
+          if (req.method !== 'GET') {
+            res.writeHead(405)
+            res.end()
+            return
+          }
+          let sessionId = null
+          try {
+            sessionId = new URL(req.url || '/', 'http://x').searchParams.get('sessionId')
+          } catch (e) {
+            sessionId = null
+          }
+          const mode = typeof sessionId === 'string' && sessionId.length > 0 ? readMode(sessionId) : 'full'
+          res.writeHead(200, { 'content-type': 'application/json' })
+          res.end(JSON.stringify({ mode }))
+        },
+      })
+    } catch (e) {
+      console.error('[caveman] /caveman/state route registration failed:', e && e.message)
+    }
+  }
+
+  // ---- badge click toggle: POST /caveman/toggle { sessionId } -------------
+  // Cycles off -> lite -> full -> ultra -> off through the sidecar (the same
+  // mutation /caveman performs) and returns the new value so the badge can
+  // self-update from the response.
   if (webServer !== undefined) {
     try {
       webServer.register({
@@ -151,18 +243,9 @@ export function apply(ctx) {
           res.end(JSON.stringify({ ok: false, error: 'session not found' }))
           return
         }
-        let mode = 'full'
-        if (projections !== undefined) {
-          try {
-            const value = projections.snapshot(session).values.caveman
-            if (value && typeof value.mode === 'string') mode = value.mode
-          } catch (e) {
-            mode = 'full'
-          }
-        }
-        const at = CYCLE.indexOf(mode)
+        const at = CYCLE.indexOf(readMode(sessionId))
         const next = CYCLE[(at === -1 ? 0 : at) + 1] === undefined ? CYCLE[0] : CYCLE[at + 1]
-        session.append('caveman/change', { mode: next })
+        writeMode(sessionId, next)
         res.writeHead(200, { 'content-type': 'application/json' })
         res.end(JSON.stringify({ ok: true, mode: next }))
       },
@@ -179,14 +262,9 @@ export function apply(ctx) {
       order: 50,
       text: (context) => {
         const agent = context && context.agent
-        if (!agent || projections === undefined) return ''
-        let mode = 'full'
-        try {
-          const value = projections.snapshot(agent.session).values.caveman
-          if (value && typeof value.mode === 'string') mode = value.mode
-        } catch (err) {
-          mode = 'full'
-        }
+        if (!agent) return ''
+        const sid = agent.session && agent.session.id
+        const mode = typeof sid === 'string' && sid.length > 0 ? readMode(sid) : defaultMode
         if (mode === 'off') return ''
         const tag = mode === 'full' ? '[CAVEMAN]' : '[CAVEMAN:' + mode.toUpperCase() + ']'
         return tag + ' Current user-set communication style. Follow the caveman skill rules at intensity "' + mode + '" for every response; this overrides any default in AGENTS.md.'
@@ -194,5 +272,5 @@ export function apply(ctx) {
     })
   }
 
-  console.log('[caveman] host active (event projection + KNOWN registration)')
+  console.log('[caveman] host active (sidecar mode state + prompt section; writes no session events)')
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-caveman",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -8,7 +8,7 @@
     "./client": "./lib/client.js",
     "./package.json": "./package.json"
   },
-  "description": "Per-session caveman mode state (session projection unit) + composer dock badge + /caveman command + prompt-section injection. Caveman skills ship from the deployment shared skill library (see ~/.dsh/skills), not from this package.",
+  "description": "Per-session caveman mode state + composer dock badge + /caveman command + prompt-section injection. Writes NO session events: mode state lives in a $DSH_HOME/plugin-state sidecar keyed by session id (default from the 'caveman' settings namespace), and the badge reads GET /caveman/state (fetch mode). The KNOWN event-type registration is kept read-only for legacy sessions. Caveman skills ship from the deployment shared skill library (see ~/.dsh/skills), not from this package.",
   "license": "MIT",
   "keywords": [
     "dsh",
@@ -23,9 +23,6 @@
     "lib",
     "cordis.patch.yml"
   ],
-  "dependencies": {
-    "zod": "^4.4.3"
-  },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"