dsh-continual-evolve 0.15.4 → 0.15.5

package/lib/memory-snapshot.d.ts

@@ -63,4 +63,56 @@ export declare function listCardWorkspaces(store: MemoryStore): {
     root: string;
     label: string;
 }[];
+/** One skill row the card renders (scope resolved: project shadows global). */
+export interface SkillFileInfo {
+    id: string;
+    title: string;
+    description: string;
+    /** `project` or `global` — which partition the row was read from. */
+    scope: string;
+    /** Row status; quarantined rows render in the patrol section, not here. */
+    status: string;
+    /** Update time in epoch milliseconds (the card's "updated" line). */
+    updatedAt: number;
+}
+/** The full read-only skill snapshot the card renders for one workspace root. */
+export interface SkillSnapshot {
+    root: string;
+    exists: boolean;
+    /** Set when the store query failed; null otherwise. */
+    readError: string | null;
+    /** Active row count (the number the card's stats line shows). */
+    fileCount: number;
+    /** Active rows, project first (the list the card renders). */
+    files: SkillFileInfo[];
+    /** Rows quarantined by patrol — displayed as 巡检异常, never in the list. */
+    quarantined: {
+        id: string;
+        scope: string;
+        reason: string;
+    }[];
+}
+/**
+ * The read-only skill snapshot for one workspace partition. Mirrors the
+ * memory snapshot's degrade contract: unknown partitions read `exists:
+ * false`, failing queries report `readError` instead of throwing.
+ */
+export declare function skillSnapshot(store: MemoryStore, root: string): SkillSnapshot;
+/** The content endpoint's outcomes for one skill body. */
+export type SkillEntryContent = {
+    ok: true;
+    id: string;
+    scope: string;
+    content: string;
+    updatedAtMs: number;
+} | {
+    ok: false;
+    reason: "absent" | "too-large";
+};
+/**
+ * Read one skill's body for the card's content preview — project shadowing
+ * global, keyed by id, never by file name. Bodies are schema-capped at 64KB,
+ * so `too-large` is dead code kept for the day the preview limit shrinks.
+ */
+export declare function skillEntryContent(store: MemoryStore, root: string, id: string): SkillEntryContent;
 //# sourceMappingURL=memory-snapshot.d.ts.map

package/lib/memory-snapshot.js

@@ -127,13 +127,109 @@ export function memoryEntryContent(store, root, id) {
 /** The workspace rows the card lists: active partitions whose directory survives. */
 export function listCardWorkspaces(store) {
     try {
-        return store
-            .listWorkspaces()
-            .filter((workspace) => existsSync(workspace.workspaceId))
-            .map((workspace) => ({ root: workspace.workspaceId, label: basename(workspace.workspaceId) }));
+        const seen = new Set();
+        const rows = [];
+        // One fence for every card route: partitions holding memories or
+        // skills. A skills-only workspace lists (its memory snapshot reads
+        // empty); global skills ride along with whichever workspace is open.
+        for (const workspace of [...store.listWorkspaces(), ...store.listSkillWorkspaces()]) {
+            if (workspace.workspaceId === "" || seen.has(workspace.workspaceId)) {
+                continue;
+            }
+            seen.add(workspace.workspaceId);
+            if (!existsSync(workspace.workspaceId)) {
+                continue;
+            }
+            rows.push({ root: workspace.workspaceId, label: basename(workspace.workspaceId) });
+        }
+        return rows;
     }
     catch {
         return [];
     }
 }
+/** Project-first merge of one partition's skills with the global scope. */
+function scopedSkills(store, root) {
+    const seen = new Set();
+    const merged = [];
+    for (const record of store.listAllSkills(root)) {
+        if (seen.has(record.id)) {
+            continue;
+        }
+        seen.add(record.id);
+        merged.push({ record, scope: "project" });
+    }
+    for (const record of store.listAllSkills("")) {
+        if (seen.has(record.id)) {
+            continue;
+        }
+        seen.add(record.id);
+        merged.push({ record, scope: "global" });
+    }
+    return merged;
+}
+function skillInfoOf(entry) {
+    return {
+        id: entry.record.id,
+        title: entry.record.title,
+        description: entry.record.description,
+        scope: entry.scope,
+        status: entry.record.status,
+        updatedAt: Date.parse(entry.record.updatedAt) || 0,
+    };
+}
+/**
+ * The read-only skill snapshot for one workspace partition. Mirrors the
+ * memory snapshot's degrade contract: unknown partitions read `exists:
+ * false`, failing queries report `readError` instead of throwing.
+ */
+export function skillSnapshot(store, root) {
+    const absent = { root, exists: false, readError: null, fileCount: 0, files: [], quarantined: [] };
+    let entries;
+    try {
+        entries = scopedSkills(store, root);
+        if (entries.length === 0) {
+            return absent;
+        }
+    }
+    catch (error) {
+        return { ...absent, exists: true, readError: error instanceof Error ? error.message : String(error) };
+    }
+    return {
+        root,
+        exists: true,
+        readError: null,
+        fileCount: entries.filter((entry) => entry.record.status === "active").length,
+        files: entries.filter((entry) => entry.record.status === "active").map(skillInfoOf),
+        quarantined: entries
+            .filter((entry) => entry.record.status === "quarantined")
+            .map((entry) => ({ id: entry.record.id, scope: entry.scope, reason: quarantineReasonOf(store, entry.record) })),
+    };
+}
+/**
+ * Read one skill's body for the card's content preview — project shadowing
+ * global, keyed by id, never by file name. Bodies are schema-capped at 64KB,
+ * so `too-large` is dead code kept for the day the preview limit shrinks.
+ */
+export function skillEntryContent(store, root, id) {
+    if (id.length === 0) {
+        return { ok: false, reason: "absent" };
+    }
+    let entries;
+    try {
+        entries = scopedSkills(store, root);
+    }
+    catch {
+        return { ok: false, reason: "absent" };
+    }
+    const hit = entries.find((entry) => entry.record.id === id);
+    if (hit === undefined) {
+        return { ok: false, reason: "absent" };
+    }
+    /* v8 ignore next 3 */
+    if (hit.record.body.length > MEMORY_FILE_PREVIEW_LIMIT) {
+        return { ok: false, reason: "too-large" };
+    }
+    return { ok: true, id: hit.record.id, scope: hit.scope, content: hit.record.body, updatedAtMs: Date.parse(hit.record.updatedAt) || 0 };
+}
 //# sourceMappingURL=memory-snapshot.js.map

package/lib/skill-rules.d.ts

@@ -0,0 +1,73 @@
+import { isValidMemoryId, slugifyId } from "./memory-rules.js";
+export { isValidMemoryId as isValidSkillId, slugifyId as slugifySkillId };
+/** Skill scopes: project rows live in their workspace partition, global rows in `""`. */
+export declare const SKILL_SCOPES: readonly ["project", "global"];
+export type SkillScope = (typeof SKILL_SCOPES)[number];
+/** The global partition id (shared with the memory store's global state rows). */
+export declare const SKILL_GLOBAL_WORKSPACE = "";
+/** Max rendered frontmatter description length (loaders truncate anyway). */
+export declare const MAX_SKILL_DESCRIPTION_LENGTH = 240;
+/**
+ * Marker carried by every materialized file, right after the frontmatter.
+ * Patrol only touches files carrying it — hand-written skills in the same
+ * directories are never rewritten or removed.
+ */
+export declare const SKILL_GENERATED_MARKER = "<!-- generated by dsh-continual-evolve \u2014 the central store is the source of truth; edit via skill_write, manual edits are reverted by patrol -->";
+/** One proposed skill mutation — the closed shape the write paths speak. */
+export interface SkillProposal {
+    action: "create" | "update" | "delete" | "move-to-global";
+    /** Required for update/delete/move-to-global; optional for create (derived from title). */
+    id?: string | undefined;
+    /** Which partition update/delete targets. Create always lands in the project. */
+    scope?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    body?: string | undefined;
+    /** Trajectory provenance ("820-831"), kept for parity with memory proposals. */
+    sourceSeqs?: string | undefined;
+}
+/** The merged field values a create/update would write (delete checks none). */
+export interface SkillFields {
+    title: string;
+    description: string;
+    body: string;
+}
+/**
+ * Gates that depend only on the merged field values (not on store state).
+ * Runs the secret screen over the full visible text so a secret smuggled
+ * into any field blocks the write.
+ */
+export declare function skillFieldGateReasons(fields: SkillFields): string[];
+/**
+ * Render a skill as a discoverable SKILL.md document. The frontmatter
+ * description carries a routing hint — title plus the first meaningful body
+ * line — instead of the bare title: the skill catalog matches on
+ * description, and a title-only description gives loaders nothing to route
+ * on.
+ */
+export declare function renderSkillMarkdown(skill: {
+    id: string;
+    title: string;
+    description: string;
+    body: string;
+}): string;
+/**
+ * Mechanical problems that would make the platform's skill loader ignore the
+ * rendered file. The file is still written, but the caller surfaces these:
+ * a silently ignored skill is worse than a noisy one.
+ */
+export declare function validateRenderedSkill(skill: {
+    id: string;
+    description: string;
+}): string[];
+/** Where project skills materialize: the workspace's own discovered skill directory. */
+export declare function projectSkillsDir(workspaceId: string): string;
+/** Where global skills materialize: the host-wide discovered skill directory. */
+export declare function globalSkillsDir(): string;
+/**
+ * Resolve and defend the materialized directory for a skill id. Ids are
+ * kebab slugs by gate, but the containment check stays: a caller bug must
+ * never turn a skill write into a write elsewhere.
+ */
+export declare function skillDir(root: string, id: string): string;
+//# sourceMappingURL=skill-rules.d.ts.map

package/lib/skill-rules.js

@@ -0,0 +1,158 @@
+/**
+ * The mechanical write gates every skill passes before the store accepts it
+ * — the same "模型提议，代码保证" boundary as memories, minus the
+ * taxonomy: skills carry no type enum and no feedback body contract. Both
+ * entry points (the explicit `skill_write` tool and the manual move to the
+ * global scope) funnel through these checks; nothing reaches the database or
+ * the materialized files without them.
+ *
+ * File rendering follows the previously validated shape (pre-teardown
+ * `skill-render.ts`, itself checked against the platform loader): YAML-ish
+ * frontmatter (`name` + `description` carrying a routing hint) over the body.
+ * The official skill-creator template is no longer shipped locally, so the
+ * live host preset skills (same frontmatter contract) are the format anchor.
+ */
+import { homedir } from "node:os";
+import { join, resolve, sep } from "node:path";
+import { isValidMemoryId, MEMORY_BODY_LIMIT, MEMORY_DESCRIPTION_LIMIT, MEMORY_TITLE_LIMIT, secretLeakReason, slugifyId, } from "./memory-rules.js";
+export { isValidMemoryId as isValidSkillId, slugifyId as slugifySkillId };
+/** Skill scopes: project rows live in their workspace partition, global rows in `""`. */
+export const SKILL_SCOPES = ["project", "global"];
+/** The global partition id (shared with the memory store's global state rows). */
+export const SKILL_GLOBAL_WORKSPACE = "";
+/** Max rendered frontmatter description length (loaders truncate anyway). */
+export const MAX_SKILL_DESCRIPTION_LENGTH = 240;
+/**
+ * Marker carried by every materialized file, right after the frontmatter.
+ * Patrol only touches files carrying it — hand-written skills in the same
+ * directories are never rewritten or removed.
+ */
+export const SKILL_GENERATED_MARKER = "<!-- generated by dsh-continual-evolve — the central store is the source of truth; edit via skill_write, manual edits are reverted by patrol -->";
+/**
+ * Gates that depend only on the merged field values (not on store state).
+ * Runs the secret screen over the full visible text so a secret smuggled
+ * into any field blocks the write.
+ */
+export function skillFieldGateReasons(fields) {
+    const reasons = [];
+    if (fields.title.trim().length === 0) {
+        reasons.push("title must not be empty");
+    }
+    else if (fields.title.length > MEMORY_TITLE_LIMIT) {
+        reasons.push(`title exceeds ${MEMORY_TITLE_LIMIT} characters`);
+    }
+    if (fields.description.trim().length === 0) {
+        reasons.push("description must not be empty — it is the skill trigger");
+    }
+    else if (fields.description.length > MEMORY_DESCRIPTION_LIMIT) {
+        reasons.push(`description exceeds ${MEMORY_DESCRIPTION_LIMIT} characters`);
+    }
+    if (fields.body.trim().length === 0) {
+        reasons.push("body must not be empty");
+    }
+    else if (fields.body.length > MEMORY_BODY_LIMIT) {
+        reasons.push(`body exceeds the ${MEMORY_BODY_LIMIT}-character cap`);
+    }
+    const leak = secretLeakReason(`${fields.title}\n${fields.description}\n${fields.body}`);
+    if (leak !== undefined) {
+        reasons.push(leak);
+    }
+    return reasons;
+}
+/** Collapse prose to one line for the frontmatter description. */
+function oneLine(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+/**
+ * First content line usable as a routing hint: non-empty, not a Markdown
+ * heading, not a list marker, not frontmatter. Undefined when the body is
+ * effectively empty.
+ */
+function routingHint(body) {
+    for (const rawLine of body.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        if (line.startsWith("#") || line.startsWith("---") || line.startsWith("-") || line.startsWith("*"))
+            continue;
+        return oneLine(line);
+    }
+    return undefined;
+}
+/**
+ * Render a skill as a discoverable SKILL.md document. The frontmatter
+ * description carries a routing hint — title plus the first meaningful body
+ * line — instead of the bare title: the skill catalog matches on
+ * description, and a title-only description gives loaders nothing to route
+ * on.
+ */
+export function renderSkillMarkdown(skill) {
+    const hint = routingHint(skill.body);
+    const stated = oneLine(skill.description);
+    const base = oneLine(skill.title);
+    // Prefer the author's own description; fall back to title + hint exactly
+    // like the pre-teardown renderer so re-materialized rows stay byte-stable.
+    let description;
+    if (stated.length > 0) {
+        description = stated;
+    }
+    else if (base.length === 0) {
+        description = (hint ?? "").slice(0, MAX_SKILL_DESCRIPTION_LENGTH);
+    }
+    else if (hint !== undefined && !base.toLowerCase().includes(hint.toLowerCase())) {
+        description = `${base} — use when: ${hint}`.slice(0, MAX_SKILL_DESCRIPTION_LENGTH);
+    }
+    else {
+        description = base.slice(0, MAX_SKILL_DESCRIPTION_LENGTH);
+    }
+    return ["---", `name: ${skill.id}`, `description: ${description}`, "---", "", SKILL_GENERATED_MARKER, "", skill.body.trim(), ""].join("\n");
+}
+/**
+ * Mechanical problems that would make the platform's skill loader ignore the
+ * rendered file. The file is still written, but the caller surfaces these:
+ * a silently ignored skill is worse than a noisy one.
+ */
+export function validateRenderedSkill(skill) {
+    const problems = [];
+    if (!isValidMemoryId(skill.id)) {
+        problems.push(`name "${skill.id}" is not kebab-case — the platform ignores the file`);
+    }
+    const description = oneLine(skill.description);
+    if (description.length === 0) {
+        problems.push("empty description — the catalog has nothing to route on");
+    }
+    else if (description.length > MAX_SKILL_DESCRIPTION_LENGTH) {
+        problems.push(`description exceeds ${MAX_SKILL_DESCRIPTION_LENGTH} characters — loaders truncate it`);
+    }
+    if (/[\r\n]/.test(skill.description)) {
+        problems.push("description spans lines — frontmatter must stay one line");
+    }
+    return problems;
+}
+/** The DSH home the global skills directory lives under (same rule as the store path). */
+function dshHome() {
+    const home = process.env.DSH_HOME?.trim();
+    return home !== undefined && home.length > 0 ? home : join(homedir(), ".dsh");
+}
+/** Where project skills materialize: the workspace's own discovered skill directory. */
+export function projectSkillsDir(workspaceId) {
+    return join(workspaceId, ".agents", "skills");
+}
+/** Where global skills materialize: the host-wide discovered skill directory. */
+export function globalSkillsDir() {
+    return join(dshHome(), "skills");
+}
+/**
+ * Resolve and defend the materialized directory for a skill id. Ids are
+ * kebab slugs by gate, but the containment check stays: a caller bug must
+ * never turn a skill write into a write elsewhere.
+ */
+export function skillDir(root, id) {
+    const base = resolve(root);
+    const dir = resolve(join(base, id));
+    if (dir !== base && !dir.startsWith(`${base}/`) && !dir.startsWith(`${base}${sep}`)) {
+        throw new Error(`skill path escapes skills root: ${dir}`);
+    }
+    return dir;
+}
+//# sourceMappingURL=skill-rules.js.map

package/lib/skill-tools.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryStore } from "./store.js";
+import type { ToolsService, ToolDefinition } from "./memory-tools.js";
+export type { ToolsService, ToolDefinition };
+/**
+ * Register the skill tools and return a disposer that removes them (the
+ * host may return one; call only the functions among whatever comes back).
+ */
+export declare function registerSkillTools(tools: ToolsService, store: MemoryStore): () => void;
+//# sourceMappingURL=skill-tools.d.ts.map

package/lib/skill-tools.js

@@ -0,0 +1,198 @@
+/**
+ * The model-facing skill tools: `skill_write` (the explicit write path
+ * through the store's gates, plus the manual move to the global scope) and
+ * `skill_read` (bodies and search across the project partition and the
+ * global scope, project shadowing global on name collisions).
+ *
+ * Skills are created in the project only — global rows arise solely from an
+ * explicit `move-to-global`. There is no promotion mechanism: no counters,
+ * no confidence, no automation. Definitions are hand-built to the shape
+ * `ctx.tools.register` consumes (standard JSON Schema with a root-level
+ * `required` array, docs/FAQ.md #2). Host API shapes are declared locally;
+ * the plugin imports nothing from DSH at runtime.
+ */
+import { cwdOf } from "./memory-section.js";
+function textTool(name, description, parameters, execute) {
+    return {
+        name,
+        description,
+        parameters,
+        output: {
+            schema: {
+                type: "object",
+                properties: { text: { type: "string", description: "结果说明" } },
+                required: ["text"],
+                additionalProperties: false,
+            },
+            render: (_args, value) => [{ type: "text", text: value.text ?? "" }],
+        },
+        execute: async (args, exec) => ({ text: await execute(args, exec) }),
+    };
+}
+/** The calling agent's session id (provenance for the ledger). */
+function sessionIdOf(exec) {
+    const id = exec?.agent?.id;
+    return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+const SKILL_WRITE_PARAMETERS = {
+    type: "object",
+    properties: {
+        action: {
+            type: "string",
+            enum: ["create", "update", "delete", "move-to-global"],
+            description: "create 在本项目新建技能；update 更新已有技能（只给要改的字段）；delete 删除技能；move-to-global 把本项目技能手动搬到全局（项目侧归档，没有自动晋升）。",
+        },
+        scope: {
+            type: "string",
+            enum: ["project", "global"],
+            description: "update/delete 的目标分区（默认 project；全局行只可显式指定 global 更新或删除）。",
+        },
+        id: {
+            type: "string",
+            description: "短横线小写标识。update/delete/move-to-global 必填；create 可省略（从 title 推导，中文标题会得到哈希后缀）。",
+        },
+        title: { type: "string", description: "短标题（create 必填）。" },
+        description: {
+            type: "string",
+            description: "一句话触发钩子——决定未来会话会不会想起这个技能（create 必填，会进 SKILL.md 的 description）。",
+        },
+        body: { type: "string", description: "技能正文（create 必填；update 时传新正文整体替换）。" },
+    },
+    required: ["action"],
+    additionalProperties: false,
+};
+const SKILL_READ_PARAMETERS = {
+    type: "object",
+    properties: {
+        id: { type: "string", description: "按 id 直取一条技能的完整内容（同名时项目遮蔽全局）。" },
+        query: { type: "string", description: "关键词检索（不传 id 时生效；不传 query 则列出本项目与全局技能）。" },
+        limit: { type: "number", description: "检索/列出的最大条数，默认 3，上限 10。" },
+    },
+    additionalProperties: false,
+};
+/**
+ * Register the skill tools and return a disposer that removes them (the
+ * host may return one; call only the functions among whatever comes back).
+ */
+export function registerSkillTools(tools, store) {
+    const disposers = [];
+    disposers.push(tools.register(textTool("skill_write", "写入可复用的技能（create 新建 / update 更新 / delete 删除 / move-to-global 手动搬到全局）。用户明确要求沉淀技能时使用；技能只在本项目创建，全局只接受手动搬家，由插件代码校验后落库并物化为 SKILL.md。", SKILL_WRITE_PARAMETERS, async (args, exec) => {
+        const cwd = cwdOf(exec.agent);
+        if (cwd === undefined) {
+            return "错误：当前会话没有可用的工作区路径，无法写入技能。";
+        }
+        const action = args.action;
+        const { outcomes, warnings } = store.applySkillProposals({ workspaceId: cwd, trigger: "explicit", sessionId: sessionIdOf(exec) }, [
+            {
+                action,
+                scope: typeof args.scope === "string" ? args.scope : undefined,
+                id: typeof args.id === "string" ? args.id : undefined,
+                title: typeof args.title === "string" ? args.title : undefined,
+                description: typeof args.description === "string" ? args.description : undefined,
+                body: typeof args.body === "string" ? args.body : undefined,
+            },
+        ]);
+        const outcome = outcomes[0];
+        if (outcome === undefined || !outcome.ok) {
+            return `写入被门禁拒绝，技能未落盘：${outcome?.reason ?? "未知原因"}`;
+        }
+        const warningText = warnings.length > 0 ? `（文件投影告警：${warnings.map((w) => w.warning).join("；")}）` : "";
+        if (outcome.action === "delete") {
+            return `已删除技能 \`${outcome.id}\`。旧内容保留在技能账本中，可由用户恢复。${warningText}`;
+        }
+        if (outcome.action === "move-to-global") {
+            return `已把技能 \`${outcome.id}\` 手动搬到全局（本项目侧已归档）。重启后所有工作区可用。${warningText}`;
+        }
+        return `已${outcome.action === "create" ? "写入" : "更新"}技能 \`${outcome.id}\`（本项目，重启后本工作区可用）。${warningText}`;
+    })));
+    disposers.push(tools.register(textTool("skill_read", "读取技能：按 id 取一条的完整内容，或按关键词检索本项目与全局的技能（同名时项目遮蔽全局，只返回项目那条）。", SKILL_READ_PARAMETERS, async (args, exec) => {
+        const cwd = cwdOf(exec.agent);
+        if (cwd === undefined) {
+            return "错误：当前会话没有可用的工作区路径，无法读取技能。";
+        }
+        const limit = clampLimit(args.limit);
+        if (typeof args.id === "string" && args.id.length > 0) {
+            const found = readWithScope(store, cwd, args.id);
+            return found === undefined ? `没有找到 id 为 "${args.id}" 的技能。` : formatSkill(found.record, found.scope);
+        }
+        const query = typeof args.query === "string" ? args.query : "";
+        const merged = query.length > 0 ? searchWithScope(store, cwd, query, limit) : listWithScope(store, cwd, limit);
+        if (merged.length === 0) {
+            return query.length > 0 ? `没有匹配 "${query}" 的技能。` : "本项目和全局都还没有技能。";
+        }
+        return merged.map((entry) => formatSkill(entry.record, entry.scope)).join("\n\n---\n\n");
+    })));
+    return () => {
+        for (const disposer of disposers) {
+            if (typeof disposer === "function") {
+                disposer();
+            }
+        }
+    };
+}
+/** Project-first read: a project row shadows the global row of the same id. */
+function readWithScope(store, workspaceId, id) {
+    const project = store.getSkill(workspaceId, id);
+    if (project !== undefined && project.status !== "archived") {
+        return { record: project, scope: "project" };
+    }
+    const global = store.getSkill("", id);
+    if (global !== undefined && global.status !== "archived") {
+        return { record: global, scope: "global" };
+    }
+    return undefined;
+}
+/** Scope-merged search: project wins on id collisions, global fills the rest. */
+function searchWithScope(store, workspaceId, query, limit) {
+    const seen = new Set();
+    const merged = [];
+    for (const record of store.searchSkills(workspaceId, query, limit)) {
+        if (seen.has(record.id)) {
+            continue;
+        }
+        seen.add(record.id);
+        merged.push({ record, scope: "project" });
+    }
+    if (merged.length < limit) {
+        for (const record of store.searchSkills("", query, limit)) {
+            if (seen.has(record.id)) {
+                continue;
+            }
+            seen.add(record.id);
+            merged.push({ record, scope: "global" });
+        }
+    }
+    return merged.slice(0, limit);
+}
+/** Scope-merged listing: project rows first, then global rows. */
+function listWithScope(store, workspaceId, limit) {
+    const merged = store
+        .listSkills(workspaceId)
+        .slice(0, limit)
+        .map((record) => ({ record, scope: "project" }));
+    if (merged.length < limit) {
+        const seen = new Set(merged.map((entry) => entry.record.id));
+        for (const record of store.listSkills("")) {
+            if (merged.length >= limit) {
+                break;
+            }
+            if (seen.has(record.id)) {
+                continue;
+            }
+            seen.add(record.id);
+            merged.push({ record, scope: "global" });
+        }
+    }
+    return merged;
+}
+function clampLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return 3;
+    }
+    return Math.min(10, Math.max(1, Math.floor(value)));
+}
+/** Full skill text: header line with scope, then the body. */
+function formatSkill(record, scope) {
+    return [`# ${record.title}`, `id: ${record.id} ｜ 范围: ${scope === "global" ? "全局" : "本项目"} ｜ 状态: ${record.status} ｜ 更新: ${record.updatedAt}`, `钩子: ${record.description}`, "", record.body].join("\n");
+}
+//# sourceMappingURL=skill-tools.js.map