@toddzheng024/dscode-bundle 0.7.15 → 0.7.17

package/THIRD_PARTY_NOTICES.md

@@ -25,8 +25,5 @@ Local changes: DSCODE effort, shell control, TUI commands and footer.
 @deepseek-ai/dsh-terminal-bash@0.1.5-rc.2: MIT; {"type":"git","url":"git+https://github.com/deepseek-ai/deepseek-harness.git","directory":"packages/terminal/terminal-bash"}
 Local changes: DSCODE effort, shell control, TUI commands and footer.
 
-@deepseek-ai/dsh-compaction-basic@0.1.5-rc.2: MIT; {"type":"git","url":"git+https://github.com/deepseek-ai/deepseek-harness.git","directory":"packages/compaction/compaction-basic"}
-Local changes: DSCODE effort, shell control, TUI commands and footer.
-
 dsh-code (DSCODE vendored terminal, forked from dsh-code@1.2.0): MIT; https://github.com/unlinearity/dsh-code
 Local changes: DSCODE UI (welcome header, activity line, footer telemetry, effort bar), commands, panels and paste handling.

package/bootstrap.mjs

@@ -18,6 +18,7 @@ export function apply(ctx) {
   // resolution the launcher runs happens here before the agent preset mounts.
   process.env.DSCODE_SKILL_ANCESTOR_DIRS = JSON.stringify(ancestorSkillDirs({ cwd: process.cwd(), home: homedir() }));
   process.env.DSCODE_INSTRUCTION_HOME = writeWorkspaceInstructions({ cwd: process.cwd(), home: homedir(), stateDir: home }) ?? home;
+  process.env.DSCODE_SANDBOX_RUNNER = join(root, 'plugins/tui-tools/sandbox-runner.mjs');
   ctx.provide('dscodePaths', { presets: join(root, 'presets'), hooks: hookConfig.path });
   const oldPath = process.env.PATH;
   const added = join(root, 'bin');

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.15",
+  "version": "0.7.17",
   "type": "module",
   "license": "MIT",
   "author": "Todd Zheng",
@@ -49,7 +49,7 @@
     "./bash": "./vendor/bash/index.js",
     "./persistent": "./vendor/persistent/index.js",
     "./terminal": "./vendor/terminal/index.js",
-    "./compaction-basic": "./vendor/compaction-basic/index.js",
+    "./compaction": "./plugins/compaction/engine.mjs",
     "./policy": "./plugins/dscode/index.mjs",
     "./code-review": "./plugins/code-review/index.mjs",
     "./auto-review": "./plugins/auto-review/index.mjs",

package/plugins/compaction/engine.mjs

@@ -0,0 +1,304 @@
+import { BasicCompactionEngine } from '@deepseek-ai/dsh-compaction-basic';
+import { ManualCompactionError, toolPairingBalancedBefore } from '@deepseek-ai/dsh-compaction';
+import { SessionSeq } from '@deepseek-ai/dsh-session';
+import { effectiveContextWindow, fitsInWindow, prefetchThresholdTokens, pricedCompactionPolicy } from './threshold.mjs';
+
+// DSCODE's compaction policy as a subclass of the upstream engine instead of a
+// build-time patch of its source. It owns exactly the decisions this deployment
+// adds - a threshold priced from the route's cache discount, the adapter's
+// completion reserve, background prefetch, and overflow recovery that lets
+// pruning decide first - and leaves the durable surface transaction to the
+// upstream `compactRegion`, which stays the only writer.
+//
+// `BasicCompactionEngine` registers the automatic hooks itself and dispatches
+// them through `this.compactIfNeeded`, so overriding it here replaces the policy
+// without touching the installed package.
+export class DscodeCompactionEngine extends BasicCompactionEngine {
+  constructor(ctx, config) {
+    super(ctx, config);
+    // The upstream default hides whether the deployment configured a threshold,
+    // so the priced policy is enabled only when the raw config left it unset.
+    this.dscodePricedThreshold = config?.thresholdRatio === undefined;
+    this.dscodePrefetch = new WeakMap();
+    this.dscodePendingPrefetch = new WeakMap();
+    this.dscodeWarnedTargets = new Set();
+  }
+
+  /**
+   * Compact for step-boundary pressure or one provider-confirmed overflow, with
+   * the threshold priced from the route's cache discount and the completion
+   * budget the adapter reserves inside the window.
+   * @param agent - agent whose latest durable routed request is measured.
+   * @param trigger - normal step-boundary pressure or context-overflow recovery.
+   * @param signal - live turn cancellation signal forwarded to summarization.
+   * @returns the latest summary compaction result, or `null` when no summary ran.
+   */
+  async compactIfNeeded(agent, trigger, signal) {
+    const target = this.dscodeRoutedTarget(agent.session);
+    if (target === undefined) return null;
+    const policy = this.dscodeTargetPolicy(target);
+    const meter = this.ctx.tokenMeter;
+    const prune = this.ctx.get('toolResultPruner');
+    let measurement = meter.measure(agent.session);
+
+    if (trigger === 'context-overflow') {
+      // The pruner runs first and may already return the failed request under the
+      // window. The caller retries whenever that prune replaced the surface, so a
+      // summary here would only add a model call and its stall to a request that
+      // no longer needs one.
+      const generation = agent.session.surface.replaceGeneration;
+      if (prune !== undefined) {
+        prune.pruneSession(agent.session);
+        measurement = meter.measure(agent.session);
+      }
+      if (agent.session.surface.replaceGeneration > generation) {
+        const info = await this.ctx.llm.resolveModelInfo(target.provider, target.model, signal);
+        if (fitsInWindow(measurement.totalTokens, info)) return null;
+      }
+      return this.dscodeCompactOldest(agent, measurement, 0, signal);
+    }
+
+    const modelInfo = await this.ctx.llm.resolveModelInfo(target.provider, target.model, signal);
+    const context = modelInfo.context;
+    if (context === undefined) {
+      const key = `${target.provider}/${target.model}`;
+      if (!this.dscodeWarnedTargets.has(key)) {
+        this.dscodeWarnedTargets.add(key);
+        this.ctx.logger.warn(`compaction: no context capacity for ${key}; configure contextWindow on that adapter model`);
+      }
+      return null;
+    }
+    this.dscodeAssertInactive(agent.session, 'automatic pressure compaction');
+    const spec = this.dscodeCompactSpec(await pricedCompactionPolicy({ ...this.config, dscodePricedThreshold: this.dscodePricedThreshold }, policy), effectiveContextWindow(context, modelInfo));
+
+    this.dscodePlanPrefetch(agent, measurement, spec, signal);
+    if (measurement.totalTokens < spec.thresholdTokens) return null;
+    if (prune !== undefined) {
+      prune.pruneSession(agent.session);
+      measurement = meter.measure(agent.session);
+    }
+    if (measurement.totalTokens < spec.thresholdTokens) return null;
+
+    let result = null;
+    const prefetched = await this.dscodeCommitPrefetch(agent, signal);
+    if (prefetched !== null) {
+      result = prefetched;
+      measurement = meter.measure(agent.session);
+      if (measurement.totalTokens < spec.thresholdTokens) return result;
+    }
+    for (let attempt = 0; attempt <= spec.compactionRetries; attempt += 1) {
+      const range = this.dscodeSelectRange(agent.session, measurement, spec.retainTokens);
+      if (range === null) {
+        if (result === null) return null;
+        break;
+      }
+      result = await this.compactRegion(range.start, range.end, agent, signal);
+      measurement = meter.measure(agent.session);
+      if (measurement.totalTokens < spec.thresholdTokens) return result;
+    }
+    throw new Error(`compaction still above threshold after ${spec.compactionRetries + 1} compaction attempts (${measurement.totalTokens} estimated tokens >= threshold ${spec.thresholdTokens})`);
+  }
+
+  /**
+   * Summarize the replayed region through the upstream cache-reusing call, or
+   * return the summary a prefetch already produced for this exact commit.
+   * @param input - replayed conversation prefix to condense.
+   * @param agent - supplies routed-model history, fallback model, and session id.
+   * @param signal - optional cancellation forwarded to the adapter.
+   * @returns the summary blocks and the call envelope behind them.
+   */
+  async summarize(input, agent, signal) {
+    const pending = this.dscodePendingPrefetch.get(agent.session);
+    if (pending === undefined) return super.summarize(input, agent, signal);
+    this.dscodePendingPrefetch.delete(agent.session);
+    // The upstream transaction already opened its marker, so this wait is the visible
+    // compaction. A failed or invalidated prefetch falls back to a fresh call instead
+    // of failing a transaction that has already begun.
+    await pending.wait;
+    if (pending.failure !== null || agent.session.surface.replaceGeneration !== pending.generation) return super.summarize(input, agent, signal);
+    return pending.summarized;
+  }
+
+  /** Compact the oldest compactable span for a retention budget, or return null when none is safe. */
+  async dscodeCompactOldest(agent, measurement, retainTokens, signal) {
+    const range = this.dscodeSelectRange(agent.session, measurement, retainTokens);
+    if (range === null) return null;
+    return this.compactRegion(range.start, range.end, agent, signal);
+  }
+
+  /** The routed provider/model of the session's latest durable request. */
+  dscodeRoutedTarget(session) {
+    const config = session.requestHeader()?.config;
+    if (config === undefined || config.provider.length === 0 || config.model.length === 0) return undefined;
+    return { provider: config.provider, model: config.model };
+  }
+
+  /** Merge the exact-target override over the validated defaults for one routed target. */
+  dscodeTargetPolicy(target) {
+    const config = this.config;
+    const override = config.modelPolicies.find(entry => entry.provider === target.provider && entry.model === target.model);
+    const inherited = config.retainTokens === undefined ? { retainRatio: config.retainRatio } : { retainTokens: config.retainTokens };
+    const retention = override?.retainTokens !== undefined ? { retainTokens: override.retainTokens }
+      : override?.retainRatio !== undefined ? { retainRatio: override.retainRatio }
+        : inherited;
+    return {
+      target: { ...target },
+      thresholdRatio: override?.thresholdRatio ?? config.thresholdRatio,
+      ...retention,
+      summarizationProvider: override?.summarizationProvider ?? config.summarizationProvider,
+      summarizationModel: override?.summarizationModel ?? config.summarizationModel,
+      maxTokens: override?.maxTokens ?? config.maxTokens,
+      compactionRetries: override?.compactionRetries ?? config.compactionRetries,
+      maxOverflowRetries: override?.maxOverflowRetries ?? config.maxOverflowRetries,
+    };
+  }
+
+  /** Scale one routed policy into concrete token budgets for its effective window. */
+  dscodeCompactSpec(policy, contextWindow) {
+    const key = `${policy.target.provider}/${policy.target.model}`;
+    if (!Number.isInteger(contextWindow) || contextWindow <= 0) throw new Error(`compaction: contextWindow (${contextWindow}) must be a positive integer for ${key}`);
+    const thresholdTokens = Math.floor(contextWindow * policy.thresholdRatio);
+    const retainTokens = policy.retainTokens === undefined ? Math.floor(contextWindow * policy.retainRatio) : policy.retainTokens;
+    if (retainTokens >= thresholdTokens) throw new Error(`compaction: retainTokens (${retainTokens}) must be less than threshold tokens ${thresholdTokens} for ${key}`);
+    return { ...policy, contextWindow, thresholdTokens, retainTokens };
+  }
+
+  /**
+   * Resolve the next range starting at the first non-system surface node while
+   * retaining a priced recent tail and never splitting a tool-call/result pair.
+   * @param session - session supplying authoritative current surface positions.
+   * @param measurement - unified pressure and surface measurement from the conversation meter.
+   * @param retainTokens - minimum recent tail budget retained verbatim.
+   * @returns the positional range to compact, or `null`.
+   */
+  dscodeSelectRange(session, measurement, retainTokens) {
+    const pricedNodes = measurement.nodes;
+    if (pricedNodes.length === 0) return null;
+    const surfaceNodes = session.surface.nodes;
+    if (surfaceNodes.length !== pricedNodes.length || surfaceNodes.some((seq, index) => seq !== pricedNodes[index]?.seq)) throw new Error('compaction: token-meter surface does not match the current session surface');
+    const firstIdx = this.dscodeSystemHead(session, surfaceNodes[0]) === undefined ? 0 : 1;
+    let accumulated = 0;
+    let keepFromIdx = pricedNodes.length;
+    for (let index = pricedNodes.length - 1; index >= 0; index -= 1) {
+      accumulated += pricedNodes[index].tokens;
+      keepFromIdx = index;
+      if (accumulated >= retainTokens) break;
+    }
+    if (keepFromIdx <= firstIdx) return null;
+    while (keepFromIdx > firstIdx) {
+      if (toolPairingBalancedBefore(session, surfaceNodes[keepFromIdx])) break;
+      keepFromIdx -= 1;
+    }
+    if (keepFromIdx <= firstIdx) return null;
+    return { start: surfaceNodes[firstIdx], end: surfaceNodes[keepFromIdx - 1], startIdx: firstIdx, endIdx: keepFromIdx - 1 };
+  }
+
+  /** The `system/message` at a surface head, or undefined when that node is something else. */
+  dscodeSystemHead(session, headSeq) {
+    if (headSeq === undefined) return undefined;
+    const head = session.eventAt(headSeq);
+    return head.type === 'system/message' ? head : undefined;
+  }
+
+  /** The replayed conversation prefix a summary call condenses: system head, tools, then the shadowed messages. */
+  dscodeSummarizationInput(session, shadowedSeqs) {
+    const header = session.requestHeader();
+    const nodes = session.surface.nodes;
+    const system = this.dscodeSystemHead(session, nodes[0]);
+    const head = system === undefined ? null : session.deriveEventMessage(system);
+    const region = shadowedSeqs.map(seq => session.deriveEventMessage(session.eventAt(seq))).filter(message => message !== null);
+    return { ...header?.tools === undefined ? {} : { tools: header.tools }, messages: head === null ? region : [head, ...region] };
+  }
+
+  /** The newest unmatched compaction start and end-seed boundary of one session. */
+  dscodeEntryState(session) {
+    let unmatchedCompactionStart;
+    let entryStateKnown = false;
+    let latestEndSeedSeq;
+    for (let seq = session.seq - 1; seq >= 0; seq -= 1) {
+      const event = session.eventAt(SessionSeq(seq));
+      if (latestEndSeedSeq === undefined && event.type === 'session/end-seed') latestEndSeedSeq = event.seq;
+      if (!entryStateKnown) {
+        if (event.type === 'compaction/start') {
+          unmatchedCompactionStart = event;
+          entryStateKnown = true;
+        } else if (event.type === 'compaction/end') entryStateKnown = true;
+      }
+      if (entryStateKnown && latestEndSeedSeq !== undefined) break;
+    }
+    return { unmatchedCompactionStart, latestEndSeedSeq };
+  }
+
+  /** Reject a second compaction while the durable compaction lock is active. */
+  dscodeAssertInactive(session, stage) {
+    const { unmatchedCompactionStart, latestEndSeedSeq } = this.dscodeEntryState(session);
+    if (unmatchedCompactionStart === undefined || (latestEndSeedSeq !== undefined && latestEndSeedSeq > unmatchedCompactionStart.seq)) return;
+    throw new ManualCompactionError('busy', `${stage}: compaction already in progress; the session compaction lock is already active`);
+  }
+
+  /**
+   * Start one background summarization of the oldest compactable span once the
+   * measured pressure crosses the mark one lead below the priced threshold.
+   * Nothing is appended and no compaction lock is taken, so an invalidated or
+   * cancelled prefetch costs only the summarization call.
+   * @param agent - agent whose pressure the caller just priced.
+   * @param measurement - the measurement the caller priced.
+   * @param spec - the caller's resolved spec for this route.
+   * @param signal - live turn signal forwarded to the summarizer.
+   */
+  dscodePlanPrefetch(agent, measurement, spec, signal) {
+    const session = agent.session;
+    const existing = this.dscodePrefetch.get(session);
+    if (existing !== undefined) {
+      if (existing.failure === null) return;
+      this.dscodePrefetch.delete(session);
+    }
+    if (measurement.totalTokens >= spec.thresholdTokens) return;
+    if (measurement.totalTokens < prefetchThresholdTokens(spec.thresholdTokens, spec.contextWindow)) return;
+    if (this.dscodeEntryState(session).unmatchedCompactionStart !== undefined) return;
+    let range;
+    try {
+      range = this.dscodeSelectRange(session, measurement, spec.retainTokens);
+    } catch (error) {
+      return;
+    }
+    if (range === null) return;
+    const shadowedSeqs = session.surface.nodes.slice(range.startIdx, range.endIdx + 1);
+    const prefetch = { range: { start: range.start, end: range.end }, generation: session.surface.replaceGeneration, summarized: null, failure: null, wait: null };
+    this.dscodePrefetch.set(session, prefetch);
+    prefetch.wait = (async () => {
+      try {
+        const input = this.dscodeSummarizationInput(session, shadowedSeqs);
+        prefetch.summarized = await this.summarize(input, agent, signal);
+      } catch (error) {
+        prefetch.failure = error;
+      }
+    })();
+  }
+
+  /**
+   * Commit the pending prefetch when its span is still the same replacement
+   * target, or return null so the caller summarizes afresh. The upstream
+   * `compactRegion` owns the marker pair, the surface replacement and every
+   * stability check; `summarize` then returns the summary already produced.
+   * @param agent - agent whose pressure triggered the automatic compaction.
+   * @param signal - live turn signal forwarded to the transaction.
+   * @returns the committed compaction result, or null when no prefetch was usable.
+   */
+  async dscodeCommitPrefetch(agent, signal) {
+    const session = agent.session;
+    const prefetch = this.dscodePrefetch.get(session);
+    if (prefetch === undefined) return null;
+    this.dscodePrefetch.delete(session);
+    if (prefetch.failure !== null) return null;
+    if (session.surface.replaceGeneration !== prefetch.generation) return null;
+    this.dscodePendingPrefetch.set(session, prefetch);
+    try {
+      return await this.compactRegion(prefetch.range.start, prefetch.range.end, agent, signal);
+    } finally {
+      this.dscodePendingPrefetch.delete(session);
+    }
+  }
+}
+
+export default DscodeCompactionEngine;

package/plugins/compaction/threshold.mjs

@@ -28,6 +28,46 @@ export function prefetchThresholdTokens(thresholdTokens, contextWindow, leadRati
   return Math.max(0, thresholdTokens - Math.floor(contextWindow * leadRatio));
 }
 
+/**
+ * The window the session messages may occupy. An adapter that keeps the completion
+ * budget inside the context window rejects a request once messages plus completion
+ * exceed it, so a threshold priced from the full window sits above a ceiling the
+ * provider enforces first: the pressure path never fires and every compaction arrives
+ * through overflow recovery, which summarizes synchronously and stalls the turn.
+ *
+ * A reported budget is always subtracted: every OpenAI-compatible adapter counts
+ * `max_tokens` toward the same limit, and an adapter that reports none keeps the full
+ * window, so the subtraction can only make compaction earlier than the low-level
+ * threshold would, never later than the provider allows.
+ * @param context - the resolved model info context, `{ contextWindow }`.
+ * @param modelInfo - the resolved model info, whose `defaultMaxTokens` is that budget.
+ */
+/** The completion budget an adapter reserves inside the window, 0 when it reports none. */
+function completionReserve(contextWindow, modelInfo) {
+  const reserve = modelInfo?.defaultMaxTokens;
+  if (!Number.isInteger(reserve) || reserve <= 0 || reserve >= contextWindow) return 0;
+  return reserve;
+}
+
+export function effectiveContextWindow(context, modelInfo) {
+  const contextWindow = context?.contextWindow;
+  if (!Number.isInteger(contextWindow) || contextWindow <= 0) return contextWindow;
+  return contextWindow - completionReserve(contextWindow, modelInfo);
+}
+
+/**
+ * Whether a measured request envelope plus the reserved completion budget fits the models
+ * window, which is the rule the provider enforces. Overflow recovery uses it to tell a
+ * request that pruning alone returned under the window from one that still needs a summary.
+ * @param totalTokens - the measured request envelope.
+ * @param modelInfo - the resolved model info: `context.contextWindow` and `defaultMaxTokens`.
+ */
+export function fitsInWindow(totalTokens, modelInfo) {
+  const contextWindow = modelInfo?.context?.contextWindow;
+  if (!Number.isInteger(totalTokens) || !Number.isInteger(contextWindow) || contextWindow <= 0) return false;
+  return totalTokens + completionReserve(contextWindow, modelInfo) <= contextWindow;
+}
+
 /** The route's threshold ratio, waiting for the OpenRouter listing when it has not loaded yet. */
 export async function pricedThresholdRatio(provider, model, now = Date.now()) {
   if (provider === 'openrouter') await ensureOpenRouterModels({ home: process.env.DSH_HOME, now });

package/plugins/tui-tools/sandbox-runner.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// A custom runner for @deepseek-ai/dsh-sandbox-local, selected through the `sandbox`
+// row's `runnerCommand`. The provider appends a bwrap-compatible profile and then
+// `--` and the command:
+//
+//   dsh-sandbox-runner --ro-bind / / --dev /dev --unshare-pid --proc /proc
+//     --die-with-parent [--tmpfs /tmp] [--bind <root> <root>] -- <command...>
+//
+// We translate the profile into a Seatbelt one and add the single grant the built-in
+// profile lacks: /dev/ptmx. Without it a confined command cannot allocate a PTY
+// (posix_openpt returns EPERM), which silently breaks nested harnesses, tmux, expect
+// and any node-pty based suite. When the kernel refuses to apply another profile —
+// which is exactly what happens inside an already-confined process — the command
+// inherits the enclosing profile instead of nesting a second one.
+import { spawn, spawnSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const NAME = 'dscode-sandbox-runner';
+// Configure this string as runnerFailureSignatures so the provider recognises our
+// own failures instead of reading them as a denied command.
+export const FATAL_PREFIX = `${NAME}: fatal: `;
+// Informational output must never carry the configured failure signature: the provider
+// turns any non-zero exit whose stderr matches it into a sandbox failure, so a notice
+// would misreport a failing command as a broken runner.
+export const NOTICE_PREFIX = `${NAME}: notice: `;
+export const SANDBOX_EXEC = '/usr/bin/sandbox-exec';
+
+const OPERAND_FLAGS = new Map([['--ro-bind', 2], ['--bind', 2], ['--tmpfs', 1], ['--dev', 1], ['--proc', 1], ['--dir', 1]]);
+
+const canonical = path => {
+  try { return realpathSync(path); } catch { return resolve(path); }
+};
+
+const sbpl = path => `"${String(path).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+
+/** Split the appended bwrap-compatible profile from the command after `--`. */
+export function parseProfile(argv) {
+  const writable = [];
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === '--') { index += 1; break; }
+    if (!token.startsWith('--')) throw new Error(`unexpected profile argument ${JSON.stringify(token)}`);
+    const operands = OPERAND_FLAGS.get(token) ?? 0;
+    if (operands === 2) {
+      const [, destination] = [argv[index + 1], argv[index + 2]];
+      if (!destination) throw new Error(`${token} needs two operands`);
+      if (token === '--bind') writable.push(destination);
+    } else if (operands === 1 && !argv[index + 1]) throw new Error(`${token} needs an operand`);
+    index += operands + 1;
+  }
+  return { writable, command: argv.slice(index) };
+}
+
+/** Writable roots that mirror the provider's own Seatbelt grant, plus the temp areas. */
+export function writableRoots(parsed, { temp = tmpdir() } = {}) {
+  return [...new Set([...parsed.writable, '/tmp', temp].map(canonical))];
+}
+
+/** The SBPL profile: upstream's deny-by-default write policy plus /dev/ptmx. */
+export function seatbeltProfile(roots) {
+  const forms = [
+    '(version 1)',
+    '(allow default)',
+    '(deny file-write*)',
+    `(allow file-write* (literal ${sbpl('/dev/null')}))`,
+    `(allow file-write* (literal ${sbpl('/dev/ptmx')}))`,
+  ];
+  if (roots.length) forms.push(`(allow file-write* ${roots.map(root => `(subpath ${sbpl(root)})`).join(' ')})`);
+  return forms.join(' ');
+}
+
+/** Whether this process may apply a Seatbelt profile at all. */
+export function seatbeltApplies(exec = SANDBOX_EXEC) {
+  const probe = spawnSync(exec, ['-p', '(version 1)(allow default)', '/usr/bin/true'], { stdio: ['ignore', 'ignore', 'pipe'], encoding: 'utf8' });
+  if (probe.error) return probe.error.code === 'ENOENT' ? { ok: false, reason: 'missing' } : { ok: false, reason: probe.error.message };
+  if (probe.status === 0) return { ok: true };
+  return { ok: false, reason: (probe.stderr ?? '').trim().split('\n').at(-1) || `exit ${probe.status}` };
+}
+
+const SIGNAL_CODES = { SIGHUP: 129, SIGINT: 130, SIGTERM: 143 };
+
+function runUnder(program, args) {
+  return new Promise(resolvePromise => {
+    const child = spawn(program, args, { stdio: 'inherit' });
+    const forward = signal => () => { try { child.kill(signal); } catch { /* already gone */ } };
+    const handlers = Object.keys(SIGNAL_CODES).map(signal => [signal, forward(signal)]);
+    for (const [signal, handler] of handlers) process.on(signal, handler);
+    child.on('error', error => { process.stderr.write(`${FATAL_PREFIX}${error.message}\n`); resolvePromise(126); });
+    child.on('exit', (code, signal) => resolvePromise(code ?? SIGNAL_CODES[signal] ?? 1));
+  });
+}
+
+export async function run(argv, { exec = SANDBOX_EXEC, stderr = process.stderr } = {}) {
+  const parsed = parseProfile(argv);
+  if (parsed.command.length === 0) {
+    stderr.write(`${FATAL_PREFIX}no command after --\n`);
+    return 126;
+  }
+  const [program, ...args] = parsed.command;
+  const applies = seatbeltApplies(exec);
+  if (!applies.ok && applies.reason === 'missing') {
+    stderr.write(`${FATAL_PREFIX}${exec} is not available; refusing to run unconfined\n`);
+    return 126;
+  }
+  if (!applies.ok) {
+    // Applying a profile is what the kernel refuses inside an existing one, so this
+    // process is already confined: inherit that profile rather than nest a second.
+    stderr.write(`${NOTICE_PREFIX}inheriting the enclosing profile (${applies.reason})\n`);
+    return runUnder(program, args);
+  }
+  return runUnder(exec, ['-p', seatbeltProfile(writableRoots(parsed)), '--', program, ...args]);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  run(process.argv.slice(2)).then(code => { process.exitCode = code; }).catch(error => {
+    process.stderr.write(`${FATAL_PREFIX}${error.message}\n`);
+    process.exitCode = 126;
+  });
+}

package/presets/dscode/agent.cordis.yml

@@ -198,7 +198,7 @@
     toolResultPruner: true
   config:
     - id: compaction-basic
-      name: '@toddzheng024/dscode-bundle/compaction-basic'
+      name: '@toddzheng024/dscode-bundle/compaction'
 
     - id: command-compact
       name: '@deepseek-ai/dsh-command-compact'

package/vendor/tui/lib/app.mjs

@@ -32,7 +32,7 @@ import { dscodeChatLines } from './dscode/chat.mjs';
 import { readFileSync } from 'node:fs';
 import { footerFor as dscodeFooterFor } from '../../../plugins/session-metrics/view.mjs';
 import { newerVersion as dscodeNewerVersion } from '../../../plugins/tui-tools/update.mjs';
-import { t as dscodeMessage, normalizeLanguage as dscodeNormalizeLanguage } from '../../../plugins/i18n/messages.mjs';
+import { languageName as dscodeLanguageName, normalizeLanguage as dscodeNormalizeLanguage, t as dscodeMessage } from '../../../plugins/i18n/messages.mjs';
 import { dscodeTelemetryNodes } from './dscode/telemetry.mjs';
 import { dscodeFooterHeader } from './render/status.mjs';
 import { dscodePadEnd, welcomeArtRows, welcomePath, WELCOME_ART, WELCOME_ART_SMALL } from './dscode/welcome.mjs';
@@ -4604,9 +4604,10 @@ function Input({ effortSurface, ultraPulse, active, frozen, frozenHint, busy, de
                 const argument = text.slice('/language'.length).trim();
                 if (argument === '')
                     openLanguage();
-                else if (argument === 'en' || argument === 'zh') {
-                    saveLanguage(parseLanguageName(argument));
-                    notify(t('notice.languageSaved', { name: argument }));
+                else if (dscodeNormalizeLanguage(argument) !== null) {
+                    const name = parseLanguageName(argument);
+                    saveLanguage(name);
+                    notify(t('notice.languageSaved', { name: dscodeLanguageName(name) }));
                     refresh();
                 }
                 else

package/vendor/tui/lib/i18n.mjs

@@ -6,26 +6,32 @@
  * choice lives in language.json next to theme.json (see the runner's
  * persistence block).
  *
+ * The selectable list and the alias table come from the DSCODE message
+ * tables, so `/language` offers everything those tables translate. The
+ * terminal's own catalogues still only cover English and Simplified Chinese:
+ * any other choice paints the shell in English and DSCODE's labels in the
+ * chosen language, which is exactly what `/language` promises.
+ *
  * @module @deepseek-ai/dsh-tui/i18n
  */
 import { en } from './locales/en.mjs';
 import { zh } from './locales/zh.mjs';
-/** Valid language names for argument parsing. */
-export const LANGUAGE_NAMES = ['en', 'zh'];
+import { LANGUAGES as DSCODE_LANGUAGES, normalizeLanguage } from '../../../plugins/i18n/messages.mjs';
+/** Valid language names for argument parsing, in picker order. */
+export const LANGUAGE_NAMES = DSCODE_LANGUAGES.map(language => language.code);
 /** The /language picker rows in canonical order. */
-export const LANGUAGES = [
-    { id: 'en', label: 'English' },
-    { id: 'zh', label: '中文' },
-];
-const CATALOGS = { en, zh };
+export const LANGUAGES = DSCODE_LANGUAGES.map(language => ({ id: language.code, label: language.name }));
+/** Catalogues this module can paint; anything else keeps English. */
+const CATALOGS = { en, 'zh-CN': zh, 'zh-TW': zh };
 /** The language in force. */
 let activeName = 'en';
 /**
- * Parse a persisted or typed language name: only 'en' and 'zh' survive;
- * anything else falls back to English.
+ * Parse a persisted or typed language name through the DSCODE alias table, so
+ * `zh`, `jp` or `简体中文` all resolve. An unknown value falls back to English.
  */
 export function parseLanguageName(value) {
-    return value === 'zh' ? 'zh' : 'en';
+    const code = normalizeLanguage(value);
+    return code !== null && LANGUAGE_NAMES.includes(code) ? code : 'en';
 }
 /** The language name in force. */
 export function getLanguage() {
@@ -37,11 +43,11 @@ export function setLanguage(name) {
 }
 /**
  * One message from the active catalog, with `{n}`-style placeholders filled
- * from the params record. Unknown placeholders stay literal; a missing key
- * falls back to the English entry so a catalog gap degrades visibly but
- * never crashes.
+ * from the params record. Unknown placeholders stay literal; a language the
+ * terminal cannot paint, or a missing key, falls back to the English entry so
+ * a catalog gap degrades visibly but never crashes.
  */
 export function t(key, params = {}) {
-    const template = CATALOGS[activeName][key] ?? en[key];
+    const template = CATALOGS[activeName]?.[key] ?? en[key];
     return template.replace(/\{(\w+)\}/gu, (whole, name) => params[name] === undefined ? whole : String(params[name]));
 }

package/vendor/tui/lib/index.mjs

@@ -26,7 +26,7 @@ import { internals } from './internals.mjs';
 import { syncModelCapabilities } from './model-capabilities.mjs';
 import { ensureProviderRoute as dscodeEnsureProviderRoute, migrateOpenRouterProfile as dscodeMigrateOpenRouter } from '../../../plugins/providers/catalog.mjs';
 import { grokStatusSnapshot } from '../../../plugins/grok/status.mjs';
-import { compactionPreview as dscodeCompactionPreview, pricedThresholdRatio as dscodePricedThresholdRatio } from '../../../plugins/compaction/threshold.mjs';
+import { compactionPreview as dscodeCompactionPreview, effectiveContextWindow as dscodeEffectiveContextWindow, pricedThresholdRatio as dscodePricedThresholdRatio } from '../../../plugins/compaction/threshold.mjs';
 import { dscodeLoadOpenRouterAccountFor, dscodeManagementKeyStatus, dscodeSaveManagementKey } from './app.mjs';
 import { buildModelSelection, applyModelSelectionToConfig, loadModelDirectory, modelSelectionLabel, pendingModelSelection, resolveEffectiveSelection } from './models.mjs';
 import { discoverProviderModels, loadProviderSettings, removeProviderSettings, saveProviderCredential, saveProviderConfiguration, subscribeProviderSettings, unsetProviderCredential, } from './provider-settings.mjs';
@@ -1462,7 +1462,7 @@ async function run(ctx, startup, io) {
         const info = await llm.resolveModelInfo(row.provider, row.model);
         return dscodeCompactionPreview({
             used,
-            contextWindow: info?.context?.contextWindow,
+            contextWindow: dscodeEffectiveContextWindow(info?.context, info),
             thresholdRatio: await dscodePricedThresholdRatio(row.provider, row.model),
             label: row.provider + '/' + row.model,
         });

package/vendor/compaction-basic/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 DeepSeek
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.