@fonlan/dsh-task-kanban 0.1.1 → 0.2.1

package/lib/index.js

@@ -3,7 +3,8 @@ import { settingsNamespace } from "@deepseek-ai/dsh-settings";
 import { randomUUID } from "node:crypto";
 import { appendFile, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { ReasoningEffortId, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { installModelSelection } from "@deepseek-ai/dsh-agent";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { isSkillName, isUserInvocable, renderSkillContent } from "@deepseek-ai/dsh-skill";
@@ -12,12 +13,32 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 const KANBAN_SETTINGS_NS = settingsNamespace("task-kanban");
 const KanbanSettingsSchema = z.object({
 	maxParallelWorkers: z.natural().min(1).default(1),
-	defaultModel: z.string().default("")
+	refinementModel: z.string().default(""),
+	refinementProvider: z.string().default(""),
+	refinementReasoningEffort: z.string().default(""),
+	refinementPreset: z.string().default(""),
+	phaseModel: z.string().default(""),
+	phaseProvider: z.string().default(""),
+	phaseReasoningEffort: z.string().default(""),
+	phasePreset: z.string().default("")
 });
+const EMPTY_DEFAULTS = {
+	model: "",
+	provider: "",
+	reasoningEffort: "",
+	preset: ""
+};
 function registerSettings(ctx) {
 	let current = {
 		maxParallelWorkers: 1,
-		defaultModel: ""
+		refinementModel: "",
+		refinementProvider: "",
+		refinementReasoningEffort: "",
+		refinementPreset: "",
+		phaseModel: "",
+		phaseProvider: "",
+		phaseReasoningEffort: "",
+		phasePreset: ""
 	};
 	let service;
 	ctx.inject(["settings"], (sctx) => {
@@ -30,6 +51,24 @@ function registerSettings(ctx) {
 	});
 	return {
 		get: () => current,
+		sessionDefaults: (kind) => {
+			const s = current;
+			switch (kind) {
+				case "refine": return {
+					model: s.refinementModel,
+					provider: s.refinementProvider,
+					reasoningEffort: s.refinementReasoningEffort,
+					preset: s.refinementPreset
+				};
+				case "phase": return {
+					model: s.phaseModel,
+					provider: s.phaseProvider,
+					reasoningEffort: s.phaseReasoningEffort,
+					preset: s.phasePreset
+				};
+				case "merge": return EMPTY_DEFAULTS;
+			}
+		},
 		defaultModelRoute: () => {
 			if (service === void 0) return {};
 			try {
@@ -611,6 +650,11 @@ var KanbanRunner = class {
 	merging = /* @__PURE__ */ new Set();
 	/** Retained agent handles (kept so ended sessions stay in the store/UI). */
 	handles = /* @__PURE__ */ new Map();
+	/** Whether startup recovery + session indexing ran (deferred until workspaces exist). */
+	recovered = false;
+	/** Agents that already got their scoped kanban tools (event idempotency). */
+	toolScopedAgents = /* @__PURE__ */ new WeakSet();
+	agentStartOff;
 	constructor(ctx, store, settings) {
 		this.ctx = ctx;
 		this.store = store;
@@ -623,9 +667,17 @@ var KanbanRunner = class {
 		this.pumpTimer = setInterval(() => {
 			this.pump();
 		}, 2500);
+		this.agentStartOff = this.ctx.on("agent/session-start", (payload) => {
+			this.onAgentSessionStart(payload.agent);
+		});
 	}
 	stop() {
 		if (this.pumpTimer !== void 0) clearInterval(this.pumpTimer);
+		this.pumpTimer = void 0;
+		if (this.agentStartOff !== void 0) {
+			this.agentStartOff();
+			this.agentStartOff = void 0;
+		}
 	}
 	newSessionId() {
 		return `session-${randomUUID()}`;
@@ -703,6 +755,52 @@ var KanbanRunner = class {
 			}
 		}
 	}
+	/**
+	* Rebuild sessionId → cardId from the task store. Runs once the workspace
+	* registry is available (see pump), so kanban sessions resumed after a
+	* restart still resolve their card.
+	*/
+	async indexSessions() {
+		for (const ws of await this.workspaceList()) {
+			const cards = await this.store.list(ws.path);
+			for (const card of cards) this.mapCardSessions(card.id, card);
+		}
+	}
+	mapCardSessions(cardId, card) {
+		for (const sid of card.sessions.refinement) this.sessionCards.set(sid, cardId);
+		for (const attempt of card.sessions.phases) this.sessionCards.set(attempt.sessionId, cardId);
+		for (const sid of card.sessions.merge) this.sessionCards.set(sid, cardId);
+	}
+	/** Fallback lookup when a session starts before indexSessions ran. */
+	async lookupCardOfSession(sessionId) {
+		for (const ws of await this.workspaceList()) {
+			const cards = await this.store.list(ws.path);
+			for (const card of cards) if (card.sessions.refinement.includes(sessionId) || card.sessions.phases.some((a) => a.sessionId === sessionId) || card.sessions.merge.includes(sessionId)) {
+				this.mapCardSessions(card.id, card);
+				return card.id;
+			}
+		}
+	}
+	/**
+	* The single place kanban tools get registered. `agent/session-start` fires
+	* for BOTH `agents.create` (startup) and `agents.resume` (host re-open after
+	* a restart), so a resumed refinement/phase/merge session keeps its scoped
+	* tools. Idempotent per agent object; non-kanban sessions are skipped.
+	*/
+	async onAgentSessionStart(agent) {
+		if (agent === void 0 || agent.id === void 0 || agent.ctx === void 0) return;
+		if (this.toolScopedAgents.has(agent)) return;
+		let cardId = this.sessionCards.get(agent.id);
+		if (cardId === void 0) cardId = await this.lookupCardOfSession(agent.id);
+		if (cardId === void 0) return;
+		this.sessionCards.set(agent.id, cardId);
+		try {
+			registerKanbanTools(agent.ctx, this.toolResolver());
+			this.toolScopedAgents.add(agent);
+		} catch (error) {
+			console.error("[task-kanban] register kanban tools for " + agent.id + " failed:", String(error));
+		}
+	}
 	async listCards(workspacePath) {
 		return this.store.list(workspacePath);
 	}
@@ -859,6 +957,21 @@ var KanbanRunner = class {
 		return this.settings.get().maxParallelWorkers;
 	}
 	async pump() {
+		if (!this.recovered) {
+			if ((await this.workspaceList()).length > 0) {
+				this.recovered = true;
+				try {
+					await this.recoverInterrupted();
+				} catch (error) {
+					console.error("[task-kanban] recoverInterrupted failed:", String(error));
+				}
+				try {
+					await this.indexSessions();
+				} catch (error) {
+					console.error("[task-kanban] indexSessions failed:", String(error));
+				}
+			}
+		}
 		if (this.slots >= this.maxParallel()) return;
 		const workspaces = await this.workspaceList();
 		for (const ws of workspaces) {
@@ -902,7 +1015,7 @@ var KanbanRunner = class {
 	async runRefinement(cardId, wsPath) {
 		const card = await this.store.get(wsPath, cardId);
 		if (card === void 0) return;
-		const route = await this.modelRoute(cardId, wsPath);
+		const route = await this.modelRoute(cardId, wsPath, "refine");
 		const sessionId = this.newSessionId();
 		this.sessionCards.set(sessionId, cardId);
 		await this.store.mutate(cardId, (c) => {
@@ -911,7 +1024,7 @@ var KanbanRunner = class {
 			c.sessions.refinement.push(sessionId);
 		}, wsPath);
 		try {
-			const handle = await this.createAgent(sessionId, wsPath, route, this.toolResolver());
+			const handle = await this.createAgent(sessionId, wsPath, route, "refine");
 			this.keepHandle(cardId, handle);
 			await this.attachRefinementSession(wsPath, sessionId);
 			const skill = card.skill !== void 0 ? await loadCardSkill(this.ctx, card.skill, wsPath, handle.agent) : void 0;
@@ -1015,20 +1128,47 @@ var KanbanRunner = class {
 			dispose
 		};
 	}
-	async createAgent(sessionId, cwd, route, resolver) {
+	/**
+	* Create one kanban session agent. `kind` decides the per-session preset:
+	* refine/phase use their settings default (falling back to the roster's
+	* default preset when unset), merge keeps the historical 'standard' preset.
+	* When the kind defaults configure a reasoning effort, an
+	* `installModelSelection` ref couples the provider/model + effort into every
+	* prompt assembly and model request. Without a configured effort no
+	* selection is installed: `agentOptions` carries the route and the loop
+	* materializes the model's own default effort — the historical behavior.
+	*/
+	async createAgent(sessionId, cwd, route, kind) {
 		const agentOptions = route.provider !== void 0 && route.model !== void 0 && route.model !== "" ? {
 			provider: route.provider,
 			model: route.model
 		} : void 0;
+		const selectionRef = {
+			current: route.provider !== void 0 && route.model !== void 0 && route.model !== "" ? {
+				provider: route.provider,
+				model: route.model,
+				...route.reasoningEffort !== void 0 && route.reasoningEffort !== "" ? { reasoningEffort: ReasoningEffortId(route.reasoningEffort) } : {}
+			} : void 0,
+			assembled: void 0
+		};
+		let presetId;
+		const presets = this.ctx.get("agentPresets");
+		if (presets !== void 0) {
+			const requested = kind === "merge" ? "standard" : this.settings.sessionDefaults(kind).preset;
+			presetId = (await presets.resolve(requested === "" ? void 0 : requested)).id;
+		}
 		return this.ctx.agents.create({
 			sessionId,
-			meta: { cwd },
+			meta: {
+				cwd,
+				...presetId !== void 0 ? { agentPreset: presetId } : {}
+			},
 			...agentOptions !== void 0 ? { agentOptions } : {},
 			setup: async (agentCtx) => {
 				const agentPresets = agentCtx.get("agentPresets");
-				if (agentPresets !== void 0) await agentPresets.mount(agentCtx, "standard");
+				if (agentPresets !== void 0) await agentPresets.mount(agentCtx, presetId);
 				else throw new Error("@fonlan/dsh-task-kanban: agent-presets service is not mounted");
-				registerKanbanTools(agentCtx, resolver);
+				if (selectionRef.current !== void 0 && selectionRef.current.reasoningEffort !== void 0) installModelSelection(agentCtx, selectionRef);
 			}
 		});
 	}
@@ -1060,8 +1200,15 @@ var KanbanRunner = class {
 			if (candidate !== void 0 && typeof candidate.resolveByPath === "function") return candidate;
 		}
 	}
-	/** Resolve the provider+model route for an agent (both are required). */
-	async modelRoute(cardId, wsPath) {
+	/**
+	* Resolve the provider+model route for an agent (both are required), plus
+	* the per-kind reasoning effort. Precedence per kind:
+	*   1. the card's explicit model (chosen at creation) — wins for every kind;
+	*   2. the session-kind defaults (refine/phase settings);
+	*   3. the host `agent-default-model` route.
+	* Merge sessions skip step 2 (no per-type defaults for them).
+	*/
+	async modelRoute(cardId, wsPath, kind) {
 		const card = await this.store.get(wsPath, cardId);
 		if (card === void 0) return {};
 		if (card.model !== "" && card.provider !== void 0 && card.provider !== "") return {
@@ -1075,14 +1222,12 @@ var KanbanRunner = class {
 				model: card.model
 			} : { model: card.model };
 		}
-		const userDefault = this.settings.get().defaultModel;
-		if (userDefault !== "") {
-			const fallback = this.settings.defaultModelRoute();
-			return fallback.provider !== void 0 ? {
-				provider: fallback.provider,
-				model: userDefault
-			} : { model: userDefault };
-		}
+		const kindDefaults = this.settings.sessionDefaults(kind);
+		if (kindDefaults.model !== "") return {
+			...kindDefaults.provider !== "" ? { provider: kindDefaults.provider } : {},
+			model: kindDefaults.model,
+			...kindDefaults.reasoningEffort !== "" ? { reasoningEffort: kindDefaults.reasoningEffort } : {}
+		};
 		return this.settings.defaultModelRoute();
 	}
 	async runCard(wsPath, card, entry) {
@@ -1179,9 +1324,9 @@ var KanbanRunner = class {
 				startedAt: Date.now()
 			});
 		}, wsPath);
-		const route = await this.modelRoute(cardId, wsPath);
+		const route = await this.modelRoute(cardId, wsPath, "phase");
 		try {
-			const handle = await this.createAgent(sessionId, workdir, route, this.toolResolver());
+			const handle = await this.createAgent(sessionId, workdir, route, "phase");
 			this.keepHandle(cardId, handle);
 			entry.cancel = () => handle.agent.cancel({ kind: "user" });
 			handle.agent.followup(this.asUserMessage(phasePrompt({
@@ -1473,9 +1618,9 @@ var KanbanRunner = class {
 		await this.store.mutate(cardId, (c) => {
 			c.sessions.merge.push(sessionId);
 		}, wsPath);
-		const route = await this.modelRoute(cardId, wsPath);
+		const route = await this.modelRoute(cardId, wsPath, "merge");
 		try {
-			const handle = await this.createAgent(sessionId, workdir, route, this.toolResolver());
+			const handle = await this.createAgent(sessionId, workdir, route, "merge");
 			this.keepHandle(cardId, handle);
 			handle.agent.followup(this.asUserMessage(mergePrompt(workdir, conflicts)));
 			await handle.agent.whenIdle();
@@ -1532,6 +1677,28 @@ async function listModels(ctx) {
 	} catch {}
 	return out;
 }
+/**
+* Resolve the adapter-owned reasoning efforts of one exact provider/model
+* route. On-demand (one model at a time) so the settings picker can offer the
+* levels the selected model actually supports; failures yield an empty list.
+*/
+async function reasoningOptions(ctx, provider, model) {
+	const llm = ctx.get("llm");
+	if (llm === void 0) return { efforts: [] };
+	try {
+		const info = await llm.resolveModelInfo(provider, model);
+		return {
+			efforts: (info.reasoning?.efforts ?? []).map((e) => ({
+				id: String(e.id),
+				name: e.name,
+				...e.description !== void 0 ? { description: e.description } : {}
+			})),
+			...info.reasoning?.defaultEffort !== void 0 ? { defaultEffort: String(info.reasoning.defaultEffort) } : {}
+		};
+	} catch {
+		return { efforts: [] };
+	}
+}
 //#endregion
 //#region src/server/rpc.ts
 const API_PREFIX = "/plugins/@fonlan/dsh-task-kanban/api";
@@ -1664,14 +1831,37 @@ function registerApiRoutes(ctx, runner, settings) {
 	route("retry", async (p) => runner.retryTask(requireString(p.cardId, "cardId")));
 	route("remove", async (p) => runner.deleteTask(requireString(p.cardId, "cardId")));
 	route("settings.get", async () => settings.get());
+	/** Every settings field the client may write (per-session-type defaults included). */
+	const SETTING_STRING_FIELDS = [
+		"refinementModel",
+		"refinementProvider",
+		"refinementReasoningEffort",
+		"refinementPreset",
+		"phaseModel",
+		"phaseProvider",
+		"phaseReasoningEffort",
+		"phasePreset"
+	];
 	route("settings.set", async (p) => {
 		const patch = {};
 		if (typeof p.maxParallelWorkers === "number") patch.maxParallelWorkers = p.maxParallelWorkers;
-		if (typeof p.defaultModel === "string") patch.defaultModel = p.defaultModel;
+		for (const key of SETTING_STRING_FIELDS) if (typeof p[key] === "string") patch[key] = p[key];
 		await settings.update(patch);
 		return settings.get();
 	});
 	route("models.list", async () => listModels(ctx));
+	route("presets.list", async () => {
+		const presets = ctx.get("agentPresets");
+		if (presets === void 0) return [];
+		return (await presets.list()).map((r) => ({
+			id: r.id,
+			name: r.name,
+			description: r.description
+		}));
+	});
+	route("reasoning.options", async (p) => {
+		return reasoningOptions(ctx, requireString(p.provider, "provider"), requireString(p.model, "model"));
+	});
 	return () => {
 		for (const d of disposers) d();
 	};

package/lib/types/server/models.d.ts

@@ -2,3 +2,19 @@ import type { Context } from '@deepseek-ai/cordis';
 import type { ModelOption } from '../shared/card.js';
 /** Available models from every registered LLM provider (advisory catalog). */
 export declare function listModels(ctx: Context): Promise<ModelOption[]>;
+/** One selectable reasoning effort of a model (display vocabulary for the settings picker). */
+export interface ReasoningEffortOption {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface ReasoningOptions {
+    efforts: ReasoningEffortOption[];
+    defaultEffort?: string;
+}
+/**
+ * Resolve the adapter-owned reasoning efforts of one exact provider/model
+ * route. On-demand (one model at a time) so the settings picker can offer the
+ * levels the selected model actually supports; failures yield an empty list.
+ */
+export declare function reasoningOptions(ctx: Context, provider: string, model: string): Promise<ReasoningOptions>;

package/lib/types/server/runner.d.ts

@@ -17,6 +17,11 @@ export declare class KanbanRunner implements KanbanToolResolver {
     private merging;
     /** Retained agent handles (kept so ended sessions stay in the store/UI). */
     private handles;
+    /** Whether startup recovery + session indexing ran (deferred until workspaces exist). */
+    private recovered;
+    /** Agents that already got their scoped kanban tools (event idempotency). */
+    private toolScopedAgents;
+    private agentStartOff;
     constructor(ctx: Context, store: TaskStore, settings: KanbanSettingsFace);
     register(ctx: Context): void;
     start(): void;
@@ -30,6 +35,22 @@ export declare class KanbanRunner implements KanbanToolResolver {
     mergeResolved(sessionId: string): Promise<void>;
     private toolResolver;
     recoverInterrupted(): Promise<void>;
+    /**
+     * Rebuild sessionId → cardId from the task store. Runs once the workspace
+     * registry is available (see pump), so kanban sessions resumed after a
+     * restart still resolve their card.
+     */
+    private indexSessions;
+    private mapCardSessions;
+    /** Fallback lookup when a session starts before indexSessions ran. */
+    private lookupCardOfSession;
+    /**
+     * The single place kanban tools get registered. `agent/session-start` fires
+     * for BOTH `agents.create` (startup) and `agents.resume` (host re-open after
+     * a restart), so a resumed refinement/phase/merge session keeps its scoped
+     * tools. Idempotent per agent object; non-kanban sessions are skipped.
+     */
+    private onAgentSessionStart;
     listCards(workspacePath: string): Promise<KanbanCard[]>;
     createTask(input: {
         workspacePath: string;
@@ -82,6 +103,16 @@ export declare class KanbanRunner implements KanbanToolResolver {
      * resolve it — only real human replies drive the interactive refinement.
      */
     private waitForUserReply;
+    /**
+     * Create one kanban session agent. `kind` decides the per-session preset:
+     * refine/phase use their settings default (falling back to the roster's
+     * default preset when unset), merge keeps the historical 'standard' preset.
+     * When the kind defaults configure a reasoning effort, an
+     * `installModelSelection` ref couples the provider/model + effort into every
+     * prompt assembly and model request. Without a configured effort no
+     * selection is installed: `agentOptions` carries the route and the loop
+     * materializes the model's own default effort — the historical behavior.
+     */
     private createAgent;
     private keepHandle;
     /**
@@ -93,7 +124,14 @@ export declare class KanbanRunner implements KanbanToolResolver {
     private attachRefinementSession;
     /** The host workspace registry, whichever service name carries it. */
     private attachRegistry;
-    /** Resolve the provider+model route for an agent (both are required). */
+    /**
+     * Resolve the provider+model route for an agent (both are required), plus
+     * the per-kind reasoning effort. Precedence per kind:
+     *   1. the card's explicit model (chosen at creation) — wins for every kind;
+     *   2. the session-kind defaults (refine/phase settings);
+     *   3. the host `agent-default-model` route.
+     * Merge sessions skip step 2 (no per-type defaults for them).
+     */
     private modelRoute;
     private runCard;
     private runPhase;

package/lib/types/server/settings.d.ts

@@ -1,20 +1,42 @@
 /**
- * User-facing plugin settings (global parallel worker count, default model),
- * persisted through the settings service namespace `task-kanban`. The DSH
- * settings service requires a lowercase kebab-case namespace
- * (/^[a-z][a-z0-9-]*$/), so the scoped package name cannot be used here.
+ * User-facing plugin settings (global parallel worker count, per-session-type
+ * model/effort/preset defaults), persisted through the settings service
+ * namespace `task-kanban`. The DSH settings service requires a lowercase
+ * kebab-case namespace (/^[a-z][a-z0-9-]*$/), so the scoped package name
+ * cannot be used here.
  */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
-import type { KanbanSettingsShape } from '../shared/card.js';
+import type { KanbanSessionKind, KanbanSettingsShape } from '../shared/card.js';
 export declare const KANBAN_SETTINGS_NS: import("@deepseek-ai/dsh-settings").SettingsNamespace;
 export declare const KanbanSettingsSchema: z<Schemastery.ObjectS<{
     maxParallelWorkers: z<number, number>;
-    defaultModel: z<string, string>;
+    refinementModel: z<string, string>;
+    refinementProvider: z<string, string>;
+    refinementReasoningEffort: z<string, string>;
+    refinementPreset: z<string, string>;
+    phaseModel: z<string, string>;
+    phaseProvider: z<string, string>;
+    phaseReasoningEffort: z<string, string>;
+    phasePreset: z<string, string>;
 }>, Schemastery.ObjectT<{
     maxParallelWorkers: z<number, number>;
-    defaultModel: z<string, string>;
+    refinementModel: z<string, string>;
+    refinementProvider: z<string, string>;
+    refinementReasoningEffort: z<string, string>;
+    refinementPreset: z<string, string>;
+    phaseModel: z<string, string>;
+    phaseProvider: z<string, string>;
+    phaseReasoningEffort: z<string, string>;
+    phasePreset: z<string, string>;
 }>>;
+/** The per-session-type default slice a session kind resolves. */
+export interface KanbanSessionDefaults {
+    model: string;
+    provider: string;
+    reasoningEffort: string;
+    preset: string;
+}
 export interface KanbanSettingsFace {
     get(): KanbanSettingsShape;
     update(patch: Partial<KanbanSettingsShape>): Promise<void>;
@@ -23,5 +45,11 @@ export interface KanbanSettingsFace {
         provider?: string;
         model?: string;
     };
+    /**
+     * The configured model/effort/preset defaults for one session kind.
+     * `merge` sessions deliberately carry no per-type defaults: they keep the
+     * legacy resolution chain (card model → host default).
+     */
+    sessionDefaults(kind: KanbanSessionKind): KanbanSessionDefaults;
 }
 export declare function registerSettings(ctx: Context): KanbanSettingsFace;

package/lib/types/shared/card.d.ts

@@ -82,7 +82,18 @@ export interface ModelOption {
     id: string;
     name?: string;
 }
+/** Which kanban session kind a per-type default applies to. */
+export type KanbanSessionKind = 'refine' | 'phase' | 'merge';
 export interface KanbanSettingsShape {
     maxParallelWorkers: number;
-    defaultModel: string;
+    /** Requirement-refinement session defaults. */
+    refinementModel: string;
+    refinementProvider: string;
+    refinementReasoningEffort: string;
+    refinementPreset: string;
+    /** Phase implementation session defaults. */
+    phaseModel: string;
+    phaseProvider: string;
+    phaseReasoningEffort: string;
+    phasePreset: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonlan/dsh-task-kanban",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "DSH web plugin: a task kanban that refines requirements into phased plans, auto-executes them in git worktrees (one session per phase), and auto-merges into the main branch on completion.",
   "license": "MIT",
   "repository": {
@@ -44,6 +44,7 @@
   },
   "scripts": {
     "build": "rm -rf lib && tsc -p tsconfig.build.json && tsdown",
+    "prepare": "npm run build",
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.client.json",
     "bundle": "tsdown",
     "watch": "tsdown --watch",
@@ -64,6 +65,7 @@
         "@deepseek-ai/dsh-client-ui-layout",
         "@deepseek-ai/dsh-client-ui-conversation",
         "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-settings-plugins",
         "@deepseek-ai/dsh-client-web-react"
       ]
     }
@@ -82,6 +84,7 @@
     "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings-plugins": "^0.1.0-rc.6",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
@@ -104,6 +107,7 @@
     "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-layout": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-settings-plugins": "^0.1.0-rc.6",
     "vitest": "^3.2.0"
   },
   "packageManager": "pnpm@11.21.0"

package/src/client/api.ts

@@ -69,6 +69,21 @@ export async function gatewaySkillList(sessionId: string): Promise<SkillOption[]
   return parsed.result.value?.skills ?? []
 }
 
+/** One row of the host `agentPresets.list()` roster. */
+export interface PresetOption {
+  id: string
+  name?: string
+  description?: string
+}
+
+/** Reasoning efforts of one provider/model route (`reasoning.options`). */
+export interface ReasoningOptions {
+  efforts: Array<{ id: string; name: string; description?: string }>
+  defaultEffort?: string
+  /** Client-side marker: the fetch failed; the stored effort must be kept. */
+  failed?: boolean
+}
+
 export const api = {
   list: (workspacePath: string) => call<KanbanCard[]>('list', { workspacePath }),
   create: (workspacePath: string, requirement: string, model: string, provider?: string, skill?: string) =>
@@ -80,4 +95,7 @@ export const api = {
   settingsGet: () => call<KanbanSettingsShape>('settings.get'),
   settingsSet: (patch: Partial<KanbanSettingsShape>) => call<KanbanSettingsShape>('settings.set', patch),
   models: () => call<ModelOption[]>('models.list'),
-}
+  presets: () => call<PresetOption[]>('presets.list'),
+  reasoningOptions: (provider: string, model: string) =>
+    call<ReasoningOptions>('reasoning.options', { provider, model }),
+}