dsh-switchman 1.9.0 → 1.10.3

package/host/context-trim/trigger.js

@@ -47,6 +47,13 @@ export function computeFoldableRange(messages, ledger, protectedTail) {
 		const list = positions.get(ledger.frontier);
 		if (list !== undefined && list.length > 0) startFrom = list[list.length - 1] + 1;
 	}
+	// A leading system message is the frozen head of the wire array: a fold
+	// anchored on it would put a surface replace op (and a view splice) over
+	// the system prompt, which the host rejects outright
+	// (assertSystemHeadRewrite — node 0 may be rewritten only by a
+	// system/message over exactly that node). Covers both the frontier-null
+	// first fold and any frontier-set fold that lands on the head.
+	if (messages[0]?.role === "system") startFrom = Math.max(startFrom, 1);
 	let best = null;
 	for (const [start, end] of segmentBounds(messages)) {
 		if (start < startFrom) continue; // behind the frontier

package/host/context-trim/view.js

@@ -25,9 +25,39 @@
 
 import { createHash } from "node:crypto";
 
-/** Cheap char → token estimate (the brief's char/4 heuristic). */
+/** Cheap char → token estimate (the brief's char/4 heuristic). Applies to
+ *  ASCII/latin text; CJK text tokenizes far denser (see below). */
 export const TOKENS_PER_CHAR = 1 / 4;
 
+/** CJK/fullwidth chars cost roughly ONE token each in the glm/deepseek BPE
+ *  vocabularies (vs 0.25 for the char/4 ASCII heuristic). Pinned at 1.0:
+ *  slightly high for common hanzi bigrams, which errs toward earlier folds
+ *  (the safe direction). NOT the 2026-11-04 incident root cause (that session
+ *  was only 4.8% CJK — the real bug was frozen-dispatch view injection); this
+ *  is a general accuracy fix for CJK-heavy sessions. */
+export const TOKENS_PER_CJK_CHAR = 1;
+
+/** CJK-ish ranges: kana, Hangul jamo+syllables, CJK radicals/blocks and
+ *  unified ideographs (incl. Ext-A), compat ideographs, vertical forms,
+ *  fullwidth forms, and the supplementary-plane CJK extensions (Ext-B..F,
+ *  /u flag — astral chars otherwise count as two ascii units). Halfwidth
+ *  katakana (\uFF61-\uFF9F) rides in the fullwidth range at the CJK weight:
+ *  slightly high, the safe direction for fold scheduling. */
+const CJK_CHAR_RE = /[\u1100-\u11FF\u2E80-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFFEF\u{20000}-\u{2FA1F}]/gu;
+
+/** Split one text into (asciiChars, cjkChars) in one pass over the string.
+ *  The replace allocates a second string — same order of cost as the
+ *  JSON.stringify this sits next to. */
+function countChars(text) {
+	let plain;
+	try {
+		plain = text.replace(CJK_CHAR_RE, "");
+	} catch {
+		return { ascii: text.length, cjk: 0 };
+	}
+	return { ascii: plain.length, cjk: text.length - plain.length };
+}
+
 /** Object keys dropped before hashing (volatility would churn refs). */
 const VOLATILE_KEYS = new Set(["ts", "time", "timestamp", "createdAt", "updatedAt", "receivedAt", "sentAt"]);
 
@@ -94,23 +124,34 @@ export function refPositions(messages) {
 }
 
 /** Estimated token count of one message (text content + tool-call payloads
- * + small per-message framing overhead). Never throws. */
+ * + small per-message framing overhead). CJK-aware — see TOKENS_PER_CJK_CHAR.
+ * Never throws. */
 export function messageTokens(message) {
-	let chars = 8;
+	let ascii = 8; // per-message framing overhead, counted in the ascii pool
+	let cjk = 0;
 	const content = message?.content;
 	try {
-		if (typeof content === "string") chars += content.length;
-		else if (Array.isArray(content)) {
+		if (typeof content === "string") {
+			const counted = countChars(content);
+			ascii += counted.ascii;
+			cjk += counted.cjk;
+		} else if (Array.isArray(content)) {
 			for (const block of content) {
-				if (block !== null && typeof block === "object" && typeof block.text === "string") chars += block.text.length;
-				else chars += JSON.stringify(block ?? null).length;
+				const text = block !== null && typeof block === "object" && typeof block.text === "string" ? block.text : JSON.stringify(block ?? null);
+				const counted = countChars(text);
+				ascii += counted.ascii;
+				cjk += counted.cjk;
 			}
 		}
-		if (Array.isArray(message?.tool_calls)) chars += JSON.stringify(message.tool_calls).length;
+		if (Array.isArray(message?.tool_calls)) {
+			const counted = countChars(JSON.stringify(message.tool_calls));
+			ascii += counted.ascii;
+			cjk += counted.cjk;
+		}
 	} catch {
 		/* unserializable block: keep the framing estimate */
 	}
-	return Math.max(1, Math.round(chars * TOKENS_PER_CHAR));
+	return Math.max(1, Math.round(ascii * TOKENS_PER_CHAR + cjk * TOKENS_PER_CJK_CHAR));
 }
 
 /** Estimated token count of a message range (inclusive indices). */
@@ -122,18 +163,26 @@ export function estimateTokensOf(messages, startIdx = 0, endIdx = messages.lengt
 
 // ---- tool-pair segmentation -------------------------------------------------
 
-/** True when the message OPENS tool calls (either wire shape). */
+/** True when the message OPENS tool calls. Covers the DSH-native shape
+ *  (assistant content block {type:'tool-call', id} — packages/llm/llm/src/
+ *  types.ts ToolCallBlock) plus the provider-shaped variants: the OpenAI
+ *  message.tool_calls array and the Anthropic {type:'tool_use'} block. The
+ *  DSH-native shape is what actually reaches this plugin's captures; missing
+ *  it made every native assistant tool call look like a plain message, so
+ *  segmentBounds below split the call from its results. */
 function opensToolCalls(message) {
 	if (message?.role !== "assistant") return false;
 	if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) return true;
-	if (Array.isArray(message.content)) return message.content.some((block) => block?.type === "tool_use");
+	if (Array.isArray(message.content)) return message.content.some((block) => block?.type === "tool_use" || block?.type === "tool-call");
 	return false;
 }
 
-/** True when the message CARRIES tool results (either wire shape). */
+/** True when the message CARRIES tool results. DSH-native results are
+ *  role:'tool' messages (with their call id on the message); provider-shaped
+ *  variants keep a tool_result/tool-result content block. */
 function carriesToolResults(message) {
 	if (message?.role === "tool") return true;
-	if (Array.isArray(message.content)) return message.content.some((block) => block?.type === "tool_result");
+	if (Array.isArray(message.content)) return message.content.some((block) => block?.type === "tool_result" || block?.type === "tool-result");
 	return false;
 }
 
@@ -261,6 +310,10 @@ export function buildView(messages, ledger, options = {}) {
 	for (const entry of located) {
 		if (entry.firstIdx < at) continue; // overlaps an applied block — skip
 		if (protectedTail > 0 && entry.lastIdx >= messages.length - protectedTail) continue;
+		// The system prompt at index 0 is never foldable: splicing it off the
+		// wire would drop the prompt itself. Plain skip (not unlocated) so
+		// the ledgerIsStale epoch semantics stay untouched.
+		if (entry.firstIdx === 0 && messages[0]?.role === "system") continue;
 		if (!rangeIsSegmentAligned(messages, entry.firstIdx, entry.lastIdx)) continue; // never split a tool pair (design §4)
 		for (let i = at; i < entry.firstIdx; i++) out.push(messages[i]);
 		out.push(summaryMessageOf(entry.block));
@@ -287,21 +340,22 @@ export function ledgerIsStale(view, ledger) {
  * identity-preserving), resumed sessions re-send FROZEN host-assembled
  * history (splice throws on its internal index deletes), and some dispatch
  * options are frozen objects on top of that. Returns the strategy used so
- * the caller can log it: "in-place" | "swapped" | "none". */
+ * the caller can log it: "in-place" | "swapped" | "none" (a fold existed but
+ * the dispatch could not carry it — the wire ships raw history) |
+ * "nothing-to-apply" (no located fold blocks; the raw history IS the view). */
 export function injectView(options, messages, view) {
-	if (view.applied > 0) {
-		try {
-			replaceInPlace(messages, view.messages);
-			return "in-place";
-		} catch {
-			/* frozen array — fall through to the reference swap */
-		}
-		try {
-			options.messages = view.messages;
-			return "swapped";
-		} catch {
-			/* frozen options — this dispatch cannot carry the view; fail open */
-		}
+	if (view.applied <= 0) return "nothing-to-apply";
+	try {
+		replaceInPlace(messages, view.messages);
+		return "in-place";
+	} catch {
+		/* frozen array — fall through to the reference swap */
+	}
+	try {
+		options.messages = view.messages;
+		return "swapped";
+	} catch {
+		/* frozen options — this dispatch cannot carry the view; fail open */
 	}
 	return "none";
 }

package/host/context-watch.js

@@ -26,8 +26,8 @@
  *   reach it — the borrowed handler's closure carries the right composition.
  *   Every handover trigger — the force-tier automation (fire-and-forget,
  *   session-level in-flight flag plus a 10-minute cooldown) and manual
- *   /ctx-handover — shares one four-step flow: fork a dormant backup
- *   session (subagents' fork provider, economy pool model); then, on
+ *   /ctx-handover — shares one three-step flow: write the handover
+ *   document; then, on
  *   every compaction attempt, re-enumerate the live dispatched
  *   subagents and refresh the handover document as the very last
  *   action before compacting via the borrowed per-agent /compact
@@ -54,7 +54,6 @@ import { dirname, join } from "node:path";
 import { clearHandover, handoverOf, recordHandover } from "./handover-state.js";
 import { enumerateLiveSubagents, sessionRecordPath, sessionRecordsDir } from "./subagents.js";
 import { recentTrimViewTokensOf } from "./context-trim/index.js";
-import { recordForkLink, trimStateDirOf } from "./context-trim/fork.js";
 
 /** Tools whose result text is accounted against the per-turn read budget. */
 const ACCOUNT_TOOLS = new Set(["read", "glob", "grep", "bash"]);
@@ -187,7 +186,7 @@ function bucketKilo(tokens) {
  * invariant); the numbers live in the tail context line only. */
 const PROTOCOL_ROOT_TEXT = [
 	"[SWITCHMAN:WATERMARK] protocol: this session is guarded by a context watermark measured every step.",
-	"ok tier is silent. soft tier: prefer delegating lightweight work (subagent/workflow) over reading more context yourself. hard tier: stop broad reading (read/glob/grep are budget-limited and may be denied) and start wrapping up. force tier: MANDATORY wrap-up now — produce the final answer from what you already hold; an automatic context handover (backup + document + compaction + continuation) may run and will tell you to end the turn.",
+	"ok tier is silent. soft tier: prefer delegating lightweight work (subagent/workflow) over reading more context yourself. hard tier: stop broad reading (read/glob/grep are budget-limited and may be denied) and start wrapping up. force tier: MANDATORY wrap-up now — produce the final answer from what you already hold; an automatic context handover (document + compaction + continuation) may run and will tell you to end the turn.",
 	"The live tier and the bucketed used-token reading (against the soft/hard/force budget) arrive ONLY as [SWITCHMAN:WATERMARK] lines inside the appended runtime-context snapshot at the conversation tail; a tier change is announced on the step it happens. /ctx-pause pauses every watermark enforcement (measurement continues), /ctx-resume restores it, /ctx-handover starts a handover immediately.",
 ].join("\n");
 
@@ -215,7 +214,7 @@ function renderRootWatermark(level, used, th, status) {
 	const lines = [head, "force tier: MANDATORY wrap-up now — produce the final answer from what you already hold."];
 	const phase = status?.phase;
 	if (phase === "backup") {
-		lines.push(`context handover running: forking the backup session and writing the handover document…`);
+		lines.push(`context handover running: writing the handover document…`);
 	} else if (phase === "compacting") {
 		lines.push(`context handover running: compaction attempt ${status?.attempt ?? "?"} (retries while the turn is still running)…`);
 	} else if (phase === "continuation") {
@@ -224,7 +223,7 @@ function renderRootWatermark(level, used, th, status) {
 		lines.push(
 			status?.cooldownMin > 0
 				? `automatic handover cooldown: ${status.cooldownMin} min left; run /ctx-handover${status?.tool ? " or call the ctx_handover tool" : ""} to force one now.`
-				: `an automatic context handover (backup + document + compaction + continuation) is armed and will fire at the next step boundary${status?.tool ? "; calling the ctx_handover tool triggers it immediately" : ""}.`,
+				: `an automatic context handover (document + compaction + continuation) is armed and will fire at the next step boundary${status?.tool ? "; calling the ctx_handover tool triggers it immediately" : ""}.`,
 		);
 	} else {
 		lines.push(`run /ctx-handover${status?.tool ? " or call the ctx_handover tool" : ""} to trigger a manual context handover.`);
@@ -423,56 +422,6 @@ function applyContextWatch(ctx, config) {
 		return typeof first.provider === "string" && typeof first.model === "string" ? first : null;
 	};
 
-	/** Manual handover step 1 — fork a dormant backup child of this session
-	 *  through the subagents service's fork provider (the child inherits the
-	 *  completed turns, runs one tiny confirmation turn on the economy pool
-	 *  model when configured, then stays idle as a browsable snapshot). The
-	 *  spec MUST carry a signal: the manager calls spec.signal.throwIfAborted()
-	 *  unconditionally, so a missing signal fails the whole fork with a
-	 *  TypeError (the live failure observed on 2026-10-01). The append-only
-	 *  session log always remains the full-fidelity backup, so a failed fork
-	 *  only downgrades the UX, never the data. Returns {childId, reason}. */
-	const forkBackup = async (agent, sessionId, signal) => {
-		try {
-			const economy = firstPoolRoute(config.poolEconomy);
-			const started = await ctx.subagents?.startContinuable?.({
-				provider: "fork",
-				label: "dsh-switchman handover backup",
-				signal: signal ?? new AbortController().signal,
-				request: {
-					parent: agent,
-					prompt: [
-						{
-							type: "text",
-							text: "[SWITCHMAN:HANDOVER-BACKUP] This session is a dormant fork snapshot taken immediately before a context handover in the parent session. Do not perform any work. Reply with exactly one line confirming you hold the complete pre-handover state, then stay idle.",
-						},
-					],
-					...(economy === null ? {} : { agentOptions: { provider: economy.provider, model: economy.model } }),
-				},
-			});
-			if (typeof started?.childId !== "string") {
-				const reason = `startContinuable returned no child id (${JSON.stringify(started ?? null)})`;
-				warn(
-					`handover backup fork failed for session ${sessionId} (continuing; the append-only log remains the full backup): ${reason}`,
-				);
-				return { childId: null, reason };
-			}
-			// Copy-on-fork: the backup child inherits this session's trim fold
-			// ledger at its first model call (host/context-trim/fork.js). The
-			// link is best-effort bookkeeping on an already-successful fork —
-			// recordForkLink never throws; a lost link only downgrades the
-			// child to a clean ledger.
-			recordForkLink(sessionId, started.childId, { stateDir: trimStateDirOf(config), warn });
-			return { childId: started.childId, reason: null };
-		} catch (error) {
-			const reason = error?.message ?? String(error);
-			warn(
-				`handover backup fork failed for session ${sessionId} (continuing; the append-only log remains the full backup): ${reason}`,
-			);
-			return { childId: null, reason };
-		}
-	};
-
 	/** One handover-document path per handover run (stamp frozen at run
 	 *  start so refreshes overwrite the same file). Null when the session
 	 *  exposes no usable cwd. */
@@ -531,7 +480,7 @@ function applyContextWatch(ctx, config) {
 					``,
 					`- handed over at: ${new Date().toISOString()} (document refreshed before every compaction attempt)`,
 					`- context used before compaction: ~${used ?? "unknown"} tokens`,
-					`- backup fork session: ${backupId ?? "(fork failed — the full history remains in this session's append-only log)"}`,
+					`- backup snapshot: none — the append-only session log holds the full pre-handover history`,
 					``,
 					...liveSection,
 					`## Task state (filled in by the agent right after the handover)`,
@@ -644,9 +593,7 @@ function applyContextWatch(ctx, config) {
 				: `If the compaction summary mentions dispatched subagents that are NOT listed above, they materialized after this enumeration — a post-wake recheck will announce them within seconds; do not re-dispatch anything before it fires.`;
 		const instruction = [
 			"[SWITCHMAN:HANDOVER] A context handover just completed for this session.",
-			backupId !== null
-				? `A dormant fork backup holding the full pre-handover state is session ${backupId}.`
-				: `No fork backup was created; the append-only session log still holds the full history.`,
+			`The append-only session log holds the full pre-handover history (no fork snapshot).`,
 			docFile !== null
 				? `The handover document is at ${docFile}.`
 				: `Create the handover document under .dsh-switchman/handover/ in the working directory.`,
@@ -690,8 +637,11 @@ function applyContextWatch(ctx, config) {
 		state.inflight.add(sessionId);
 		try {
 			recordHandover(sessionId, { phase: "backup", source, at: Date.now() });
-			const backup = await forkBackup(agent, sessionId, signal);
-			const backupId = backup.childId;
+			// Backup = the append-only session log itself (full fidelity). The
+			// old fork-snapshot step was removed 2026-11-05: the subagents
+			// fork API (ctx.subagents.startContinuable) is absent from the
+			// installed host, so the fork failed on every single run.
+			const backupId = null;
 			// One document path per handover run (the stamp freezes here so
 			// refreshes overwrite the same file). The document itself is
 			// written as the LAST action before every compaction attempt —
@@ -806,7 +756,7 @@ function applyContextWatch(ctx, config) {
 			if (!outcome.ok)
 				return {
 					kind: "error",
-					text: `/ctx-handover: compaction failed after backup ${backupId ?? "n/a"} — ${outcome.reason}`,
+					text: `/ctx-handover: compaction failed — ${outcome.reason}`,
 				};
 			recordHandover(sessionId, { phase: "continuation", source, at: Date.now() });
 			// Final enumeration right after compaction settled: anything that
@@ -840,7 +790,7 @@ function applyContextWatch(ctx, config) {
 			}
 			await armContinuation(agent, backupId, docFile, live, appeared);
 			scheduleMaterializationRecheck(agent, sessionId, backupId, docFile, live);
-			const backupText = backupId ?? `n/a (${backup.reason ?? "log retains full history"})`;
+			const backupText = "session log (full pre-handover history; no fork snapshot)";
 			return {
 				kind: "success",
 				text: `[SWITCHMAN:WATERMARK] handover complete — backup ${backupText}, document ${docFile ?? "agent-created"}, compaction done, continuation armed.`,
@@ -978,7 +928,7 @@ function applyContextWatch(ctx, config) {
 	});
 	ctx.commands.register({
 		name: "ctx-handover",
-		description: "Trigger a full context handover for this session now (backup fork + document + compaction + continuation).",
+		description: "Trigger a full context handover for this session now (document + compaction + continuation).",
 		handler: (invocation) =>
 			runHandover(invocation?.agent, sessionIdOf(invocation?.agent), invocation?.commandId, invocation?.signal, "manual"),
 	});
@@ -996,7 +946,7 @@ function applyContextWatch(ctx, config) {
 		ctx.tools?.register?.({
 			name: "ctx_handover",
 			description:
-				"Trigger a full dsh-switchman context handover for this session NOW: fork a dormant backup session, write the handover document, compact this session at the idle boundary, then wake it to fill in the document and continue the task. Call it when the watermark banner reaches the force tier or the user asks for a handover, then END the turn immediately.",
+				"Trigger a full dsh-switchman context handover for this session NOW: write the handover document, compact this session at the idle boundary, then wake it to fill in the document and continue the task. Call it when the watermark banner reaches the force tier or the user asks for a handover, then END the turn immediately.",
 			parameters: {
 				type: "object",
 				properties: {
@@ -1022,7 +972,7 @@ function applyContextWatch(ctx, config) {
 						),
 					(error) => warn(`ctx_handover handover crashed: ${error?.message ?? error}`),
 				);
-				return "[SWITCHMAN:WATERMARK] ctx_handover scheduled: backup fork + handover document + compaction + continuation are running. END this turn now — reply briefly and call no more tools, so the compaction lands at the idle boundary. Your closing line must tell the user the handover is running in the background and will continue automatically (the session-header badge shows the live state) — otherwise the GUI looks idle during fork+compact.";
+				return "[SWITCHMAN:WATERMARK] ctx_handover scheduled: handover document + compaction + continuation are running. END this turn now — reply briefly and call no more tools, so the compaction lands at the idle boundary. Your closing line must tell the user the handover is running in the background and will continue automatically (the session-header badge shows the live state) — otherwise the GUI looks idle during the handover window.";
 			},
 			presentCall: (args) => ({
 				card: "generic",

package/host/handover-state.js

@@ -2,10 +2,10 @@
  * Shared in-flight handover registry (process-lifetime, never persisted).
  *
  * context-watch.js records phase transitions from the first synchronous
- * line of runHandover (t=0, before the fork even starts); routes.js
+ * line of runHandover (t=0); routes.js
  * exposes the read-only snapshot behind GET /api/dsh-switchman/
  * handover-state so the client badge can show a live "handover in
- * progress" cue during the otherwise-silent fork+compact window.
+ * progress" cue during the otherwise-silent handover window.
  */
 
 /** sessionId -> { sessionId, phase, source?, attempt?, at }. */

package/host/routes.js

@@ -587,7 +587,7 @@ export function makeRoutes(ctx, config) {
 			handler: async (req, res) => {
 				if (!guard(req, res, "GET")) return;
 				// Read-only live registry: the client badge polls this during
-				// the otherwise-silent fork+compact window ({count, handovers}),
+				// the otherwise-silent handover window ({count, handovers}),
 				// so the GUI shows an animated "handover in progress" cue.
 				const handovers = handoverSnapshot();
 				writeJson(res, 200, { count: handovers.length, handovers });

package/index.js

@@ -20,8 +20,8 @@
  *
  * Phase 3 mounts the context-watermark layer (host/context-watch.js): the
  * `[SWITCHMAN:WATERMARK]` tiered banner from the live token meter, a per-turn
- * read budget with deny/cap gates, the four-step force-tier handover
- * (backup fork + document + compaction + continuation) plus the
+ * read budget with deny/cap gates, the force-tier handover
+ * (document + compaction + continuation) plus the
  * ctx_handover agent tool, and the /ctx-pause, /ctx-resume,
  * /ctx-handover commands.
  *
@@ -89,7 +89,7 @@ const name = "dsh-switchman";
  * system-prompt section registry, the settings store it writes back to, the
  * token meter and agent registry the watermark reads, the command registry
  * for /ctx-*, the tools registry for the ctx_handover agent tool, the
- * subagents service the handover's backup fork goes through, the sessions
+ * subagents service the teams layer dispatch goes through, the sessions
  * persistence the handover's continuation flush uses, the plugin-manager
  * service the teams layer's bundle enable goes through, and the session
  * query engine the subagent model annotation + per-session vision verdicts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dsh-switchman",
-	"version": "1.9.0",
+	"version": "1.10.3",
 	"description": "Autonomous Agent Teams doctrine for the four shipped DeepSeek Harness presets, plus language preferences, dispatch pools with model ranking, and context watermark control.",
 	"license": "MIT",
 	"keywords": [