dsh-switchman 1.10.3 → 1.11.1

package/host/context-watch.js

@@ -53,7 +53,7 @@ import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
 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 { recentTrimPromptTokensOf } from "./context-trim/index.js";
 
 /** Tools whose result text is accounted against the per-turn read budget. */
 const ACCOUNT_TOOLS = new Set(["read", "glob", "grep", "bash"]);
@@ -115,11 +115,6 @@ function levelOf(used, th) {
 	return "ok";
 }
 
-/** `42k`-style rounding for the anchor line. */
-function kilo(tokens) {
-	return `${Math.round(tokens / 1000)}k`;
-}
-
 /** Session id off an exec/invocation agent (shared agent/session id). */
 function sessionIdOf(agent) {
 	const id = agent?.session?.id ?? agent?.id;
@@ -141,7 +136,7 @@ function isRoot(ctx, agent) {
 function readThresholds(config) {
 	return {
 		soft: readNumber(config.wmSoftTokens, 80000),
-		hard: readNumber(config.wmHardTokens, 120000),
+		hard: readNumber(config.wmHardTokens, 95000),
 		force: readNumber(config.wmForceTokens, 150000),
 	};
 }
@@ -151,15 +146,22 @@ export function measureNow(ctx, agent) {
 	try {
 		const measurement = agent?.session ? ctx.tokenMeter?.measure?.(agent.session) : undefined;
 		const used = Number.isFinite(measurement?.totalTokens) ? measurement.totalTokens : null;
-		// Meter duality (design §8): prefer the trim layer's fresh outbound-view
-		// estimate when present — billion-context can fold far more away than the
-		// meter's stored tally admits, and the watermark must track what the
-		// model actually sees. Strictly additive + fail-open: any trim failure
-		// falls back to the stored measure.
+		// Meter duality (design §8): prefer the trim layer's wire-domain meter —
+		// max(fresh outbound view, last sampled MAIN-dispatch prompt), the same
+		// number the trim pressure tiers evaluate — when present. Each pure
+		// source has one bias: the stored tally is wire-domain but never
+		// re-prices splice-level folds (it keeps counting material the model no
+		// longer receives — high bias), while the bare view never counts the
+		// system/tool sections (low bias). max(view, wire) fixes both and puts
+		// the watermark tiers (soft/hard/force + read budget) on the SAME
+		// boundary as the fold engine — wmHardTokens 95k ≈ trim pressure
+		// 97.5k (65% of the 150k window) — holds in units, not just in
+		// numbers. Strictly additive +
+		// fail-open: any trim failure falls back to the stored measure.
 		try {
 			const sessionId = agent?.session?.id ?? (typeof agent?.id === "string" ? agent.id : null);
-			const viewTokens = sessionId === null ? null : recentTrimViewTokensOf(sessionId);
-			if (viewTokens !== null) return viewTokens;
+			const promptTokens = sessionId === null ? null : recentTrimPromptTokensOf(sessionId);
+			if (promptTokens !== null) return promptTokens;
 		} catch {
 			// fall through to the stored measure
 		}
@@ -171,58 +173,53 @@ export function measureNow(ctx, agent) {
 
 // ---- watermark rendering (pure given state + measurement) ------------------
 
-/** Bucket width for the live used reading. 5k steps keep the tail snapshot
- * emission rate low (the snapshot re-emits only when its joined text
- * changes); tier crossings change the line immediately regardless. */
-const USED_BUCKET_TOKENS = 5000;
-
-/** `~50k`-style bucketed reading for the live watermark line. */
-function bucketKilo(tokens) {
-	return `${Math.round(tokens / USED_BUCKET_TOKENS) * (USED_BUCKET_TOKENS / 1000)}k`;
-}
+/** MODEL-VISIBILITY POLICY (docs/ladder-fold.md, bili lesson #2): the
+ * watermark NEVER shows the model a water level — no used-token counts, no
+ * budget values, no percentages, no cooldown minutes. A model told "you're
+ * at 20%" anchors on "looks healthy" and refuses to fold or wrap; with the
+ * numbers hidden, judgment roots in the task. Only BEHAVIORAL directives
+ * travel, and only when enforcement changes (a tier crossing or a handover
+ * phase change), which also keeps the runtime-context snapshot byte-stable
+ * between those events. The full numeric picture stays available to the
+ * human through the client badge. */
 
 /** Byte-stable protocol text for root sessions: no live numbers, so the
  * request head stays byte-identical for the whole session (KV-cache
- * invariant); the numbers live in the tail context line only. */
+ * invariant). */
 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 (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.",
+	"[SWITCHMAN:WATERMARK] protocol: this session's context is managed automatically (folding runs before you notice; a handover may run when needed). You will never receive token counts, percentages, or progress numbers — none exist in this protocol, and no pacing decision is yours to make from them.",
+	"Only BEHAVIORAL directives arrive, as [SWITCHMAN:WATERMARK] lines inside the appended runtime-context snapshot, when enforcement changes: a soft line asks you to prefer delegation over reading more context yourself; a hard line says broad reading is budget-limited this turn and it is time to start wrapping up; a force line is a MANDATORY wrap-up — produce the final answer from what you already hold. /ctx-pause pauses every watermark enforcement (measurement continues), /ctx-resume restores it, /ctx-handover starts a handover immediately.",
 ].join("\n");
 
 /** Byte-stable protocol text for subagent sessions (same invariant). */
 const PROTOCOL_SUB_TEXT = [
-	"[SWITCHMAN:WATERMARK] protocol: this subagent session is guarded by a context watermark measured every step.",
-	"ok tier is silent. soft tier: keep reads narrow and drop bulky raw output. hard tier: stop broad reading; wrap toward the final summary. force tier: stop reading and return the final summary now — end the FINAL message with a HANDOFF block: completed / key findings (file:line) / remaining / next steps.",
-	"The live tier and the bucketed used-token reading arrive ONLY as [SWITCHMAN:WATERMARK] lines inside the appended runtime-context snapshot; a tier change is announced on the step it happens.",
+	"[SWITCHMAN:WATERMARK] protocol: this subagent session's context is managed automatically. You will never receive token counts, percentages, or progress numbers — judgment stays rooted in the task.",
+	"Only BEHAVIORAL directives arrive, as [SWITCHMAN:WATERMARK] lines inside the appended runtime-context snapshot, when enforcement changes: a soft line asks for narrow reads; a hard line says stop broad reading and wrap toward the final summary; a force line says stop reading and return the final summary now, ending the FINAL message with a HANDOFF block: completed / key findings (file:line) / remaining / next steps.",
 ].join("\n");
 
-/** Static paused line (numbers omitted on purpose: enforcement is off, and a
+/** Static paused line (never changes while paused: enforcement is off, and a
  * frozen string emits once and never churns the snapshot again). */
 const PAUSED_LINE =
 	"[SWITCHMAN:WATERMARK] paused — measurement continues, but every watermark enforcement stays off until /ctx-resume.";
 
-/** Root-session live line: "" at ok (token economy), tier advice lines plus
- * the live handover progress (phase/attempt) and auto-cooldown state. */
-function renderRootWatermark(level, used, th, status) {
+/** Root-session live line: directive text only — no numbers (see the
+ * policy note above). "" while the session sits at the silent ok tier. */
+function renderRootWatermark(level, status) {
 	if (level === "ok") return "";
-	const head =
-		`[SWITCHMAN:WATERMARK] ${level} tier — used ~${bucketKilo(used)}` +
-		` of budget ${kilo(th.soft)}/${kilo(th.hard)}/${kilo(th.force)}`;
-	if (level === "soft") return `${head}\nsoft tier: prefer delegating lightweight work (subagent/workflow) over reading more context yourself.`;
-	if (level === "hard") return `${head}\nhard tier: stop broad reading (read/glob/grep are budget-limited this turn) and start wrapping up.`;
-	const lines = [head, "force tier: MANDATORY wrap-up now — produce the final answer from what you already hold."];
+	if (level === "soft") return "[SWITCHMAN:WATERMARK] soft tier: prefer delegating lightweight work (subagent/workflow) over reading more context yourself.";
+	if (level === "hard") return "[SWITCHMAN:WATERMARK] hard tier: stop broad reading (read/glob/grep are budget-limited this turn) and start wrapping up.";
+	const lines = ["[SWITCHMAN:WATERMARK] 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: writing the handover document…`);
 	} else if (phase === "compacting") {
-		lines.push(`context handover running: compaction attempt ${status?.attempt ?? "?"} (retries while the turn is still running)…`);
+		lines.push(`context handover running: compaction in progress (retries while the turn is still running)…`);
 	} else if (phase === "continuation") {
 		lines.push(`context handover completing: waking this session to fill in the document and continue the task…`);
 	} else if (status?.autoHandover) {
 		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.`
+			status?.cooldown
+				? `automatic handover is cooling down; run /ctx-handover${status?.tool ? " or call the ctx_handover tool" : ""} to force one now.`
 				: `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 {
@@ -231,21 +228,16 @@ function renderRootWatermark(level, used, th, status) {
 	return lines.join("\n");
 }
 
-/** Subagent-session live line: the same soft/hard/force absolute-token tiers
- *  as the root line ("" while ok — token economy), with subagent-flavored
- *  advice and the HANDOFF block due at the force tier. Pausing never applies
- *  to subagents (oc index.ts:187-190). */
-function renderSubWatermark(used, th) {
-	const level = levelOf(used, th);
+/** Subagent-session live line: the same tiers as the root line, directive
+ * text only — no numbers (see the policy note above). Pausing never
+ * applies to subagents (oc index.ts:187-190). */
+function renderSubWatermark(level) {
 	if (level === "ok") return "";
-	const head =
-		`[SWITCHMAN:WATERMARK] subagent ${level} tier — used ~${bucketKilo(used)}` +
-		` of budget ${kilo(th.soft)}/${kilo(th.hard)}/${kilo(th.force)}`;
-	if (level === "soft") return `${head}\nsoft tier: keep reads narrow and drop bulky raw output.`;
-	if (level === "hard") return `${head}\nhard tier: stop broad reading; start wrapping toward the final summary.`;
+	if (level === "soft") return "[SWITCHMAN:WATERMARK] soft tier: keep reads narrow and drop bulky raw output.";
+	if (level === "hard") return "[SWITCHMAN:WATERMARK] hard tier: stop broad reading; start wrapping toward the final summary.";
 	return (
-		`${head}\nforce tier: stop reading and return the final summary now.\n` +
-		`End the FINAL message with a HANDOFF block: completed / key findings (file:line) / remaining / next steps.`
+		"[SWITCHMAN:WATERMARK] force tier: stop reading and return the final summary now.\n" +
+		"End the FINAL message with a HANDOFF block: completed / key findings (file:line) / remaining / next steps."
 	);
 }
 
@@ -258,24 +250,24 @@ function renderWatermarkContext(ctx, config, state, agent) {
 		const th = readThresholds(config);
 		const used = measureNow(ctx, agent);
 		if (used === null) return "";
+		const level = levelOf(used, th);
+		if (level === "ok") return "";
 		if (!isRoot(ctx, agent)) {
 			// Subagents share the root soft/hard thresholds; the optional
 			// wmSubagentForceTokens override replaces only the force tier
 			// (enabled by the wmSubagentCap toggle, 0/0 = follow the root set).
 			const subForce = readBool(config.wmSubagentCap, true) ? readNumber(config.wmSubagentForceTokens, 0) : 0;
 			const subTh = subForce > 0 ? { ...th, force: subForce } : th;
-			return renderSubWatermark(used, subTh);
+			return renderSubWatermark(levelOf(used, subTh));
 		}
 		if (state.paused.has(sessionId)) return PAUSED_LINE;
 		const live = handoverOf(sessionId);
 		const elapsed = Date.now() - (state.lastHandover.get(sessionId) ?? 0);
-		// Cooldown quantized to 5-minute steps so the emitted line stays
-		// byte-stable between steps (snapshot re-emits only on change).
-		return renderRootWatermark(levelOf(used, th), used, th, {
+		return renderRootWatermark(level, {
 			autoHandover: readBool(config.wmAutoHandover, true),
 			phase: live?.phase,
 			attempt: live?.attempt,
-			cooldownMin: Math.max(0, Math.ceil((HANDOVER_COOLDOWN_MS - elapsed) / 300_000) * 5),
+			cooldown: elapsed < HANDOVER_COOLDOWN_MS,
 			tool: state.handoverTool ?? undefined,
 		});
 	} catch {
@@ -846,16 +838,26 @@ function applyContextWatch(ctx, config) {
 						readString(config.wmDenyMode) !== "deny" &&
 						Array.isArray(result?.content)
 					) {
-						return {
-							kind: "accept",
-							content: [
-								...result.content,
-								{
-									type: "text",
-									text: `[SWITCHMAN:WATERMARK] read budget exceeded this turn (used ${Math.round(entry.used)}/${Math.round(ceiling)} tokens) — further reads may be denied; wrap up or delegate the remaining reading.`,
-								},
-							],
-						};
+						// [2026-11-07]-[the warning branch used to return without
+						// calling next()]-[that short-circuited every post-execute
+						// handler downstream of the watermark (trim fork-link
+						// accounting, subagent model annotation) on exactly the
+						// turns that read the most. Run the pipeline first, then
+						// append the warning to whatever the pipeline accepted.]
+						return (async () => {
+							const downstream = await next();
+							const base = downstream !== null && typeof downstream === "object" && downstream.kind === "accept" && Array.isArray(downstream.content) ? downstream : result;
+							return {
+								kind: "accept",
+								content: [
+									...base.content,
+									{
+										type: "text",
+										text: `[SWITCHMAN:WATERMARK] read budget exceeded this turn (used ${Math.round(entry.used)}/${Math.round(ceiling)} tokens) — further reads may be denied; wrap up or delegate the remaining reading.`,
+									},
+								],
+							};
+						})();
 					}
 				}
 			}
@@ -929,8 +931,15 @@ function applyContextWatch(ctx, config) {
 	ctx.commands.register({
 		name: "ctx-handover",
 		description: "Trigger a full context handover for this session now (document + compaction + continuation).",
+		// Signal deliberately dropped (inspection W20): a turn-scoped
+		// AbortSignal shared by every /compact retry turns a user cancel into
+		// six straight failures walking the full ~530 s backoff ladder with a
+		// misleading error text — the same reason the ctx_handover TOOL path
+		// drops its turn signal. sessionCompact fabricates a fresh un-aborted
+		// signal when none arrives; user cancel lets compaction finish, like
+		// the tool path.
 		handler: (invocation) =>
-			runHandover(invocation?.agent, sessionIdOf(invocation?.agent), invocation?.commandId, invocation?.signal, "manual"),
+			runHandover(invocation?.agent, sessionIdOf(invocation?.agent), invocation?.commandId, undefined, "manual"),
 	});
 
 	// --- E. ctx_handover: the agent-callable front door to the same
@@ -989,7 +998,6 @@ function applyContextWatch(ctx, config) {
 
 export {
 	applyContextWatch,
-	bucketKilo,
 	PAUSED_LINE,
 	PROTOCOL_ROOT_TEXT,
 	PROTOCOL_SUB_TEXT,

package/host/dispatch.js

@@ -284,15 +284,40 @@ function annotationFixOf(args, config) {
 	);
 }
 
+/** The assembling session's own route, from the DSH agent-loop's assemble
+ *  context (`agent.ts` passes `modelSelection` with every turn assembly;
+ *  older builds and non-agent assemblies omit it). Null when absent or
+ *  malformed — the session-route line then does not render (fail-open,
+ *  like every capability read in this file family). */
+function sessionRouteOf(context) {
+	const route = context === null || typeof context !== "object" ? undefined : context.modelSelection;
+	if (route === null || typeof route !== "object") return null;
+	const provider = typeof route.provider === "string" ? route.provider.trim() : "";
+	const model = typeof route.model === "string" ? route.model.trim() : "";
+	if (provider === "" || model === "") return null;
+	const effort = typeof route.reasoningEffort === "string" && route.reasoningEffort !== "" ? route.reasoningEffort : null;
+
+	return { provider, model, effort };
+}
+
+
 /** The `[SWITCHMAN:POOLS]` block: anchor line, one line per configured lane,
  *  then the guidance lines (byte-stable for a given configuration). Routes
  *  outside the session's DSH-authorized child models carry a ⚠not-authorized
  *  marker (after any @effort suffix) — teams mode only: with teamsMode OFF
  *  the whitelist is never read, `state.authorized` stays null, and neither
- *  the markers nor the drift guidance lines render. */
-function renderPoolsBlock(state) {
+ *  the markers nor the drift guidance lines render. When the assembling
+ *  context carries the session's own model selection, a `session route:`
+ *  line follows the anchor. */
+function renderPoolsBlock(state, sessionRoute = null) {
 	const configured = state.lanePools.filter((pool) => pool.routes.length > 0);
 	const lines = [`[SWITCHMAN:POOLS] configured=${configured.length}/6 enforce=${state.enforce}`];
+	if (sessionRoute !== null) {
+		lines.push(
+			`session route: ${sessionRoute.provider}/${sessionRoute.model}${sessionRoute.effort === null ? "" : `@${sessionRoute.effort}`}` +
+				` — implicit dispatch (omitting provider/model/effort) gives the child THIS route; when it differs from the lane entries, only an explicit dispatch lands a lane model.`,
+		);
+	}
 	let anyUnauthorized = false;
 	for (const pool of state.lanePools) {
 		if (pool.routes.length === 0) continue;
@@ -317,7 +342,7 @@ function renderPoolsBlock(state) {
 		`Entries render as provider/model(TIER)@effort: (TIER) is the S/A/B/C capability grade and @effort a manually pinned reasoning effort — both are display-only annotations, NEVER parts of the model id.`,
 		`Decompose before dispatching: provider/model(TIER)@effort → provider=provider, model=model, reasoning_effort=effort (a pin overrides the lane default); a route without @effort carries no per-route pin — fall back to the lane's default effort above.`,
 		`Review delegations: anchor independence on the code AUTHOR's model, not the main session's (author = the agent that produced the diff: its explicit dispatch route, or the inherited session model when unspecified). Prefer a reviewer model different from the author's; also avoiding the session model is a bonus (its integration pass already covers that angle). If no pool entry differs from the author, same-model review is allowed — declare DOWNGRADED and state whether it is relative to the author or the session.`,
-		`Explicit provider/model/effort on subagent/workflow calls is validated against this session's DSH-authorized child models (DSH Settings: allow agents to choose subagent models) — NOT against this table; when denied, discover allowed routes via list_subagent_models, or dispatch implicitly by omitting all three fields (the child then uses configured defaults or inherits the parent route).`,
+		`Explicit lane dispatch is the DEFAULT for subagent/workflow: name provider+model+reasoning_effort decomposed from the lane row (validated against this session's DSH-authorized child models — DSH Settings: allow agents to choose subagent models — NOT against this table). Implicit dispatch (omitting all three fields) is a LAST-RESORT fallback, never a shortcut: use it only after an explicit attempt was denied or list_subagent_models confirmed no authorized route, and declare IMPLICIT-DOWNGRADED in your report when you do — the child then uses configured defaults or inherits the parent route, so the lane's model is lost.`,
 	);
 	if (anyUnauthorized) {
 		lines.push(
@@ -353,11 +378,11 @@ function applyDispatch(ctx, config) {
 		name: "switchman:dispatch",
 		order: 10400,
 		interpolate: false,
-		text: () => {
+		text: (context) => {
 			const state = readDispatchState(ctx, config);
 			const anyConfigured = state.lanePools.some((pool) => pool.routes.length > 0) || state.modelRank.length > 0;
 			if (!anyConfigured) return "";
-			return renderPoolsBlock(state);
+			return renderPoolsBlock(state, sessionRouteOf(context));
 		},
 	});
 

package/host/routes.js

@@ -95,6 +95,24 @@ const NUMBER_FIELDS = [
 	"wmReadBudgetTokens",
 	"wmSubagentForceTokens",
 ];
+/** Trim numbers carry their own schema bounds (host/config.js), so the
+ *  shared NUMBER_FIELDS coercion (which only rejects negatives) is too
+ *  loose — these validate against each field's declared min/max. This group
+ *  MUST mirror the client page's TRIM_NUMBER_FIELDS: a field coerced here
+ *  but never sent by the client fails every fenced write (and vice versa). */
+const TRIM_NUMBER_FIELDS = [
+	{ field: "trimGrowthTokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 22500 },
+	{ field: "trimIncrementTokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 25000 },
+	{ field: "trimPressurePercent", min: 5, max: 100, def: 65 },
+	{ field: "trimEmergencyPercent", min: 5, max: 100, def: 95 },
+	{ field: "trimWindowTokens", min: 0, max: Number.POSITIVE_INFINITY, def: 0 },
+	{ field: "trimProtectedTail", min: 0, max: 100, def: 10 },
+	{ field: "trimLadderT2Tokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 8000 },
+	{ field: "trimLadderT2MinBlocks", min: 2, max: 200, def: 3 },
+	{ field: "trimLadderT3Tokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 6000 },
+	{ field: "trimLadderT3MinBlocks", min: 2, max: 200, def: 2 },
+	{ field: "trimMaxFoldsPerHour", min: 1, max: 60, def: 30 },
+];
 const BOOLEAN_FIELDS = [
 	"wmAutoHandover",
 	"wmSubagentCap",
@@ -110,6 +128,10 @@ const BOOLEAN_FIELDS = [
 	"syncWhitelist",
 	// Intent recognition (mirrors the intent* group in host/config.js).
 	"intentEnabled",
+	// Context trim switches (mirrors the trim group in host/config.js).
+	"trimEnabled",
+	"trimLadderEnabled",
+	"surfaceFold",
 ];
 /** Intent numbers carry their own schema bounds (config.js), so the shared
  *  NUMBER_FIELDS coercion (which only rejects negatives) is too loose — these
@@ -125,7 +147,7 @@ const INTENT_NUMBER_FIELDS = [
 /** Intent route references: unlike pool routes they round-trip the "unset"
  *  {provider:"", model:""} pair, so they validate against the loosened
  *  cleanIntentRoute (both keys must be strings; either may be empty). */
-const INTENT_ROUTE_FIELDS = ["intentClassifierRoute", "intentFallbackRoute"];
+const INTENT_ROUTE_FIELDS = ["intentClassifierRoute", "intentFallbackRoute", "trimSideModel", "trimFoldFallbackModel"];
 /** Intent candidate list (route + optional effort/note per entry). */
 const INTENT_CANDIDATE_FIELDS = ["intentCandidates"];
 
@@ -144,7 +166,10 @@ const ENUM_FIELDS = {
 	dispatchEnforce: ["off", "advice", "enforce"],
 	wmDenyMode: ["cap", "deny"],
 	intentClassifierKind: ["chat", "systemone"],
+	trimMode: ["off", "advisory", "auto"],
 };
+/** Trim string fields (mirrors host/config.js strings). */
+const TRIM_STRING_FIELDS = ["trimStateDir"];
 
 /** JSON response helper. */
 function writeJson(res, status, payload) {
@@ -312,6 +337,7 @@ function cleanIntentCandidate(entry) {
 export function snapshotOf(config) {
 	const values = {};
 	for (const field of STRING_FIELDS) values[field] = String(rawOf(config?.[field]) ?? "");
+	for (const field of TRIM_STRING_FIELDS) values[field] = String(rawOf(config?.[field]) ?? "");
 	for (const field of POOL_FIELDS)
 		values[field] = Array.isArray(rawOf(config?.[field]))
 			? rawOf(config[field]).map(cleanRoute).filter(Boolean)
@@ -337,6 +363,11 @@ export function snapshotOf(config) {
 	values.dispatchEnforce = ENUM_FIELDS.dispatchEnforce.includes(rawOf(config?.dispatchEnforce))
 		? rawOf(config.dispatchEnforce)
 		: "advice";
+	values.trimMode = ENUM_FIELDS.trimMode.includes(rawOf(config?.trimMode)) ? rawOf(config.trimMode) : "auto";
+	for (const { field, def } of TRIM_NUMBER_FIELDS) {
+		const raw = Number(rawOf(config?.[field]));
+		values[field] = Number.isFinite(raw) ? raw : def;
+	}
 	for (const field of NUMBER_FIELDS) {
 		const raw = Number(rawOf(config?.[field]));
 		values[field] = Number.isFinite(raw) ? raw : 0;
@@ -407,6 +438,17 @@ export function coerceValues(input) {
 	values.langScope = input.langScope;
 	if (!ENUM_FIELDS.dispatchEnforce.includes(input.dispatchEnforce)) return null;
 	values.dispatchEnforce = input.dispatchEnforce;
+	if (!ENUM_FIELDS.trimMode.includes(input.trimMode)) return null;
+	values.trimMode = input.trimMode;
+	for (const field of TRIM_STRING_FIELDS) {
+		if (typeof input[field] !== "string") return null;
+		values[field] = input[field];
+	}
+	for (const { field, min, max } of TRIM_NUMBER_FIELDS) {
+		const raw = Number(input[field]);
+		if (!Number.isFinite(raw) || raw < min || raw > max) return null;
+		values[field] = raw;
+	}
 	for (const field of NUMBER_FIELDS) {
 		const raw = Number(input[field]);
 		if (!Number.isFinite(raw) || raw < 0) return null;
@@ -421,9 +463,27 @@ export function coerceValues(input) {
 	return values;
 }
 
-/** Deep-equal on the plain-JSON value shapes this module exchanges. */
-function sameValues(a, b) {
-	return JSON.stringify(a) === JSON.stringify(b);
+/** Stable JSON text: object keys sorted at every depth. snapshotOf and
+ *  coerceValues build the same fields in DIFFERENT insertion orders
+ *  (e.g. trimStateDir sits 7th in a snapshot but near the tail after
+ *  coercion), so a raw stringify compared key order, not content —
+ *  every fenced save 409'd ("settings changed elsewhere") even with no
+ *  intervening writer (2026-11-07 settings-save bug). */
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value !== null && typeof value === "object")
+		return `{${Object.keys(value)
+			.sort()
+			.map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+			.join(",")}}`;
+	return JSON.stringify(value) ?? "undefined";
+}
+
+/** Deep-equal on the plain-JSON value shapes this module exchanges;
+ *  key-order insensitive (see canonicalJson). Exported for the smoke
+ *  suite alongside coerceValues — the fence predicate IS the contract. */
+export function sameValues(a, b) {
+	return canonicalJson(a) === canonicalJson(b);
 }
 
 /** Enumerate the model catalog from the host session controller. */

package/host/teams.js

@@ -84,6 +84,7 @@ const TEAMS_SECTION_TEXT = [
 	"## 五、团队触发与协作纪律",
 	"- 需要多成员持久协作、共享任务板、消息往来的用 Agent Teams（满足任一即触发 spawn_teammate：可并行的多个独立子任务；量大且自包含；主上下文水位已高；需要角色分离）；一次性、无需共享状态的单点调查用 subagent。",
 	"- 写作域隔离：共享任务上写明互不重叠的 write_scopes；用 team_task_* 维护任务板与依赖顺序；Lead 汇总最终 diff、复核关键改动并运行测试；用 wait_agent 等到必需的 teammate 完成，绝不在结果未回前下最终结论。",
+	"- 子智能体消息通道：subagent/workflow 返回的子会话 id 只能经 child_message 桥接送达——send_message 只解析 teammate 名字，对子会话 id 必报 active teammate「…」not found；该报错不代表子会话死亡，先改用 child_message，不要据此重派或判定死亡。",
 ].join("\n");
 
 // ---- shared volatile-read helpers (mirrors dispatch.js) --------------------
@@ -580,4 +581,4 @@ function applyTeams(ctx, config) {
 	syncChildMessageTool();
 }
 
-export { applyTeams, pumpTeamsOrchestration, SWITCHMAN_SETTINGS_NS, scheduleTeamsOrchestration, teamsBundleState, teamsSyncSnapshot };
+export { applyTeams, pumpTeamsOrchestration, SWITCHMAN_SETTINGS_NS, TEAMS_SECTION_TEXT, scheduleTeamsOrchestration, teamsBundleState, teamsSyncSnapshot };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dsh-switchman",
-	"version": "1.10.3",
+	"version": "1.11.1",
 	"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": [
@@ -28,7 +28,7 @@
 	"icon": "./icon.svg",
 	"engines": {
 		"node": ">=24",
-		"dsh": ">=0.2.1-rc.1"
+		"dsh": ">=0.2.2-rc.1"
 	},
 	"exports": {
 		".": "./index.js",