@fonlan/dsh-task-kanban 0.1.0 → 0.2.0

package/lib/index.js

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { isSkillName, isUserInvocable, renderSkillContent } from "@deepseek-ai/dsh-skill";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 //#region src/server/settings.ts
 const KANBAN_SETTINGS_NS = settingsNamespace("task-kanban");
@@ -114,6 +115,7 @@ var TaskStore = class {
 			requirement: input.requirement,
 			model: input.model,
 			...input.provider !== void 0 ? { provider: input.provider } : {},
+			...input.skill !== void 0 && input.skill !== "" ? { skill: input.skill } : {},
 			status: input.status ?? "draft",
 			currentPhase: 0,
 			phaseCount: 0,
@@ -249,6 +251,29 @@ ${workspacePath}
 4. 完成后调用 kanban_write_plan 工具把完整计划写回（title、summary、phases）。这是唯一写回方式，不要把计划 JSON 直接输出到对话里。
 5. 不要向用户提问，自主决策。`;
 }
+/**
+* Interactive refinement prompt for a card created with a skill (e.g.
+* `/grill-me`). The refinement session is explicit — the user can reply —
+* so instead of deciding autonomously, the agent follows the skill's
+* interview and asks whatever it needs before writing the plan back.
+*/
+function interactiveRefinementPrompt(requirement, workspacePath) {
+	return `你是一个需求分析师。请分析下面的需求，并为它在指定项目中的实现制定一个可执行的分阶段实现计划。
+
+【需求】
+${requirement}
+
+【项目目录】
+${workspacePath}
+
+【要求】
+1. 先浏览项目目录了解现状（阅读 README、关键源码与文档；本会话只做只读探索，不要修改任何文件）。
+2. 这是一个显式会话，可以且应该与用户交流：按上方 Skill 的指引对需求进行充分打磨，通过提问澄清需求中模糊、缺失或相互矛盾的地方，直到需求足够明确。
+3. 需求打磨完成后，把需求拆解为按顺序串行执行的实现阶段（phase）。简单需求 1 个 phase 即可；复杂需求拆多个 phase，每个 phase 必须是独立的、可串行执行的实现单元，后面的 phase 依赖前面 phase 的产出。
+4. 每个 phase 必须包含：id（如 p1/p2/p3）、标题、目标（goal，说明该 phase 要交付什么）。
+5. 完成后调用 kanban_write_plan 工具把完整计划写回（title、summary、phases）。这是唯一写回方式，不要把计划 JSON 直接输出到对话里。
+6. 用户回复前不要擅自调用 kanban_write_plan；也不要因为用户暂时没有回复就放弃，等待用户回答即可。`;
+}
 /** Phase implementation session prompt; identical on retries (the model reads git status/diff itself). */
 function phasePrompt(card, phaseIndex, workdir) {
 	const plan = card.plan;
@@ -283,6 +308,75 @@ ${conflicts}
 3. 解决完成后调用 kanban_merge_resolved 工具声明完成（可附简短说明）。`;
 }
 //#endregion
+//#region src/server/skills.ts
+/**
+* The public skill-name gesture shape: a whitespace-bounded `/name` token
+* matching the grammar `tool-skill` uses (kebab-case letters/digits), at the
+* very start of the input (leading whitespace allowed). A second `/` or
+* non-boundary character breaks the match, keeping file paths (`/usr/bin`)
+* and fractions (`5/8`) out.
+*/
+const SKILL_GESTURE = /^\s*\/([a-z0-9]+(?:-[a-z0-9]+)*)(?=\s|$)/;
+/**
+* Extract a leading `/skill-name` gesture from raw create-task input. Only a
+* token at the very start selects a skill; tokens later in the text are
+* ordinary requirement prose (the user might legitimately mention paths or
+* fractions). The name is grammar-validated but not registry-checked here —
+* unknown names surface as a refinement error with a clear message.
+*/
+function parseSkillGesture(raw) {
+	const m = SKILL_GESTURE.exec(raw);
+	if (m === null) return { requirement: raw.trim() };
+	return {
+		skill: m[1],
+		requirement: raw.slice(m[0].length).trim()
+	};
+}
+/** Resolve the host skill registry, or undefined when this profile lacks one. */
+function skillRegistry(ctx) {
+	try {
+		return ctx.get("skills");
+	} catch {
+		return;
+	}
+}
+/**
+* Build the instructions-form message carrying the rendered skill body, the
+* same shape a user `/grill-me` invocation injects through `tool-skill`. The
+* `skill-invocation` source is what the transcript UI decorates as a skill
+* chip; the content is the canonical `<skill_content>` block.
+*/
+function skillInvocationMessage(skill) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: renderSkillContent(skill)
+		}],
+		source: {
+			kind: "skill-invocation",
+			name: skill.name,
+			form: "instructions"
+		}
+	});
+}
+/**
+* Load the skill body the card names, scoped to the refinement agent so
+* preset-layer providers (the filesystem skill roots) are visible. Returns
+* undefined when the skill is unknown, not user-invocable, or the registry is
+* absent — the caller decides how to surface that.
+*/
+async function loadCardSkill(ctx, name, cwd, scope) {
+	if (name === void 0 || !isSkillName(name)) return void 0;
+	const registry = skillRegistry(ctx);
+	if (registry === void 0) return void 0;
+	const skill = await registry.get(name, {
+		cwd,
+		scope
+	});
+	if (skill === void 0 || !isUserInvocable(skill)) return void 0;
+	return skill;
+}
+//#endregion
 //#region src/shared/plan.ts
 function validatePlan(input) {
 	if (typeof input !== "object" || input === null) return {
@@ -517,6 +611,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;
@@ -529,9 +628,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()}`;
@@ -609,15 +716,65 @@ 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);
 	}
 	async createTask(input) {
+		const parsed = parseSkillGesture(input.requirement);
+		const skill = input.skill !== void 0 && input.skill !== "" ? input.skill : parsed.skill;
+		const requirement = skill !== void 0 ? parsed.requirement : input.requirement.trim();
 		const card = await this.store.create({
 			workspacePath: input.workspacePath,
-			requirement: input.requirement,
+			requirement,
 			model: input.model,
 			provider: input.provider,
+			...skill !== void 0 ? { skill } : {},
 			status: "refining"
 		});
 		await this.ensureGitignoreDsh(input.workspacePath);
@@ -761,6 +918,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) {
@@ -813,13 +985,46 @@ 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);
 			this.keepHandle(cardId, handle);
 			await this.attachRefinementSession(wsPath, sessionId);
-			handle.agent.followup(this.asUserMessage(refinementPrompt(card.requirement, wsPath)));
+			const skill = card.skill !== void 0 ? await loadCardSkill(this.ctx, card.skill, wsPath, handle.agent) : void 0;
+			if (card.skill !== void 0 && skill === void 0) {
+				await this.fail(cardId, "refine_failed", `Skill "${card.skill}" 不存在或不可用于用户调用，请检查后重试`, "demand");
+				return;
+			}
+			if (skill !== void 0) handle.agent.inject(skillInvocationMessage(skill));
+			const interactive = skill !== void 0;
+			handle.agent.followup(this.asUserMessage(interactive ? interactiveRefinementPrompt(card.requirement, wsPath) : refinementPrompt(card.requirement, wsPath)));
+			await this.driveRefinement(cardId, wsPath, sessionId, handle, interactive);
+		} catch (error) {
+			console.error("[task-kanban] refinement create/drive failed:", String(error));
+			await this.fail(cardId, "refine_failed", `细化会话失败: ${String(error)}`, "demand");
+		}
+	}
+	/**
+	* Drive the refinement session to a terminal card state. Non-interactive
+	* cards follow the original contract: the agent finishes one turn and must
+	* have written the plan. Interactive cards (created with a refinement
+	* skill) may ask the user clarifying questions — the session is explicit
+	* and visible in the workspace chat, so the runner waits for each reply
+	* instead of failing, and only settles when the plan is written or the
+	* session errors out.
+	*/
+	async driveRefinement(cardId, wsPath, sessionId, handle, interactive) {
+		while (true) {
+			const reply = this.waitForUserReply(sessionId);
+			const settlement = this.waitForCardSettlement(cardId, wsPath);
 			await handle.agent.whenIdle();
 			const fresh = await this.store.get(wsPath, cardId);
-			if (fresh !== void 0 && fresh.status === "refining") {
+			if (fresh === void 0 || fresh.status !== "refining") {
+				reply.dispose();
+				settlement.dispose();
+				return;
+			}
+			if (!interactive) {
+				reply.dispose();
+				settlement.dispose();
 				try {
 					const tail = handle.agent.session.events.slice(-10).map((e) => ({
 						type: e.type,
@@ -830,13 +1035,61 @@ var KanbanRunner = class {
 					console.error("[task-kanban] could not read session events:", String(error));
 				}
 				await this.fail(cardId, "refine_failed", "细化会话结束但未通过 kanban_write_plan 写回计划", "demand");
+				return;
 			}
-		} catch (error) {
-			console.error("[task-kanban] refinement create/drive failed:", String(error));
-			await this.fail(cardId, "refine_failed", `细化会话失败: ${String(error)}`, "demand");
+			await Promise.race([reply.promise, settlement.promise]);
+			reply.dispose();
+			settlement.dispose();
 		}
 	}
-	async createAgent(sessionId, cwd, route, resolver) {
+	/**
+	* A promise resolving when the card stops being 'refining' (planned,
+	* failed, or gone), plus a disposer stopping the polling interval.
+	*/
+	waitForCardSettlement(cardId, wsPath) {
+		let resolve;
+		const promise = new Promise((res) => {
+			resolve = res;
+		});
+		const timer = setInterval(async () => {
+			const fresh = await this.store.get(wsPath, cardId);
+			if (fresh === void 0 || fresh.status !== "refining") {
+				clearInterval(timer);
+				resolve();
+			}
+		}, 1e3);
+		timer.unref?.();
+		return {
+			promise,
+			dispose: () => clearInterval(timer)
+		};
+	}
+	/**
+	* A promise resolving when a NEW human message enters the given session,
+	* plus a disposer detaching the listener. Messages injected by plugins with
+	* non-`user` sources (such as our skill-invocation instructions) never
+	* resolve it — only real human replies drive the interactive refinement.
+	*/
+	waitForUserReply(sessionId) {
+		let settle;
+		const promise = new Promise((resolve) => {
+			settle = resolve;
+		});
+		const listener = (session, event) => {
+			if (session.id !== sessionId) return;
+			if (event.type !== "user/message") return;
+			if (("source" in event.data ? event.data.source : void 0)?.kind === "user") settle();
+		};
+		const detach = this.ctx.on("session/event", listener);
+		const dispose = () => {
+			if (typeof detach === "function") detach();
+		};
+		return {
+			promise,
+			dispose
+		};
+	}
+	async createAgent(sessionId, cwd, route) {
 		const agentOptions = route.provider !== void 0 && route.model !== void 0 && route.model !== "" ? {
 			provider: route.provider,
 			model: route.model
@@ -849,7 +1102,6 @@ var KanbanRunner = class {
 				const agentPresets = agentCtx.get("agentPresets");
 				if (agentPresets !== void 0) await agentPresets.mount(agentCtx, "standard");
 				else throw new Error("@fonlan/dsh-task-kanban: agent-presets service is not mounted");
-				registerKanbanTools(agentCtx, resolver);
 			}
 		});
 	}
@@ -1002,7 +1254,7 @@ var KanbanRunner = class {
 		}, wsPath);
 		const route = await this.modelRoute(cardId, wsPath);
 		try {
-			const handle = await this.createAgent(sessionId, workdir, route, this.toolResolver());
+			const handle = await this.createAgent(sessionId, workdir, route);
 			this.keepHandle(cardId, handle);
 			entry.cancel = () => handle.agent.cancel({ kind: "user" });
 			handle.agent.followup(this.asUserMessage(phasePrompt({
@@ -1296,7 +1548,7 @@ var KanbanRunner = class {
 		}, wsPath);
 		const route = await this.modelRoute(cardId, wsPath);
 		try {
-			const handle = await this.createAgent(sessionId, workdir, route, this.toolResolver());
+			const handle = await this.createAgent(sessionId, workdir, route);
 			this.keepHandle(cardId, handle);
 			handle.agent.followup(this.asUserMessage(mergePrompt(workdir, conflicts)));
 			await handle.agent.whenIdle();
@@ -1460,11 +1712,13 @@ function registerApiRoutes(ctx, runner, settings) {
 		const requirement = requireString(p.requirement, "requirement");
 		const model = typeof p.model === "string" ? p.model : "";
 		const provider = typeof p.provider === "string" ? p.provider : void 0;
+		const skill = typeof p.skill === "string" && p.skill !== "" ? p.skill : void 0;
 		return runner.createTask({
 			workspacePath,
 			requirement,
 			model,
-			provider
+			provider,
+			...skill !== void 0 ? { skill } : {}
 		});
 	});
 	route("move", async (p) => {
@@ -1498,7 +1752,11 @@ function registerApiRoutes(ctx, runner, settings) {
 //#endregion
 //#region src/index.ts
 const name = "@fonlan/dsh-task-kanban";
-const inject = ["webServer", "agents"];
+const inject = [
+	"webServer",
+	"agents",
+	"skills"
+];
 const Config = z.object({});
 function apply(ctx, _config) {
 	const settings = registerSettings(ctx);

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

@@ -1,6 +1,13 @@
 import type { KanbanCard } from '../shared/card.js';
 /** Refinement session prompt: analyze the repo read-only and write back a plan. */
 export declare function refinementPrompt(requirement: string, workspacePath: string): string;
+/**
+ * Interactive refinement prompt for a card created with a skill (e.g.
+ * `/grill-me`). The refinement session is explicit — the user can reply —
+ * so instead of deciding autonomously, the agent follows the skill's
+ * interview and asks whatever it needs before writing the plan back.
+ */
+export declare function interactiveRefinementPrompt(requirement: string, workspacePath: string): string;
 /** Phase implementation session prompt; identical on retries (the model reads git status/diff itself). */
 export declare function phasePrompt(card: KanbanCard, phaseIndex: number, workdir: string): string;
 /** Merge-conflict resolution session prompt: resolve conflicts only, never commit. */

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,12 +35,29 @@ 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;
         requirement: string;
         model: string;
         provider?: string;
+        skill?: string;
     }): Promise<KanbanCard>;
     moveTask(cardId: string, toLane: Lane): Promise<{
         ok: boolean;
@@ -59,6 +81,28 @@ export declare class KanbanRunner implements KanbanToolResolver {
     private requestStop;
     private fail;
     private runRefinement;
+    /**
+     * Drive the refinement session to a terminal card state. Non-interactive
+     * cards follow the original contract: the agent finishes one turn and must
+     * have written the plan. Interactive cards (created with a refinement
+     * skill) may ask the user clarifying questions — the session is explicit
+     * and visible in the workspace chat, so the runner waits for each reply
+     * instead of failing, and only settles when the plan is written or the
+     * session errors out.
+     */
+    private driveRefinement;
+    /**
+     * A promise resolving when the card stops being 'refining' (planned,
+     * failed, or gone), plus a disposer stopping the polling interval.
+     */
+    private waitForCardSettlement;
+    /**
+     * A promise resolving when a NEW human message enters the given session,
+     * plus a disposer detaching the listener. Messages injected by plugins with
+     * non-`user` sources (such as our skill-invocation instructions) never
+     * resolve it — only real human replies drive the interactive refinement.
+     */
+    private waitForUserReply;
     private createAgent;
     private keepHandle;
     /**

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

@@ -0,0 +1,71 @@
+/**
+ * Skill wiring for requirement refinement.
+ *
+ * A task card may carry a skill name (e.g. `grill-me`) chosen in the
+ * create-task requirement input via a leading `/skill-name` gesture, matching
+ * the harness's user-invocation convention (the same whitespace-bounded token
+ * shape `tool-skill` scans for). The server strips the gesture from the stored
+ * requirement, records the skill on the card, and injects the canonical
+ * `renderSkillContent` block into the refinement session as an instructions-
+ * form user message with the harness's `skill-invocation` source, so the
+ * transcript UI renders it exactly like a user-invoked skill in chat.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type SkillDefinition, type SkillSummary } from '@deepseek-ai/dsh-skill';
+/** A parsed leading skill gesture: the skill name plus the cleaned requirement. */
+export interface SkillGestureParse {
+    /** The skill name from the leading `/name` token, if the input led with one. */
+    skill?: string;
+    /** The requirement text with the leading gesture removed. */
+    requirement: string;
+}
+/**
+ * Extract a leading `/skill-name` gesture from raw create-task input. Only a
+ * token at the very start selects a skill; tokens later in the text are
+ * ordinary requirement prose (the user might legitimately mention paths or
+ * fractions). The name is grammar-validated but not registry-checked here —
+ * unknown names surface as a refinement error with a clear message.
+ */
+export declare function parseSkillGesture(raw: string): SkillGestureParse;
+/**
+ * The minimal view of the hosted skill registry the plugin needs: list for a
+ * summary lookup and get for a full body, both honoring the calling scope.
+ */
+export interface SkillRegistryFace {
+    list(options?: {
+        cwd?: string;
+        scope?: unknown;
+    }): Promise<SkillSummary[]>;
+    get(name: string, options?: {
+        cwd?: string;
+        scope?: unknown;
+    }): Promise<SkillDefinition | undefined>;
+}
+/** Resolve the host skill registry, or undefined when this profile lacks one. */
+export declare function skillRegistry(ctx: Context): SkillRegistryFace | undefined;
+/** Whether the provided skill name is a syntactically valid skill name. */
+export declare function validSkillName(name: string): boolean;
+/**
+ * Build the instructions-form message carrying the rendered skill body, the
+ * same shape a user `/grill-me` invocation injects through `tool-skill`. The
+ * `skill-invocation` source is what the transcript UI decorates as a skill
+ * chip; the content is the canonical `<skill_content>` block.
+ */
+export declare function skillInvocationMessage(skill: Pick<SkillDefinition, 'name' | 'provider' | 'resourceBase' | 'content'>): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    source: {
+        kind: "skill-invocation";
+        name: string;
+        form: "instructions";
+    };
+} & Pick<import("@deepseek-ai/dsh-llm").UserMessage, "id" | "role">;
+/**
+ * Load the skill body the card names, scoped to the refinement agent so
+ * preset-layer providers (the filesystem skill roots) are visible. Returns
+ * undefined when the skill is unknown, not user-invocable, or the registry is
+ * absent — the caller decides how to surface that.
+ */
+export declare function loadCardSkill(ctx: Context, name: string | undefined, cwd: string, scope: unknown): Promise<Pick<SkillDefinition, 'name' | 'provider' | 'resourceBase' | 'content'> | undefined>;

package/lib/types/server/task-store.d.ts

@@ -18,6 +18,7 @@ export declare class TaskStore {
         requirement: string;
         model: string;
         provider?: string;
+        skill?: string;
         status?: KanbanCard['status'];
     }): Promise<KanbanCard>;
     /** Run a mutation under the card's lock; returns the updated card. */

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

@@ -47,6 +47,8 @@ export interface KanbanCard {
     id: string;
     workspacePath: string;
     requirement: string;
+    /** Optional skill (e.g. `grill-me`) used to drive requirement refinement. */
+    skill?: string;
     model: string;
     /** Provider route for the model (from the modal selection). */
     provider?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonlan/dsh-task-kanban",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "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": {
@@ -39,6 +39,9 @@
     "README.md",
     "LICENSE"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "rm -rf lib && tsc -p tsconfig.build.json && tsdown",
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.client.json",
@@ -73,6 +76,7 @@
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-skill": "^0.1.0-rc.6",
     "@deepseek-ai/schemastery": "^3.18.1",
     "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
@@ -94,6 +98,7 @@
     "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-skill": "^0.1.0-rc.6",
     "@deepseek-ai/schemastery": "^3.18.1",
     "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-client-ui-sidebar": "^0.1.0-rc.6",

package/src/client/api.ts

@@ -28,10 +28,51 @@ async function call<T>(method: string, payload: Record<string, unknown> = {}): P
   return parsed.value as T
 }
 
+/** One row of the host `skill.list` catalog (same shape DSH's chat autocomplete uses). */
+export interface SkillOption {
+  name: string
+  description: string
+  whenToUse?: string
+  modelInvocable: boolean
+}
+
+/**
+ * Call the host gateway's `skill.list` unary RPC over the same-origin HTTP
+ * bridge (the exact wire shape DSH's chat input uses for its /-autocomplete).
+ * The requested `sessionId` scopes the catalog to that session's agent
+ * preset, which is where the filesystem skill roots are registered.
+ */
+export async function gatewaySkillList(sessionId: string): Promise<SkillOption[]> {
+  let response: Response
+  try {
+    response = await fetch('/api/skill.list', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        type: 'client-request',
+        rpcId: `task-kanban-${Math.random().toString(36).slice(2)}`,
+        method: 'skill.list',
+        payload: { sessionId },
+      }),
+    })
+  } catch (error) {
+    throw new KanbanApiError('network', error instanceof Error ? error.message : String(error))
+  }
+  const parsed: { type?: string; result?: { ok?: boolean; value?: { skills?: SkillOption[] }; error?: { code?: string; message?: string } } } | null
+    = await response.json().catch(() => null)
+  if (!response.ok || parsed === null || parsed.type !== 'server-response' || parsed.result?.ok !== true) {
+    throw new KanbanApiError(
+      parsed?.result?.error?.code ?? 'http',
+      parsed?.result?.error?.message ?? `HTTP ${response.status}`,
+    )
+  }
+  return parsed.result.value?.skills ?? []
+}
+
 export const api = {
   list: (workspacePath: string) => call<KanbanCard[]>('list', { workspacePath }),
-  create: (workspacePath: string, requirement: string, model: string, provider?: string) =>
-    call<KanbanCard>('create', { workspacePath, requirement, model, provider }),
+  create: (workspacePath: string, requirement: string, model: string, provider?: string, skill?: string) =>
+    call<KanbanCard>('create', { workspacePath, requirement, model, provider, ...(skill !== undefined && skill !== '' ? { skill } : {}) }),
   move: (cardId: string, toLane: Lane) => call<{ ok: boolean; message?: string }>('move', { cardId, toLane }),
   stop: (cardId: string) => call<{ ok: boolean; message?: string }>('stop', { cardId }),
   retry: (cardId: string) => call<{ ok: boolean; message?: string }>('retry', { cardId }),