@toddzheng024/dscode-bundle 0.7.15 → 0.7.16

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.16",
   "type": "module",
   "license": "MIT",
   "author": "Todd Zheng",

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/vendor/compaction-basic/index.js

@@ -1,6 +1,8 @@
+// dscode-compaction-overflow-prune-v1
+// dscode-compaction-reserve-v1
 // dscode-compaction-prefetch-v1
 // dscode-compaction-threshold-v1
-import { prefetchThresholdTokens as dscodePrefetchThresholdTokens, pricedCompactionPolicy as dscodePricedCompactionPolicy } from "../../plugins/compaction/threshold.mjs";
+import { effectiveContextWindow as dscodeEffectiveContextWindow, fitsInWindow as dscodeFitsInWindow, prefetchThresholdTokens as dscodePrefetchThresholdTokens, pricedCompactionPolicy as dscodePricedCompactionPolicy } from "../../plugins/compaction/threshold.mjs";
 import z from "@deepseek-ai/schemastery";
 import { CompactionEngine, CompactionId, ManualCompactionError, compactCheckpointSource, toolPairingBalancedAfter, toolPairingBalancedBefore } from "@deepseek-ai/dsh-compaction";
 import { BlockAssembler, CONTEXT_WINDOW_EXCEEDED_CODE, LlmError, contentHasImage, createUserMessage, errorChain } from "@deepseek-ai/dsh-llm";
@@ -888,20 +890,23 @@ var BasicCompactionEngine = class extends CompactionEngine {
 		}
 		const prune = this.ctx.get("toolResultPruner");
 		if (trigger === "context-overflow") {
+			const dscodePrunedGeneration = agent.session.surface.replaceGeneration;
 			if (prune !== void 0) {
 				prune.pruneSession(agent.session);
 				measurement = meter.measure(agent.session);
 			}
+			if (await this.dscodeOverflowFits(agent, target, dscodePrunedGeneration, measurement, signal)) return null;
 			const range = selectCompactableRange(agent.session, measurement, 0);
 			if (range === null) return null;
 			return this.compactRegion(range.start, range.end, agent, signal);
 		}
-		const context = (await this.ctx.llm.resolveModelInfo(target.provider, target.model, signal)).context;
+		const dscodeModelInfo = await this.ctx.llm.resolveModelInfo(target.provider, target.model, signal);
+		const context = dscodeModelInfo.context;
 		assertNoActiveCompaction(agent.session, "automatic pressure compaction");
 		const targetKey = `${target.provider}/${target.model}`;
 		if (context === void 0) throw new TargetPressureConfigError(targetKey, `compaction-basic: no context capacity for ${targetKey}; configure contextWindow on that adapter model`);
-		const spec = resolveCompactSpec(await dscodePricedCompactionPolicy(this.config, policy), context.contextWindow);
-		this.dscodePlanPrefetch(agent, measurement, spec, context.contextWindow, signal);
+		const spec = resolveCompactSpec(await dscodePricedCompactionPolicy(this.config, policy), dscodeEffectiveContextWindow(context, dscodeModelInfo));
+		this.dscodePlanPrefetch(agent, measurement, spec, spec.contextWindow, signal);
 		if (measurement.totalTokens < spec.thresholdTokens) return null;
 		if (prune !== void 0) {
 			prune.pruneSession(agent.session);
@@ -1061,6 +1066,22 @@ var BasicCompactionEngine = class extends CompactionEngine {
 			return null;
 		}
 	}
+	/**
+	 * dscode: whether overflow-recovery pruning alone returned the failed request under the
+	 * window. The caller retries whenever the prune replaced the surface, so a summary here
+	 * would only add a model call and its stall to a request that already fits.
+	 * @param agent - agent recovering from a provider context overflow.
+	 * @param target - the routed provider/model that rejected the request.
+	 * @param generation - the surface generation before the prune.
+	 * @param measurement - the measurement taken after the prune.
+	 * @param signal - live turn cancellation signal.
+	 * @returns whether the retry may skip compaction.
+	 */
+	async dscodeOverflowFits(agent, target, generation, measurement, signal) {
+		if (agent.session.surface.replaceGeneration <= generation) return false;
+		const info = await this.ctx.llm.resolveModelInfo(target.provider, target.model, signal);
+		return dscodeFitsInWindow(measurement.totalTokens, info);
+	}
 	/** Bind the effective token meter and dynamically dispatched summarizer hook. */
 	regionDependencies() {
 		return {

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,
         });