@agentstorm/server 0.2.5

package/dist/template-library.js

@@ -0,0 +1,572 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHash } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { safeParseWorkflowSpec } from "@agentstorm/protocol";
+import { nowBeijing } from "@agentstorm/kernel";
+import { assertInsidePackage, assertWorkflowDisplayName, recordWorkflowPackageVersion, safePackageRelativePath, workflowPackageExists, workflowPackagePaths, workflowPromptRelativePath, writeJsonAtomic as writePackageJsonAtomic, } from "./workflow-package.js";
+const TEMPLATE_ROOT_NAME = "templates";
+const LEGACY_TEMPLATE_ROOT_NAME = "agentstorm/templates";
+const TEMPLATE_ROOT_MIGRATION_ID = "nested-template-root-v1";
+const MAX_ASSET_BYTES = 8 * 1024 * 1024;
+const TEMPLATE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const BUILTIN_TEMPLATE_IDS = ["general-workflow", "sonic-pipeline"];
+const BUILTIN_TEMPLATE_ROOT = resolveBuiltinTemplateRoot();
+const RETIRED_SEED_TEMPLATES = {
+    "grpc-migration": "gRPC migration 示例",
+    "review-loop": "审核循环",
+};
+/**
+ * The checked-in packages are bootstrap seeds. Once copied into
+ * AGENTSTORM_HOME, user edits are authoritative and upgrades do not overwrite
+ * them.
+ */
+const DEFAULT_TEMPLATES = BUILTIN_TEMPLATE_IDS.map(loadSeedTemplate);
+export function resolveBuiltinTemplateRoot(options) {
+    const configured = options?.home?.trim() || process.env.AGENTSTORM_BUILTIN_TEMPLATE_HOME?.trim();
+    if (configured)
+        return path.resolve(expandHome(configured));
+    const electronResourcesPath = options?.resourcesPath?.trim() ||
+        process.resourcesPath?.trim();
+    if (electronResourcesPath) {
+        return path.resolve(electronResourcesPath, TEMPLATE_ROOT_NAME);
+    }
+    const moduleDirectory = path.dirname(fileURLToPath(options?.moduleUrl ?? import.meta.url));
+    const packageTemplates = path.resolve(moduleDirectory, "templates");
+    if (fs.existsSync(packageTemplates))
+        return packageTemplates;
+    return path.resolve(moduleDirectory, "../../../templates");
+}
+function loadSeedTemplate(id) {
+    const dir = path.join(BUILTIN_TEMPLATE_ROOT, id);
+    const manifest = readJson(path.join(dir, "manifest.json"));
+    if (manifest.schemaVersion !== 1 || manifest.id !== id) {
+        throw new Error(`内置模板 ${id} 的 manifest 无效`);
+    }
+    const spec = readJson(path.join(dir, "workflow.json"));
+    const layout = readJson(path.join(dir, "layout.json"));
+    const parsed = safeParseWorkflowSpec(spec);
+    if (!parsed.success)
+        throw new Error(`内置模板 ${id} 的 WorkflowSpec 无效`);
+    const assets = {};
+    for (const config of Object.values(parsed.data.agents)) {
+        if (!config.prompt?.startsWith("@"))
+            continue;
+        const relative = safeRelativePath(config.prompt.slice(1));
+        if (!relative)
+            throw new Error(`内置模板 ${id} 的 Prompt 路径无效`);
+        const target = path.resolve(dir, relative);
+        assertInside(dir, target);
+        assets[relative] = fs.readFileSync(target, "utf8");
+    }
+    return {
+        id,
+        name: manifest.name,
+        description: manifest.description,
+        spec,
+        layout,
+        assets,
+        seedVersion: manifest.version,
+        seedUpdatedAt: manifest.updatedAt,
+    };
+}
+export function resolveTemplateRoot(options) {
+    const configured = options?.home?.trim() || process.env.AGENTSTORM_TEMPLATE_HOME?.trim();
+    if (configured)
+        return path.resolve(expandHome(configured));
+    const agentstormHome = process.env.AGENTSTORM_HOME?.trim() || "~/.agentstorm";
+    return path.resolve(expandHome(path.join(agentstormHome, TEMPLATE_ROOT_NAME)));
+}
+export class GlobalTemplateLibrary {
+    rootPath;
+    constructor(options) {
+        this.rootPath = resolveTemplateRoot(options);
+        if (!options?.home?.trim() && !process.env.AGENTSTORM_TEMPLATE_HOME?.trim()) {
+            migrateNestedTemplateRoot(this.rootPath);
+        }
+        this.migrateGeneralWorkflowId();
+        this.retireLegacySeedTemplates();
+        this.ensureSeedTemplates();
+    }
+    list() {
+        this.ensureSeedTemplates();
+        return fs
+            .readdirSync(this.rootPath, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && isSafeTemplateId(entry.name))
+            .flatMap((entry) => {
+            try {
+                const document = this.get(entry.name);
+                return [toSummary(document)];
+            }
+            catch {
+                return [];
+            }
+        })
+            .sort((left, right) => left.name.localeCompare(right.name));
+    }
+    get(id) {
+        assertTemplateId(id);
+        const dir = this.templateDir(id);
+        const manifest = readJson(path.join(dir, "manifest.json"));
+        if (manifest.schemaVersion !== 1 ||
+            manifest.id !== id ||
+            !Number.isSafeInteger(manifest.version)) {
+            throw new Error(`模板 ${id} 的 manifest 无效`);
+        }
+        const parsed = safeParseWorkflowSpec(readJson(path.join(dir, "workflow.json")));
+        if (!parsed.success)
+            throw new Error(`模板 ${id} 的 WorkflowSpec 无效`);
+        const layout = parseLayout(readJson(path.join(dir, "layout.json")));
+        const assets = readTemplateAssets(dir, parsed.data);
+        return {
+            ...manifest,
+            spec: parsed.data,
+            layout,
+            assets,
+            etag: templateEtag(manifest, parsed.data, layout, assets),
+        };
+    }
+    create(input) {
+        const parsed = parseInput(input);
+        const id = input.id?.trim() ? input.id.trim() : slugify(parsed.name);
+        assertTemplateId(id);
+        if (fs.existsSync(this.templateDir(id)))
+            throw new Error(`模板 ${id} 已存在`);
+        const now = nowBeijing();
+        const manifest = {
+            schemaVersion: 1,
+            id,
+            name: parsed.name,
+            description: parsed.description,
+            version: 1,
+            seeded: false,
+            updatedAt: now,
+        };
+        this.writeDocument(manifest, parsed.spec, parsed.layout, parsed.assets);
+        return this.get(id);
+    }
+    update(id, input, expectedEtag) {
+        const current = this.get(id);
+        if (expectedEtag && expectedEtag !== current.etag)
+            throw new Error("模板 ETag mismatch");
+        const parsed = parseInput(input);
+        const now = nowBeijing();
+        const manifest = {
+            ...current,
+            name: parsed.name,
+            description: input.description === undefined ? current.description : parsed.description,
+            version: current.version + 1,
+            updatedAt: now,
+        };
+        this.writeDocument(manifest, parsed.spec, parsed.layout, parsed.assets);
+        return this.get(id);
+    }
+    delete(id) {
+        const current = this.get(id);
+        fs.rmSync(this.templateDir(id), { recursive: true, force: true });
+        const deleted = readJson(path.join(this.rootPath, ".deleted.json"), {});
+        deleted[id] = current.updatedAt;
+        writeJsonAtomic(path.join(this.rootPath, ".deleted.json"), deleted);
+    }
+    materialize(id, workspaceRoot, options) {
+        const template = this.get(id);
+        const spec = applyAgentConfig(template.spec, options?.agentConfig);
+        const workflowId = assertWorkflowDisplayName(options?.name?.trim() || spec.name || id);
+        if (workflowPackageExists(workspaceRoot, workflowId)) {
+            throw new Error(`Workflow “${workflowId}” 已存在，请更换显示名称`);
+        }
+        const packagePaths = workflowPackagePaths(workspaceRoot, workflowId);
+        fs.mkdirSync(packagePaths.root, { recursive: true });
+        const raw = JSON.stringify(spec, null, 2);
+        for (const [relative, content] of Object.entries(template.assets)) {
+            const safe = safePackageRelativePath(relative);
+            if (!safe)
+                throw new Error(`模板 Prompt 路径无效：${relative}`);
+            const target = path.resolve(packagePaths.root, safe);
+            assertInsidePackage(packagePaths.root, target);
+            if (!fs.existsSync(target)) {
+                fs.mkdirSync(path.dirname(target), { recursive: true });
+                fs.writeFileSync(target, content, "utf8");
+            }
+        }
+        const now = nowBeijing();
+        writePackageJsonAtomic(packagePaths.workflow, spec);
+        writePackageJsonAtomic(packagePaths.layout, template.layout);
+        writePackageJsonAtomic(packagePaths.manifest, {
+            schemaVersion: 1,
+            name: workflowId,
+            description: template.description,
+            version: 1,
+            source: { kind: "template", templateId: template.id, templateVersion: template.version },
+            createdAt: now,
+            updatedAt: now,
+        });
+        const version = recordWorkflowPackageVersion(packagePaths, raw);
+        return {
+            id: workflowId,
+            spec,
+            etag: etagOf(raw),
+            updatedAt: nowBeijing(),
+            version,
+            templateId: template.id,
+            templateVersion: template.version,
+        };
+    }
+    ensureSeedTemplates() {
+        fs.mkdirSync(this.rootPath, { recursive: true, mode: 0o700 });
+        const deleted = readJson(path.join(this.rootPath, ".deleted.json"), {});
+        for (const seed of DEFAULT_TEMPLATES) {
+            const id = seed.id;
+            if (deleted[id])
+                continue;
+            if (fs.existsSync(this.templateDir(id))) {
+                // Earlier development builds stored the complete document inside
+                // manifest.json. The current package contract keeps the executable
+                // graph, layout and Prompt files in their own files. When those files
+                // already exist, trim only the obsolete embedded fields and preserve
+                // the user's display name, description and version.
+                this.normalizeLegacyManifest(id);
+                continue;
+            }
+            const parsed = parseInput(seed);
+            const now = nowBeijing();
+            const manifest = {
+                schemaVersion: 1,
+                id,
+                name: parsed.name,
+                description: parsed.description,
+                version: seed.seedVersion,
+                seeded: true,
+                updatedAt: seed.seedUpdatedAt || now,
+            };
+            this.writeDocument(manifest, parsed.spec, parsed.layout, parsed.assets);
+        }
+    }
+    migrateGeneralWorkflowId() {
+        const legacyId = "grpc-migration";
+        const currentId = "general-workflow";
+        const legacyDir = this.templateDir(legacyId);
+        const currentDir = this.templateDir(currentId);
+        if (!fs.existsSync(legacyDir) || fs.existsSync(currentDir))
+            return;
+        let manifest;
+        try {
+            manifest = readJson(path.join(legacyDir, "manifest.json"));
+        }
+        catch {
+            return;
+        }
+        if (manifest.name !== "通用work flow")
+            return;
+        fs.renameSync(legacyDir, currentDir);
+        writeJsonAtomic(path.join(currentDir, "manifest.json"), {
+            ...manifest,
+            id: currentId,
+        });
+    }
+    retireLegacySeedTemplates() {
+        for (const [id, expectedName] of Object.entries(RETIRED_SEED_TEMPLATES)) {
+            const dir = this.templateDir(id);
+            if (!fs.existsSync(dir))
+                continue;
+            let manifest;
+            try {
+                manifest = readJson(path.join(dir, "manifest.json"));
+            }
+            catch {
+                continue;
+            }
+            if (manifest.seeded && manifest.version === 1 && manifest.name === expectedName) {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        }
+    }
+    normalizeLegacyManifest(id) {
+        const manifestPath = path.join(this.templateDir(id), "manifest.json");
+        if (!fs.existsSync(manifestPath) ||
+            !fs.existsSync(path.join(this.templateDir(id), "workflow.json")))
+            return;
+        let current;
+        try {
+            current = readJson(manifestPath);
+        }
+        catch {
+            return;
+        }
+        if (!("spec" in current) && !("layout" in current) && !("assets" in current))
+            return;
+        const now = nowBeijing();
+        writeJsonAtomic(manifestPath, {
+            schemaVersion: 1,
+            id,
+            name: typeof current.name === "string" && current.name.trim() ? current.name : id,
+            description: typeof current.description === "string" ? current.description : "",
+            version: Number.isSafeInteger(current.version) && Number(current.version) > 0
+                ? Number(current.version)
+                : 1,
+            seeded: current.seeded !== false,
+            updatedAt: typeof current.updatedAt === "string" ? current.updatedAt : now,
+        });
+    }
+    templateDir(id) {
+        return path.join(this.rootPath, id);
+    }
+    writeDocument(manifest, spec, layout, assets) {
+        const dir = this.templateDir(manifest.id);
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        writeJsonAtomic(path.join(dir, "workflow.json"), spec);
+        writeJsonAtomic(path.join(dir, "layout.json"), layout);
+        // Prompt files are one-to-one with the current Workflow nodes. Remove
+        // stale Prompt files left by a node rename/delete before writing the new
+        // asset set; otherwise an edited global template would silently retain
+        // orphan files that are no longer part of its package.
+        fs.rmSync(path.join(dir, "prompts"), { recursive: true, force: true });
+        for (const [relative, content] of Object.entries(assets)) {
+            const safe = safeRelativePath(relative);
+            if (!safe || Buffer.byteLength(content, "utf8") > MAX_ASSET_BYTES) {
+                throw new Error(`模板 Prompt 资源无效：${relative}`);
+            }
+            const target = path.resolve(dir, safe);
+            assertInside(dir, target);
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, content, "utf8");
+        }
+        writeJsonAtomic(path.join(dir, "manifest.json"), manifest);
+    }
+}
+function parseInput(input) {
+    const name = input.name?.trim();
+    if (!name)
+        throw new Error("模板名称不能为空");
+    const parsed = safeParseWorkflowSpec(input.spec);
+    if (!parsed.success)
+        throw new Error("模板 WorkflowSpec 无效");
+    const layout = parseLayout(input.layout ?? {});
+    const assets = {};
+    for (const [key, value] of Object.entries(input.assets ?? {})) {
+        const relative = safeRelativePath(key);
+        if (!relative)
+            throw new Error(`模板资源路径无效：${key}`);
+        if (typeof value !== "string")
+            throw new Error(`模板资源必须是 UTF-8 文本：${key}`);
+        if (relative in assets)
+            throw new Error(`模板资源路径重复：${key}`);
+        if (Buffer.byteLength(value, "utf8") > MAX_ASSET_BYTES) {
+            throw new Error(`模板资源超过 8 MiB：${key}`);
+        }
+        assets[relative] = value;
+    }
+    for (const [agentId, config] of Object.entries(parsed.data.agents)) {
+        if (!config.prompt?.startsWith("@"))
+            continue;
+        const relative = safeRelativePath(config.prompt.slice(1));
+        const expected = workflowPromptRelativePath(agentId);
+        if (!relative ||
+            !relative.startsWith(`prompts${path.sep}`) ||
+            relative !== expected ||
+            !(relative in assets)) {
+            throw new Error(`模板 Prompt 资源缺失：${config.prompt}`);
+        }
+    }
+    return { name, description: input.description?.trim() ?? "", spec: parsed.data, layout, assets };
+}
+function parseLayout(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const result = {};
+    for (const graph of ["plan", "execute"]) {
+        const candidate = value[graph];
+        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+            continue;
+        const points = {};
+        for (const [id, point] of Object.entries(candidate)) {
+            if (!point || typeof point !== "object" || Array.isArray(point))
+                continue;
+            const x = point.x;
+            const y = point.y;
+            if (typeof x === "number" &&
+                Number.isFinite(x) &&
+                typeof y === "number" &&
+                Number.isFinite(y)) {
+                points[id] = { x, y };
+            }
+        }
+        if (Object.keys(points).length > 0)
+            result[graph] = points;
+    }
+    const rawEdgeHandles = value.edgeHandles;
+    if (rawEdgeHandles && typeof rawEdgeHandles === "object" && !Array.isArray(rawEdgeHandles)) {
+        const edgeHandles = {};
+        for (const graph of ["plan", "execute"]) {
+            const candidate = rawEdgeHandles[graph];
+            if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+                continue;
+            const parsed = {};
+            for (const [index, override] of Object.entries(candidate)) {
+                if (!/^\d+$/.test(index) || !override || typeof override !== "object")
+                    continue;
+                const sourceHandle = override.sourceHandle;
+                const targetHandle = override.targetHandle;
+                if (typeof sourceHandle !== "string" && typeof targetHandle !== "string")
+                    continue;
+                parsed[index] = {
+                    ...(typeof sourceHandle === "string" ? { sourceHandle } : {}),
+                    ...(typeof targetHandle === "string" ? { targetHandle } : {}),
+                };
+            }
+            if (Object.keys(parsed).length > 0)
+                edgeHandles[graph] = parsed;
+        }
+        if (Object.keys(edgeHandles).length > 0)
+            result.edgeHandles = edgeHandles;
+    }
+    return result;
+}
+function readTemplateAssets(dir, spec) {
+    const assets = {};
+    for (const [agentId, config] of Object.entries(spec.agents)) {
+        if (!config.prompt?.startsWith("@"))
+            continue;
+        const relative = safeRelativePath(config.prompt.slice(1));
+        const expected = workflowPromptRelativePath(agentId);
+        if (!relative || !relative.startsWith(`prompts${path.sep}`) || relative !== expected) {
+            throw new Error(`模板 Prompt 路径无效：${config.prompt}`);
+        }
+        if (relative in assets)
+            continue;
+        const target = path.resolve(dir, relative);
+        assertInside(dir, target);
+        if (!fs.existsSync(target) || !fs.statSync(target).isFile()) {
+            throw new Error(`模板 Prompt 不存在：${relative}`);
+        }
+        assets[relative] = fs.readFileSync(target, "utf8");
+    }
+    return assets;
+}
+function applyAgentConfig(spec, config) {
+    if (!config)
+        return spec;
+    return {
+        ...spec,
+        agents: Object.fromEntries(Object.entries(spec.agents).map(([id, current]) => [
+            id,
+            {
+                ...current,
+                ...config,
+            },
+        ])),
+    };
+}
+function toSummary(document) {
+    const { spec: _spec, layout: _layout, assets: _assets, ...summary } = document;
+    return summary;
+}
+function templateEtag(manifest, spec, layout, assets) {
+    return etagOf(JSON.stringify({ manifest, spec, layout, assets }));
+}
+function etagOf(raw) {
+    return `"${createHash("sha256").update(raw).digest("hex").slice(0, 16)}"`;
+}
+function readJson(filePath, fallback) {
+    if (!fs.existsSync(filePath)) {
+        if (fallback !== undefined)
+            return fallback;
+        throw new Error(`文件不存在：${filePath}`);
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+function writeJsonAtomic(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, filePath);
+}
+/**
+ * Early development builds placed templates below
+ * `$AGENTSTORM_HOME/agentstorm/templates`. Import that directory once into the
+ * final `$AGENTSTORM_HOME/templates` location. Existing destination files win,
+ * the source is never modified, and runtime reads only the destination after
+ * this function returns.
+ */
+function migrateNestedTemplateRoot(targetRoot) {
+    const agentstormHome = path.dirname(targetRoot);
+    const sourceRoot = path.resolve(agentstormHome, LEGACY_TEMPLATE_ROOT_NAME);
+    const markerPath = path.join(agentstormHome, "migrations", `${TEMPLATE_ROOT_MIGRATION_ID}.json`);
+    if (sourceRoot === targetRoot || fs.existsSync(markerPath) || !fs.existsSync(sourceRoot))
+        return;
+    const copied = [];
+    const skipped = [];
+    copyMissingTemplateEntries(sourceRoot, targetRoot, "", copied, skipped);
+    writeJsonAtomic(markerPath, {
+        id: TEMPLATE_ROOT_MIGRATION_ID,
+        completedAt: nowBeijing(),
+        sourceRoot,
+        targetRoot,
+        copied,
+        skipped,
+    });
+}
+function copyMissingTemplateEntries(source, target, relative, copied, skipped) {
+    const sourceStat = fs.lstatSync(source);
+    if (sourceStat.isSymbolicLink()) {
+        skipped.push(relative || ".");
+        return;
+    }
+    if (sourceStat.isDirectory()) {
+        if (fs.existsSync(target) && !fs.lstatSync(target).isDirectory()) {
+            skipped.push(relative || ".");
+            return;
+        }
+        fs.mkdirSync(target, { recursive: true, mode: 0o700 });
+        for (const entry of fs.readdirSync(source)) {
+            copyMissingTemplateEntries(path.join(source, entry), path.join(target, entry), relative ? path.join(relative, entry) : entry, copied, skipped);
+        }
+        return;
+    }
+    if (!sourceStat.isFile() || fs.existsSync(target)) {
+        skipped.push(relative || ".");
+        return;
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+    fs.copyFileSync(source, target, fs.constants.COPYFILE_EXCL);
+    copied.push(relative);
+}
+function expandHome(value) {
+    if (value === "~")
+        return process.env.HOME ?? value;
+    if (value.startsWith("~/"))
+        return path.join(process.env.HOME ?? value.slice(2), value.slice(2));
+    return value;
+}
+function isSafeTemplateId(value) {
+    return TEMPLATE_ID_PATTERN.test(value);
+}
+function assertTemplateId(value) {
+    if (!isSafeTemplateId(value))
+        throw new Error("模板 ID 只能包含小写字母、数字、点、短横线和下划线");
+}
+function slugify(value) {
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || `template-${Date.now()}`;
+}
+function safeRelativePath(value) {
+    const normalized = value.replaceAll("\\", "/");
+    if (!normalized || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized))
+        return null;
+    const parts = normalized.split("/");
+    if (parts.some((part) => !part || part === "." || part === ".."))
+        return null;
+    return parts.join(path.sep);
+}
+function assertInside(root, candidate) {
+    const resolvedRoot = path.resolve(root);
+    const resolvedCandidate = path.resolve(candidate);
+    if (resolvedCandidate !== resolvedRoot &&
+        !resolvedCandidate.startsWith(`${resolvedRoot}${path.sep}`)) {
+        throw new Error("路径超出模板根目录");
+    }
+}
+//# sourceMappingURL=template-library.js.map

package/dist/templates/general-workflow/layout.json

@@ -0,0 +1,88 @@
+{
+  "plan": {
+    "planner": {
+      "x": 163,
+      "y": 171
+    },
+    "plan-reviewer": {
+      "x": 389,
+      "y": 171
+    },
+    "approve": {
+      "x": 609,
+      "y": 169
+    },
+    "@done": {
+      "x": 833,
+      "y": 186
+    },
+    "@blocked": {
+      "x": 770,
+      "y": 260
+    }
+  },
+  "execute": {
+    "worker": {
+      "x": 157,
+      "y": 180
+    },
+    "code-reviewer": {
+      "x": 390,
+      "y": 180
+    },
+    "tester": {
+      "x": 624,
+      "y": 179
+    },
+    "@done": {
+      "x": 856,
+      "y": 200
+    },
+    "@blocked": {
+      "x": 778,
+      "y": 273
+    }
+  },
+  "edgeHandles": {
+    "plan": {
+      "0": {
+        "sourceHandle": "source-right-50",
+        "targetHandle": "target-left-60"
+      },
+      "1": {
+        "sourceHandle": "source-right-50",
+        "targetHandle": "target-left-60"
+      },
+      "2": {
+        "sourceHandle": "source-bottom-50",
+        "targetHandle": "target-bottom-50"
+      },
+      "3": {
+        "sourceHandle": "source-right-50",
+        "targetHandle": "target-left-60"
+      },
+      "4": {
+        "sourceHandle": "source-top-40",
+        "targetHandle": "target-top-50"
+      }
+    },
+    "execute": {
+      "0": {
+        "sourceHandle": "source-right-50",
+        "targetHandle": "target-left-60"
+      },
+      "1": {
+        "sourceHandle": "source-right-50",
+        "targetHandle": "target-left-60"
+      },
+      "2": {
+        "sourceHandle": "source-bottom-50",
+        "targetHandle": "target-bottom-50"
+      },
+      "4": {
+        "sourceHandle": "source-top-50",
+        "targetHandle": "target-top-50"
+      }
+    }
+  }
+}

package/dist/templates/general-workflow/manifest.json

@@ -0,0 +1,9 @@
+{
+  "schemaVersion": 1,
+  "id": "general-workflow",
+  "name": "通用work flow",
+  "description": "通用 Plan → 审批 → Execute 流水线。",
+  "version": 20,
+  "seeded": true,
+  "updatedAt": "2026-08-09T16:15:02.000+08:00"
+}

package/dist/templates/general-workflow/prompts/code-reviewer.md

@@ -0,0 +1,20 @@
+---
+name: code-reviewer
+description: 通用代码审查 Agent：检查当前任务实现，不代替动态测试
+role: reviewer
+---
+
+# Code Reviewer
+
+你负责审查当前任务的实现质量和静态可验证部分，不修改与审查无关的代码。
+
+## 审查方式
+
+1. 读取任务、验收标准、前置摘要与资源，并检查实际 diff 和相关源码。
+2. 检查改动是否符合任务边界，是否保持既有 API、错误处理、安全和兼容性约定。
+3. 查找空实现、遗漏分支、资源泄漏、明显回归、测试缺口和不可维护的复杂度。
+4. 亲自运行可行的格式检查、类型检查、静态分析或最小导入检查，不只相信自报结果。
+
+## 判定标准
+
+只有关键问题均已解决并有真实证据时才通过。需要返工时指出具体位置、影响和建议修复方向；动态行为留给 Tester 验证，不把“代码看起来正确”当成测试通过。