@toddzheng024/dscode-bundle 0.7.12 → 0.7.14

package/vendor/compaction-basic/index.js

@@ -1,5 +1,6 @@
+// dscode-compaction-prefetch-v1
 // dscode-compaction-threshold-v1
-import { pricedCompactionPolicy as dscodePricedCompactionPolicy } from "../../plugins/compaction/threshold.mjs";
+import { 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";
@@ -900,6 +901,7 @@ var BasicCompactionEngine = class extends CompactionEngine {
 		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);
 		if (measurement.totalTokens < spec.thresholdTokens) return null;
 		if (prune !== void 0) {
 			prune.pruneSession(agent.session);
@@ -907,6 +909,12 @@ var BasicCompactionEngine = class extends CompactionEngine {
 		}
 		if (measurement.totalTokens < spec.thresholdTokens) return null;
 		let result = null;
+		const dscodePrefetched = await this.dscodeCommitPrefetch(agent);
+		if (dscodePrefetched !== null) {
+			result = dscodePrefetched;
+			measurement = meter.measure(agent.session);
+			if (measurement.totalTokens < spec.thresholdTokens) return result;
+		}
 		for (let attempt = 0; attempt <= spec.compactionRetries; attempt += 1) {
 			const range = selectCompactableRange(agent.session, measurement, spec.retainTokens);
 			if (range === null) {
@@ -971,6 +979,88 @@ var BasicCompactionEngine = class extends CompactionEngine {
 			throw new ManualCompactionError("busy", "manual compaction requires an idle agent with no waking queued work", { cause: error });
 		}
 	}
+	/** dscode: the one background prefetch this engine may hold per session. */
+	dscodePrefetch = /* @__PURE__ */ new WeakMap();
+	/**
+	 * dscode: start one background summarization of the oldest compactable span once the
+	 * measured pressure crosses the prefetch 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 contextWindow - the route's context window.
+	 * @param signal - live turn signal forwarded to the summarizer.
+	 */
+	dscodePlanPrefetch(agent, measurement, spec, contextWindow, signal) {
+		const session = agent.session;
+		const existing = this.dscodePrefetch.get(session);
+		if (existing !== void 0) {
+			if (existing.failure === null) return;
+			this.dscodePrefetch.delete(session);
+		}
+		if (measurement.totalTokens >= spec.thresholdTokens) return;
+		if (measurement.totalTokens < dscodePrefetchThresholdTokens(spec.thresholdTokens, contextWindow)) return;
+		if (inspectCompactionEntryState(session).unmatchedCompactionStart !== void 0) return;
+		const range = selectCompactableRange(session, measurement, spec.retainTokens);
+		if (range === null) return;
+		let selection;
+		try {
+			selection = validateSurfaceRegion(session, range.start, range.end);
+		} catch (error) {
+			return;
+		}
+		const prefetch = { compactionId: CompactionId(randomUUID()), summarized: null, failure: null, wait: null };
+		this.dscodePrefetch.set(session, prefetch);
+		prefetch.wait = (async () => {
+			try {
+				prefetch.summarized = await summarizeCompaction(this.regionDependencies(), prepareCompaction(this.regionDependencies(), session, selection), agent, prefetch.compactionId, void 0, signal);
+			} catch (error) {
+				prefetch.failure = error;
+			}
+		})();
+	}
+	/**
+	 * dscode: commit the pending prefetch, or return null so the caller summarizes afresh.
+	 * A finished summary is validated before the durable marker opens; one still running
+	 * opens the marker first, so its wait carries the ordinary compaction indicator.
+	 * Commit replaces the prefetched span with its checkpoint and leaves everything
+	 * appended after it verbatim.
+	 * @param agent - agent whose pressure triggered the automatic compaction.
+	 * @returns the committed compaction result, or null when no prefetch was usable.
+	 */
+	async dscodeCommitPrefetch(agent) {
+		const session = agent.session;
+		const prefetch = this.dscodePrefetch.get(session);
+		if (prefetch === void 0) return null;
+		this.dscodePrefetch.delete(session);
+		if (prefetch.failure !== null) return null;
+		const dependencies = this.regionDependencies();
+		if (prefetch.summarized !== null) try {
+			assertSelectedSpanStable(dependencies, session, prefetch.summarized);
+		} catch (error) {
+			return null;
+		}
+		const openTurn = inspectCompactionEntryState(session).openTurn;
+		const lifecycle = {
+			compactionId: prefetch.compactionId,
+			...openTurn === null ? {} : { turn: openTurn }
+		};
+		const startEvent = session.append("compaction/start", lifecycle);
+		let closing = false;
+		try {
+			await prefetch.wait;
+			if (prefetch.failure !== null) throw prefetch.failure;
+			assertSelectedSpanStable(dependencies, session, prefetch.summarized);
+			const pending = commitCompactionBody(session, startEvent, prefetch.summarized);
+			closing = true;
+			const endEvent = session.append("compaction/end", lifecycle);
+			return completeCompaction(pending, endEvent);
+		} catch (error) {
+			if (!closing) session.append("compaction/end", { ...lifecycle, error: errorChain(error) });
+			return null;
+		}
+	}
 	/** Bind the effective token meter and dynamically dispatched summarizer hook. */
 	regionDependencies() {
 		return {

package/vendor/persistent/index.js

@@ -1,3 +1,4 @@
+// dscode-shell-capture-v1
 // dscode-stdin-stall-v2
 const STDIN_STALL_MS = 5000;
 const STDIN_STALL_NOTE = "\n[Interrupted after 5s with no output: the command held the terminal without producing anything, and this tool cannot supply terminal input. Give it stdin (a heredoc, `< file` or `< /dev/null`) or use a non-interactive form.]";
@@ -174,7 +175,8 @@ function renderShellExitStatus(content, exitCode, signal) {
 * @returns the complete model-facing result.
 */
 async function respondToSessionExit(ctx, shells, owner, id, status, marker, fallback, fallbackTruncated, config) {
-	const snapshot = retainedScrollback(ctx, owner, id);
+	const window = ctx.terminals.read(owner, id, { capture: true });
+	const snapshot = window.text.length > 0 ? window : retainedScrollback(ctx, owner, id);
 	await shells.reset(owner, "persistent bash shell exited");
 	return [renderShellExitStatus(renderCaptured(partialOutput(snapshot, marker, fallback, fallbackTruncated), config.maxOutputChars), status.exitCode, status.signal), SHELL_RESET_MESSAGE].filter((part) => part.length > 0).join("\n");
 }
@@ -272,6 +274,7 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 			try {
 				operation = ctx.terminals.startSend(owner, id, {
 					text: first ? wrapped : "",
+					capture: first,
 					submit: first,
 					signal: commandDeadline.signal
 				});
@@ -284,13 +287,11 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 			const incremental = operation.readOutput();
 			fallback = incremental.delta.length > 0 ? fallback + incremental.delta : result.viewport;
 			fallbackTruncated ||= incremental.truncated || result.truncated;
-			const latest = ctx.terminals.read(owner, id, {
-				offset: 0,
-				count: SCROLLBACK_PAGE_LINES
-			});
+			const captured = ctx.terminals.read(owner, id, { capture: true });
+			fallbackTruncated ||= captured.truncated;
 			const timedOut = timeoutOf(commandDeadline.signal, TIMEOUT_CODE);
 			if (timedOut !== void 0) {
-				const partial = renderCaptured(partialOutput(retainedScrollback(ctx, owner, id, latest), marker, fallback, fallbackTruncated), config.maxOutputChars);
+				const partial = renderCaptured(partialOutput(captured, marker, fallback, fallbackTruncated), config.maxOutputChars);
 				await shells.reset(owner, "persistent bash command timed out");
 				return [
 					`Your command timed out after ${Math.round(timedOut.timeoutMs / 1e3)} seconds or experienced an OOM error. Below is partial output:`,
@@ -302,12 +303,12 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 				await shells.reset(owner, "persistent bash command aborted");
 				commandDeadline.signal.throwIfAborted();
 			}
-			if (latest.text.includes(marker.end)) {
-				const complete = commandOutput(retainedScrollback(ctx, owner, id, latest), marker);
+			if (captured.text.includes(marker.end)) {
+				const complete = commandOutput(captured, marker);
 				if (complete !== void 0) return renderCaptured(complete, config.maxOutputChars) + (stdinStalled ? STDIN_STALL_NOTE : "");
 			}
 			if (result.sessionStatus.kind === "exited") return await respondToSessionExit(ctx, shells, owner, id, result.sessionStatus, marker, fallback, fallbackTruncated, config);
-			const partial = renderCaptured(partialOutput(retainedScrollback(ctx, owner, id, latest), marker, fallback, fallbackTruncated), config.maxOutputChars);
+			const partial = renderCaptured(partialOutput(captured, marker, fallback, fallbackTruncated), config.maxOutputChars);
 			if (result.waitReason === "stdin_read") stdinWaited = true;
 			if (result.waitReason === "stdin_read" && partial.length > 0) return partial;
 			if (stdinWaited && partial.length === 0 && !stdinStalled && Date.now() - startedAt >= STDIN_STALL_MS) {

package/vendor/terminal/index.js

@@ -1,3 +1,4 @@
+// dscode-shell-capture-v1
 // dscode-no-history-expansion-v1
 import { createRequire } from "node:module";
 import { TerminalBackendCleanupError, TerminalError } from "@deepseek-ai/dsh-terminal";
@@ -254,6 +255,7 @@ function utf8Tail(text, maxBytes) {
 		truncated: true
 	};
 }
+const CAPTURE_MAX_BYTES = 4194304;
 var BoundedTextBuffer = class {
 	maxBytes;
 	maxLines;
@@ -454,6 +456,7 @@ var LocalPtySession = class {
 		if (this.statusValue.kind === "exited") throw new Error("PTY session has exited");
 		if (this.active !== void 0) throw new TerminalError(`PTY session already has an active send${this.activeWrite !== void 0 ? " or draining provider write" : this.interrupting !== void 0 ? " or draining foreground interrupt" : ""}`, "SEND_ACTIVE");
 		if (request.signal?.aborted === true) throw new Error("PTY send aborted before write");
+		if (request.capture === true) this.capture = new BoundedTextBuffer(CAPTURE_MAX_BYTES);
 		const operation = new LocalSendOperation(this.config.maxReadBytes, Date.now(), () => {
 			this.interrupt(operation);
 		});
@@ -520,6 +523,7 @@ var LocalPtySession = class {
 		this.promptTail = "";
 	}
 	read(request) {
+		if (request.capture === true) return this.capture?.snapshot() ?? { text: "", truncated: false };
 		const snapshot = this.scrollback.snapshot();
 		const lines = snapshot.text.split("\n");
 		const totalLines = snapshot.text.length === 0 ? 0 : lines.length;
@@ -625,6 +629,7 @@ var LocalPtySession = class {
 		if (text.length === 0) return;
 		this.lastOutputAt = Date.now();
 		this.scrollback.append(text);
+		this.capture?.append(text);
 		this.active?.append(text);
 	}
 	schedulePoll(operation, delayMs = this.config.pollIntervalMs) {