dsh-switchman 1.7.1 → 1.8.1

package/host/routes.js

@@ -26,6 +26,12 @@
  *                                      `session` query parameter judges image
  *                                      capability against THAT session's
  *                                      model (unknown/missing → root model).
+ *   GET  /api/dsh-switchman/intent-state — live intent-routing state for the
+ *                                      dock chip (optional `session` query
+ *                                      parameter judges THAT session's
+ *                                      auto-selection and pinned decision).
+ *   POST /api/dsh-switchman/intent-reset — { session } clears one session's
+ *                                      intent decision state (debug/reset).
  *   POST /api/dsh-switchman/ui-locale — the client half reports its active
  *                                      UI locale (feeds the ask guidance's
  *                                      question language; no settings write).
@@ -38,6 +44,8 @@
 
 import { authorizedChildRoutes } from "./dispatch.js";
 import { handoverSnapshot } from "./handover-state.js";
+import { clearSessionState, intentStateOf } from "./intent.js";
+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";
@@ -50,6 +58,8 @@ const ROUTES = {
 	authorized: "/api/dsh-switchman/authorized",
 	handoverState: "/api/dsh-switchman/handover-state",
 	visionState: "/api/dsh-switchman/vision-state",
+	intentState: "/api/dsh-switchman/intent-state",
+	intentReset: "/api/dsh-switchman/intent-reset",
 	uiLocale: "/api/dsh-switchman/ui-locale",
 };
 
@@ -62,7 +72,14 @@ const ROUTES = {
 const NS = SWITCHMAN_SETTINGS_NS;
 
 /** All settings field names, grouped for coercion (mirrors host/config.js). */
-const STRING_FIELDS = ["langConversation", "langComments", "langDocs"];
+const STRING_FIELDS = [
+	"langConversation",
+	"langComments",
+	"langDocs",
+	"intentClassifierEffort",
+	"intentClassifierEndpoint",
+	"intentClassifierSystemoneModel",
+];
 const POOL_FIELDS = [
 	"poolEconomy",
 	"poolMechanical",
@@ -91,7 +108,27 @@ const BOOLEAN_FIELDS = [
 	// Teams switches (mirrors the teams* group in host/config.js)
 	"teamsMode",
 	"syncWhitelist",
+	// Intent recognition (mirrors the intent* group in host/config.js).
+	"intentEnabled",
+];
+/** 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. */
+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 },
 ];
+/** 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"];
+/** Intent candidate list (route + optional effort/note per entry). */
+const INTENT_CANDIDATE_FIELDS = ["intentCandidates"];
+
 /** Per-pool effort-route lists (mirrors host/config.js pool*Efforts). */
 const EFFORTS_FIELDS = [
 	"poolEconomyEfforts",
@@ -106,6 +143,7 @@ const ENUM_FIELDS = {
 	langScope: ["global", "project"],
 	dispatchEnforce: ["off", "advice", "enforce"],
 	wmDenyMode: ["cap", "deny"],
+	intentClassifierKind: ["chat", "systemone"],
 };
 
 /** JSON response helper. */
@@ -233,6 +271,43 @@ function cleanEffortEntry(entry) {
 	return provider !== "" && model !== "" && effort !== "" ? { provider, model, effort } : null;
 }
 
+/** Coerce one intent route reference: both keys must be strings and either
+ *  may be empty (the round-tripped "unset" pair) — non-empty values trim.
+ *  null for any other shape. */
+function cleanIntentRoute(entry) {
+	if (entry === null || typeof entry !== "object") return null;
+	const provider = typeof entry.provider === "string" ? entry.provider.trim() : null;
+	const model = typeof entry.model === "string" ? entry.model.trim() : null;
+	return provider === null || model === null ? null : { provider, model };
+}
+
+/** Coerce one intent candidate: provider/model must be non-empty; effort/note
+ *  ride along as trimmed strings when non-empty, otherwise are omitted
+ *  (mirrors client.js's sanitizeIntentCandidate). */
+function cleanIntentCandidate(entry) {
+	if (entry === null || typeof entry !== "object") return null;
+	const id = typeof entry.id === "string" ? entry.id.trim() : "";
+	const provider = typeof entry.provider === "string" ? entry.provider.trim() : "";
+	const model = typeof entry.model === "string" ? entry.model.trim() : "";
+	const effort = typeof entry.effort === "string" ? entry.effort.trim() : "";
+	const note = typeof entry.note === "string" ? entry.note.trim() : "";
+	const preset = INTENT_PRESETS.find((row) => row.id === id) ?? null;
+	// Empty routes are legal ONLY for identified rows (a preset waiting for
+	// its model, or a half-edited custom row); anonymous empty junk is data
+	// noise and dropped.
+	if (preset === null && id === "" && provider === "" && model === "" && effort === "" && note === "") return null;
+	if (preset !== null) {
+		// Defense in depth: whatever the client echoes back, a preset row's
+		// note stays the code value and the row keeps its identity.
+		const candidate = { id: preset.id, preset: true, enabled: entry.enabled !== false, provider, model, note: preset.note };
+		if (effort !== "") candidate.effort = effort;
+		return candidate;
+	}
+	const candidate = { id, preset: false, enabled: entry.enabled !== false, provider, model, note };
+	if (effort !== "") candidate.effort = effort;
+	return candidate;
+}
+
 /** Snapshot the plugin's live volatile config into plain JSON values. */
 export function snapshotOf(config) {
 	const values = {};
@@ -247,6 +322,16 @@ export function snapshotOf(config) {
 		values[field] = Array.isArray(rawOf(config?.[field]))
 			? 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 INTENT_CANDIDATE_FIELDS)
+		values[field] = mergeIntentCandidates(rawOf(config?.[field]));
+	values.intentClassifierKind = ENUM_FIELDS.intentClassifierKind.includes(rawOf(config?.intentClassifierKind))
+		? rawOf(config.intentClassifierKind)
+		: "chat";
+	for (const { field, def } of INTENT_NUMBER_FIELDS) {
+		const raw = Number(rawOf(config?.[field]));
+		values[field] = Number.isFinite(raw) ? raw : def;
+	}
 	values.uiLocale = ENUM_FIELDS.uiLocale.includes(rawOf(config?.uiLocale)) ? rawOf(config.uiLocale) : "auto";
 	values.langScope = ENUM_FIELDS.langScope.includes(rawOf(config?.langScope)) ? rawOf(config.langScope) : "global";
 	values.dispatchEnforce = ENUM_FIELDS.dispatchEnforce.includes(rawOf(config?.dispatchEnforce))
@@ -273,7 +358,9 @@ function whitelistSyncOf(config) {
 }
 
 /** Coerce and validate a client-submitted values object; null when invalid. */
-function coerceValues(input) {
+/** Validate+normalize an incoming settings payload; exported so the
+ *  smoke suite can exercise the PUT-fence round-trip invariant. */
+export function coerceValues(input) {
 	if (input === null || typeof input !== "object" || Array.isArray(input)) return null;
 	const values = {};
 	for (const field of STRING_FIELDS) {
@@ -296,6 +383,24 @@ function coerceValues(input) {
 		if (efforts.some((entry) => entry === null)) return null;
 		values[field] = efforts;
 	}
+	for (const field of INTENT_ROUTE_FIELDS) {
+		const route = cleanIntentRoute(input[field]);
+		if (route === null) return null;
+		values[field] = route;
+	}
+	for (const field of INTENT_CANDIDATE_FIELDS) {
+		if (!Array.isArray(input[field])) return null;
+		const candidates = input[field].map(cleanIntentCandidate);
+		if (candidates.some((entry) => entry === null)) return null;
+		values[field] = candidates;
+	}
+	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]);
+		if (!Number.isFinite(raw) || raw < min || raw > max) return null;
+		values[field] = raw;
+	}
 	if (!ENUM_FIELDS.uiLocale.includes(input.uiLocale)) return null;
 	values.uiLocale = input.uiLocale;
 	if (!ENUM_FIELDS.langScope.includes(input.langScope)) return null;
@@ -411,7 +516,17 @@ export function makeRoutes(ctx, config) {
 				const current = snapshotOf(config);
 				if (body.expected !== undefined) {
 					const expected = coerceValues(body.expected);
-					if (expected === null || !sameValues(expected, current)) {
+					// Compare candidate rows through the idempotent merge on
+					// BOTH sides: the snapshot carries derived labels and the
+					// coerce path strips them, so a raw stringify would never
+					// match once presets exist (PHANTOM 409 on every save).
+					const fenceSame =
+						expected !== null &&
+						sameValues(
+							{ ...expected, intentCandidates: mergeIntentCandidates(expected.intentCandidates) },
+							{ ...current, intentCandidates: mergeIntentCandidates(current.intentCandidates) },
+						);
+					if (!fenceSame) {
 						writeJson(res, 409, { error: "conflict: settings changed since load", values: current });
 						return;
 					}
@@ -498,6 +613,46 @@ export function makeRoutes(ctx, config) {
 				}
 			},
 		},
+		{
+			kind: "exact",
+			path: ROUTES.intentState,
+			handler: async (req, res) => {
+				if (!guard(req, res, "GET")) return;
+				pumpTeamsOrchestration(ctx, config); // clean-context retry pump (see GET config)
+				try {
+					// Optional `session` query parameter (a child session id):
+					// report THAT session's auto-selection and pinned decision;
+					// a missing session reports enabled/configured/candidates
+					// with autoSelected=false.
+					const session = new URL(req.url ?? "/", "http://localhost").searchParams.get("session");
+					writeJson(res, 200, await intentStateOf(ctx, config, typeof session === "string" && session !== "" ? session : null));
+				} catch (error) {
+					ctx.logger.warn(`dsh-switchman: intent-state 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;
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch (error) {
+					writeJson(res, 400, { error: error?.message ?? String(error) });
+					return;
+				}
+				const session = typeof body?.session === "string" ? body.session : "";
+				if (session === "") {
+					writeJson(res, 400, { error: "missing session" });
+					return;
+				}
+				clearSessionState(session);
+				writeJson(res, 200, { ok: true });
+			},
+		},
 		{
 			kind: "exact",
 			path: ROUTES.uiLocale,

package/host/vision.js

@@ -21,12 +21,15 @@
  * placeholder, so the followup forbids that. With an empty vision
  * pool the command refuses with setup guidance instead, and the client
  * composer-dock hint (fed by GET /api/dsh-switchman/vision-state)
- * points at the same setting. The hint's imageCapable verdict normally
- * reads the first root session's model; the route's optional `session`
- * query parameter judges the named session's own model instead (via the
- * session-query observeSession channel shared with host/subagent-model.js),
- * so a child session on a different route no longer misreports — unknown
- * sessions fall back to the root verdict.
+ * points at the same setting. The route's optional `session` query
+ * parameter judges the named session's own model (via the session-query
+ * observeSession channel shared with host/subagent-model.js), so a child
+ * session on a different route no longer misreports — unknown sessions
+ * report null (unknown), never another conversation's verdict; only
+ * session-less probes fall back to a best-effort root verdict. Auto
+ * pseudo-model selections are judged through the intent layer's current
+ * decided route; the hint itself renders only on a positively confirmed
+ * text-only verdict (client.js), so "unknown" stays silent.
  */
 
 import { execFile as execFileCb } from "node:child_process";
@@ -36,6 +39,7 @@ import { access, copyFile, mkdir, open, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { dshHome } from "./lib/dsh-home.js";
+import { AUTO_PROVIDER, intentStateOf } from "./intent.js";
 import { sessionModelSelectionOf } from "./subagent-model.js";
 import { reportedUiLocale } from "./ui-locale.js";
 
@@ -200,13 +204,17 @@ async function materializeImage(store, ref, warn) {
  *  exact semantics: undefined inputModalities pass (no restriction
  *  declared); anything else must include "image". Returns null when
  *  unknowable (bad route, no llm service, resolution failure) — callers
- *  treat null as "don't know", never as capable/incapable. */
+ *  treat null as "don't know", never as capable/incapable.
+ *
+ *  The resolveModelInfo call MUST stay receiver-bound: LlmRuntime methods
+ *  read `this` (this.resolveModelInfoFor), so detaching the method turned
+ *  every probe into a TypeError → null (the "hint always shows" bug). */
 async function modelImageCapableOf(ctx, provider, model) {
 	try {
 		if (typeof provider !== "string" || provider === "" || typeof model !== "string" || model === "") return null;
-		const resolveModelInfo = ctx.get?.("llm", false)?.resolveModelInfo;
-		if (typeof resolveModelInfo !== "function") return null;
-		const info = await resolveModelInfo(provider, model);
+		const llm = ctx.get?.("llm", false);
+		if (llm === null || typeof llm !== "object" || typeof llm.resolveModelInfo !== "function") return null;
+		const info = await llm.resolveModelInfo(provider, model);
 		if (info?.inputModalities === undefined) return true;
 		return Array.isArray(info.inputModalities) && info.inputModalities.includes("image");
 	} catch {
@@ -214,15 +222,43 @@ async function modelImageCapableOf(ctx, provider, model) {
 	}
 }
 
+/** Image verdict for one session's model SELECTION. A concrete route is
+ *  judged directly; the dsh-switchman-auto pseudo route is judged through
+ *  the intent layer's current decided route (the adapter's routing point is
+ *  invisible to every DSH projection, so switchman's own routedCurrent is
+ *  the only source). No decision yet (fresh auto session) or an unreadable
+ *  intent state yields null — "don't know", not incapable. */
+async function selectionImageCapableOf(ctx, config, selection, sessionId) {
+	if (selection === null) return null;
+	if (selection.provider === AUTO_PROVIDER) {
+		try {
+			const state = await intentStateOf(ctx, config, sessionId);
+			const decided = state?.current;
+			if (decided === null || typeof decided !== "object") return null;
+			return modelImageCapableOf(ctx, decided.provider, decided.model);
+		} catch {
+			return null;
+		}
+	}
+	return modelImageCapableOf(ctx, selection.provider, selection.model);
+}
+
 /** Whether the first root session's selected model accepts image input.
- * Null when unknowable (no root, no usable selection). */
-async function rootImageCapableOf(ctx) {
+ *  Null when unknowable. Best-effort for probes WITHOUT a session id only
+ *  (the client dock always passes one): `selectionFor` lives on the
+ *  session-controller's internal controller, not on the cordis ctx.agents
+ *  registry, so the first read yields undefined on current DSH and the
+ *  dsh ≥0.2.2 `agent.model.current()` shape is tried as the second
+ *  attempt. The root's session id rides along so an auto-selection
+ *  resolves its decided route through the intent layer (agent ids are
+ *  session ids in the agents registry). */
+async function rootImageCapableOf(ctx, config) {
 	try {
 		const root = ctx.agents?.roots?.()?.[0];
 		if (root === undefined) return null;
-		const current = ctx.agents?.selectionFor?.(root)?.current;
+		const current = ctx.agents?.selectionFor?.(root)?.current ?? root?.model?.current?.();
 		if (!current?.provider || !current?.model) return null;
-		return modelImageCapableOf(ctx, current.provider, current.model);
+		return selectionImageCapableOf(ctx, config, current, typeof root?.id === "string" ? root.id : null);
 	} catch {
 		return null;
 	}
@@ -231,27 +267,27 @@ async function rootImageCapableOf(ctx) {
 /** Whether ONE named session's effective model accepts image input, via the
  *  session-query observeSession channel (shared with host/subagent-model.js;
  *  cold sessions resolve without activating the child). Null when the
- *  session is unknown, unreadable, or carries no selection yet — callers
- *  fall back to the root verdict. */
-async function sessionImageCapableOf(ctx, sessionId) {
-	const selection = await sessionModelSelectionOf(ctx, sessionId);
-	if (selection === null) return null;
-	return modelImageCapableOf(ctx, selection.provider, selection.model);
+ *  session is unknown, unreadable, or carries no selection yet. */
+async function sessionImageCapableOf(ctx, config, sessionId) {
+	return selectionImageCapableOf(ctx, config, await sessionModelSelectionOf(ctx, sessionId), sessionId);
 }
 
 /**
  * Live vision-gate state for the client hint route. `sessionId` (an optional
  * child session id, from the vision-state route's `session` query parameter)
- * judges image capability against THAT session's model; a missing/unknown
- * session falls back to the first root session's verdict.
+ * judges image capability against THAT session's model — a known-but-
+ * unreadable session stays null instead of judging some other conversation's
+ * root model. Only probes WITHOUT a session id fall back to the first root
+ * session's verdict.
  * @param {import("@deepseek-ai/cordis").Context} ctx - host plugin context.
  * @param {object} config - this plugin's live volatile config.
  * @param {string | null} [sessionId] - session to judge instead of the root.
  * @returns {Promise<{poolConfigured: boolean, imageCapable: boolean | null}>}
  */
 export async function visionStateOf(ctx, config, sessionId = null) {
-	let imageCapable = typeof sessionId === "string" && sessionId !== "" ? await sessionImageCapableOf(ctx, sessionId) : null;
-	if (imageCapable === null) imageCapable = await rootImageCapableOf(ctx);
+	const hasSession = typeof sessionId === "string" && sessionId !== "";
+	let imageCapable = hasSession ? await sessionImageCapableOf(ctx, config, sessionId) : null;
+	if (imageCapable === null && !hasSession) imageCapable = await rootImageCapableOf(ctx, config);
 	return {
 		poolConfigured: readPool(config.poolVision).length > 0,
 		imageCapable,
@@ -306,8 +342,8 @@ export function applyVision(ctx, config) {
 				return {
 					kind: "error",
 					text: isZh()
-						? "/vision：视觉池未配置模型。当前会话模型不支持读图——请先在 设置 → dsh-switchman → 派发池与模型排序 的「视觉池 · vision」中添加模型，再重新发送。"
-						: "/vision: the vision pool has no models. This session model cannot read images — add vision-pool models under Settings → dsh-switchman → dispatch pools, then resend.",
+						? "/vision：视觉池未配置模型——请先在 设置 → dsh-switchman → 派发池与模型排序 的「视觉池 · vision」中添加模型，再重新发送。"
+						: "/vision: the vision pool has no models — add vision-pool models under Settings → dsh-switchman → dispatch pools, then resend.",
 				};
 			}
 			const store = ctx.get?.("attachments", false);

package/index.js

@@ -33,6 +33,18 @@
  * 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).
+ *
+ * The intent layer (host/intent.js) adds the "auto" pseudo-model: a
+ * `dsh-switchman-auto` adapter registered on `ctx.llm` (native catalog entry,
+ * composer dropdown) plus an `agent/request` waterfall listener that rewrites
+ * the pseudo route onto a real model — a small classifier model scores the
+ * recent conversation against the configured candidate list once per turn,
+ * the decision pins for the turn's retries and later steps, and a
+ * provider-cache window keeps the current model while confidence stays below
+ * the switch threshold. The llm/sessions services are reached through
+ * defensive ctx.get reads (NOT declared in inject): a deployment without the
+ * llm service leaves this layer a warn-once no-op — a documented runtime
+ * precondition, like sessionQuery/pluginManager above.
  */
 
 import { readdirSync, readFileSync } from "node:fs";
@@ -60,6 +72,9 @@ import { applyContextWatch } from "./host/context-watch.js";
 // Vision dispatch gate (/vision command + vision-state route for the
 // composer-dock hint): unlocks image sending on text-only models.
 import { applyVision } from "./host/vision.js";
+// Intent-routing layer ("auto" pseudo-model: classifier-routed real model,
+// per-turn pin + prompt-cache window; intent-state/intent-reset routes).
+import { applyIntent } from "./host/intent.js";
 // Client-bridge routes (config snapshot/fenced write + model catalog for the
 // restricted browser half, which has no configForms/remote services).
 import { applyRoutes } from "./host/routes.js";
@@ -159,8 +174,8 @@ function loadSkillCandidates(root, warn) {
 
 /** Register the bundled dsh-switchman skill provider on `ctx.skills` and
  *  mount the language (lang), dispatch (dispatch), teams (teams), watermark
- *  (context-watch), vision (vision), subagent model visibility
- *  (subagent-model), and client-bridge (routes) layers. */
+ *  (context-watch), vision (vision), intent routing (intent), subagent model
+ *  visibility (subagent-model), and client-bridge (routes) layers. */
 function apply(ctx, config) {
 	const root = fileURLToPath(new URL("./skills/", import.meta.url));
 	const warn = (message) => ctx.logger.warn(`dsh-switchman: ${message}`);
@@ -179,6 +194,7 @@ function apply(ctx, config) {
 	applyTeams(ctx, config);
 	applyContextWatch(ctx, config);
 	applyVision(ctx, config);
+	applyIntent(ctx, config);
 	applySubagentModel(ctx);
 	applyRoutes(ctx, config);
 }

package/locale/en.json

@@ -1,6 +1,6 @@
 {
 	"meta": {
 		"title": "dsh-switchman",
-		"description": "Autonomous Agent Teams for the four shipped presets, plus language preferences, dispatch pools with model ranking, and context watermark control."
+		"description": "Autonomous Agent Teams for the four shipped presets, plus language preferences, dispatch pools with model ranking, context watermark control, and intent routing that auto-selects a model per turn."
 	}
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
 	"meta": {
 		"title": "dsh-switchman 调度管家",
-		"description": "为四个出厂预设注入「默认委派 + 分级验证」的自主智能体团队规程（总纲：返工是最贵的 token），并提供多语言偏好、派发池与模型能力排序、上下文水位控制的设置页。"
+		"description": "为四个出厂预设注入「默认委派 + 分级验证」的自主智能体团队规程（总纲：返工是最贵的 token），并提供多语言偏好、派发池与模型能力排序、上下文水位控制、意图识别自动选模型的设置页。"
 	}
 }

package/package.json

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