dsh-switchman 1.11.3 → 1.11.5

package/host/context-trim/index.js

@@ -695,10 +695,9 @@ export function applyContextTrim(ctx, config) {
 		} else if (view.applied > 0) {
 			epochResetDoneBySession.delete(sessionId);
 		}
-		// Capture the session's own resolved reasoningEffort alongside
-		// provider/model: at stream-listener time DSH has already resolved the
-		// effective effort for this dispatch, so the side route can inherit it
-		// verbatim instead of re-deriving (and losing) it.
+		// Record the active request's route and resolved effort for diagnostics only.
+		// The side summarizer follows provider/model only and resolves effort from its
+		// model metadata rather than inheriting this dispatch's effort.
 		const model = {
 			provider: options.provider ?? null,
 			model: options.model ?? null,
@@ -718,16 +717,14 @@ export function applyContextTrim(ctx, config) {
 	}
 
 	/** Resolve the side-model route: explicit trimSideModel route, else the
-	 * session's own model (inherit — design §5). */
+	 * session's own provider/model. Effort is resolved from that model's
+	 * supported thinking metadata, not inherited from the active session call. */
 	function sideRouteFor(sessionId) {
 		const explicit = readRoute(config, "trimSideModel");
 		if (explicit !== null) return explicit;
 		const model = metrics.of(sessionId)?.lastModel ?? null;
 		if (model !== null && typeof model.provider === "string" && model.provider !== "" && typeof model.model === "string" && model.model !== "") {
-			// Inherit the session's own resolved effort when one was captured.
-			return typeof model.effort === "string" && model.effort !== ""
-				? { provider: model.provider, model: model.model, effort: model.effort }
-				: { provider: model.provider, model: model.model };
+			return { provider: model.provider, model: model.model };
 		}
 		return null;
 	}

package/host/context-trim/summarizer.js

@@ -224,15 +224,25 @@ function describeFailure(chunk) {
 	return ` (${raw.replace(/\s+/gu, " ").trim().slice(0, 300)})`;
 }
 
-/** Side-model summary. llm: the dsh llm service (receiver-bound methods);
- * route: { provider, model, effort? } | null (null → caller skips); materialText:
- * compression prompt (the ladder distillation passes its own); deadlineMs:
- * hard budget. Returns the summary text, or null on ANY failure (caller
- * skips the fold cycle). */
+/** Choose the lowest enabled tier when several reasoning levels are available.
+ * A model with only an on/off switch is pinned to "off"; when reasoning
+ * metadata is absent, leave the model's adapter default unchanged. */
+export function recommendedReasoningEffort(modelInfo) {
+	const efforts = modelInfo?.reasoning?.efforts;
+	if (!Array.isArray(efforts) || efforts.length === 0) return null;
+	const ids = efforts.map((entry) => typeof entry === "string" ? entry : entry?.id).filter((id) => typeof id === "string" && id !== "");
+	const enabled = ids.filter((id) => id !== "off");
+	if (enabled.length > 1) return enabled[0];
+	return ids.includes("off") ? "off" : null;
+}
+
+/** Side-model summary. llm: the dsh llm service; route: {provider, model, effort?}.
+ * An empty effort pin is resolved from model reasoning metadata; unavailable
+ * metadata leaves the adapter default unchanged. Returns summary text or null. */
 export async function summarizeWithModel(llm, route, materialText, options = {}) {
 	const fail = typeof options.onFail === "function" ? options.onFail : null;
-	// Effort-retry notice: fires BEFORE the low-pinned retry, whether or not
-	// the retry lands. Falls back to fail when the caller doesn't supply one.
+	// Effort-retry notice: fires before a one-time effort fallback, whether
+	// or not that retry lands. Falls back to fail when no notice is supplied.
 	const notice = typeof options.onNotice === "function" ? options.onNotice : null;
 	if (route === null || route === undefined) { fail?.("no-route"); return null; }
 	if (typeof llm?.prepareCall !== "function") { fail?.("no-prepare-call"); return null; }
@@ -242,39 +252,40 @@ export async function summarizeWithModel(llm, route, materialText, options = {})
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(new Error("trim summary deadline")), deadlineMs);
 	try {
-		// Effort policy: inherit the route's effort verbatim when it carries
-		// one (session-inherited routes carry the session's own DSH-resolved
-		// effort; explicit trimSideModel configs may pin theirs), else pin
-		// "low" — summaries are auxiliary work. NEVER send without an effort,
-		// and never send "off": pi-ai maps both to thinking:{type:"disabled"}
-		// (profileOptions turns "off" back into an absent reasoning option),
-		// which newer Anthropic endpoints reject with 400. A DSH session run
-		// with thinking disabled resolves its effort to "off", so an inherited
-		// route can carry exactly that value — treat it like empty here.
-		// The effort rides the prepareCall proposal so it resolves into
-		// call.config, keeping stream options consistent with the prepared
-		// call (INVALID_PREPARED_CALL guard).
-		const requestedEffort = typeof route.effort === "string" && route.effort !== "" && route.effort !== "off" ? route.effort : "low";
+		// Resolve from the selected model itself: an empty pin means the lowest
+		// advertised thinking effort, while absent reasoning metadata leaves
+		// the adapter default (no thinking) untouched. Explicit effort pins win.
+		let modelInfo = null;
+		if (typeof llm.resolveModelInfo === "function") {
+			try { modelInfo = await llm.resolveModelInfo(route.provider, route.model, controller.signal); }
+			catch { /* Metadata is advisory; prepareCall remains authoritative. */ }
+		}
+		const automaticEffort = recommendedReasoningEffort(modelInfo);
+		const hasOffEffort = Array.isArray(modelInfo?.reasoning?.efforts) && modelInfo.reasoning.efforts.some((entry) => (typeof entry === "string" ? entry : entry?.id) === "off");
+		const explicitEffort = typeof route.effort === "string" && route.effort !== "";
+		const requestedEffort = explicitEffort ? route.effort : automaticEffort;
+		const proposalFor = (effort) => ({
+			provider: route.provider,
+			model: route.model,
+			maxTokens,
+			...(typeof effort === "string" && effort !== "" ? { reasoningEffort: effort } : {}),
+		});
 		let call;
 		try {
-			call = await llm.prepareCall(
-				{ provider: route.provider, model: route.model, maxTokens, reasoningEffort: requestedEffort },
-				controller.signal,
-				(controls) => controls,
-			);
+			call = await llm.prepareCall(proposalFor(requestedEffort), controller.signal, (controls) => controls);
 		} catch (prepareError) {
-			// An inherited session effort can exceed what the route's adapter
-			// supports: retry once pinned low before giving up (the outer
-			// catch then turns the failure into a skipped fold cycle).
 			const code = prepareError?.code ?? null;
 			const named = typeof prepareError?.message === "string" && prepareError.message.includes("UNSUPPORTED_REASONING_EFFORT");
-			if (requestedEffort === "low" || (code !== "UNSUPPORTED_REASONING_EFFORT" && !named)) throw prepareError;
-			(notice ?? fail)?.(`effort "${requestedEffort}" unsupported, retrying low`);
-			call = await llm.prepareCall(
-				{ provider: route.provider, model: route.model, maxTokens, reasoningEffort: "low" },
-				controller.signal,
-				(controls) => controls,
-			);
+			if (code !== "UNSUPPORTED_REASONING_EFFORT" && !named) throw prepareError;
+			// Stale metadata or a stale pin should not prevent a summary: retry
+			// once at the model's automatic minimum, or without an effort. Never
+			// turn an explicitly requested "off" into enabled reasoning.
+			const retryEffort = requestedEffort === "off"
+				? null
+				: (explicitEffort && automaticEffort !== requestedEffort ? automaticEffort : (hasOffEffort ? "off" : null));
+			if (retryEffort === requestedEffort) throw prepareError;
+			(notice ?? fail)?.(`effort "${requestedEffort ?? "default"}" unsupported, retrying ${retryEffort ?? "without reasoning"}`);
+			call = await llm.prepareCall(proposalFor(retryEffort), controller.signal, (controls) => controls);
 		}
 		let text = "";
 		let finishKind = null;

package/host/ptc-guard.js

@@ -89,6 +89,12 @@ function renderPtcGuard() {
 		`- Every other tool MUST be invoked as an awaited SDK function inside a ${RUN_CODE_NAME} program: \`await tools.name(args)\` — e.g. \`await tools.skill({ name: "git-commit-message" })\` or \`await tools.spawn_teammate({ ... })\`.`,
 		`- A direct call fails with: unknown tool "x": only \`${RUN_CODE_NAME}\` is callable directly — call \`x\` from inside a \`${RUN_CODE_NAME}\` program instead. Never retry the direct form; wrap the call.`,
 		`- Wherever this prompt says "call the X tool" (skill catalog, doctrines, per-turn reminders), read it as "call X inside a ${RUN_CODE_NAME} program". Batch independent calls as parallel awaits inside ONE program.`,
+		`- \`grep.pattern\` is a regular expression. In a normal JavaScript string inside \`${RUN_CODE_NAME}\`, double backslashes: write \`"\\\\("\` to pass \`\\(\` to grep; \`String.raw\` tagged templates also preserve backslashes. If grep reports \`unclosed group\`, fix the pattern before retrying; never repeat it unchanged.`,
+		`- Unless this call must intentionally retain state across calls (e.g. the one-time CUA bridge initialization), MUST wrap the entire ${RUN_CODE_NAME} program body in an async IIFE: \`await (async () => { ... })();\`. Keep all temporary \`const\`/\`let\`/\`class\` declarations inside it; this makes reusing local names such as \`res\` safe even when an earlier call used them. Top-level bindings persist for this Agent: only create them for intentionally shared state, and never redeclare existing top-level \`const\`/\`let\`/\`class\`; reassign an existing top-level \`var\` or choose a fresh unique name. If \`Identifier ... has already been declared\` occurs, rewrite the program in the IIFE rather than merely rerunning it—the SyntaxError happens before the body runs.`,
+		`- For intentional top-level bindings, maintain a ledger of declared names at \`globalThis.__dshSwitchmanPtcBindings\` (initialize idempotently with \`globalThis.__dshSwitchmanPtcBindings ??= new Set()\`). Before emitting a program with top-level declarations, check each name against this ledger and the visible prior \`${RUN_CODE_NAME}\` snippets; after a successful declaration, add the name with \`globalThis.__dshSwitchmanPtcBindings.add("name")\`. This ledger is manually maintained, not automatic introspection: if the old history or ledger is incomplete, do not guess—keep the code in an IIFE or choose a fresh name.`,
+		`- For routine \`${RUN_CODE_NAME}\` calls — including programs that only call SDK tools such as \`tools.skill(...)\` — pass only \`code\`, \`description\`, and \`timeoutMs\`; omit both \`sandbox_permissions\` and \`justification\`. If a call is rejected for invalid justification, never repeat it unchanged; retry without those fields.`,
+		`- If ${RUN_CODE_NAME} returns a parser error such as "Expected ident", treat it as a syntax issue in the submitted code; when present, the appended "File sandbox: ..." reports execution context, not the cause. Correct the code before retrying; never repeat it unchanged.`,
+		`- When a ${RUN_CODE_NAME} program embeds long prompt text, do not hand-write it as a double-quoted JavaScript string if it contains quotes (for example, getResource(".") or System.getProperty("user.dir")): build the text as data, escape the inner quotes, or serialize it with JSON.stringify(text); inspect or syntax-check the complete source before retrying.`,
 		`- Never set \`sandbox_permissions\` on any call, direct or SDK: it is a privilege-escalation request and fails with "not strictly wider than this call's current ... mode" whenever the session already runs at least that access level — retry without the field.`,
 	].join("\n");
 }

package/host/routes.js

@@ -150,13 +150,12 @@ const INTENT_NUMBER_FIELDS = [
 	{ field: "intentHistoryMaxChars", min: 200, max: 20000, def: 2400 },
 	{ field: "intentContextWindow", min: 1024, max: Number.POSITIVE_INFINITY, def: 200000 },
 ];
-/** Intent route references round-trip the "unset" {provider:"", model:""}
+/** Intent classifier routes round-trip the "unset" {provider:"", model:""}
  *  pair, so they validate against the loosened cleanIntentRoute (both keys
- *  must be strings; either may be empty); intent routes never carry effort. */
-const INTENT_ROUTE_FIELDS = ["intentClassifierRoute", "intentFallbackRoute"];
-/** Trim side routes additionally round-trip an optional effort pin — the
- *  settings page's reasoning-effort select — via cleanTrimRoute below. */
-const TRIM_ROUTE_FIELDS = ["trimSideModel", "trimFoldFallbackModel"];
+ *  must be strings; either may be empty). */
+const INTENT_ROUTE_FIELDS = ["intentClassifierRoute"];
+/** Summary routes and the intent fallback route can carry an effort pin. */
+const EFFORT_ROUTE_FIELDS = ["trimSideModel", "trimFoldFallbackModel", "intentFallbackRoute"];
 /** Intent candidate list (route + optional effort/note per entry). */
 const INTENT_CANDIDATE_FIELDS = ["intentCandidates"];
 
@@ -315,11 +314,8 @@ function cleanIntentRoute(entry) {
 	return provider === null || model === null ? null : { provider, model };
 	}
 
-/** Coerce one TRIM side route: like cleanIntentRoute, but a non-empty string
- *  effort rides along — the trim summarizer pins reasoning effort on its side
- *  model, and stripping it here made every settings save silently revert the
- *  settings page's effort select to the default. Intent routes omit effort. */
-function cleanTrimRoute(entry) {
+/** Coerce one route that may carry an optional reasoning-effort pin. */
+function cleanEffortRoute(entry) {
 	const route = cleanIntentRoute(entry);
 	if (route === null) return null;
 	const effort = typeof entry.effort === "string" ? entry.effort.trim() : "";
@@ -370,7 +366,7 @@ export function snapshotOf(config) {
 			? rawOf(config[field]).map(cleanEffortEntry).filter(Boolean)
 			: [];
 	for (const field of INTENT_ROUTE_FIELDS) values[field] = cleanIntentRoute(rawOf(config?.[field])) ?? { provider: "", model: "" };
-	for (const field of TRIM_ROUTE_FIELDS) values[field] = cleanTrimRoute(rawOf(config?.[field])) ?? { provider: "", model: "" };
+	for (const field of EFFORT_ROUTE_FIELDS) values[field] = cleanEffortRoute(rawOf(config?.[field])) ?? { provider: "", model: "" };
 	for (const field of INTENT_CANDIDATE_FIELDS)
 		values[field] = mergeIntentCandidates(rawOf(config?.[field]));
 	values.intentClassifierKind = ENUM_FIELDS.intentClassifierKind.includes(rawOf(config?.intentClassifierKind))
@@ -445,8 +441,8 @@ export function coerceValues(input) {
 		if (route === null) return null;
 		values[field] = route;
 	}
-	for (const field of TRIM_ROUTE_FIELDS) {
-		const route = cleanTrimRoute(input[field]);
+	for (const field of EFFORT_ROUTE_FIELDS) {
+		const route = cleanEffortRoute(input[field]);
 		if (route === null) return null;
 		values[field] = route;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dsh-switchman",
-	"version": "1.11.3",
+	"version": "1.11.5",
 	"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": [