@toddzheng024/dscode-bundle 0.1.0

package/plugins/session-metrics/index.mjs

@@ -0,0 +1,44 @@
+import { randomUUID } from 'node:crypto';
+import { appendMetric } from './store.mjs';
+import { estimateCost, PRICE_VERSION } from './pricing.mjs';
+import { setMetricSource } from './view.mjs';
+export const name = 'dscode-session-metrics';
+export const inject = ['llm', 'agents', 'tokenMeter', 'sessionProjections'];
+export function apply(ctx) {
+  const snapshots = new WeakMap();
+  ctx.effect(() => setMetricSource(id => {
+    const agent = ctx.agents.get(id);
+    if (!agent) return undefined;
+    const session = agent.session;
+    const cached = snapshots.get(session);
+    if (cached?.seq === session.seq) return cached.value;
+    const state = ctx.sessionProjections.stateOf(session, 'contextPressure');
+    const measurement = ctx.tokenMeter.measure(session);
+    const value = { events: session.snapshotEvents(), used: measurement.totalTokens, capacity: state?.contextWindow };
+    snapshots.set(session, { seq: session.seq, value });
+    return value;
+  }));
+  const home = process.env.DSH_HOME;
+  const record = (id, entry) => { try { appendMetric(home, id, entry); } catch { ctx.logger.warn('Session cost telemetry could not be saved.'); } };
+  ctx.on('llm/stream', async function* (options, next) {
+    if (!options.sessionId || !home) { yield* next(); return; }
+    const id = randomUUID(), time = Date.now();
+    const recipients = new Set([options.sessionId]);
+    let child = ctx.agents.get(options.sessionId);
+    while (child?.session.header.origin === 'subagent' && child.session.header.parentSession && !recipients.has(child.session.header.parentSession)) {
+      recipients.add(child.session.header.parentSession);
+      child = ctx.agents.get(child.session.header.parentSession);
+    }
+    const save = entry => { for (const recipient of recipients) record(recipient, { ...entry, sessionId: options.sessionId }); };
+    save( { kind: 'start', id, time, provider: options.provider, model: options.model, purpose: options.purpose ?? 'agent' });
+    let usage;
+    try {
+      for await (const chunk of next()) {
+        if (chunk.type === 'usage') usage = chunk.usage;
+        yield chunk;
+      }
+    } finally {
+      save({ kind: 'end', id, time, usage: usage ?? null, cost: estimateCost(options.provider, options.model, usage, time), priceVersion: PRICE_VERSION });
+    }
+  });
+}

package/plugins/session-metrics/pricing.mjs

@@ -0,0 +1,18 @@
+// USD per million tokens. Snapshot of the official page opened 2026-09-11.
+// https://api-docs.deepseek.com/quick_start/pricing/
+export const PRICE_SOURCE = 'https://api-docs.deepseek.com/quick_start/pricing/';
+export const PRICE_VERSION = 'deepseek-2026-09-11';
+export function estimateCost(provider, model, usage, time) {
+  if (provider !== 'deepseek-official' || !usage || !Number.isFinite(time)) return null;
+  // Earlier requests require an older price table; never back-price them at today's rate.
+  if (time < Date.UTC(2026, 8, 11)) return null;
+  const flash = ['deepseek-flash', 'deepseek-v4-flash', 'deepseek-v4-flash-vision-exp'].includes(model)
+    || model === 'deepseek-v4-pro' && time >= Date.UTC(2026, 8, 14, 4);
+  if (!flash && model !== 'deepseek-v4-pro') return null;
+  const date = new Date(time), day = date.getUTCDay(), hour = date.getUTCHours();
+  const peak = day >= 1 && day <= 5 && (hour >= 1 && hour < 4 || hour >= 6 && hour < 10);
+  const [read, input, output] = flash ? [0.003, 0.15, 0.6] : [0.022, 0.66, 1.98];
+  const values = [usage.inputTokens, usage.outputTokens, usage.cacheReadTokens ?? 0, usage.cacheWriteTokens ?? 0];
+  if (!values.every(n => Number.isFinite(n) && n >= 0) || values[3] !== 0) return null;
+  return (values[0] * input + values[1] * output + values[2] * read) * (peak ? 2 : 1) / 1e6;
+}

package/plugins/session-metrics/store.mjs

@@ -0,0 +1,24 @@
+import { appendFileSync, mkdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+const cache = new Map();
+export const ledgerPath = (home, id) => join(home, 'session-metrics', createHash('sha256').update(id).digest('hex') + '.jsonl');
+export function appendMetric(home, id, entry) {
+  const path = ledgerPath(home, id);
+  mkdirSync(join(home, 'session-metrics'), { recursive: true, mode: 0o700 });
+  appendFileSync(path, JSON.stringify(entry) + '\n', { mode: 0o600, flush: true });
+}
+export function readMetrics(home, id) {
+  const path = ledgerPath(home, id);
+  try {
+    const st = statSync(path), key = `${st.mtimeMs}:${st.size}`;
+    if (cache.get(path)?.key === key) return cache.get(path).value;
+    let corrupt = false;
+    const rows = readFileSync(path, 'utf8').split('\n').filter(Boolean).flatMap(line => {
+      try { return [JSON.parse(line)]; } catch { corrupt = true; return []; }
+    });
+    const value = { rows, corrupt };
+    cache.set(path, { key, value });
+    return value;
+  } catch (e) { return { rows: [], corrupt: e.code !== 'ENOENT' }; }
+}

package/plugins/session-metrics/view.mjs

@@ -0,0 +1,58 @@
+import { readMetrics } from './store.mjs';
+import { estimateCost } from './pricing.mjs';
+let source;
+export function setMetricSource(next) { source = next; return () => { if (source === next) source = undefined; }; }
+export function summarize(rows, events = [], corrupt = false) {
+  const requests = new Map();
+  let first = Infinity;
+  for (const row of rows) {
+    if (row.kind === 'start') first = Math.min(first, row.time);
+    requests.set(row.id, { ...requests.get(row.id), ...row });
+  }
+  // Backfill old main/compaction calls from the durable log, only before the new ledger.
+  let route = {};
+  const history = [];
+  for (const event of events) {
+    if (event.type === 'request/header') route = event.data.header.config;
+    if (event.time >= first) continue;
+    if (event.type === 'assistant/message' || event.type === 'compaction/summary' && event.data.llmStreamCall) {
+      const r = event.type === 'compaction/summary' ? event.data : route;
+      history.push({ usage: event.data.usage, cost: estimateCost(r.provider, r.model, event.data.usage, event.time), kind: 'end' });
+    } else if (event.type === 'assistant/attempt') history.push({ kind: 'end', cost: null });
+  }
+  let cost = 0, unknown = corrupt || history.length > 0, input = 0, hit = 0, cacheUnknown = false, calls = 0, pending = 0;
+  // Historical overhead (review/title) was not recorded by this collector: mark partial.
+  for (const row of [...history, ...requests.values()]) {
+    calls++;
+    if (row.kind !== 'end') { pending++; continue; }
+    if (!Number.isFinite(row.cost)) unknown = true;
+    else cost += row.cost;
+    const u = row.usage;
+    if (!u || !Number.isFinite(u.inputTokens) || !Number.isFinite(u.outputTokens)) { cacheUnknown = true; continue; }
+    const total = u.inputTokens + (u.cacheReadTokens ?? 0) + (u.cacheWriteTokens ?? 0);
+    input += total; hit += u.cacheReadTokens ?? 0;
+    if (total > 0 && u.cacheReadTokens === undefined) cacheUnknown = true;
+  }
+  return { cost, unknown, calls, pending, cache: input > 0 && !cacheUnknown ? Math.min(100, hit / input * 100) : null };
+}
+export function formatFooter(metrics, context, columns = 80) {
+  const ctx = Number.isFinite(context) ? `${Math.round(context)}%` : '--';
+  const cache = metrics.cache === null ? '--' : `${metrics.cache.toFixed(1)}%`;
+  const dollars = metrics.unknown && metrics.cost === 0 ? '--' : `~$${metrics.cost.toFixed(metrics.cost < 1 ? 4 : 2)}${metrics.unknown ? '+' : ''}${metrics.pending ? '…' : ''}`;
+  const full = `ctx ${ctx} · session ${dollars} · cache ${cache}`;
+  if (full.length <= columns) return full;
+  const short = `ctx ${ctx} $ ${dollars.replace('~$', '~')} hit ${cache}`;
+  if (short.length <= columns) return short;
+  const tiny = `${ctx} ${dollars} ${cache}`;
+  return tiny.length <= columns ? tiny : tiny.slice(0, Math.max(0, columns));
+}
+export function footerFor(id, stats, columns) {
+  try {
+    const data = id ? source?.(id) : undefined;
+    const ledger = id && process.env.DSH_HOME ? readMetrics(process.env.DSH_HOME, id) : { rows: [], corrupt: false };
+    const summary = summarize(ledger.rows, data?.events ?? [], ledger.corrupt);
+    const used = data?.used;
+    const capacity = data?.capacity ?? stats.contextWindow;
+    return formatFooter(summary, Number.isFinite(used) && capacity > 0 ? used / capacity * 100 : undefined, columns);
+  } catch { return formatFooter({ cost: 0, unknown: true, cache: null }, undefined, columns); }
+}

package/plugins/tui-tools/hooks.mjs

@@ -0,0 +1,23 @@
+export const hookEvents = ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop'];
+// Fail visibly instead of letting the upstream compatibility bridge silently skip gates.
+export function validateHooks(raw) {
+  const hooks = raw?.hooks ?? raw;
+  if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) throw new Error('hooks must be an event map');
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!hookEvents.includes(event)) throw new Error(`Unsupported hook event: ${event}`);
+    if (!Array.isArray(groups)) throw new Error(`${event}: expected matcher groups`);
+    for (const group of groups) {
+      if (!group || !Array.isArray(group.hooks)) throw new Error(`${event}: expected hooks array`);
+      if (group.matcher !== undefined) {
+        if (typeof group.matcher !== 'string') throw new Error(`${event}: matcher must be a regex string`);
+        new RegExp(group.matcher);
+      }
+      for (const hook of group.hooks) {
+        if (!hook || (hook.type !== undefined && hook.type !== 'command') || hook.async === true || typeof hook.command !== 'string' || !hook.command.trim()) throw new Error(`${event}: only synchronous command hooks are supported`);
+        const timeout = hook.timeout ?? hook.timeoutSec;
+        if (timeout !== undefined && (!Number.isFinite(timeout) || timeout <= 0 || timeout > 600)) throw new Error(`${event}: timeout must be 0–600 seconds, excluding zero`);
+      }
+    }
+  }
+  return hooks;
+}

package/plugins/tui-tools/index.mjs

@@ -0,0 +1,164 @@
+import { readFile, readdir, access } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { parse } from 'yaml';
+import { hookEvents, validateHooks } from './hooks.mjs';
+import { redact } from '../auto-review/policy.mjs';
+
+export const name = 'dscode-tui-tools';
+export const inject = ['commands', 'agents', 'tools', 'skills', 'permissionPresets'];
+const phases = ['pending', 'loading', 'active', 'failed', 'unavailable', 'unloading'];
+const ok = text => ({ kind: 'success', text });
+const fail = text => ({ kind: 'error', text });
+const show = value => typeof value === 'string' ? value : JSON.stringify(value ?? null);
+const exists = path => access(path).then(() => true, () => false);
+
+export async function findConflicts(cwd, configs, winners, env = process.env) {
+  let project = resolve(cwd);
+  while (!await exists(join(project, '.git')) && dirname(project) !== project) project = dirname(project);
+  if (!await exists(join(project, '.git'))) project = resolve(cwd);
+  const roots = [];
+  const skipSystemRoots = new Set();
+  for (const config of configs) {
+    if (config.includeDefaultRoots !== false) {
+      roots.push(join(project, '.dsh/skills'), join(project, '.agents/skills'));
+      const dshHome = config.dshHome ?? env.DSH_HOME;
+      const agentsHome = config.agentsHome ?? env.DSH_AGENTS_HOME;
+      if (typeof dshHome === 'string') { const path = resolve(dshHome, 'skills'); roots.push(path); skipSystemRoots.add(path); }
+      if (typeof agentsHome === 'string') roots.push(resolve(agentsHome, 'skills'));
+    }
+    roots.push(...(config.customSkillDirs ?? []).filter(x => typeof x === 'string').map(x => resolve(x)));
+    const bundled = config.bundledSkillDir ?? (config.includeDefaultRoots !== false ? env.DSH_BUNDLED_SKILL_DIR : undefined);
+    if (typeof bundled === 'string') roots.push(resolve(bundled));
+  }
+  const candidates = new Map();
+  const errors = [];
+  for (const root of new Set(roots)) {
+    let entries;
+    try { entries = await readdir(root, { withFileTypes: true }); }
+    catch (e) { if (e.code !== 'ENOENT') errors.push(`${root}: ${e.code}`); continue; }
+    for (const entry of entries) {
+      if (entry.name === '.system' && skipSystemRoots.has(root)) continue;
+      const path = entry.isFile() && entry.name.endsWith('.md') ? join(root, entry.name) : join(root, entry.name, 'SKILL.md');
+      try {
+        const raw = await readFile(path, 'utf8');
+        const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+        const meta = match && parse(match[1]);
+        if (typeof meta?.name !== 'string' || typeof meta.description !== 'string') continue;
+        const list = candidates.get(meta.name) ?? [];
+        list.push(path); candidates.set(meta.name, list);
+      } catch (e) { if (!['ENOENT', 'ENOTDIR'].includes(e.code)) errors.push(`${path}: invalid or unreadable`); }
+    }
+  }
+  const lines = [];
+  for (const [name, paths] of candidates) if (paths.length > 1) {
+    const winner = winners.find(s => s.name === name);
+    lines.push(`${name}: effective source=${winner?.source ?? 'not in catalog'} provider=${winner?.provider ?? '?'}\n${paths.map(p => `  ${p}`).join('\n')}`);
+  }
+  return [...lines, ...errors, 'Scope: filesystem roots only; runtime/remote provider shadowed candidates are not exposed by DSH.'].join('\n');
+}
+
+export function apply(ctx) {
+  const entries = () => [...(ctx.get('loader')?.entries() ?? [])].filter(e => e.options.group !== true);
+  const mcps = () => entries().filter(e => e.options.name === '@deepseek-ai/dsh-mcp-client');
+  const hook = () => entries().find(e => e.options.id === 'dscode-hooks');
+  const state = e => e.disabled ? 'disabled' : phases[e.fiber?.state] ?? 'unavailable';
+  let changing = false;
+  const mutate = async fn => {
+    if (changing || ctx.agents.list().some(a => a.status === 'running')) return fail('Wait until all agents are idle before changing process-wide plugins.');
+    changing = true;
+    try { return await fn(); } finally { changing = false; }
+  };
+  const register = (name, description, handler) => ctx.commands.register({ name, description, handler: async inv => {
+    try { const result = await handler(inv); return { ...result, text: redact(result.text ?? '') }; }
+    catch (e) { return fail(redact(`${name}: ${e.message}`)); }
+  }});
+  register('status', 'Session, model, permissions, usage and plugin health', ({ agent }) => {
+    const session = agent.session;
+    const route = session.requestHeader()?.config ?? agent.options;
+    const events = session.snapshotEvents();
+    const projections = ctx.get('sessionProjections');
+    const usage = projections?.stateOf(session, 'tokenUsage')?.totals;
+    const pressure = projections?.stateOf(session, 'contextPressure');
+    return ok([
+      `Session: ${session.id}`, `Workspace: ${session.header.cwd ?? process.cwd()}`,
+      `Agent: ${agent.status} | preset: ${session.header.agentPreset ?? 'standard'}`,
+      `Model: ${route?.provider ?? 'default'} / ${route?.model ?? 'default'}`,
+      `Effort: ${route?.reasoningEffort ?? 'model default'}${route?.reasoningEffort === 'ultra' ? ' (DeepSeek wire: max; collaboration enabled)' : ''}`,
+      `Permission: ${show(ctx.permissionPresets.current(session))}`,
+      `Tokens: ${show(usage ?? 'no provider usage yet')}`,
+      `Context: ${pressure?.pressureTokens ?? pressure?.surfaceTokens ?? '?'} / ${pressure?.contextWindow ?? '?'} tokens`,
+      `Events: ${events.length}; /review-usage shows reviewer tokens`,
+      `Tools: ${ctx.tools.schemas(agent).length}; MCP entries: ${mcps().length}`,
+      `Plugins: ${entries().filter(e => state(e) === 'active').length} active, ${entries().filter(e => state(e) === 'failed').length} failed`,
+      'Use /doctor for diagnostics; /statusline for live context/token display.',
+    ].join('\n'));
+  });
+  register('doctor', 'Read-only runtime diagnostics (no model requests)', async ({ agent, signal }) => {
+    const tools = ctx.tools.schemas(agent).map(t => t.name);
+    const catalog = await ctx.skills.snapshot({ cwd: agent.session.header.cwd, scope: agent, signal });
+    const computer = ctx.get('computerUse');
+    return ok([
+      `Node: ${process.version}; platform: ${process.platform}/${process.arch}`,
+      ...entries().filter(e => !e.disabled && state(e) !== 'active').map(e => `CHECK plugin ${e.id}: ${state(e)}`),
+      `Skills: ${catalog.skills.length}; discovery ${catalog.complete ? 'complete' : 'incomplete'}`,
+      `Core tools: ${['bash', 'skill', 'computer_use_activate'].map(n => `${n}=${tools.includes(n)}`).join(', ')}`,
+      ...mcps().map(e => `MCP ${e.id}: ${state(e)}; ${tools.filter(n => n.startsWith(`mcp__${e.options.config?.serverName}__`)).length} registered tools`),
+      `Computer Use: ${computer ? show(computer.status()) : 'service unavailable'}`,
+      'Credentials and remote model access: not tested. No credential values are read or printed.',
+      'For deterministic execution checks outside this session: npm run doctor (in the installation directory).',
+    ].join('\n'));
+  });
+  register('mcp', 'MCP list, tools <id>, enable/disable/reconnect <id>', async ({ agent, rawInput }) => {
+    const [action = 'list', id, extra] = rawInput.trim().split(/\s+/).filter(Boolean);
+    const list = mcps();
+    if (action === 'list') return ok(list.map(e => `${e.id}: ${state(e)} | server=${show(e.options.config?.serverName)} | transport=${show(e.options.config?.transport)}`).join('\n') + '\n/mcp tools|enable|disable|reconnect <entry-id> — changes last for this process; persist startup config in mcp.local.yml.');
+    const matches = list.filter(e => e.id === id || e.options.id === id);
+    const entry = matches.length === 1 ? matches[0] : undefined;
+    if (!entry || extra) return fail('Usage: /mcp [list | tools|enable|disable|reconnect <entry-id>]');
+    if (action === 'tools') return ok(ctx.tools.schemas(agent).filter(t => t.name.startsWith(`mcp__${entry.options.config?.serverName}__`)).map(t => t.name).join('\n') || 'No tools currently registered.');
+    if (!['enable', 'disable', 'reconnect'].includes(action)) return fail('Unknown MCP action.');
+    return mutate(async () => {
+      if (action === 'reconnect' && entry.disabled) return fail('Enable this server before reconnecting.');
+      if (action === 'reconnect') await entry.update({ disabled: true });
+      await entry.update({ disabled: action === 'disable' });
+      return ok(`${entry.id}: ${state(entry)}. Use /mcp tools ${entry.id} to check discovery.`);
+    });
+  });
+  register('skills', 'Skill catalog, sources, details and filesystem conflicts', async ({ agent, rawInput, signal }) => {
+    const options = { cwd: agent.session.header.cwd ?? process.cwd(), scope: agent, signal };
+    const { skills, complete } = await ctx.skills.snapshot(options);
+    const arg = rawInput.trim();
+    if (arg === 'conflicts') return ok(await findConflicts(options.cwd, entries().filter(e => !e.disabled && e.options.name === '@deepseek-ai/dsh-skill-filesystem').map(e => e.options.config ?? {}), skills));
+    if (arg && arg !== 'list') {
+      const skill = await ctx.skills.get(arg, options);
+      return skill ? ok(`${skill.name}\n${skill.description}\nsource: ${skill.source}\nprovider: ${skill.provider}\npath: ${skill.path ?? '(provider managed)'}\ninvocation: ${show(skill.invocation)}`) : fail(`Unknown skill: ${arg}`);
+    }
+    return ok(`Discovery: ${complete ? 'complete' : 'incomplete'}\n${skills.map(s => `${s.name} [${s.source}; ${s.provider}] user=${s.invocation.userInvocable} model=${s.invocation.modelInvocable}\n  ${s.description}`).join('\n')}\n/skills <name> for details; /skills conflicts for duplicate filesystem names.`);
+  });
+  const hookPaths = new WeakMap();
+  const hookPath = entry => {
+    const path = entry.fiber?.config?.configPath ?? entry.options.config?.configPath;
+    if (typeof path === 'string') { hookPaths.set(entry, path); return path; }
+    const cached = hookPaths.get(entry) ?? ctx.get('dscodePaths')?.hooks;
+    if (typeof cached !== 'string') throw new Error('Hook configuration path has not resolved');
+    return cached;
+  };
+  register('hooks', 'Hook status and reload/disable/enable (installation-owned config)', async ({ rawInput }) => {
+    const entry = hook();
+    if (!entry) return fail('Hooks plugin is not mounted. Restart dscode after setup.');
+    const action = rawInput.trim() || 'list';
+    if (action !== 'list') {
+      if (!['reload', 'disable', 'enable'].includes(action)) return fail('Usage: /hooks [list|reload|disable|enable]');
+      return mutate(async () => {
+        if (action !== 'disable') validateHooks(JSON.parse(await readFile(hookPath(entry), 'utf8')));
+        if (action === 'reload') await entry.update({ disabled: true });
+        await entry.update({ disabled: action === 'disable' });
+        return ok(`Hooks: ${state(entry)}. Configuration changes apply after reload or restart.`);
+      });
+    }
+    const path = hookPath(entry);
+    const raw = JSON.parse(await readFile(path, 'utf8'));
+    const hooks = raw.hooks ?? raw;
+    return ok(`Hooks: ${state(entry)}\nConfig: ${path}\n${Object.entries(hooks).map(([event, groups]) => `${event}: ${hookEvents.includes(event) ? 'supported' : 'UNSUPPORTED'}; ${Array.isArray(groups) ? groups.length : 0} groups`).join('\n')}\nSupported: ${hookEvents.join(', ')}\nOnly synchronous command hooks. Runs as your OS user, outside tool approval. Edit only trusted installation-owned config; /hooks reload applies it. No project hook auto-loading.\nPreCompact/PostCompact, PermissionRequest and subagent events are not supported by this bridge.`);
+  });
+}

package/plugins/ultra/policy.mjs

@@ -0,0 +1,11 @@
+export const ULTRA_POLICY = `DSCODE ULTRA — max reasoning with deliberate collaboration.
+Actively look for useful independent tasks: investigation, implementation in disjoint files, and independent review. Delegate only when it improves the outcome; simple tasks need no child agents. Give each child a bounded objective, relevant context, file ownership and acceptance criteria. Keep useful work for yourself while children run. Never have multiple agents edit the same files concurrently. Shared files are not isolated worktrees.
+In ultra use subagent/subagent_fork and send_message for delegation, not workflow or ralph. Use at most three child agents concurrently across this root session. Do not recursively proliferate agents or duplicate investigations. The parent owns integration, verifies child claims, resolves conflicts and runs appropriate checks. Seek independent review of substantial changes when useful. Parent/child messages are available; sibling direct messaging is not. Preserve the user's permission policy: ultra grants no extra authority. Track progress and costs, reuse findings, and stop delegating when coordination costs outweigh value.`;
+export function ultraRequest(options, messages) {
+  if (options.reasoningEffort !== 'ultra' || options.purpose || !options.tools?.some(t => t.name === 'subagent' || t.name === 'subagent_fork')) return messages;
+  const copy = messages.map(m => ({ ...m }));
+  const system = copy.findLast(m => m.role === 'system' && typeof m.content === 'string');
+  if (system) system.content += '\n\n' + ULTRA_POLICY;
+  else copy.unshift({ role: 'system', content: ULTRA_POLICY });
+  return copy;
+}

package/presets/dscode/agent.cordis.yml

@@ -0,0 +1,288 @@
+# The `dscode` agent preset: the full coding agent, mounted once per process.
+#
+# This file is an AGENT-PLANE composition. The roster mounts it ONCE under a
+# standing scope; every session naming it joins by scope parentage, so the
+# tools and prompt sections registered here cover each joined agent while a
+# session's own state stays keyed per Session/Agent inside the plugins. The
+# host composition (`base.cordis.yml` + `web.cordis.yml`) keeps everything a
+# preset must not own: the registries themselves, the sandbox and approval
+# stack, persistence, and the model route.
+#
+# A service row here MUST sit inside a group carrying an `isolate` realm.
+# Without one it publishes into the root realm, where it is process-global —
+# another preset publishing the same name collides, and a host reader would
+# resolve one preset's instance for every session; `dsh-agent-presets` rejects
+# that at mount. `true` means an entry-local realm: this standing mount's own
+# private instance, apart from every other preset's. (A shared label does NOT
+# pool instances — `provide()` throws on the second registration under the
+# same realm symbol; labels join REALMS, and are not what this file needs.)
+
+# ── identity ────────────────────────────────────────────────────────────────
+
+# The preset's own persona, shadowing the deployment default for this agent.
+# `{{model}}` and `{{cwd}}` resolve from the agent's own route and workspace.
+- id: persona
+  name: '@deepseek-ai/dsh-persona'
+  config:
+    suffix: Your working directory is {{cwd}}.
+    prefix: >-
+      You are a coding agent powered by the {{model}} model. Use the persistent shell for file reading, searching, and editing. Prefer rg and precise patches.
+
+- id: agent-instructions
+  name: '@deepseek-ai/dsh-agent-instructions'
+  config:
+    maxBytes: 65536
+
+- id: persistent-shell
+  name: cordis:group
+  group: true
+  isolate:
+    terminals: true
+  config:
+    - id: pty
+      name: '@deepseek-ai/dsh-terminal'
+
+    - id: terminal-bash
+      name: '@deepseek-ai/dsh-terminal-bash'
+      disabled: !!js process.platform === 'win32'
+      config:
+        timeoutMs: 300000
+
+    - id: persistent-bash
+      name: '@toddzheng024/dscode-bundle/persistent'
+      disabled: !!js process.platform === 'win32'
+      config:
+        timeoutMs: 300000
+        description: |-
+          Run commands in a bash shell
+          * When invoking this tool, the contents of the "command" parameter does NOT need to be XML-escaped.
+          * Network access depends on the task environment. Prefer configured mirrors/proxies when they are available.
+          * State is persistent across command calls and discussions with the user.
+          * To inspect a particular line range of a file, e.g. lines 10-25, try 'sed -n 10,25p /path/to/the/file'.
+          * Please avoid commands that may produce a very large amount of output.
+          * Please run long lived commands in the background, e.g. 'sleep 10 &' or start a server in the background.
+
+    - id: terminal-pwsh
+      name: '@deepseek-ai/dsh-terminal-bash'
+      disabled: !!js process.platform !== 'win32'
+      config:
+        shellDialect: pwsh
+        timeoutMs: 300000
+
+    - id: persistent-pwsh
+      name: '@deepseek-ai/dsh-tool-pwsh-persistent'
+      disabled: !!js process.platform !== 'win32'
+      config:
+        timeoutMs: 300000
+        description: |-
+          Run commands in a PowerShell shell
+          * When invoking this tool, the contents of the "command" parameter does NOT need to be XML-escaped.
+          * You don't have access to the internet via this tool.
+          * State is persistent across command calls and discussions with the user.
+          * Use native Windows paths (C:\...) and $env:NAME variables; this is PowerShell, not bash.
+          * Please avoid commands that may produce a very large amount of output.
+          * Please run long lived commands in the background, e.g. 'Start-Job' or start a server with Start-Process.
+
+    - id: dscode-policy
+      name: '@toddzheng024/dscode-bundle/policy'
+
+# A fresh shell for reviewed escalation. It does not inherit PTY state.
+- id: shell-retry
+  name: '@toddzheng024/dscode-bundle/bash'
+  config:
+    toolName: shell_retry
+
+
+# ── background jobs ────────────────────────────────────────────────────────
+
+# Only the model-facing controls. The task REGISTRY stays on the host plane:
+# its producers sit outside any realm this file could put it in — `tool-bash`
+# above resolves it with `ctx.get`, and an entry-local realm here is invisible
+# to every sibling row, so `run_in_background` would answer "background jobs
+# unavailable" while these controls sat in the catalog. The registry is keyed by
+# owning agent anyway, so one host instance serves every session. What a preset
+# chooses is whether its agent can collect and stop background work at all.
+- id: tool-jobs
+  name: '@deepseek-ai/dsh-tool-jobs'
+
+# ── skills ──────────────────────────────────────────────────────────────────
+
+# The skill REGISTRY lives in the host composition and is layered per scope:
+# these rows register into THIS preset's layer of it, so they need no realm.
+# `skill-filesystem` contributes local-root discovery for agents on this preset, and
+# `tool-skill` gives them the catalog and loader; the merged catalog also
+# carries whatever the deployment registered globally (repository plugins).
+- id: skill-filesystem
+  name: '@deepseek-ai/dsh-skill-filesystem'
+
+- id: tool-skill
+  name: '@deepseek-ai/dsh-tool-skill'
+
+# ── goals ───────────────────────────────────────────────────────────────────
+
+# The goal service and session driver stay on the host plane, where the Gateway
+# can resolve them. The human command and model-facing tool register into this
+# preset's scoped layers.
+- id: command-goal
+  name: '@deepseek-ai/dsh-command-goal'
+
+- id: tool-goal
+  name: '@deepseek-ai/dsh-tool-goal'
+
+# ── plan mode ───────────────────────────────────────────────────────────────
+
+# Plan state is per-agent by nature, so an entry-local realm is not a
+# workaround here — it is the correct lifetime.
+- id: planning
+  name: cordis:group
+  group: true
+  isolate:
+    planMode: true
+  config:
+    - id: plan-mode
+      name: '@deepseek-ai/dsh-plan-mode'
+      config:
+        section: |
+              You are in plan mode. Stay in plan mode until exit_plan_mode succeeds or the user switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.
+
+              Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.
+
+              The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed to keep the tool catalog unchanged. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.
+
+              Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.
+
+              Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.
+
+              When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
+
+# ── compaction ──────────────────────────────────────────────────────────────
+
+# `compaction-basic` reads `toolResultPrune` through `ctx.get`, so the pruner must
+# share this realm rather than sit outside it.
+#
+# `tokenMeter` is deliberately NOT in this realm: the meter stays on the HOST
+# plane, and the rows here resolve that one instance. It takes no configuration,
+# keys every fold by Session, and owns the context-meter projection units the
+# browser reads for every session — behind a realm those units would come and go
+# with whichever presets happen to be mounted. What a preset chooses is whether
+# its agent compacts at all, which is `compaction-basic` below.
+- id: compaction
+  name: cordis:group
+  group: true
+  isolate:
+    compaction: true
+    toolResultPruner: true
+  config:
+    - id: compaction-basic
+      name: '@deepseek-ai/dsh-compaction-basic'
+
+    - id: command-compact
+      name: '@deepseek-ai/dsh-command-compact'
+
+    - id: tool-result-pruner
+      name: '@deepseek-ai/dsh-compaction-tool-result-pruner'
+      config:
+        thresholdChars: 8192
+        headChars: 4096
+        tailChars: 1024
+
+# ── delegation and workflows ────────────────────────────────────────────────
+
+# The `subagents` registry and its spawn/fork backends live in the HOST
+# composition: the registry is a process singleton whose cross-session queries
+# the api-proxy serves to the browser, and a provider name may only be
+# registered once. This preset contributes the delegation TOOLS, which resolve
+# that host registry.
+#
+# `workflows` is different — nothing outside an agent reads it — so every row
+# that reaches it shares one entry-local realm here, and a consumer left
+# outside would resolve a host registry this preset does not populate.
+- id: delegation
+  name: cordis:group
+  group: true
+  isolate:
+    workflowEngine: true
+  config:
+    - id: tool-subagent-control
+      name: '@deepseek-ai/dsh-tool-subagent-control'
+
+    - id: tool-subagent-list-agents
+      name: '@deepseek-ai/dsh-tool-subagent-control/list-agents'
+
+    - id: tool-subagent
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: spawn
+        toolName: subagent
+        modelSelectionSettings: true
+        backgroundMode: continuable
+        maxDepth: 1
+
+    # Fork omits model selection so provider/model stay equal to the parent and
+    # the inherited history remains eligible for KV Cache reuse. This preset
+    # keeps fork continuable; parent and child inherit the same messaging tool,
+    # while the parent id and return guidance follow the inherited history.
+    - id: tool-subagent-fork
+      name: '@deepseek-ai/dsh-tool-subagent'
+      config:
+        provider: fork
+        toolName: subagent_fork
+        backgroundMode: continuable
+        maxDepth: 1
+
+    # Production dsh does not install these optional providers. Install the
+    # matching Bundle in this Profile and restart the Host, then copy this
+    # preset and remove `disabled` from the matching tool row. Host availability
+    # alone grants no tool.
+    - id: tool-subagent-codex
+      name: '@deepseek-ai/dsh-tool-subagent'
+      disabled: true
+      config:
+        provider: codex
+        toolName: subagent_codex
+        backgroundMode: one-shot
+        maxDepth: provider-managed
+
+    - id: tool-subagent-claude-code
+      name: '@deepseek-ai/dsh-tool-subagent'
+      disabled: true
+      config:
+        provider: claude-code
+        toolName: subagent_claude_code
+        backgroundMode: one-shot
+        maxDepth: provider-managed
+
+    - id: workflow-worker-thread
+      name: '@deepseek-ai/dsh-workflow-worker-thread'
+      config:
+        provider: spawn
+
+    - id: tool-workflow
+      name: '@deepseek-ai/dsh-tool-workflow'
+
+    - id: tool-ralph
+      name: '@deepseek-ai/dsh-tool-ralph'
+      config:
+        subagentProvider: spawn
+        maxRounds: 64
+
+# ── remaining model-facing rows ─────────────────────────────────────────────
+
+- id: tool-ask-user
+  name: '@deepseek-ai/dsh-tool-ask-user'
+
+- id: tool-todo
+  name: '@deepseek-ai/dsh-tool-todo'
+  config:
+    allowParallelInProgress: true
+
+# The `web` service and its search provider stay in the host composition; only
+# the model-facing tool is per-session.
+- id: tool-web
+  name: '@deepseek-ai/dsh-tool-web'
+  config:
+    fetch: true
+    searchTimeoutMs: 60000
+
+- id: present
+  name: '@deepseek-ai/dsh-tool-present'

package/presets/dscode/preset.yml

@@ -0,0 +1,3 @@
+name: DSCODE
+description: 持久 Shell 编码环境，保留 Skills、压缩、目标、子代理与工作流。
+order: 0