@deepseek-insight/dsi 0.11.3 → 0.11.5

package/.agents/skills/dsi-plugin-rack/SKILL.md

@@ -1,3 +1,8 @@
+---
+name: dsi-plugin-rack
+description: Use when asked to install or uninstall a dsh plugin from the plugins reference (~/.dsi/resources/plugins-reff.md) — dsh-delegated apply via rack.mjs, snapshot-first cache, manifest-recorded removes per the Plugin Rack ADR. Reserved keyword /dsi-plugin-rack.
+---
+
 # dsi-plugin-rack
 
 Install and uninstall dsh plugins from the plugins reference (~/.dsi/resources/plugins-reff.md), cached at ~/.dsi/resources/pgr-cache.json. Implements the ADR "The Plugin Rack" (dev/architectural-decission/2026-09/, 2026-09-27).

package/.agents/skills/dsi-skill-shelf/SKILL.md

@@ -1,3 +1,8 @@
+---
+name: dsi-skill-shelf
+description: Use when asked to install or uninstall agent skills from the SKR reference (~/.dsi/resources/skills-reff.md) — signed installs and signature-gated uninstalls via shelf.mjs, unstable tier opt-in, collision abort, per the Skill Shelf ADR. Reserved keyword /dsi-skill-shelf.
+---
+
 # dsi-skill-shelf
 
 Install and uninstall agent skills from the SKR reference (`~/.dsi/resources/skills-reff.md`). Implements the ADR 'The Skill Shelf' (dev/architectural-decission/2026-09/, 2026-09-20).

package/.agents/skills/glass-dsh/DESIGN.md

@@ -0,0 +1,36 @@
+# glass-dsh — short design (approved 2026-11-09)
+
+**Intent.** One skill that owns the creator-mode verification loop for a new DSH
+web-UI plugin: install → probe → real gestures → persistence → restore, ending in
+a gate report the operator can trust. Plugin craft stays in the harness's
+`cordis-plugin-development` skill.
+
+**Approaches considered** (operator decision 2026-11-09, recorded in ADR-0045
+Amendment 6 D12–D15):
+- *Full creator loop* (chosen) vs verification-only half — the operator picked the loop.
+- *Own driver scripts* (chosen) vs reusing glass-dsi's `_connect.mjs` — decoupling beats
+  shared-drift risk at this size (accepted duplication, D1/D12 give-up).
+- *Repo `skills/` folder* (chosen, operator override) + `~/.agents/skills/` mirror for
+  the slash menu — same pattern as every DSI skill.
+- *Probe-then-env port resolution* (chosen, D13): `--dsh-url`/`--dsh-port` argument >
+  `DSH_PORT` env > default `3080`; CLI `--port` applies at boot, so the env/arg the agent
+  sees is authoritative — stated first in SKILL.md.
+
+**Goals.** Five machine-checkable gates (console baseline, origin tab pick, real
+gestures with control assertions, localStorage persistence, state restore) runnable
+against any slot-rendering DSH plugin with plugin-supplied selectors.
+
+**Non-goals.** No plugin authoring; no DSI-surface verification (glass-dsi); no
+foreign URLs (glass-url); no changes to sibling glass skills; no synthetic-event
+"testing" (D15); no state files (the floor registry is the only truth, ADR-0030).
+
+**Constraints.** playwright-core resolves only from the DSI repo root; the glass
+session is claimed by harness-session identity or refused loudly (D7); a failing
+gate ends the run with a report (D11 stop-loss).
+
+**Left to the builder.** Per-plugin selectors and store keys come from the plugin's
+own client module; the gesture composition (which verbs, which order) is the
+calling agent's judgment inside the gates.
+
+**Status:** built and gate-verified on the live sticky-notes plugin 2026-11-09 —
+see completion notes in the spec folder.

package/.agents/skills/glass-dsh/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: glass-dsh
+description: "Use when a newly created DSH web-UI plugin (plugin_manager returned application=applied) must be verified live on the DSH page of the operator's glass browser — probe, real gestures, persistence and restore gates per ADR-0045. NOT for DSI's own workspace surface (that is glass-dsi) or arbitrary foreign URLs (that is glass-url). Reserved keyword /glass-dsh."
+---
+
+# glass-dsh — verify a new DSH web-UI plugin on the operator's glass, creator mode
+
+Use when you just created and installed a **DSH web-UI plugin** (`plugin_manager`
+returned `application: applied`) and must prove it live on the glass browser —
+the surface at the DSH GUI (`http://127.0.0.1:3080/` by default). This skill owns
+the full creator loop's verification half: the plugin CRAFT itself (manifest,
+locale, icon, slot choice) belongs to the harness's `cordis-plugin-development`
+skill — defer to it first, then run THIS skill.
+
+**Dispatch rule (ADR-0045 Amendment 6, the three hands):**
+- Verifying DSI's own workspace surface → `glass-dsi` (its driver DIES without a
+  DSI tab; it cannot verify DSH work — observed live 2026-11-09).
+- Driving an arbitrary foreign URL → `glass-url` (opens a NEW tab; never touches
+  the DSI tab).
+- Verifying a newly created **DSH plugin** on the DSH page → **this skill**.
+
+## The law (every gate cites ADR-0045)
+
+1. **The registry is the only way in.** Never launch your own browser; never
+   POST your own glass session (orphans can never be adopted — the operator must
+   click the Browser chip). ADR-0030.
+2. **The glass is claimed by identity, never by index.** `_connect.mjs`
+   resolves `--owner-session` flag > `GLASS_OWNER_SESSION` > `DSH_SESSION_ID`;
+   multiple glasses with no match = loud refusal. D7.
+3. **The DSH tab is picked by ORIGIN compare, never a port substring.** D13.
+4. **Console-error baseline (Gate 0) before any gesture.** A
+   `slot entry crashed in '<slot>'` naming your plugin is an automatic FAIL with
+   the stack in the report — element presence alone verifies nothing (observed
+   live: the only signal of a dead plugin was the console crash). D14.
+5. **Real gestures only; every read gates on a control.** `page.mouse` /
+   `page.keyboard` with stepped moves; synthetic `dispatchEvent` is not
+   verification. Assert the gesture moved what it should before reading
+   counters. D15. Failure branches live in §gates below.
+6. **A refusal is an answer; stop-loss.** A failing gate ENDS the run with a
+   report — no improvised fixes beyond the plugin under test. D11.
+7. **Restore user state.** Clear and label anything you seeded. Gate 5.
+
+## DSH base resolution (probe then env; D13)
+
+Order: explicit argument > environment > default.
+
+1. `--dsh-url <url>` or `--dsh-port <n>` argument (highest).
+2. `DSH_PORT` env — note: when the floor was booted with the CLI `--port` flag
+   it wins over the env at boot time, so if the operator booted with `--port`
+   but exported no `DSH_PORT`, ONLY the explicit argument form can find the
+   tab; state which source resolved the base in the report.
+3. Default `http://127.0.0.1:3080/`.
+
+The floor registry (glass sessions) is resolved separately: `DSI_UI` env when
+set, else probe `5175` then `5174` (`/api/browser`). A floor stamps its own
+addresses at boot — agents in a floor's conversations drive that floor's glass.
+
+## Environment contract (D6, amended by D16 2026-11-09)
+
+- Plain node ESM, no build step. The driver resolves `playwright-core`
+  **itself** (D16): script-relative `node_modules` → the cwd's `package.json`
+  tree → `$DSI_REPO_ROOT` → loud death naming the remedy. Running from the DSI
+  repo root still works (the cwd fallback), but is no longer required; there is
+  NO symlink step. If the skill directory is read-only (harness workspace-write
+  mode), copying `scripts/` into the workspace is the sanctioned deployment —
+  the copy bootstraps itself.
+- Every verb prints ONE JSON verdict on stdout and exits 0/1; failures print
+  `{"error": ...}` via `die()` — a refusal is an answer, quote it.
+- No state files between runs: every run re-derives session and tab from the
+  registry and the resolved origin.
+
+## The loop (creator mode)
+
+1. **Install** — via the harness `plugin_manager` (`install_bundle`; replacing
+   an installed package = `remove_bundle` then `install_bundle` again —
+   observed 2026-11-09). This skill starts when `application: applied`.
+2. **Probe (Gates 0–2)** —
+   `node skills/glass-dsh/scripts/probe-dsh.mjs --expect '<selector>' --store '<localStorageKey>'`
+   → reloads the DSH tab, arms the console listener, emits
+   `{launcherProbe, consoleErrors, crashedSlots, moduleLoader}`.
+3. **Gestures (Gates 3–4)** — one verb per process, composition in your hands:
+   `glass-dsh.mjs eval --b64` for reads, `gesture.mjs click|type|drag|control|persist`
+   for real input. Each verb prints `{before, after, moved}` — quote the pair.
+   For gesture SEQUENCES prefer the D17 composite (one process, one CDP session,
+   one verdict per step):
+   `node gesture.mjs run steps.json` where steps.json is an array like
+   `[{"verb":"click","selector":"…","label":"open"},{"verb":"drag","selector":"…","dx":-433,"dy":-303},{"verb":"type","selector":"…","text":"…"},{"verb":"control","expr":"…"}]`
+   → `{"verb":"run","steps":4,"executed":N,"failedAt":null,"ok":true,"results":[…per-step verdicts…]}`
+   and exit 1 if any step failed. The composite STOPS at the first failed gate
+   (control `pass:false`, gesture `moved:false`, any `die`) and reports the
+   completed prefix — quote the prefix, do not improvise onward (D11). Single
+   verbs stay for one-off reads and re-runs of a single failed step.
+4. **Restore (Gate 5)** — clear seeded state via the page's own store, reload,
+   re-probe: launcher present, console clean, store empty.
+5. **Report** — table of before/after numbers, the gesture that produced them,
+   gates passed/failed, what was seeded and cleared.
+
+## Gates (machine-checkable)
+
+| Gate | Asserts | Verb |
+|---|---|---|
+| 0 | glass session exists, owned by you | `probe-dsh.mjs` (dies loudly otherwise) |
+| 1 | DSH tab found by origin | `glass-dsh.mjs pages` (origin classification) |
+| 2 | console baseline clean of the plugin's slot crash | `probe-dsh.mjs` (`crashedSlots`) |
+| 3 | real gesture moved its control | `gesture.mjs` (`moved: true` + control expr) |
+| 4 | persistence via the plugin's own store | `gesture.mjs persist` before/after reload |
+| 5 | state restored | `probe-dsh.mjs` re-run after cleanup |
+
+## Failure branches (the 2026-11-09 sticky-notes incidents)
+
+| Symptom | Root cause | Remedy |
+|---|---|---|
+| Plugin entry absent, console has `slot entry crashed in '<slot>': TypeError ...` | a thrown factory/component blanks the slot entry | Gate 2 FAIL → fix the plugin module, reinstall, re-probe |
+| Click on element X times out: `X ... subtree intercepts pointer events` | another plugin element covers the target (stacked notes) | drag the covering element aside first, or click the TOPMOST instance (`.last()`); then report the overlap as a plugin defect |
+| Click "succeeds" but the button's handler never fires | an ancestor's `setPointerCapture` on pointerdown retargets the derived click | plugin defect: skip capture when `e.target.closest('button')` |
+| Drag moved nothing but gates "pass" | geometry lied or the drag clamped at viewport bounds | control gate (`moved: true`) is mandatory before reading counters; fix coordinates inside the container |
+| `no glass ...` / multiple glasses | no panel, or foreign ownership | operator clicks the Browser chip in THIS conversation; `--owner-session <id>` if env lacks identity |## Reserved keys
+
+Plugin selectors and localStorage keys are plugin-owned (read them from the
+plugin's client module — e.g. sticky-notes uses `.sticky-notes-launcher` and
+`dsh-sticky-notes:v1`). This skill hardcodes none.
+
+---
+Driver scripts: `scripts/_connect.mjs` (header lists exports), `scripts/glass-dsh.mjs`,
+`scripts/probe-dsh.mjs`, `scripts/gesture.mjs`.
+Companions: ADR-0045 Amendment 6; spec `dev/specs/2026-11/2026-11-09 - Glass DSH Skill/`.

package/.agents/skills/glass-dsh/scripts/_connect.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * _connect.mjs — shared glass connection for the glass-dsh driver (skills/glass-dsh).
+ * Dated copy 2026-11-09; derived from glass-dsi's helper (ADR-0045 D1/D12 —
+ * accepted duplication, each copy dated and attributed).
+ *
+ * EXPORTS (do not guess — this header is the contract):
+ *   die(msg)             — print a JSON error and exit 1.
+ *   identityFrom(argv)   — caller identity, first-wins: --owner-session flag
+ *                          > GLASS_OWNER_SESSION > DSH_SESSION_ID env.
+ *   pickSession(sessions, envId)
+ *                        — PURE D7 resolver: match identity to ownerSessionId;
+ *                          NEVER a registry index. { session } | { session:null, error }.
+ *   resolveDsiBase({env, fetchImpl, timeoutMs})
+ *                        — the floor that owns the registry: DSI_UI env wins,
+ *                          else probe http://127.0.0.1:5175 then :5174 (/api/browser).
+ *                          Returns { base, reg }; dies loudly when no floor answers.
+ *   resolveDshBase(argv, env)
+ *                        — the DSH surface to verify (D13, probe-then-env):
+ *                          --dsh-url / --dsh-port argument > DSH_PORT env >
+ *                          default http://127.0.0.1:3080. Returns origin string.
+ *   connect(argv)        — resolveDsiBase → pickSession → chromium.connectOverCDP
+ *                          → { session, browser, ctx, floorBase, dshOrigin }.
+ *                          Dies loudly on ambiguity (D7) or CDP failure.
+ *   pickByOrigin(ctx, origin) — the page whose URL ORIGIN equals `origin`
+ *                          (never a port substring, never positional). Dies when
+ *                          absent, naming the resolved origin.
+ */
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+
+// D16 (ADR-0045 Amendment 7) — the driver resolves its own engine; the cwd is
+// never the contract. Resolution order: script-relative node_modules → the
+// cwd's package.json tree (the documented "run from the repo root" case) →
+// the stamped default repo (~/agentic-ai/deepseek-insight) or $DSI_REPO_ROOT →
+// die loudly with the exact remedy. ESM bare imports resolve from the script's
+// own directory, which is why cwd alone was never enough.
+function resolveChromium() {
+  const attempts = [];
+  const repoCandidates = [];
+  if (process.env.DSI_REPO_ROOT) repoCandidates.push(process.env.DSI_REPO_ROOT);
+  if (process.env.HOME) repoCandidates.push(join(process.env.HOME, 'agentic-ai', 'deepseek-insight'));
+  const tryRequire = (label, anchor) => {
+    try {
+      return createRequire(anchor)('playwright-core');
+    } catch (e) {
+      attempts.push(label + ': ' + (e?.code ?? e?.message ?? String(e)));
+      return null;
+    }
+  };
+  let mod = tryRequire('script-relative', import.meta.url);
+  if (!mod) mod = tryRequire('cwd', join(process.cwd(), 'package.json'));
+  for (const root of repoCandidates) {
+    if (mod) break;
+    mod = tryRequire('repo:' + root, join(root, 'package.json'));
+  }
+  if (!mod?.chromium) {
+    die('playwright-core not resolvable — tried: ' + attempts.join(' | ') +
+      '. Remedy: run from the DSI repo root (cwd with a package.json), copy these ' +
+      'scripts next to a node_modules that has playwright-core, export DSI_REPO_ROOT=<repo path>, ' +
+      'or clone the DSI repo to ~/agentic-ai/deepseek-insight.');
+  }
+  return mod.chromium;
+}
+const chromium = resolveChromium();
+
+const DEFAULT_FLOOR_BASES = ['http://127.0.0.1:5175', 'http://127.0.0.1:5174'];
+
+export function die(msg) {
+  console.error(JSON.stringify({ error: msg }));
+  process.exit(1);
+}
+
+export function identityFrom(argv) {
+  const flag = argv.indexOf('--owner-session');
+  if (flag !== -1 && argv[flag + 1]) return argv[flag + 1];
+  if (process.env.GLASS_OWNER_SESSION) return process.env.GLASS_OWNER_SESSION;
+  if (process.env.DSH_SESSION_ID) return process.env.DSH_SESSION_ID;
+  return undefined;
+}
+
+export function pickSession(sessions, envId) {
+  const list = sessions ?? [];
+  if (envId) {
+    const mine = list.filter((s) => (s.ownerSessionId ?? null) === envId);
+    if (mine.length === 1) return { session: mine[0], degraded: false };
+    if (mine.length > 1) {
+      const newest = [...mine]
+        .sort((a, b) => String(a.createdAt ?? '').localeCompare(String(b.createdAt ?? '')))
+        .at(-1);
+      return { session: newest, degraded: false, note: 'multiple glasses owned by ' + envId + ' — newest wins' };
+    }
+    if (list.length === 1 && (list[0].ownerSessionId ?? null) === null) {
+      return { session: list[0], degraded: true, note: 'legacy session without ownerSessionId — degraded match' };
+    }
+    return { session: null, error: 'no glass owned by ' + envId + ' — your glass is dead or never summoned (the operator clicks the Browser chip in THIS conversation); live glasses belong to other conversations and are untouchable (D7)' };
+  }
+  if (list.length === 1) {
+    return { session: list[0], degraded: true, note: 'no explicit identity in env — degraded single-session resolution' };
+  }
+  return { session: null, error: 'multiple live glasses and no explicit identity — pass --owner-session <id>; refusing to guess (D7)' };
+}
+
+export async function resolveDsiBase({ env = process.env, fetchImpl = fetch, timeoutMs = 3000 } = {}) {
+  const candidates = env.DSI_UI && /^http:\/\//.test(env.DSI_UI)
+    ? [env.DSI_UI.replace(/\/$/, '')]
+    : [...DEFAULT_FLOOR_BASES];
+  const probes = await Promise.all(candidates.map(async (base) => {
+    try {
+      const res = await fetchImpl(base + '/api/browser', { signal: AbortSignal.timeout(timeoutMs) });
+      if (!res.ok) return { base, reg: null };
+      return { base, reg: await res.json() };
+    } catch { return { base, reg: null }; }
+  }));
+  const answered = probes.filter((p) => p.reg?.sessions);
+  if (answered.length === 0) {
+    die('no DSI floor answers — probed ' + candidates.join(', ') +
+      ' (the glass session registry lives on the DSI floor; open the glass from the floor panel)');
+  }
+  return answered[0];
+}
+
+/** D13 — explicit argument > DSH_PORT env > default 3080; returns an origin string. */
+export function resolveDshBase(argv = [], env = process.env) {
+  const urlFlag = argv.indexOf('--dsh-url');
+  if (urlFlag !== -1 && argv[urlFlag + 1]) return new URL(argv[urlFlag + 1]).origin;
+  const portFlag = argv.indexOf('--dsh-port');
+  if (portFlag !== -1 && argv[portFlag + 1]) return new URL('http://127.0.0.1:' + argv[portFlag + 1]).origin;
+  if (env.DSH_PORT) return new URL('http://127.0.0.1:' + env.DSH_PORT).origin;
+  return new URL('http://127.0.0.1:3080').origin;
+}
+
+export function originOf(url) {
+  try { return new URL(url).origin; } catch { return null; }
+}
+
+export async function connect(argv = []) {
+  const { base, reg } = await resolveDsiBase({ env: process.env });
+  const { session, degraded, note, error } = pickSession(reg.sessions, identityFrom(argv));
+  if (!session) die(error ?? 'no glass session resolved — the operator clicks the Browser chip');
+  if (degraded || note) console.error(JSON.stringify({ warn: note ?? 'degraded', sessionId: session.id }));
+  const browser = await chromium.connectOverCDP('http://127.0.0.1:' + session.port).catch(() => null);
+  if (!browser) die('CDP connect failed on port ' + session.port);
+  const ctx = browser.contexts()[0];
+  const dshOrigin = resolveDshBase(argv, process.env);
+  return { session, browser, ctx, floorBase: base, dshOrigin };
+}
+
+export function pickByOrigin(ctx, origin) {
+  const page = ctx.pages().find((p) => originOf(p.url()) === origin);
+  if (!page) {
+    die('no DSH tab at origin ' + origin + ' in the glass — open ' + origin +
+      ' (or pass --dsh-url/--dsh-port for a second floor); refusing positional guesses (D13)');
+  }
+  return page;
+}

package/.agents/skills/glass-dsh/scripts/gesture.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * gesture.mjs — real-gesture verbs for the glass-dsh skill (Gates 3–5, D15).
+ * Real mouse/keyboard only: synthetic dispatchEvent is not verification.
+ * One verb per process; each prints {before, after, moved|delta} JSON.
+ * Run from any cwd (D16: the driver resolves its own playwright-core).
+ *
+ * Verbs:
+ *   click <selector>            real click (raises interception as an error, never force-clicks)
+ *   type <selector> <text>      real click into the element + page.keyboard.type
+ *   drag <selector> <dx> <dy>   real mouse down → 10 stepped moves with waits → up, on the element's box
+ *   control <js-expr>           control gate: evaluate an assertion expression → {pass, result}
+ *   persist <localStorageKey>   read a store key from the DSH tab → {raw}
+ *   run <steps.json>            D17 composite: ONE process + ONE CDP session executes a JSON
+ *                               array of steps ({verb, …args, label?}) in order, printing one
+ *                               verdict per step (same shapes as the single verbs) and stopping
+ *                               at the first failed gate — control pass:false, a moved:false on
+ *                               a gesture, or any die() — reporting the completed prefix.
+ *                               Exit 1 when a step failed, 0 otherwise (D11 stop-loss, batched).
+ *
+ * Flags: --dsh-url|--dsh-port|--owner-session (see _connect.mjs); --substr <s> selects a tab by URL
+ * substring for reads (never positional, D10); input verbs always target the DSH-origin tab.
+ */
+import { readFileSync } from 'node:fs';
+import { connect, pickByOrigin, originOf, die } from './_connect.mjs';
+
+const argv = process.argv.slice(2);
+const verb = argv[0];
+function opt(name) {
+  const i = argv.indexOf(name);
+  return i !== -1 ? argv[i + 1] : undefined;
+}
+const substr = opt('--substr');
+
+const { ctx, dshOrigin } = await connect(argv);
+function page() {
+  if (substr) {
+    const p = ctx.pages().find((p) => p.url().includes(substr));
+    if (!p) die('no tab whose URL contains ' + JSON.stringify(substr));
+    return p;
+  }
+  return pickByOrigin(ctx, dshOrigin);
+}
+
+async function readHostPos(p, sel) {
+  return p.evaluate((s) => {
+    const el = document.querySelector(s);
+    if (!el) return null;
+    const host = el.closest('[style*="left"]') ?? el;
+    return { x: host.style.left, y: host.style.top };
+  }, sel);
+}
+
+/**
+ * Execute one step; returns { ok, verdict }. Verdict shapes are byte-identical
+ * to the single-verb shapes (D17 — additive composition only).
+ */
+async function execStep(p, step) {
+  const v = step.verb;
+  try {
+    if (v === 'click') {
+      const sel = step.selector;
+      if (!sel) return { ok: false, verdict: { error: 'click needs a selector' } };
+      const before = await p.evaluate((s) => !!document.querySelector(s), sel);
+      await p.locator(sel).first().click(); // locator.click raises interception loudly (no force)
+      return { ok: true, verdict: { verb: 'click', selector: sel, before, after: true, moved: before !== true } };
+    }
+    if (v === 'type') {
+      const sel = step.selector, text = step.text;
+      if (!sel || text === undefined) return { ok: false, verdict: { error: 'type needs selector + text' } };
+      const loc = p.locator(sel).first();
+      await loc.click();
+      await p.keyboard.type(text);
+      const after = await loc.inputValue().catch(() => undefined);
+      return { ok: after === text, verdict: { verb: 'type', selector: sel, before: '', after, moved: after === text } };
+    }
+    if (v === 'drag') {
+      const sel = step.selector, dx = Number(step.dx), dy = Number(step.dy);
+      if (!sel || !Number.isFinite(dx) || !Number.isFinite(dy)) {
+        return { ok: false, verdict: { error: 'drag needs selector + finite dx/dy' } };
+      }
+      const posBefore = await readHostPos(p, sel);
+      if (!posBefore) return { ok: false, verdict: { error: 'no element for ' + sel } };
+      const box = await p.locator(sel).first().boundingBox();
+      if (!box) return { ok: false, verdict: { error: 'boundingBox failed for ' + sel } };
+      const sx = box.x + box.width / 2, sy = box.y + Math.min(box.height / 2, 8);
+      await p.mouse.move(sx, sy);
+      await p.mouse.down();
+      for (let i = 1; i <= 10; i++) {
+        await p.mouse.move(sx + (dx * i) / 10, sy + (dy * i) / 10);
+        await new Promise((r) => setTimeout(r, 20));
+      }
+      await p.mouse.up();
+      await new Promise((r) => setTimeout(r, 300));
+      const posAfter = await readHostPos(p, sel);
+      const moved = JSON.stringify(posBefore) !== JSON.stringify(posAfter);
+      return { ok: moved, verdict: { verb: 'drag', selector: sel, before: posBefore, after: posAfter, moved } };
+    }
+    if (v === 'control') {
+      const expr = step.expr;
+      if (!expr) return { ok: false, verdict: { error: 'control needs a JS assertion expression' } };
+      const result = await p.evaluate('!!(' + expr + ')');
+      return { ok: result === true, verdict: { verb: 'control', expr, pass: result === true, result } };
+    }
+    if (v === 'persist') {
+      const key = step.key;
+      if (!key) return { ok: false, verdict: { error: 'persist needs a localStorage key' } };
+      const raw = await p.evaluate((k) => window.localStorage.getItem(k), key);
+      return { ok: true, verdict: { verb: 'persist', key, raw } };
+    }
+    return { ok: false, verdict: { error: 'unknown step verb ' + JSON.stringify(v) + ' — click | type | drag | control | persist' } };
+  } catch (e) {
+    return { ok: false, verdict: { error: String(e?.message ?? e) } };
+  }
+}
+
+if (verb === 'run') {
+  const file = argv[1];
+  if (!file) die('run needs a steps.json path');
+  let steps;
+  try {
+    steps = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (e) {
+    die('run cannot read steps: ' + String(e?.message ?? e));
+  }
+  if (!Array.isArray(steps)) die('run steps must be a JSON array of {verb, …}');
+  const p = page();
+  const results = [];
+  let failedAt = null;
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const { ok, verdict } = await execStep(p, step);
+    results.push({ label: step.label ?? (step.verb + '#' + i), ok, ...verdict });
+    if (!ok) { failedAt = i; break; }
+  }
+  console.log(JSON.stringify({
+    verb: 'run', steps: steps.length, executed: results.length,
+    failedAt, ok: failedAt === null, results,
+  }));
+  process.exit(failedAt === null ? 0 : 1);
+} else if (verb === 'click') {
+  const sel = argv[1];
+  if (!sel) die('click needs a selector');
+  const { verdict } = await execStep(page(), { verb: 'click', selector: sel });
+  if (verdict.error) die(verdict.error);
+  console.log(JSON.stringify(verdict));
+} else if (verb === 'type') {
+  const sel = argv[1], text = argv[2];
+  if (!sel || text === undefined) die('type needs <selector> <text>');
+  const { verdict } = await execStep(page(), { verb: 'type', selector: sel, text });
+  console.log(JSON.stringify(verdict));
+} else if (verb === 'drag') {
+  const sel = argv[1], dx = Number(argv[2]), dy = Number(argv[3]);
+  if (!sel || !Number.isFinite(dx) || !Number.isFinite(dy)) die('drag needs <selector> <dx> <dy>');
+  const { verdict } = await execStep(page(), { verb: 'drag', selector: sel, dx, dy });
+  console.log(JSON.stringify(verdict));
+} else if (verb === 'control') {
+  const expr = argv[1];
+  if (!expr) die('control needs a JS assertion expression');
+  const { verdict } = await execStep(page(), { verb: 'control', expr });
+  console.log(JSON.stringify(verdict));
+} else if (verb === 'persist') {
+  const key = argv[1];
+  if (!key) die('persist needs a localStorage key');
+  const { verdict } = await execStep(page(), { verb: 'persist', key });
+  console.log(JSON.stringify(verdict));
+} else {
+  die('unknown verb ' + JSON.stringify(verb) + ' — click | type | drag | control | persist | run');
+}
+process.exit(0);

package/.agents/skills/glass-dsh/scripts/glass-dsh.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * glass-dsh.mjs — origin-aware driver verbs for the glass-dsh skill (D13).
+ * Run from the DSI repo root (playwright-core resolves there). One JSON verdict
+ * on stdout; loud die() on refusal (D7/D11).
+ *
+ * Verbs:
+ *   pages                      list CDP pages with origin classification vs the resolved DSH origin
+ *   eval --b64 <b64> [substr]  evaluate base64 JS in the DSH tab (or the tab whose URL contains substr);
+ *                              D10 grammar law: with --b64, a leftover argument IS the substring — never positional
+ *   shot <path>                screenshot of the DSH tab
+ *
+ * Flags: --dsh-url <url> | --dsh-port <n> | --owner-session <id>  (see _connect.mjs)
+ */
+import { connect, pickByOrigin, originOf, die } from './_connect.mjs';
+
+const argv = process.argv.slice(2);
+const verb = argv[0];
+
+function pick(ctx, dshOrigin, substr) {
+  if (substr) {
+    const page = ctx.pages().find((p) => p.url().includes(substr));
+    if (!page) die('no tab whose URL contains ' + JSON.stringify(substr) + ' — refusing positional guesses (D2/D10)');
+    return page;
+  }
+  return pickByOrigin(ctx, dshOrigin);
+}
+
+const { ctx, dshOrigin } = await connect(argv);
+
+if (verb === 'pages') {
+  const pages = ctx.pages().map((p) => ({
+    url: p.url(),
+    origin: originOf(p.url()),
+    isDsh: originOf(p.url()) === dshOrigin,
+  }));
+  console.log(JSON.stringify({ dshOrigin, pages }));
+} else if (verb === 'eval') {
+  const rest = argv.slice(1);
+  const b64 = rest.indexOf('--b64');
+  let expr, substr = undefined;
+  if (b64 !== -1) {
+    expr = Buffer.from(rest[b64 + 1] ?? '', 'base64').toString('utf8');
+    const leftover = rest[b64 + 2];
+    if (leftover) substr = leftover; // D10: leftover argument IS the substring
+  } else {
+    expr = rest[0];
+    if (!expr) die('eval needs inline JS or --b64 <b64> [substr]');
+    substr = rest[1];
+  }
+  const page = pick(ctx, dshOrigin, substr);
+  const result = await page.evaluate(expr);
+  console.log(JSON.stringify({ url: page.url(), result }));
+} else if (verb === 'shot') {
+  const path = argv[1];
+  if (!path) die('shot needs a file path');
+  const page = pickByOrigin(ctx, dshOrigin);
+  await page.screenshot({ path, fullPage: false });
+  console.log(JSON.stringify({ ok: true, path, url: page.url() }));
+} else {
+  die('unknown verb ' + JSON.stringify(verb) + ' — pages | eval --b64 <b64> [substr] | shot <path>');
+}
+process.exit(0);

package/.agents/skills/glass-dsh/scripts/probe-dsh.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/**
+ * probe-dsh.mjs — Gates 0–2 of the glass-dsh skill: console baseline + crash scan.
+ * Reloads the DSH tab, arms a console listener, and emits ONE JSON verdict.
+ * Evidence over presence: `slot entry crashed in '<slot>'` naming the plugin is
+ * an automatic FAIL (D14) even when everything else looks fine.
+ *
+ * Usage (from the DSI repo root):
+ *   node skills/glass-dsh/scripts/probe-dsh.mjs [--expect '<selector>'] [--store '<localStorageKey>']
+ *       [--plugin-id '<plugin id>'] [--dsh-url|--dsh-port|--owner-session]
+ *
+ * Emits: { dshOrigin, url, moduleLoader, expectPresent?, storeRaw?,
+ *          consoleErrors, crashedSlots, pass }
+ * pass=false when a crashedSlot matches --plugin-id (or any crash, if no id given).
+ */
+import { connect, pickByOrigin } from './_connect.mjs';
+
+const argv = process.argv.slice(2);
+function opt(name) {
+  const i = argv.indexOf(name);
+  return i !== -1 ? argv[i + 1] : undefined;
+}
+const expectSel = opt('--expect');
+const storeKey = opt('--store');
+const pluginId = opt('--plugin-id');
+
+const { ctx, dshOrigin } = await connect(argv);
+const page = pickByOrigin(ctx, dshOrigin);
+
+const errors = [];
+const onConsole = (m) => { if (m.type() === 'error') errors.push(m.text().slice(0, 500)); };
+page.on('console', onConsole);
+
+await page.reload({ waitUntil: 'networkidle' }).catch(() => {});
+await new Promise((r) => setTimeout(r, 2500));
+
+const probe = await page.evaluate(({ expectSel, storeKey }) => {
+  const el = expectSel ? document.querySelector(expectSel) : null;
+  return {
+    moduleLoader: typeof window.__ModuleLoader__ !== 'undefined' && typeof window.__ModuleLoader__.load === 'function',
+    expectPresent: expectSel ? !!el : undefined,
+    expectText: el && expectSel ? (el.textContent || '').slice(0, 80) : undefined,
+    storeRaw: storeKey ? window.localStorage.getItem(storeKey) : undefined,
+  };
+}, { expectSel, storeKey });
+
+page.off('console', onConsole);
+
+const crashedSlots = errors
+  .filter((t) => t.includes("slot entry crashed in '"))
+  .map((t) => {
+    const slot = t.split("slot entry crashed in '")[1]?.split("'")[0] ?? '?';
+    return { slot, text: t };
+  });
+const relevant = crashedSlots.filter((c) => !pluginId || c.text.includes(pluginId));
+const pass = relevant.length === 0 && errors.length === 0;
+
+console.log(JSON.stringify({ dshOrigin, url: page.url(), ...probe, consoleErrors: errors, crashedSlots, pass }));
+process.exit(0);

package/README.md

@@ -84,6 +84,12 @@ When it is up, your browser opens the page by itself (default `http://127.0.0.1:
 <img src="https://github.com/mitmplay/dsh-insight/blob/main/docs/images/dsi-insight-5.ws-explorer.png?raw=true"/>
 </details>
 
+<details>
+<summary><strong>Glass browser</strong></summary>
+<p>The Glass browser is a real browser living inside DSI. While you work, agents build and change DSI itself — plugins, panels, settings — and instead of telling you "it's done", they can prove it: the work runs right there in the Glass panel, and you watch it live. If a plugin breaks, you see exactly what broke with your own eyes instead of trusting a green test report — the browser is the receipt.</p>
+<img src="https://raw.githubusercontent.com/mitmplay/dsh-insight/refs/heads/main/docs/images/dsi-insight-3.glass-browser.png"/>
+</details>
+
 ## Included skills for:
 - Coding agents: `/dsi-adr`, `/dsi-spec`, `/dsi-task`
 - Integration helper for [OpenViking](https://openviking.ai/): `/dsi-ov-setup` 
@@ -164,4 +170,4 @@ DSI_PORT=5171 DSH_PORT=3081 GLASS_CHASSIS_URL=http://192.168.1.9:9525 pnpm dsi d
 [Apache-2.0](LICENSE) — Copyright © 2026 [Widi Harsojo](https://www.linkedin.com/in/wharsojo/)
 > OPEN TO WORK (SG_PR)
 
-**Your language.** The interface speaks English, Chinese, Indonesian & Spanish.
+**Your language.** The interface speaks English, Chinese, Indonesian & Spanish.