@fieldwangai/agentflow 0.1.28 → 0.1.30

package/bin/lib/catalog-flows.mjs

@@ -50,7 +50,7 @@ export function readPipelineListDescription(flowDir) {
   }
 }
 
-export function listFlowsJson(workspaceRoot) {
+export function listFlowsJson(workspaceRoot, opts = {}) {
   const root = path.resolve(workspaceRoot);
   const out = [];
   const fromBuiltin = collectPipelineNamesFromDir(PACKAGE_BUILTIN_PIPELINES_DIR);
@@ -59,7 +59,7 @@ export function listFlowsJson(workspaceRoot) {
     const description = readPipelineListDescription(dir);
     out.push({ id: name, path: dir, source: "builtin", ...(description ? { description } : {}) });
   }
-  const userPipelinesRoot = getUserPipelinesRoot();
+  const userPipelinesRoot = getUserPipelinesRoot(opts.userId);
   const fromUserData = collectPipelineNamesFromDir(userPipelinesRoot);
   for (const name of fromUserData) {
     if (name === ARCHIVED_PIPELINES_DIR_NAME) continue;
@@ -200,6 +200,7 @@ export function parseNodeFrontmatter(raw) {
 export function listNodesJson(workspaceRoot, flowId, flowSource, opts = {}) {
   const root = path.resolve(workspaceRoot);
   const archived = Boolean(opts.archived);
+  const userPipelinesRoot = getUserPipelinesRoot(opts.userId);
   const byId = new Map();
   const pipelineTranslations = {};
   let marketplaceFlowData = null;
@@ -293,13 +294,9 @@ export function listNodesJson(workspaceRoot, flowId, flowSource, opts = {}) {
       } catch (_) {}
     } else if (flowSource === "user") {
       if (archived) {
-        addFromDir(
-          path.join(getUserPipelinesRoot(), ARCHIVED_PIPELINES_DIR_NAME, flowId, "nodes"),
-          "flow",
-          flowId,
-        );
+        addFromDir(path.join(userPipelinesRoot, ARCHIVED_PIPELINES_DIR_NAME, flowId, "nodes"), "flow", flowId);
       } else {
-        addFromDir(path.join(getUserPipelinesRoot(), flowId, "nodes"), "flow", flowId);
+        addFromDir(path.join(userPipelinesRoot, flowId, "nodes"), "flow", flowId);
         addFromDir(path.join(root, PIPELINES_DIR, flowId, "nodes"), "flow", flowId);
         addFromDir(path.join(root, LEGACY_PIPELINES_DIR, flowId, "nodes"), "flow", flowId);
       }
@@ -342,13 +339,14 @@ export function printNodesTable(list) {
 export function readFlowJson(workspaceRoot, flowId, flowSource, options = {}) {
   const root = path.resolve(workspaceRoot);
   const archived = Boolean(options.archived);
+  const userPipelinesRoot = getUserPipelinesRoot(options.userId);
   let flowDir;
   if (archived) {
     if (flowSource === "builtin") {
       return { error: t("catalog.builtin_flow_archive_not_supported") };
     }
     if (flowSource === "user") {
-      flowDir = path.join(getUserPipelinesRoot(), ARCHIVED_PIPELINES_DIR_NAME, flowId);
+      flowDir = path.join(userPipelinesRoot, ARCHIVED_PIPELINES_DIR_NAME, flowId);
     } else if (flowSource === "workspace") {
       flowDir = path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowId);
     } else {
@@ -377,7 +375,7 @@ export function readFlowJson(workspaceRoot, flowId, flowSource, options = {}) {
   if (flowSource === "builtin") {
     flowDir = path.join(PACKAGE_BUILTIN_PIPELINES_DIR, flowId);
   } else if (flowSource === "user") {
-    flowDir = path.join(getUserPipelinesRoot(), flowId);
+    flowDir = path.join(userPipelinesRoot, flowId);
   } else if (flowSource === "workspace") {
     flowDir = path.join(root, PIPELINES_DIR, flowId);
   } else {
@@ -422,13 +420,14 @@ export function readFlowJson(workspaceRoot, flowId, flowSource, options = {}) {
 export function getFlowYamlAbs(workspaceRoot, flowId, flowSource, options = {}) {
   const root = path.resolve(workspaceRoot);
   const archived = Boolean(options.archived);
+  const userPipelinesRoot = getUserPipelinesRoot(options.userId);
   let yamlPath;
   if (archived) {
     if (flowSource === "builtin") {
       return { error: t("catalog.builtin_flow_archive_path_not_supported") };
     }
     if (flowSource === "user") {
-      yamlPath = path.join(getUserPipelinesRoot(), ARCHIVED_PIPELINES_DIR_NAME, flowId, "flow.yaml");
+      yamlPath = path.join(userPipelinesRoot, ARCHIVED_PIPELINES_DIR_NAME, flowId, "flow.yaml");
     } else if (flowSource === "workspace") {
       yamlPath = path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowId, "flow.yaml");
       if (!fs.existsSync(yamlPath)) {
@@ -447,7 +446,7 @@ export function getFlowYamlAbs(workspaceRoot, flowId, flowSource, options = {})
   if (flowSource === "builtin") {
     yamlPath = path.join(PACKAGE_BUILTIN_PIPELINES_DIR, flowId, "flow.yaml");
   } else if (flowSource === "user") {
-    yamlPath = path.join(getUserPipelinesRoot(), flowId, "flow.yaml");
+    yamlPath = path.join(userPipelinesRoot, flowId, "flow.yaml");
     if (!fs.existsSync(yamlPath)) {
       const alt = path.join(root, PIPELINES_DIR, flowId, "flow.yaml");
       if (fs.existsSync(alt)) yamlPath = alt;
@@ -474,6 +473,7 @@ export function getFlowYamlAbs(workspaceRoot, flowId, flowSource, options = {})
 export function readNodeJson(workspaceRoot, nodeId, flowId, flowSource, opts = {}) {
   const root = path.resolve(workspaceRoot);
   const archived = Boolean(opts.archived);
+  const userPipelinesRoot = getUserPipelinesRoot(opts.userId);
   const marketSpec = parseMarketplaceDefinitionId(nodeId);
   if (marketSpec) {
     let flowDir = root;
@@ -515,11 +515,9 @@ export function readNodeJson(workspaceRoot, nodeId, flowId, flowSource, opts = {
       pathsToTry.push(path.join(PACKAGE_BUILTIN_PIPELINES_DIR, flowId, "nodes", fileName));
     } else if (flowSource === "user") {
       if (archived) {
-        pathsToTry.push(
-          path.join(getUserPipelinesRoot(), ARCHIVED_PIPELINES_DIR_NAME, flowId, "nodes", fileName),
-        );
+        pathsToTry.push(path.join(userPipelinesRoot, ARCHIVED_PIPELINES_DIR_NAME, flowId, "nodes", fileName));
       } else {
-        pathsToTry.push(path.join(getUserPipelinesRoot(), flowId, "nodes", fileName));
+        pathsToTry.push(path.join(userPipelinesRoot, flowId, "nodes", fileName));
         pathsToTry.push(path.join(root, PIPELINES_DIR, flowId, "nodes", fileName));
         pathsToTry.push(path.join(root, LEGACY_PIPELINES_DIR, flowId, "nodes", fileName));
       }
@@ -568,6 +566,184 @@ export function readNodeJson(workspaceRoot, nodeId, flowId, flowSource, opts = {
   return { error: "Node not found: " + nodeId };
 }
 
+const NODE_DETAIL_MAX_FILES = 300;
+const NODE_FILE_MAX_BYTES = 256 * 1024;
+
+function isTextPreviewPath(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return [
+    ".md", ".mdx", ".txt", ".json", ".yaml", ".yml", ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx",
+    ".py", ".sh", ".css", ".html", ".xml", ".toml", ".ini", ".env", ".sql",
+  ].includes(ext);
+}
+
+function listNodeFiles(baseDir, allowAllFiles, primaryFilePath = "") {
+  const root = path.resolve(baseDir);
+  const out = [];
+  const addFile = (filePath) => {
+    if (out.length >= NODE_DETAIL_MAX_FILES) return;
+    try {
+      const stat = fs.statSync(filePath);
+      if (!stat.isFile()) return;
+      const rel = path.relative(root, filePath).replace(/\\/g, "/");
+      out.push({
+        path: rel,
+        size: stat.size,
+        previewable: isTextPreviewPath(filePath),
+      });
+    } catch (_) {}
+  };
+  if (!allowAllFiles) {
+    if (primaryFilePath) addFile(primaryFilePath);
+    return out;
+  }
+  const walk = (dir) => {
+    if (out.length >= NODE_DETAIL_MAX_FILES) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (out.length >= NODE_DETAIL_MAX_FILES) return;
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(p);
+      else if (entry.isFile()) addFile(p);
+    }
+  };
+  walk(root);
+  return out;
+}
+
+function resolveMarkdownNodeFile(workspaceRoot, nodeId, flowId, flowSource, opts = {}) {
+  const root = path.resolve(workspaceRoot);
+  const archived = Boolean(opts.archived);
+  const userPipelinesRoot = getUserPipelinesRoot(opts.userId);
+  const fileName = nodeId.endsWith(".md") ? nodeId : `${nodeId}.md`;
+  const pathsToTry = [];
+  if (flowId && flowSource) {
+    if (flowSource === "builtin") {
+      pathsToTry.push(path.join(PACKAGE_BUILTIN_PIPELINES_DIR, flowId, "nodes", fileName));
+    } else if (flowSource === "user") {
+      if (archived) {
+        pathsToTry.push(path.join(userPipelinesRoot, ARCHIVED_PIPELINES_DIR_NAME, flowId, "nodes", fileName));
+      } else {
+        pathsToTry.push(path.join(userPipelinesRoot, flowId, "nodes", fileName));
+        pathsToTry.push(path.join(root, PIPELINES_DIR, flowId, "nodes", fileName));
+        pathsToTry.push(path.join(root, LEGACY_PIPELINES_DIR, flowId, "nodes", fileName));
+      }
+    } else if (flowSource === "workspace") {
+      if (archived) {
+        pathsToTry.push(path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowId, "nodes", fileName));
+        pathsToTry.push(path.join(root, LEGACY_PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowId, "nodes", fileName));
+      } else {
+        pathsToTry.push(path.join(root, PIPELINES_DIR, flowId, "nodes", fileName));
+        pathsToTry.push(path.join(root, LEGACY_PIPELINES_DIR, flowId, "nodes", fileName));
+      }
+    }
+  }
+  pathsToTry.push(path.join(root, PROJECT_NODES_DIR, fileName));
+  pathsToTry.push(path.join(root, LEGACY_NODES_DIR, fileName));
+  pathsToTry.push(path.join(PACKAGE_BUILTIN_NODES_DIR, fileName));
+  return pathsToTry.find((p) => fs.existsSync(p) && fs.statSync(p).isFile()) || "";
+}
+
+function readNodeUsage(workspaceRoot, nodeId, opts = {}) {
+  const usage = [];
+  for (const flow of listFlowsJson(workspaceRoot, opts)) {
+    const flowPath = getFlowYamlAbs(workspaceRoot, flow.id, flow.source || "user", { archived: Boolean(flow.archived), userId: opts.userId });
+    if (!flowPath.path) continue;
+    try {
+      const data = yaml.load(fs.readFileSync(flowPath.path, "utf-8"));
+      const instances = data && typeof data === "object" ? data.instances : null;
+      if (!instances || typeof instances !== "object") continue;
+      const hits = Object.entries(instances)
+        .filter(([, inst]) => inst && inst.definitionId === nodeId)
+        .map(([instanceId, inst]) => ({ instanceId, label: inst.label || instanceId }));
+      if (hits.length > 0) {
+        usage.push({ flowId: flow.id, flowSource: flow.source || "user", archived: Boolean(flow.archived), instances: hits });
+      }
+    } catch (_) {}
+  }
+  return usage;
+}
+
+function resolveNodeFileScope(workspaceRoot, nodeId, flowId, flowSource, opts = {}) {
+  const marketSpec = parseMarketplaceDefinitionId(nodeId);
+  if (marketSpec) {
+    let flowDir = path.resolve(workspaceRoot);
+    let flowData = null;
+    if (flowId && flowSource) {
+      const flowPath = getFlowYamlAbs(workspaceRoot, flowId, flowSource, opts);
+      if (flowPath.path) {
+        flowDir = path.dirname(flowPath.path);
+        try {
+          const parsed = yaml.load(fs.readFileSync(flowPath.path, "utf-8"));
+          if (parsed && typeof parsed === "object") flowData = parsed;
+        } catch (_) {}
+      }
+    }
+    const resolved = resolveMarketplaceNodePackage(workspaceRoot, flowDir, nodeId, flowData);
+    if (!resolved) return null;
+    return { baseDir: resolved.packageDir, allowAllFiles: true, primaryFilePath: path.join(resolved.packageDir, "node.yaml"), manifest: resolved };
+  }
+  const filePath = resolveMarkdownNodeFile(workspaceRoot, nodeId, flowId, flowSource, opts);
+  if (!filePath) return null;
+  return { baseDir: path.dirname(filePath), allowAllFiles: false, primaryFilePath: filePath, manifest: null };
+}
+
+export function readNodeDetailJson(workspaceRoot, nodeId, flowId = "", flowSource = "", opts = {}) {
+  if (!nodeId) return { error: "Missing node id" };
+  const node = readNodeJson(workspaceRoot, nodeId, flowId, flowSource, opts);
+  if (node.error) return node;
+  const scope = resolveNodeFileScope(workspaceRoot, nodeId, flowId, flowSource, opts);
+  const files = scope ? listNodeFiles(scope.baseDir, scope.allowAllFiles, scope.primaryFilePath) : [];
+  return {
+    node: { id: nodeId, ...node },
+    readOnly: true,
+    manifest: scope?.manifest || null,
+    runtime: node.runtime || scope?.manifest?.runtime || null,
+    body: node.executionLogic || "",
+    baseDir: scope?.baseDir || "",
+    files,
+    usage: readNodeUsage(workspaceRoot, nodeId, opts),
+  };
+}
+
+export function readNodeFilePreview(workspaceRoot, nodeId, relPath, flowId = "", flowSource = "", opts = {}) {
+  if (!nodeId) return { error: "Missing node id" };
+  const rel = String(relPath || "").trim();
+  if (!rel || rel.includes("\0") || path.isAbsolute(rel) || rel.split(/[\\/]+/).includes("..")) {
+    return { error: "Invalid file path" };
+  }
+  const scope = resolveNodeFileScope(workspaceRoot, nodeId, flowId, flowSource, opts);
+  if (!scope) return { error: "Node files not found" };
+  if (!scope.allowAllFiles) {
+    const primaryRel = path.relative(scope.baseDir, scope.primaryFilePath).replace(/\\/g, "/");
+    if (rel !== primaryRel) return { error: "File is outside node preview scope" };
+  }
+  const base = path.resolve(scope.baseDir);
+  const abs = path.resolve(base, rel);
+  if (abs !== base && !abs.startsWith(base + path.sep)) return { error: "File is outside node package" };
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) return { error: "File not found" };
+  const stat = fs.statSync(abs);
+  if (!isTextPreviewPath(abs)) {
+    return { path: rel, size: stat.size, binary: true, content: "", truncated: false };
+  }
+  const fd = fs.openSync(abs, "r");
+  try {
+    const len = Math.min(stat.size, NODE_FILE_MAX_BYTES);
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, 0);
+    return { path: rel, size: stat.size, binary: false, content: buf.toString("utf-8"), truncated: stat.size > len };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
 /** 列出所有 pipeline（包内 builtin + ~/agentflow/pipelines + 项目内 .workspace/.cursor agentflow/pipelines）；nodes 见 PROJECT_NODES_DIR / LEGACY_NODES_DIR */
 export function listPipelines(workspaceRoot) {
   const rows = listFlowsJson(workspaceRoot);

package/bin/lib/composer-agent.mjs

@@ -6,7 +6,7 @@
  */
 import fs from "fs";
 import path from "path";
-import { getAgentflowDataRoot } from "./paths.mjs";
+import { getAgentflowDataRoot, sanitizeAgentflowUserId } from "./paths.mjs";
 import { resolveCliAndModel } from "./model-config.mjs";
 import { runClaudeCodeAgentWithPrompt, runCursorAgentWithPrompt, runOpenCodeAgentWithPrompt } from "./agent-runners.mjs";
 import { planComposerTasks, hasPlannerApiAvailable, shouldUsePhased, classifyComplexity, classifyTaskComplexity, PHASED_DEFINITIONS } from "./composer-planner.mjs";
@@ -23,6 +23,11 @@ const MAX_PROMPT_CHARS = 500_000;
 const MAX_COMPOSER_VALIDATION_REPAIR = 5;
 const MAX_SCRIPT_INJECT_BYTES = 30_000;
 
+function agentflowUserEnv(userId) {
+  const safe = sanitizeAgentflowUserId(userId);
+  return safe ? { AGENTFLOW_USER_ID: safe } : {};
+}
+
 // ─── script 内容注入辅助 ─────────────────────────────────────────────────
 
 /**
@@ -113,10 +118,12 @@ export function startComposerAgent(opts) {
   const cliWs = opts.cliWorkspace ? String(opts.cliWorkspace) : getAgentflowDataRoot();
   const modelKey = opts.modelKey != null ? String(opts.modelKey).trim() : "";
   const { cli, model } = resolveCliAndModel(uiRoot, modelKey || null, null);
+  const env = agentflowUserEnv(opts.agentflowUserId);
 
   const common = {
     onStreamEvent: opts.onStreamEvent,
     force: Boolean(opts.force),
+    env,
   };
 
   if (cli === "opencode") {
@@ -185,6 +192,10 @@ function buildAgentStepPrompt(step, flowContext) {
       parts.push(`- flowId：${flowContext.flowId}`);
       parts.push(`- flowSource：${flowContext.flowSource || "user"}`);
     }
+    if (flowContext.userId) {
+      parts.push(`- agentflow 用户：${flowContext.userId}`);
+      parts.push(`- 执行 agentflow 命令时保留当前环境中的 AGENTFLOW_USER_ID，必要时显式前置 AGENTFLOW_USER_ID='${flowContext.userId}'。`);
+    }
     if (flowContext.skillsHint) {
       parts.push(flowContext.skillsHint);
     }
@@ -344,6 +355,7 @@ export async function runComposerPostFlowValidationAndRepair(opts) {
   const flowYamlAbs = String(opts.flowYamlAbs || "").trim();
   const cliWs = opts.cliWorkspace ? String(opts.cliWorkspace) : getAgentflowDataRoot();
   const maxRepair = Math.max(1, Math.min(10, Number(opts.maxRepairAttempts) || MAX_COMPOSER_VALIDATION_REPAIR));
+  const env = agentflowUserEnv(opts.agentflowUserId || opts.flowContext?.userId);
 
   if (!uiRoot || !flowYamlAbs) {
     return { ok: true, result: { skipped: true } };
@@ -405,6 +417,7 @@ export async function runComposerPostFlowValidationAndRepair(opts) {
           onStreamEvent: stepEmit,
           model: model || undefined,
           force: Boolean(opts.force),
+          env,
         });
         setChild(handle.child);
         await handle.finished;
@@ -413,6 +426,7 @@ export async function runComposerPostFlowValidationAndRepair(opts) {
           onStreamEvent: stepEmit,
           model: model || undefined,
           force: Boolean(opts.force),
+          env,
         });
         setChild(handle.child);
         await handle.finished;
@@ -421,6 +435,7 @@ export async function runComposerPostFlowValidationAndRepair(opts) {
           onStreamEvent: stepEmit,
           model: model || undefined,
           force: Boolean(opts.force),
+          env,
         });
         setChild(handle.child);
         await handle.finished;
@@ -490,6 +505,7 @@ export function startComposerMultiStep(opts) {
   const emit = typeof opts.onStreamEvent === "function" ? opts.onStreamEvent : () => {};
   let aborted = false;
   let currentChild = null;
+  const env = agentflowUserEnv(opts.agentflowUserId || opts.flowContext?.userId);
 
   const abort = () => {
     aborted = true;
@@ -674,6 +690,7 @@ export function startComposerMultiStep(opts) {
                 onStreamEvent: stepEmit,
                 model: model || undefined,
                 force: Boolean(opts.force),
+                env,
               });
               currentChild = handle.child;
               await handle.finished;
@@ -682,6 +699,7 @@ export function startComposerMultiStep(opts) {
                 onStreamEvent: stepEmit,
                 model: model || undefined,
                 force: Boolean(opts.force),
+                env,
               });
               currentChild = handle.child;
               await handle.finished;
@@ -690,6 +708,7 @@ export function startComposerMultiStep(opts) {
                 onStreamEvent: stepEmit,
                 model: model || undefined,
                 force: Boolean(opts.force),
+                env,
               });
               currentChild = handle.child;
               await handle.finished;
@@ -757,6 +776,7 @@ export function startComposerMultiStep(opts) {
           flowContext: opts.flowContext,
           modelKey: opts.modelKey,
           force: Boolean(opts.force),
+          agentflowUserId: opts.agentflowUserId || opts.flowContext?.userId,
           onStreamEvent: emit,
           getAborted: () => aborted,
           setCurrentChild: (c) => {

package/bin/lib/composer-skill-router.mjs

@@ -13,7 +13,7 @@
  */
 import fs from "fs";
 import path from "path";
-import yaml from "js-yaml";
+import { listSkills as registryListSkills, readSkillDetail as registryReadSkillDetail } from "./skill-registry.mjs";
 
 // ─── 意图模式定义 ─────────────────────────────────────────────────────────
 
@@ -125,81 +125,12 @@ function readFileCached(absPath) {
   }
 }
 
-function parseSkillFile(absPath) {
-  const content = readFileCached(absPath);
-  if (!content) return null;
-  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
-  let meta = {};
-  if (fmMatch) {
-    try {
-      meta = yaml.load(fmMatch[1]) || {};
-    } catch {
-      meta = {};
-    }
-  }
-  const dirName = path.basename(path.dirname(absPath));
-  const name = String(meta.name || dirName).trim();
-  if (!name) return null;
-  const description = String(meta.description || "").trim();
-  return {
-    name,
-    description,
-    content,
-    body: stripFrontmatter(content),
-    absPath,
-  };
-}
-
-function listSkillDirs(rootDir) {
-  try {
-    return fs.readdirSync(rootDir, { withFileTypes: true })
-      .filter((e) => e.isDirectory())
-      .map((e) => path.join(rootDir, e.name, "SKILL.md"))
-      .filter((p) => fs.existsSync(p));
-  } catch {
-    return [];
-  }
+export function listComposerSkills(packageRoot, workspaceRoot) {
+  return registryListSkills(packageRoot, workspaceRoot).map(({ body, content, ...skill }) => skill);
 }
 
-function skillSources(packageRoot, workspaceRoot) {
-  const sources = [
-    { source: "builtin", label: "AgentFlow", dir: path.join(packageRoot, "skills") },
-  ];
-  if (workspaceRoot) {
-    sources.push(
-      { source: "workspace-agents", label: ".agents", dir: path.join(workspaceRoot, ".agents", "skills") },
-      { source: "workspace-cursor", label: ".cursor", dir: path.join(workspaceRoot, ".cursor", "skills") },
-    );
-  }
-  return sources;
-}
-
-export function listComposerSkills(packageRoot, workspaceRoot) {
-  const out = [];
-  const seenKeys = new Set();
-  for (const src of skillSources(packageRoot, workspaceRoot)) {
-    for (const skillPath of listSkillDirs(src.dir)) {
-      const skill = parseSkillFile(skillPath);
-      if (!skill) continue;
-      const key = `${src.source}:${skill.name}`;
-      if (seenKeys.has(key)) continue;
-      seenKeys.add(key);
-      out.push({
-        key,
-        id: skill.name,
-        name: skill.name,
-        description: skill.description,
-        source: src.source,
-        sourceLabel: src.label,
-        path: skill.absPath,
-      });
-    }
-  }
-  return out.sort((a, b) => {
-    const bySource = a.sourceLabel.localeCompare(b.sourceLabel);
-    if (bySource !== 0) return bySource;
-    return a.name.localeCompare(b.name);
-  });
+export function readComposerSkillDetail(packageRoot, workspaceRoot, keyOrName) {
+  return registryReadSkillDetail(packageRoot, workspaceRoot, keyOrName);
 }
 
 export function loadResourcesForSkillKeys(skillKeys, packageRoot, workspaceRoot) {
@@ -210,13 +141,11 @@ export function loadResourcesForSkillKeys(skillKeys, packageRoot, workspaceRoot)
   if (wanted.size === 0) return { skills: [], references: [], skillsHint: "", hasContext: false };
 
   const skills = [];
-  for (const item of listComposerSkills(packageRoot, workspaceRoot)) {
+  for (const item of registryListSkills(packageRoot, workspaceRoot)) {
     if (!wanted.has(item.key) && !wanted.has(item.name)) continue;
-    const parsed = parseSkillFile(item.path);
-    if (!parsed) continue;
     skills.push({
       id: item.name,
-      content: parsed.body,
+      content: item.body,
       absPath: item.path,
       source: item.source,
       sourceLabel: item.sourceLabel,
@@ -356,6 +285,9 @@ export function buildSkillCompactInjectionBlock(skills, references) {
  */
 export function buildSkillInjectionBlock(skills, references) {
   const parts = [];
+  if ((skills?.length || 0) + (references?.length || 0) > 8) {
+    return buildSkillCompactInjectionBlock(skills || [], references || []);
+  }
 
   if (skills.length > 0) {
     parts.push("### 相关编辑技能（请严格遵循）");

package/bin/lib/flow-import.mjs

@@ -263,8 +263,8 @@ export function unzipAndNormalizePipelineZip(zipBuffer) {
  * @param {Map<string, Buffer>} filesRelative 相对流水线根，须含 flow.yaml
  * @returns {{ success: true } | { success: false, error: string }}
  */
-export function writePipelineTree(workspaceRoot, flowId, flowSource, filesRelative) {
-  const { flowDir, error } = resolveFlowDirForWrite(workspaceRoot, flowId, flowSource);
+export function writePipelineTree(workspaceRoot, flowId, flowSource, filesRelative, opts = {}) {
+  const { flowDir, error } = resolveFlowDirForWrite(workspaceRoot, flowId, flowSource, opts);
   if (error) return { success: false, error };
   if (fs.existsSync(flowDir)) {
     return { success: false, error: "目标目录已存在" };