dsh-switchman 1.11.6 → 1.11.7

package/host/routes.js

@@ -32,6 +32,14 @@
  *                                      auto-selection and pinned decision).
  *   POST /api/dsh-switchman/intent-reset — { session } clears one session's
  *                                      intent decision state (debug/reset).
+ *   GET  /api/dsh-switchman/trim-pressure — live trim-pressure snapshot for
+ *                                      the client dock chip (session-scoped
+ *                                      via the optional `session` query):
+ *                                      {available, mode, mass, window,
+ *                                      pressure, view, wire, proj,
+ *                                      advisoryLine, criticalLine,
+ *                                      reliefEnabled, reliefCooldownRemaining}.
+ *                                      Observability only — no gate reads it.
  *   POST /api/dsh-switchman/ui-locale — the client half reports its active
  *                                      UI locale (feeds the ask guidance's
  *                                      question language; no settings write).
@@ -49,6 +57,7 @@ import { INTENT_PRESETS, mergeIntentCandidates } from "./intent-presets.js";
 import { pumpTeamsOrchestration, scheduleTeamsOrchestration, SWITCHMAN_SETTINGS_NS, teamsBundleState, teamsSyncSnapshot } from "./teams.js";
 import { reportedUiLocale, setReportedUiLocale } from "./ui-locale.js";
 import { visionStateOf } from "./vision.js";
+import { trimPressureSnapshotOf } from "./context-trim/index.js";
 
 /** Route paths (client.js mirrors these literals). */
 const ROUTES = {
@@ -61,6 +70,7 @@ const ROUTES = {
 	intentState: "/api/dsh-switchman/intent-state",
 	intentReset: "/api/dsh-switchman/intent-reset",
 	uiLocale: "/api/dsh-switchman/ui-locale",
+	trimPressure: "/api/dsh-switchman/trim-pressure",
 };
 
 /** Settings namespace this plugin's writes target: the LOADER ENTRY id from
@@ -88,33 +98,36 @@ const POOL_FIELDS = [
 	"poolVision",
 	"poolReview",
 ];
-const NUMBER_FIELDS = [
-	"wmSoftTokens",
-	"wmHardTokens",
-	"wmForceTokens",
-	"wmReadBudgetTokens",
-	"wmSubagentForceTokens",
-];
 /** Watermark numbers with REAL bounds (host/config.js schema): rejected (not
- *  clamped) on write, defaulted on read — NUMBER_FIELDS only rejects negatives,
- *  which would let a 0 ratio silently disable subagent tier scaling. */
+ *  clamped) on write, defaulted on read — a negative-only check would let a 0
+ *  ratio silently disable subagent tier scaling, and let an astronomic token
+ *  budget (a fat-fingered or hostile write) wedge the tier math. The token cap
+ *  is 10,000,000: every real model window is orders of magnitude smaller. This
+ *  group MUST mirror the client page's WM_NUMBER_FIELDS: a field coerced here
+ *  but never sent by the client fails every fenced write (and vice versa). */
 const WM_BOUNDED_NUMBER_FIELDS = [
+	{ field: "wmSoftTokens", min: 1000, max: 10000000, def: 80000 },
+	{ field: "wmHardTokens", min: 2000, max: 10000000, def: 100000 },
+	{ field: "wmForceTokens", min: 3000, max: 10000000, def: 200000 },
+	{ field: "wmReadBudgetTokens", min: 200, max: 10000000, def: 3500 },
+	{ field: "wmSubagentForceTokens", min: 0, max: 10000000, def: 0 },
 	{ field: "wmSubagentWindowRatio", min: 0.1, max: 1, def: 0.75 },
 ];
-/** 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
+/** Trim numbers carry their own schema bounds (host/config.js), so a
+ *  negative-only coercion 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: "trimAdvisoryPercent", min: 5, max: 100, def: 65 },
-	{ field: "trimAdvisoryCriticalPercent", min: 5, max: 100, def: 95 },
+	{ field: "trimIncrementTokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 45000 },
+	{ field: "trimPressurePercent", min: 5, max: 100, def: 45 },
+	{ field: "trimEmergencyPercent", min: 5, max: 100, def: 90 },
+	{ field: "trimAdvisoryPercent", min: 5, max: 100, def: 50 },
+	{ field: "trimAdvisoryCriticalPercent", min: 5, max: 100, def: 80 },
+	{ field: "trimAdvisoryRepeatMs", min: 5000, max: 3600000, def: 120000 },
 	{ field: "trimWindowTokens", min: 0, max: Number.POSITIVE_INFINITY, def: 0 },
-	{ field: "trimProtectedTail", min: 0, max: 100, def: 10 },
+	{ field: "trimProtectedTail", min: 0, max: 100, def: 6 },
 	{ 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 },
@@ -140,18 +153,20 @@ const BOOLEAN_FIELDS = [
 	"trimEnabled",
 	"trimLadderEnabled",
 	"trimProtectTaskIntent",
+	"trimCriticalRelief",
+	"trimVerboseLog",
 	"surfaceFold",
 ];
-/** Intent numbers carry their own schema bounds (config.js), so the shared
- *  NUMBER_FIELDS coercion (which only rejects negatives) is too loose — these
- *  validate against each field's declared min/max. */
+/** Intent numbers carry their own schema bounds (config.js), so a
+ *  negative-only coercion is too loose — these validate against each
+ *  field's declared min/max. */
 const INTENT_NUMBER_FIELDS = [
 	{ field: "intentCacheTtlSeconds", min: 0, max: Number.POSITIVE_INFINITY, def: 300 },
 	{ field: "intentSwitchConfidence", min: 0, max: 100, def: 80 },
 	{ field: "intentTimeoutMs", min: 200, max: Number.POSITIVE_INFINITY, def: 60000 },
 	{ field: "intentHistoryMessages", min: 1, max: 20, def: 6 },
 	{ field: "intentHistoryMaxChars", min: 200, max: 20000, def: 2400 },
-	{ field: "intentContextWindow", min: 1024, max: Number.POSITIVE_INFINITY, def: 200000 },
+	{ field: "intentContextWindow", min: 1024, max: Number.POSITIVE_INFINITY, def: 250000 },
 ];
 /** Intent classifier routes round-trip the "unset" {provider:"", model:""}
  *  pair, so they validate against the loosened cleanIntentRoute (both keys
@@ -225,6 +240,28 @@ function isLoopbackHostname(hostname) {
 	return parts.length === 4 && parts.every((p) => /^\d+$/u.test(p)) && parts[0] === "127";
 }
 
+/** Whether the socket peer address is loopback. Absent (non-TCP transport,
+ *  e.g. a unix-socket/IPC listener) passes — the Host/Origin header fence
+ *  still applies. A PRESENT address must be loopback so a LAN or remote
+ *  TCP peer can never ride a forged Host header through the fence. */
+function isLoopbackRemoteAddress(request) {
+	const raw = request.socket?.remoteAddress ?? request.connection?.remoteAddress;
+	if (raw === undefined || raw === null || raw === "") return true;
+	const host = raw.startsWith("::ffff:") ? raw.slice(7) : raw;
+	if (host === "::1") return true;
+	const parts = host.split(".");
+	return parts.length === 4 && parts.every((p) => /^\d{1,3}$/u.test(p)) && parts[0] === "127";
+}
+
+/** Whether a state-changing request declares a JSON body. Same-origin
+ *  fetches always do (client.js sets content-type on every POST); simple
+ *  cross-origin form posts cannot — belt-and-braces under the
+ *  Host/socket fence. */
+function isJsonContentType(request) {
+	const header = request.headers["content-type"];
+	return typeof header === "string" && header.trim().toLowerCase().startsWith("application/json");
+}
+
 /** Whether this request comes from this machine's own browser page. */
 function isLoopbackRequest(request) {
 	const host = request.headers?.host;
@@ -236,6 +273,7 @@ function isLoopbackRequest(request) {
 		return false;
 	}
 	if (!isLoopbackHostname(hostUrl.hostname)) return false;
+	if (!isLoopbackRemoteAddress(request)) return false;
 	if (request.headers["sec-fetch-site"] === "cross-site") return false;
 	const origin = request.headers.origin;
 	if (origin === undefined) return true;
@@ -389,10 +427,6 @@ export function snapshotOf(config) {
 		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;
-	}
 	for (const { field, def } of WM_BOUNDED_NUMBER_FIELDS) {
 		const raw = Number(rawOf(config?.[field]));
 		values[field] = Number.isFinite(raw) ? raw : def;
@@ -416,6 +450,20 @@ function whitelistSyncOf(config) {
 /** Coerce and validate a client-submitted values object; null when invalid. */
 /** Validate+normalize an incoming settings payload; exported so the
  *  smoke suite can exercise the PUT-fence round-trip invariant. */
+/** Strict numeric coercion for client-submitted settings. Only finite
+ *  JSON numbers and plain decimal strings coerce; "", booleans, null,
+ *  and hex/other-radix strings become NaN (rejected by the callers'
+ *  Number.isFinite check) instead of silently becoming 0/1/16. */
+function strictNumberOf(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : Number.NaN;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed === "" || /^[+-]?0[xXbBoO]/u.test(trimmed) || !/^[+-]?\d+(\.\d+)?$/u.test(trimmed)) return Number.NaN;
+		return Number(trimmed);
+	}
+	return Number.NaN;
+}
+
 export function coerceValues(input) {
 	if (input === null || typeof input !== "object" || Array.isArray(input)) return null;
 	const values = {};
@@ -458,7 +506,7 @@ export function coerceValues(input) {
 	if (!ENUM_FIELDS.intentClassifierKind.includes(input.intentClassifierKind)) return null;
 	values.intentClassifierKind = input.intentClassifierKind;
 	for (const { field, min, max } of INTENT_NUMBER_FIELDS) {
-		const raw = Number(input[field]);
+		const raw = strictNumberOf(input[field]);
 		if (!Number.isFinite(raw) || raw < min || raw > max) return null;
 		values[field] = raw;
 	}
@@ -475,17 +523,12 @@ export function coerceValues(input) {
 		values[field] = input[field];
 	}
 	for (const { field, min, max } of TRIM_NUMBER_FIELDS) {
-		const raw = Number(input[field]);
+		const raw = strictNumberOf(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;
-		values[field] = raw;
-	}
 	for (const { field, min, max } of WM_BOUNDED_NUMBER_FIELDS) {
-		const raw = Number(input[field]);
+		const raw = strictNumberOf(input[field]);
 		if (!Number.isFinite(raw) || raw < min || raw > max) return null;
 		values[field] = raw;
 	}
@@ -594,6 +637,10 @@ export function makeRoutes(ctx, config) {
 					writeJson(res, 405, { error: `method not allowed: ${req.method}` });
 					return;
 				}
+					if (!isJsonContentType(req)) {
+						writeJson(res, 415, { error: "unsupported media type: content-type must be application/json" });
+						return;
+					}
 				let body;
 				try {
 					body = await readJsonBody(req);
@@ -609,6 +656,10 @@ export function makeRoutes(ctx, config) {
 				// Optimistic-concurrency fence: when the client submits the
 				// snapshot it loaded (`expected`), require it to still match.
 				const current = snapshotOf(config);
+				if (body?.expected === undefined || body?.expected === null) {
+					writeJson(res, 400, { error: "missing expected snapshot: the optimistic-concurrency fence is required — send the values snapshot you loaded" });
+					return;
+				}
 				if (body.expected !== undefined) {
 					const expected = coerceValues(body.expected);
 					// Compare candidate rows through the idempotent merge on
@@ -727,11 +778,32 @@ export function makeRoutes(ctx, config) {
 				}
 			},
 		},
+		{
+			kind: "exact",
+			path: ROUTES.trimPressure,
+			handler: async (req, res) => {
+				if (!guard(req, res, "GET")) return;
+				try {
+					// Optional `session` query parameter: the dock chip is
+					// session-scoped; a missing session id reports available=false
+					// (never another conversation's pressure).
+					const session = new URL(req.url ?? "/", "http://localhost").searchParams.get("session");
+					writeJson(res, 200, trimPressureSnapshotOf(typeof session === "string" && session !== "" ? session : ""));
+				} catch (error) {
+					ctx.logger.warn(`dsh-switchman: trim-pressure read failed: ${error?.message ?? error}`);
+					writeJson(res, 500, { error: error?.message ?? String(error) });
+				}
+			},
+		},
 		{
 			kind: "exact",
 			path: ROUTES.intentReset,
 			handler: async (req, res) => {
 				if (!guard(req, res, "POST")) return;
+					if (!isJsonContentType(req)) {
+						writeJson(res, 415, { error: "unsupported media type: content-type must be application/json" });
+						return;
+					}
 				let body;
 				try {
 					body = await readJsonBody(req);
@@ -753,6 +825,10 @@ export function makeRoutes(ctx, config) {
 			path: ROUTES.uiLocale,
 			handler: async (req, res) => {
 				if (!guard(req, res, "POST")) return;
+					if (!isJsonContentType(req)) {
+						writeJson(res, 415, { error: "unsupported media type: content-type must be application/json" });
+						return;
+					}
 				let body;
 				try {
 					body = await readJsonBody(req);

package/host/teams.js

@@ -14,9 +14,10 @@
  *   it never runs synchronously inside plugin apply (bundle changes must not
  *   nest inside the apply HMR transaction — boot/hmr forbids it): first
  *   `pluginManager.setBundleEnabled('@deepseek-ai/dsh-experimental-agent-
- *   team-profile', true)` (latched per process; never disabled on OFF), then
- *   — only when `syncWhitelist` is also ON — one replace-sync of the six-
- *   pool union into DSH's `subagent-model-selection-settings` whitelist
+ *   team-profile', true)` (never disabled on OFF; re-verified every run),
+ *   then — only when `syncWhitelist` is also ON — one replace-sync of the
+ *   dispatch model union (six pools + modelRank) into DSH's
+ *   `subagent-model-selection-settings` whitelist
  *   (`settings.describe()` → `settings.mutate(...)`, re-describing and
  *   retrying up to 3 attempts on SettingsConflictError). Replace semantics:
  *   switchman is the single source of truth, so the deduplicated exact
@@ -111,14 +112,15 @@ function readBool(field) {
 // ---- module state ----------------------------------------------------------
 
 /** Last whitelist replace-sync outcome for routes.js's whitelistSync config
- *  field; null when no sync has run in this process. Shape:
+ *  field; null when no sync has run in this process. The synced set is the
+ *  dispatch model union (six pools + modelRank). Shape:
  *  { ok: boolean, count: number, at: number, error?: string }. */
 let lastSync = null;
 
 /** Last bundle-ensure outcome for routes.js's teamsBundle field; null before
  *  the first orchestration. Shape: { ok, at, state, error? } with state in
- *  selected | applied | restart-required | failed | cancelled | <unknown
- *  application value> | unavailable. */
+ *  selected | applied | restart-required | not-offered | failed | cancelled
+ *  | <unknown application value> | unavailable. */
 let lastBundleState = null;
 
 /** Set when a run must be retried from a clean context: either it was
@@ -147,10 +149,16 @@ function isNestedHmrError(error) {
 	return /cannot be nested/iu.test(String(error?.message ?? ""));
 }
 
-/** Deduplicated exact (provider, model) union of the six pools. Exact string
- *  identity (trimmed) — DSH's whitelist authorizes exact pairs and its
+/** Deduplicated exact (provider, model) union of the six pools PLUS
+ *  modelRank. modelRank belongs in the whitelist union: its head is the
+ *  dispatch fallback route (orderedPool head / modelRank[0] in dispatch.js),
+ *  enforce mode denies any route outside "pools or modelRank", and a
+ *  rank-only head would otherwise leave subagent dispatch unable to name
+ *  its own fallback (the whitelist silently strips it). Rank entries are
+ *  { provider, model, tier? }; tier is ignored here. Exact string identity
+ *  (trimmed) — DSH's whitelist authorizes exact pairs and its
  *  assertAllowedModelRoutes rejects repeated provider/model routes outright. */
-function poolUnion(config) {
+function dispatchModelUnion(config) {
 	const seen = new Set();
 	const routes = [];
 	for (const lane of LANES) {
@@ -167,6 +175,19 @@ function poolUnion(config) {
 			routes.push({ provider, model });
 		}
 	}
+	const rank = readValue(config?.modelRank);
+	if (Array.isArray(rank)) {
+		for (const entry of rank) {
+			if (entry === null || typeof entry !== "object") continue;
+			const provider = typeof entry.provider === "string" ? entry.provider.trim() : "";
+			const model = typeof entry.model === "string" ? entry.model.trim() : "";
+			if (provider === "" || model === "") continue;
+			const key = `${provider}\u0000${model}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			routes.push({ provider, model });
+		}
+	}
 	return routes;
 }
 
@@ -183,8 +204,11 @@ function poolUnion(config) {
  *  before reload can throw). There is deliberately NO process-level success
  *  latch — the DSH-side toggle can be flipped off at any time, so every
  *  orchestration re-verifies via listBundles and re-enables when needed.
- *  A missing pluginManager service only warns; the doctrine section still
- *  renders, the tools simply stay absent. */
+ *  A bundle this DSH installation does not offer at all (absent from the
+ *  listBundles inventory) is terminal, not a failure: enabling it could
+ *  never succeed, so the orchestration records not-offered once and does
+ *  not arm a retry. A missing pluginManager service only warns; the
+ *  doctrine section still renders, the tools simply stay absent. */
 async function ensureTeamsBundle(ctx) {
 	const manager = ctx.get?.("pluginManager", false);
 	if (manager === undefined || manager === null || typeof manager.setBundleEnabled !== "function") {
@@ -198,6 +222,28 @@ async function ensureTeamsBundle(ctx) {
 			const selected = Array.isArray(bundles)
 				? bundles.find((item) => item?.name === TEAMS_BUNDLE)
 				: undefined;
+			if (selected === undefined) {
+				// Not in the inventory at all. listBundles enumerates the manifest
+				// selection ∪ recorded dependencies ∪ the installation manifest ∪
+				// the official on-demand catalog; app-boot strips retired bundles
+				// from the manifest, and bundleManifest() resolves packages only
+				// from those same sources. A name absent from all of them cannot
+				// be enabled — DSH's toggle would resolve application:'failed'
+				// (not-bundle) on every attempt — so record the terminal state
+				// once and leave pendingNestedRetry untouched (no retry loop
+				// against a fact; a future DSH update that ships the bundle
+				// re-enters this function at the next orchestration trigger).
+				lastBundleState = {
+					ok: false,
+					at: Date.now(),
+					state: "not-offered",
+					error: TEAMS_BUNDLE + " is not offered by this DSH installation"
+						+ " (absent from the profile manifest, dependencies, and the"
+						+ " official catalog); enable skipped",
+				};
+				ctx.logger?.warn?.("dsh-switchman: agent-team bundle not offered by this installation; enable skipped (teams tools stay absent)");
+				return;
+			}
 			if (selected?.enabled === true) {
 				// Already selected in the profile manifest: no call, no reload —
 				// and deliberately NO process-level latch. The user may flip the
@@ -246,12 +292,12 @@ async function ensureTeamsBundle(ctx) {
 	}
 }
 
-/** One replace-sync of the six-pool union into the DSH whitelist. describe →
+/** One replace-sync of the dispatch model union into the DSH whitelist. describe →
  *  mutate with the fresh revision; SettingsConflictError retries (re-describe
  *  first) up to MAX_MUTATE_ATTEMPTS total. Every terminal outcome lands in
  *  the module-level lastSync status; nothing throws. */
 async function syncWhitelist(ctx, config) {
-	const routes = poolUnion(config);
+	const routes = dispatchModelUnion(config);
 	if (routes.length === 0) {
 		// DSH's invariant: enabled=true with an empty allowedModels breaks
 		// every new session's composition — skipping is the only safe move.
@@ -259,7 +305,7 @@ async function syncWhitelist(ctx, config) {
 			ok: false,
 			count: 0,
 			at: Date.now(),
-			error: "six-pool union is empty; sync skipped (enabled=true requires a non-empty allowedModels)",
+			error: "dispatch model union (six pools + modelRank) is empty; sync skipped (enabled=true requires a non-empty allowedModels)",
 		};
 		ctx.logger?.warn?.(`dsh-switchman: whitelist sync skipped: ${lastSync.error}`);
 		return;
@@ -583,4 +629,4 @@ function applyTeams(ctx, config) {
 	syncChildMessageTool();
 }
 
-export { applyTeams, pumpTeamsOrchestration, SWITCHMAN_SETTINGS_NS, TEAMS_SECTION_TEXT, scheduleTeamsOrchestration, teamsBundleState, teamsSyncSnapshot };
+export { applyTeams, dispatchModelUnion, ensureTeamsBundle, pumpTeamsOrchestration, SWITCHMAN_SETTINGS_NS, TEAMS_SECTION_TEXT, scheduleTeamsOrchestration, teamsBundleState, teamsSyncSnapshot };

package/host/vision.js

@@ -35,7 +35,7 @@
 import { execFile as execFileCb } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
-import { access, copyFile, mkdir, open, rm } from "node:fs/promises";
+import { access, copyFile, mkdir, open, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { dshHome } from "./lib/dsh-home.js";
@@ -141,7 +141,19 @@ async function materializeImage(store, ref, warn) {
 		if (await exists(dst)) return { path: dst };
 		try {
 			await mkdir(dir, { recursive: true });
-			await copyFile(src, dst);
+			// Copy to a temp name and rename into place: copyFile interrupted
+			// mid-write (ENOSPC, process exit) must not leave a partial dst
+			// that the exists() cache above would serve forever (the same
+			// corrupt-cache invariant looksLikePng guards on the transcode
+			// path). rename is atomic on the same directory.
+			const tmp = `${dst}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
+			try {
+				await copyFile(src, tmp);
+				await rename(tmp, dst);
+			} catch (error) {
+				await drop(tmp);
+				throw error;
+			}
 			return { path: dst };
 		} catch (error) {
 			warn(`vision: native copy failed (${error?.message ?? error})`);
@@ -184,7 +196,16 @@ async function materializeImage(store, ref, warn) {
 	const ext = FALLBACK_EXT.get(String(ref?.mediaType ?? "").toLowerCase()) ?? "img";
 	const raw = join(dir, `${hash}.${ext}`);
 	try {
-		await copyFile(src, raw);
+		// Same partial-file guard as the native path above: the fallback
+		// copy must not leave a half-written ${hash}.${ext} behind either.
+		const tmp = `${raw}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
+		try {
+			await copyFile(src, tmp);
+			await rename(tmp, raw);
+		} catch (error) {
+			await drop(tmp);
+			throw error;
+		}
 		warn(`vision: no PNG converter available; kept ${ref?.mediaType} copy at ${raw}`);
 		return {
 			path: raw,

package/index.js

@@ -34,8 +34,9 @@
  * Teams mode mounts two more layers: host/teams.js carries the team clauses
  * extracted from the cordis.patch.yml suffix in a `[SWITCHMAN:TEAMS]` section
  * (order 10250, injected only while teamsMode is ON) plus the deferred ON
- * orchestration (agent-team bundle enable, then the optional six-pool
- * → DSH whitelist replace-sync); host/subagent-model.js annotates successful
+ * orchestration (agent-team bundle enable, then the optional dispatch-model
+ * union — six pools + modelRank — → DSH whitelist replace-sync);
+ * host/subagent-model.js annotates successful
  * subagent / subagent_fork results with one `model: provider/model@effort`
  * line from the child session's modelSelection projection (the same channel
  * host/vision.js reuses for the per-session vision-state verdict).
@@ -79,6 +80,7 @@ import { applyDispatch } from "./host/dispatch.js";
 import { applyTeams } from "./host/teams.js";
 // PTC direct-call guard (final-say transport rule for PTC-executor scopes).
 import { applyPtcGuard } from "./host/ptc-guard.js";
+import { applyPtcBindings } from "./host/ptc-bindings.js";
 // Subagent model-visibility layer (post-execute `model:` annotation).
 import { applySubagentModel } from "./host/subagent-model.js";
 
@@ -225,6 +227,7 @@ function apply(ctx, config) {
 	applyDispatch(ctx, config);
 	applyTeams(ctx, config);
 	applyPtcGuard(ctx);
+	applyPtcBindings(ctx);
 	applyContextWatch(ctx, config);
 	applyContextTrim(ctx, config);
 	applyVision(ctx, config);

package/package.json

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