@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.34

package/plugins/desktop/index.mjs

@@ -0,0 +1,10 @@
+import { apply as customSettings } from '../custom/desktop-host.mjs';
+import { apply as browserPreview } from '../browser/desktop-host.mjs';
+import { apply as providerAccounts } from '../providers/desktop-host.mjs';
+
+export const inject = ['agents', 'commands'];
+export function apply(ctx) {
+  customSettings(ctx);
+  browserPreview(ctx);
+  providerAccounts(ctx);
+}

package/plugins/desktop/shell-environment.mjs

@@ -0,0 +1,9 @@
+import { delimiter } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const bin = fileURLToPath(new URL('../../bin/', import.meta.url));
+
+/** Only DSCODE's copied shell providers receive the bundled helper directory. */
+export function desktopShellEnvironment(environment = process.env) {
+  return { PATH: bin + delimiter + (environment.PATH ?? '') };
+}

package/plugins/desktop-workspace/hooks.mjs

@@ -0,0 +1,29 @@
+import { apply as applyHooks } from '@deepseek-ai/dsh-hooks-codex';
+
+/** Reuse the native hook protocol while binding registrations to one Agent. */
+export async function mountWorkspaceHooks(agentContext, configPath, creation) {
+  await agentContext.plugin({
+    name: 'dscode-workspace-hooks',
+    inject: ['shell', 'sessionProjections'],
+    async apply(scope) {
+      let sessionStart;
+      // Hooks are mounted during agent/created, after that dispatch collected
+      // its listeners. Invoke only the newly registered SessionStart callback;
+      // re-emitting agent/created would repeat unrelated lifecycle handlers.
+      applyHooks({
+        shell: scope.shell,
+        sessionProjections: scope.sessionProjections,
+        logger: scope.logger,
+        effect: scope.effect.bind(scope),
+        on(event, listener, ...options) {
+          if (event === 'agent/created') {
+            sessionStart = listener;
+            return () => {};
+          }
+          return scope.on(event, listener, ...options);
+        },
+      }, { configPath, defaultTimeoutMs: 10000, stderrSummaryMaxChars: 500 });
+      await sessionStart?.(creation);
+    },
+  });
+}

package/plugins/desktop-workspace/index.mjs

@@ -0,0 +1,37 @@
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import * as Instructions from '@deepseek-ai/dsh-agent-instructions';
+import * as FilesystemSkills from '@deepseek-ai/dsh-skill-filesystem';
+import { ancestorSkillDirs, writeWorkspaceInstructions } from '../tui-tools/workspace-discovery.mjs';
+import { writeHookConfig } from '../tui-tools/hook-sources.mjs';
+import { mountWorkspaceHooks } from './hooks.mjs';
+
+export const name = 'dscode-desktop-workspace';
+export const inject = ['agents', 'agentPresets', 'skills', 'sessionProjections', 'shell'];
+
+/** Session-owned discovery; Desktop's process cwd is not a workspace identity. */
+export function apply(ctx) {
+  const stateDir = resolveDshHome();
+  mkdirSync(join(stateDir, 'config'), { recursive: true });
+  const installationHooks = join(stateDir, 'config/hooks.local.json');
+  if (!existsSync(installationHooks)) writeFileSync(installationHooks, '{"hooks":{}}\n', { mode: 0o600, flag: 'wx' });
+  ctx.on('agent/created', async payload => {
+    const { agent } = payload;
+    if (ctx.agentPresets.composedPreset(agent.ctx) !== 'dscode') return;
+    const cwd = agent.session.header.cwd;
+    if (!cwd) throw Error('DSCODE Desktop sessions require a workspace directory');
+    const home = homedir();
+    const key = createHash('sha256').update(JSON.stringify([agent.session.id, resolve(cwd)])).digest('hex');
+    const directory = join(stateDir, 'desktop-workspaces', key);
+    const outputDir = join(directory, 'instructions');
+    const instructionHome = writeWorkspaceInstructions({ cwd, home, stateDir, outputDir }) ?? stateDir;
+    agent.ctx.effect(() => () => rmSync(directory, { recursive: true, force: true }));
+    await agent.ctx.plugin(Instructions, { dshHome: instructionHome, maxBytes: 65536 });
+    await agent.ctx.plugin(FilesystemSkills, { customSkillDirs: ancestorSkillDirs({ cwd, home }) });
+    const hooks = writeHookConfig({ root: stateDir, cwd, home: directory });
+    await mountWorkspaceHooks(agent.ctx, hooks.path, payload);
+  });
+}

package/plugins/dscode/board.mjs

@@ -0,0 +1,260 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { scopeChainOf } from '@deepseek-ai/dsh-scope';
+
+export const COLUMNS = ['pending', 'running', 'verifying', 'complete'];
+export const PRIORITIES = ['high', 'normal', 'low'];
+const MAX_TASKS = 50;
+const rank = task => PRIORITIES.indexOf(task.priority ?? 'normal');
+const order = (a, b) => (a.urgency ?? rank(a)) - (b.urgency ?? rank(b)) || Number(a.id.slice(1)) - Number(b.id.slice(1));
+
+/**
+ * Each open task's effective rank: its own priority or that of any open task that
+ * (transitively) waits on it, whichever is higher, so work that unblocks a
+ * high-priority task is launched first.
+ */
+export function urgency(tasks) {
+  const open = tasks.filter(task => task.stage !== 'complete');
+  const dependents = new Map(open.map(task => [task.id, []]));
+  for (const task of open) for (const id of task.dependsOn ?? []) dependents.get(id)?.push(task);
+  const memo = new Map();
+  const visit = (task, seen) => {
+    if (memo.has(task.id)) return memo.get(task.id);
+    let best = rank(task);
+    for (const next of dependents.get(task.id) ?? []) if (!seen.has(next.id)) best = Math.min(best, visit(next, new Set([...seen, next.id])));
+    memo.set(task.id, best);
+    return best;
+  };
+  return new Map(open.map(task => [task.id, visit(task, new Set([task.id]))]));
+}
+const priority = value => {
+  if (value === undefined) return 'normal';
+  if (!PRIORITIES.includes(value)) throw new Error(`priority must be one of ${PRIORITIES.join(', ')}`);
+  return value;
+};
+const text = (value, label, max) => {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${label} is required`);
+  if (value.length > max) throw new Error(`${label} exceeds ${max} characters`);
+  return value.trim();
+};
+
+// One delegate board per root session. A task is stored as pending, launched or
+// complete; running and verifying are read from the child agent, so the board
+// cannot drift from what the children are actually doing. A pending task is
+// ready once every task it depends on is complete, and blocked until then.
+export class DelegateBoard {
+  constructor({ root, childName = /^[A-Za-z](?:[A-Za-z0-9_]{0,8}[A-Za-z])?$/ }) {
+    this.root = root; this.childName = childName; this.boards = new Map(); this.listeners = new Set();
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+  }
+  path(sessionId) { return join(this.root, createHash('sha256').update(sessionId).digest('hex').slice(0, 32) + '.json'); }
+  load(sessionId) {
+    if (!this.boards.has(sessionId)) {
+      let tasks = [];
+      try { tasks = JSON.parse(readFileSync(this.path(sessionId), 'utf8')).tasks ?? []; } catch { /* No board yet. */ }
+      this.boards.set(sessionId, { tasks });
+    }
+    return this.boards.get(sessionId);
+  }
+  save(sessionId) {
+    const path = this.path(sessionId), tmp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ version: 1, sessionId, tasks: this.load(sessionId).tasks }), { mode: 0o600 });
+    renameSync(tmp, path);
+    for (const listener of this.listeners) try { listener(sessionId); } catch { /* A viewer must not break the board. */ }
+  }
+  onChange(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+  task(sessionId, id) {
+    const found = this.load(sessionId).tasks.find(task => task.id === id);
+    if (!found) throw new Error(`Unknown task ${id}`);
+    return found;
+  }
+  checkName(sessionId, name, except) {
+    if (typeof name !== 'string' || !this.childName.test(name)) throw new Error('child name must be 1-10 characters of letters, digits or underscores, starting and ending with a letter');
+    if (this.load(sessionId).tasks.some(task => task !== except && task.stage !== 'complete' && task.child === name)) throw new Error(`child name /${name} is already planned for an open task`);
+    return name;
+  }
+  /** Task ids for `depends_on` entries, each a task id (t3) or a planned child name, open tasks first. */
+  resolve(tasks, refs, self) {
+    if (refs === undefined) return [];
+    if (!Array.isArray(refs)) throw new Error('depends_on must be an array of task ids or child names');
+    const ids = [];
+    for (const ref of refs) {
+      const found = tasks.find(task => task.id === ref)
+        ?? tasks.find(task => task.stage !== 'complete' && task.child === ref)
+        ?? tasks.findLast(task => task.child === ref);
+      if (!found) throw new Error(`depends_on names no task: ${ref}`);
+      if (found === self) throw new Error(`${self.id} cannot depend on itself`);
+      if (!ids.includes(found.id)) ids.push(found.id);
+    }
+    return ids;
+  }
+  /** Reject a dependency cycle, naming it. */
+  acyclic(tasks) {
+    const byId = new Map(tasks.map(task => [task.id, task]));
+    const state = new Map();
+    const visit = (task, path) => {
+      if (state.get(task.id) === 'done') return;
+      if (state.get(task.id) === 'active') throw new Error(`dependency cycle: ${[...path, task.id].join(' → ')}`);
+      state.set(task.id, 'active');
+      for (const id of task.dependsOn ?? []) if (byId.has(id)) visit(byId.get(id), [...path, task.id]);
+      state.set(task.id, 'done');
+    };
+    for (const task of tasks) visit(task, []);
+  }
+  add(sessionId, items) {
+    const board = this.load(sessionId);
+    if (!Array.isArray(items) || !items.length) throw new Error('tasks must be a non-empty array');
+    if (board.tasks.length + items.length > MAX_TASKS) throw new Error(`a board holds at most ${MAX_TASKS} tasks`);
+    let next = board.tasks.reduce((max, task) => Math.max(max, Number(task.id.slice(1))), 0);
+    const added = [];
+    for (const item of items) {
+      const task = { id: `t${++next}`, title: text(item?.title, 'title', 120), stage: 'pending', priority: priority(item?.priority), updatedAt: Date.now() };
+      task.child = this.checkName(sessionId, item?.child, task);
+      if (added.some(other => other.child === task.child)) throw new Error(`child name /${task.child} is used twice`);
+      if (item.detail !== undefined) task.detail = text(item.detail, 'detail', 2000);
+      added.push(task);
+    }
+    // Dependencies may name tasks of the same batch, so they resolve once every id exists.
+    const all = [...board.tasks, ...added];
+    items.forEach((item, index) => { added[index].dependsOn = this.resolve(all, item.depends_on, added[index]); });
+    this.acyclic(all);
+    board.tasks.push(...added);
+    this.save(sessionId);
+    return added;
+  }
+  /** Change a pending task's priority or dependencies. */
+  update(sessionId, id, { priority: nextPriority, depends_on: refs }) {
+    const board = this.load(sessionId);
+    const task = this.task(sessionId, id);
+    if (task.stage !== 'pending') throw new Error(`Task ${id} is ${task.stage}; only a pending task can be re-planned`);
+    const updated = { ...task,
+      ...(nextPriority === undefined ? {} : { priority: priority(nextPriority) }),
+      ...(refs === undefined ? {} : { dependsOn: this.resolve(board.tasks, refs, task) }),
+    };
+    this.acyclic(board.tasks.map(current => current === task ? updated : current));
+    Object.assign(task, updated, { updatedAt: Date.now() });
+    this.save(sessionId);
+    return task;
+  }
+  /** Dependencies of `task` that are not complete yet. */
+  blockers(sessionId, task) {
+    const tasks = this.load(sessionId).tasks;
+    return (task.dependsOn ?? []).filter(id => tasks.find(other => other.id === id)?.stage !== 'complete');
+  }
+  /** Why launching `child` must wait, or undefined when its task is ready or it has none. */
+  launchBlocked(sessionId, child) {
+    const task = this.load(sessionId).tasks.find(t => t.stage === 'pending' && t.child === child);
+    const waits = task ? this.blockers(sessionId, task) : [];
+    return waits.length ? `Task ${task.id} /${child} depends on ${waits.join(', ')}, which ${waits.length === 1 ? 'is' : 'are'} not complete yet. Launch a ready task instead, or change the plan with delegate_board update.` : undefined;
+  }
+  /** A subagent started under a pending task's planned name takes that task. */
+  launched(sessionId, child, subagentId, worktree) {
+    const task = this.load(sessionId).tasks.find(t => t.stage === 'pending' && t.child === child);
+    if (!task) return undefined;
+    Object.assign(task, { stage: 'launched', subagentId, waiting: false, updatedAt: Date.now(), ...(worktree ? { worktree } : {}) });
+    this.save(sessionId);
+    return task;
+  }
+  /** Questions from a child keep its task running until the parent answers. */
+  waiting(sessionId, subagentId, value) {
+    const task = this.load(sessionId).tasks.find(t => t.stage === 'launched' && t.subagentId === subagentId);
+    if (!task || task.waiting === value) return;
+    Object.assign(task, { waiting: value, updatedAt: Date.now() });
+    this.save(sessionId);
+  }
+  complete(sessionId, id, verification) {
+    const task = this.task(sessionId, id);
+    if (task.stage !== 'launched') throw new Error(`Task ${id} is ${task.stage}; only a launched task can be completed after verification`);
+    Object.assign(task, { stage: 'complete', verification: text(verification, 'verification', 2000), waiting: false, updatedAt: Date.now() });
+    this.save(sessionId);
+    return task;
+  }
+  reopen(sessionId, id, reason, child) {
+    const task = this.task(sessionId, id);
+    if (task.stage === 'pending') throw new Error(`Task ${id} is already pending`);
+    const name = this.checkName(sessionId, child === undefined ? task.child : child, task);
+    const note = text(reason, 'reason', 2000);
+    delete task.subagentId; delete task.verification; delete task.worktree;
+    Object.assign(task, { stage: 'pending', child: name, note, waiting: false, updatedAt: Date.now() });
+    this.save(sessionId);
+    return task;
+  }
+  /** Remove a task; tasks that depended on it no longer wait for it. */
+  drop(sessionId, id) {
+    const board = this.load(sessionId);
+    const task = this.task(sessionId, id);
+    board.tasks.splice(board.tasks.indexOf(task), 1);
+    const released = [];
+    for (const other of board.tasks) {
+      if (!other.dependsOn?.includes(id)) continue;
+      other.dependsOn = other.dependsOn.filter(dep => dep !== id);
+      released.push(other.id);
+    }
+    this.save(sessionId);
+    return { task, released };
+  }
+  clear(sessionId) { this.load(sessionId).tasks = []; this.save(sessionId); }
+  /** Tasks grouped by column; `status(subagentId)` is the child agent's live status. */
+  view(sessionId, status) {
+    const columns = Object.fromEntries(COLUMNS.map(column => [column, []]));
+    const tasks = this.load(sessionId).tasks;
+    const urgent = urgency(tasks);
+    for (const task of tasks) {
+      const column = task.stage === 'launched' ? (status(task.subagentId) === 'running' || task.waiting ? 'running' : 'verifying') : task.stage;
+      columns[column].push({ ...task, priority: task.priority ?? 'normal', column, ...(urgent.has(task.id) ? { urgency: urgent.get(task.id) } : {}), ...(column === 'pending' ? { blockedBy: this.blockers(sessionId, task) } : {}) });
+    }
+    // Verify what unblocks the most urgent work first, too.
+    columns.verifying.sort(order);
+    // Pending runs in launch order: ready before blocked, then by effective priority and id.
+    columns.pending.sort((a, b) => Number(a.blockedBy.length > 0) - Number(b.blockedBy.length > 0) || order(a, b));
+    return columns;
+  }
+}
+
+/** One-paragraph board state for the coordinator's next step; empty when nothing is open. */
+export function boardSummary(columns, { running, limit }) {
+  const open = columns.pending.length + columns.running.length + columns.verifying.length;
+  if (!open) return '';
+  const all = COLUMNS.flatMap(column => columns[column]);
+  const byId = new Map(all.map(task => [task.id, task]));
+  const inherited = task => task.urgency !== undefined && task.urgency < PRIORITIES.indexOf(task.priority ?? 'normal');
+  const name = task => `${task.id} /${task.child}${task.priority && task.priority !== 'normal' ? ` [${task.priority}]` : ''}${inherited(task) ? ` [${PRIORITIES[task.urgency]} via its dependents]` : ''}`;
+  const list = tasks => tasks.map(task => `${name(task)}${task.waiting ? ' (asked you a question)' : ''}`).join(', ') || 'none';
+  const ready = columns.pending.filter(task => !task.blockedBy?.length);
+  const blocked = columns.pending.filter(task => task.blockedBy?.length);
+  const free = Math.max(0, limit - running);
+  // A ready task with dependencies starts from their verified changes: name where they are.
+  const inputs = ready.filter(task => task.dependsOn?.length).map(task => `${task.id} builds on ${task.dependsOn.map(id => `${id} (${byId.get(id)?.worktree ?? 'worktree unknown'})`).join(', ')}`);
+  const parts = [
+    `Delegate board. Ready to launch, in order: ${list(ready)}.`,
+    blocked.length ? ` Blocked: ${blocked.map(task => `${name(task)} waits on ${task.blockedBy.join(', ')}`).join('; ')}.` : '',
+    ` Running: ${list(columns.running)}. Verifying: ${list(columns.verifying)}. Complete: ${columns.complete.length}.`,
+    ` Child slots: ${running} of ${limit} running, ${free} free.`,
+    ready.length && free ? ` Launch the first ${Math.min(free, ready.length)} ready ${Math.min(free, ready.length) === 1 ? 'task' : 'tasks'} now, in the order above, each with subagent named as planned and worktree: true.` : '',
+    inputs.length ? ` ${inputs.join('; ')}: tell each such child to bring those changes in first, as the protocol describes.` : '',
+    !ready.length && blocked.length && !columns.running.length && !columns.verifying.length ? ' Every pending task is blocked and nothing is in flight: fix the plan with delegate_board update or drop.' : '',
+    columns.verifying.length ? ' Verify each verifying task in its worktree, then record the outcome with delegate_board complete (with the evidence) or reopen, or send the child fixes. Verify tasks that others depend on first.' : '',
+    columns.running.some(task => task.waiting) ? ' Answer the children waiting on you.' : '',
+  ];
+  return parts.join('');
+}
+
+// Readers share the owning policy's live board, including its cache. Sources
+// belong to their policy scope, which may be a standing preset or one Agent.
+const sources = new Map();
+export function setBoardSource(next, scope) {
+  sources.set(scope, next);
+  return () => { if (sources.get(scope) === next) sources.delete(scope); };
+}
+/** `{ columns, running, limit }` for a root session, or undefined when no board source is mounted. */
+export function delegateBoardFor(sessionId, scope) {
+  if (scope !== undefined) {
+    for (const owner of scopeChainOf(scope)) if (sources.has(owner)) return sources.get(owner)(sessionId);
+    return sources.get(undefined)?.(sessionId);
+  }
+  for (const [owner, read] of sources) {
+    if (owner?.session?.id !== undefined && owner.session.id !== sessionId) continue;
+    const value = read(sessionId); if (value) return value;
+  }
+}

package/plugins/dscode/child-target.mjs

@@ -0,0 +1,11 @@
+const targets = new Map();
+
+/** Keep name resolution out of the runtime's immutable tool-call arguments. */
+export async function withChildTarget(exec, target, next) {
+  const key = exec.token ?? exec;
+  targets.set(key, target);
+  try { return await next(); }
+  finally { targets.delete(key); }
+}
+
+export function childTarget(exec) { return targets.get(exec.token ?? exec) ?? exec.arguments.agent_id; }

package/plugins/dscode/control.mjs

@@ -0,0 +1,17 @@
+import { apply as nativeControl } from '@deepseek-ai/dsh-tool-subagent-control';
+import { childTarget } from './child-target.mjs';
+
+export const inject = ['tools', 'subagents'];
+export function apply(ctx) {
+  nativeControl({ subagents: ctx.subagents, tools: { register(tool) {
+    const execute = tool.execute;
+    // Retain the native definition identity, including its non-enumerable
+    // adjacent-agent messaging marker and its result schema/presentation.
+    tool.execute = (args, exec) => {
+      const target = childTarget(exec);
+      if (typeof target === 'string' && target.startsWith('/')) throw Error('The DSCODE child-name policy is unavailable for this call.');
+      return execute({ ...args, agent_id: target }, exec);
+    };
+    return ctx.tools.register(tool);
+  } } });
+}

package/plugins/dscode/desktop-client.mjs

@@ -0,0 +1,55 @@
+globalThis.__ModuleLoader__.load({
+  id: '@toddzheng024/dscode-desktop',
+  factory: require => {
+    const { createElement: h, useState, useEffect, useRef } = require('react');
+    const columns = [['pending', 'Pending'], ['running', 'Running'], ['verifying', 'Verifying'], ['complete', 'Complete']];
+    const control = { padding: '7px 10px', border: '1px solid #8886', borderRadius: 6, background: 'transparent', color: 'inherit', font: 'inherit' };
+    function Board({ execute }) {
+      const [state, setState] = useState(null), [error, setError] = useState('');
+      const active = useRef(false), alive = useRef(true);
+      const refresh = async () => {
+        if (active.current) return; active.current = true;
+        try { const next = await execute(); if (alive.current) { setState(next); setError(''); } }
+        catch (error) { if (alive.current) { setState(null); setError(error.message); } }
+        finally { active.current = false; }
+      };
+      useEffect(() => { alive.current = true; void refresh(); const timer = setInterval(refresh, 1000);
+        return () => { alive.current = false; clearInterval(timer); }; }, []);
+      const card = (task, column) => h('li', { key: task.id, style: { listStyle: 'none', border: '1px solid #8885', borderRadius: 6, padding: 10, marginTop: 8, overflowWrap: 'anywhere' } },
+        h('strong', null, `${task.id} · ${task.title}`),
+        h('p', { style: { margin: '6px 0', fontSize: 12 } }, `/${task.child} · ${task.priority} priority`),
+        task.waiting && h('p', null, 'Waiting for the coordinator’s answer'),
+        task.blockedBy.length > 0 ? h('p', null, `Blocked by ${task.blockedBy.join(', ')}`) : column === 'pending' && h('p', null, 'Ready to launch'),
+        column === 'verifying' && h('p', null, 'Awaiting coordinator verification'),
+        task.dependsOn.length > 0 && h('p', { style: { fontSize: 12 } }, `Depends on ${task.dependsOn.join(', ')}`),
+        (task.detail || task.note || task.verification || task.worktree) && h('details', null, h('summary', null, 'Task details'),
+          ...[['Scope and checks', task.detail], ['Reopened because', task.note], ['Verification evidence', task.verification], ['Worktree', task.worktree]]
+            .filter(([, value]) => value).map(([label, value]) => h('div', { key: label, style: { marginTop: 8 } }, h('strong', null, label), h('p', { style: { whiteSpace: 'pre-wrap', margin: '4px 0' } }, value)))));
+      return h('section', { 'aria-label': 'DSCODE delegation board', style: { padding: 16, height: '100%', overflow: 'auto', boxSizing: 'border-box' } },
+        h('h2', { style: { marginTop: 0 } }, 'Delegation board'),
+        h('p', { style: { fontSize: 12 } }, 'Use /delegate <task> in the main session to coordinate work in isolated Git worktrees. The coordinator plans tasks and records verified results.'),
+        h('button', { type: 'button', style: control, onClick: refresh }, 'Refresh board'),
+        error && h('p', { role: 'alert' }, error),
+        !state && !error && h('p', { role: 'status' }, 'Loading delegation board…'),
+        state && h('div', null,
+          h('p', { role: 'status' }, `${state.running} of ${state.limit} child slots running`),
+          !columns.some(([key]) => state.columns[key].length) && h('p', null, 'No delegated tasks yet.'),
+          h('div', { style: { display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: 12 } },
+            ...columns.map(([key, label]) => h('section', { key, 'aria-label': label }, h('h3', null, `${label} (${state.columns[key].length})`),
+              state.columns[key].length ? h('ul', { style: { padding: 0, margin: 0 } }, ...state.columns[key].map(task => card(task, key))) : h('p', { style: { fontSize: 12 } }, 'None')))),
+          h('p', { style: { fontSize: 12 } }, 'Refreshes once per second while visible. Reading the board does not launch children, change tasks or merge work.')));
+    }
+    function BoardPane({ sessionId, execute, useTabInfo }) { const { tab } = useTabInfo(); return tab.visible ? h(Board, { key: sessionId, execute }) : null; }
+    const id = '@toddzheng024/dscode-delegation-desktop';
+    return { inject: ['slots', 'sidebarRightTabs', 'connection'], apply(ctx) {
+      ctx.effect(() => ctx.sidebarRightTabs.register({ id, kind: 'dscode-delegation', multiple: false, title: () => 'Delegation board',
+        guide: [{ id: 'open', order: 34, title: () => 'Delegation board', description: () => 'Follow DSCODE delegated tasks, dependencies and verification.' }] }), 'dscode-delegation.type');
+      ctx.effect(() => ctx.slots.inject('sidebar.right.pane.tab', () => ctx.slots.register({ name: 'sidebar.right.pane.tab', key: id,
+        inject: sessionId => ({ sessionId, execute: async () => {
+          const response = await ctx.connection.rpc.call('/api', 'dscode-delegation', { action: 'status', sessionId });
+          if (!response.ok) throw Error(response.error.message); return response.value;
+        } }),
+      }, BoardPane)), 'dscode-delegation.body');
+    } };
+  },
+});

package/plugins/dscode/desktop-host.mjs

@@ -0,0 +1,37 @@
+import { clientRequestSchema } from '@deepseek-ai/dsh-client-connection';
+import { scopeOf } from '@deepseek-ai/dsh-scope';
+import { COLUMNS, delegateBoardFor } from './board.mjs';
+
+export function desktopBoardRequest(ctx, payload) {
+  if (payload?.action !== 'status' || typeof payload.sessionId !== 'string') throw Error('Choose a DSCODE main session to view its delegation board.');
+  const agent = ctx.agents.get(payload.sessionId);
+  if (!agent || ctx.agentPresets.composedPreset(agent.ctx) !== 'dscode' || agent.session.header.origin === 'subagent') {
+    throw Error('The delegation board is available for an open DSCODE main session.');
+  }
+  const board = delegateBoardFor(agent.id, scopeOf(agent.ctx));
+  if (!board) throw Error('The delegation policy is unavailable for this session.');
+  return { sessionId: agent.id, running: board.running, limit: board.limit,
+    columns: Object.fromEntries(COLUMNS.map(column => [column, board.columns[column].map(task => ({
+      id: task.id, title: task.title, child: task.child, priority: task.priority,
+      dependsOn: task.dependsOn ?? [], blockedBy: task.blockedBy ?? [], waiting: task.waiting === true,
+      detail: task.detail ?? '', note: task.note ?? '', verification: task.verification ?? '', worktree: task.worktree ?? '',
+    }))])),
+  };
+}
+
+export const inject = ['agents', 'agentPresets', 'connection'];
+export function apply(ctx) {
+  ctx.effect(() => ctx.connection.fetch.register({ path: '/api/dscode-delegation', methods: ['POST'], requestBody: 'buffered',
+    fetch: async request => {
+      let body;
+      try { body = await request.json(); } catch { return new Response('Invalid JSON', { status: 400 }); }
+      const parsed = clientRequestSchema.safeParse(body);
+      if (!parsed.success || parsed.data.method !== 'dscode-delegation') return new Response('Invalid delegation request', { status: 400 });
+      const { rpcId, payload } = parsed.data;
+      let result;
+      try { result = { ok: true, value: desktopBoardRequest(ctx, payload) }; }
+      catch (error) { result = { ok: false, error: { code: 'dscode-delegation', message: error.message, details: {} } }; }
+      return Response.json({ type: 'server-response', rpcId, result }, { headers: { 'Cache-Control': 'no-store' } });
+    },
+  }), 'dscode delegation rpc');
+}