@siming-org/server 0.3.0

package/dist/chunk-T7QAGG73.js

@@ -0,0 +1,1558 @@
+// src/static.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { join, resolve, sep } from "path";
+import { Hono } from "hono";
+var ASSETS_PREFIX = "/assets/";
+var API_NAMESPACES = ["/api", "/health"];
+function isApiNamespace(pathname) {
+  return API_NAMESPACES.some((ns) => pathname === ns || pathname.startsWith(`${ns}/`));
+}
+var MIME_TYPES = {
+  html: "text/html; charset=utf-8",
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  css: "text/css; charset=utf-8",
+  json: "application/json; charset=utf-8",
+  map: "application/json",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  txt: "text/plain; charset=utf-8",
+  wasm: "application/wasm"
+};
+function contentTypeFor(filePath) {
+  const ext = filePath.includes(".") ? filePath.slice(filePath.lastIndexOf(".") + 1).toLowerCase() : "";
+  return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+function resolveWebDistRoot() {
+  const base = import.meta.dirname;
+  const candidates = [
+    join(base, "..", "web-dist"),
+    // dist 布局：包根/web-dist；src 布局：包根/web-dist（均命中）
+    join(base, "..", "..", "web", "dist")
+    // dist/src 布局回退：repo packages/web/dist
+  ];
+  for (const dir of candidates) {
+    if (existsSync(join(dir, "index.html"))) return dir;
+  }
+  return null;
+}
+function resolveSafe(webRoot, urlPathname) {
+  const segments = urlPathname.split("/").filter((s) => s.length > 0);
+  if (segments.includes("..")) return null;
+  const target = resolve(webRoot, ...segments);
+  if (target !== webRoot && !target.startsWith(webRoot + sep)) return null;
+  return target;
+}
+function serveFile(absPath, cacheControl) {
+  const body = readFileSync(absPath);
+  return new Response(body, {
+    status: 200,
+    headers: { "Content-Type": contentTypeFor(absPath), "Cache-Control": cacheControl }
+  });
+}
+function createStaticRoutes(webRoot) {
+  const app = new Hono();
+  app.get("*", async (c) => {
+    const pathname = c.req.path;
+    if (isApiNamespace(pathname)) {
+      return c.notFound();
+    }
+    if (webRoot === null) {
+      return c.json(
+        {
+          error: "web_ui_not_built",
+          message: "Web UI \u672A\u6784\u5EFA\uFF0C\u672C\u670D\u52A1\u4EC5\u63D0\u4F9B API\u3002\u5982\u5728 siming \u4ED3\u5E93\u5185\uFF1A\u6267\u884C pnpm --filter @siming-org/web build \u540E\u91CD\u542F\uFF1B\u5982\u9700\u5B8C\u6574\u7BA1\u7406\u754C\u9762\uFF1A\u901A\u8FC7 npm \u5B89\u88C5\u542B web-dist \u7684 @siming-org/server \u5206\u53D1\u7248\u672C"
+        },
+        503
+      );
+    }
+    let decoded;
+    try {
+      decoded = decodeURIComponent(pathname);
+    } catch {
+      return c.json({ error: "bad_path", message: "URL \u8DEF\u5F84\u7F16\u7801\u975E\u6CD5" }, 400);
+    }
+    const absPath = resolveSafe(webRoot, decoded === "/" ? "" : decoded);
+    if (absPath === null) {
+      return c.json({ error: "bad_path", message: "\u8DEF\u5F84\u4E0D\u5408\u6CD5" }, 403);
+    }
+    const st = statSync(absPath, { throwIfNoEntry: false });
+    if (st?.isFile()) {
+      const cache = decoded.startsWith(ASSETS_PREFIX) ? "public, max-age=31536000, immutable" : "no-cache";
+      return serveFile(absPath, cache);
+    }
+    if (decoded.startsWith(ASSETS_PREFIX)) {
+      return c.notFound();
+    }
+    const indexPath = join(webRoot, "index.html");
+    if (existsSync(indexPath)) {
+      return serveFile(indexPath, "no-cache");
+    }
+    return c.notFound();
+  });
+  return app;
+}
+
+// src/app.ts
+import { Hono as Hono11 } from "hono";
+
+// src/errors.ts
+import { AppError } from "@siming-org/core";
+function setupErrorHandler(app) {
+  app.onError((err, c) => {
+    if (err instanceof AppError) {
+      const body = JSON.stringify(err.toResponse());
+      return new Response(body, { status: err.statusCode, headers: { "Content-Type": "application/json" } });
+    }
+    if (typeof err === "object" && err !== null && "code" in err && err.code === 11e3) {
+      return c.json({ error: "conflict", message: "duplicate key" }, 409);
+    }
+    console.error("Unhandled error:", err);
+    return c.json(
+      { error: "internal_error", message: "An unexpected error occurred" },
+      500
+    );
+  });
+}
+
+// src/routes/index.ts
+import { Hono as Hono10 } from "hono";
+
+// src/routes/health.ts
+import { Hono as Hono2 } from "hono";
+import { ping, VERSION } from "@siming-org/core";
+function createHealth(client) {
+  const app = new Hono2();
+  app.get("/health", async (c) => {
+    let mongoStatus = "ok";
+    try {
+      await client.db().command({ ping: 1 });
+    } catch (e) {
+      console.error(`[health] mongo ping failed: ${e instanceof Error ? e.message : String(e)}`);
+      mongoStatus = "error";
+    }
+    const status = mongoStatus === "ok" ? "ok" : "degraded";
+    return c.json({
+      status,
+      version: VERSION,
+      pong: ping(),
+      mongo: { status: mongoStatus }
+    });
+  });
+  return app;
+}
+
+// src/routes/project.routes.ts
+import { Hono as Hono3 } from "hono";
+import { zValidator } from "@hono/zod-validator";
+import {
+  createProjectRepo,
+  ProjectCreateSchema,
+  ProjectUpdateSchema,
+  NotFoundError,
+  ConflictError,
+  BIZ_CODE_MESSAGES,
+  DEFAULT_PROJECT_KEY
+} from "@siming-org/core";
+async function loadProjectForWrite(projectRepo, projectId) {
+  const project = await projectRepo.getById(projectId);
+  if (!project) {
+    throw new NotFoundError("project", projectId, {
+      bizCode: "PROJECT_NOT_FOUND",
+      message: BIZ_CODE_MESSAGES.PROJECT_NOT_FOUND
+    });
+  }
+  if (project.status === "archived") {
+    throw new ConflictError("project", projectId, {
+      bizCode: "PROJECT_ARCHIVED",
+      message: BIZ_CODE_MESSAGES.PROJECT_ARCHIVED
+    });
+  }
+  return project;
+}
+function createProjectRoutes(client) {
+  const app = new Hono3();
+  const repo = createProjectRepo(client.db());
+  app.get("/api/projects", async (c) => {
+    const status = c.req.query("status");
+    const projects = await repo.list();
+    return c.json(status ? projects.filter((p) => p.status === status) : projects);
+  });
+  app.get("/api/projects/:id", async (c) => {
+    const id = c.req.param("id");
+    const project = await repo.getById(id);
+    if (!project) throw new NotFoundError("project", id);
+    return c.json(project);
+  });
+  app.post("/api/projects", zValidator("json", ProjectCreateSchema), async (c) => {
+    const data = c.req.valid("json");
+    return c.json(await repo.createProject(data), 201);
+  });
+  app.put("/api/projects/:id", zValidator("json", ProjectUpdateSchema), async (c) => {
+    const id = c.req.param("id");
+    const data = c.req.valid("json");
+    const existing = await repo.getById(id);
+    if (!existing) throw new NotFoundError("project", id);
+    if (data.status === "archived" && existing.key === DEFAULT_PROJECT_KEY) {
+      throw new ConflictError("project", id, {
+        bizCode: "DEFAULT_PROJECT_IMMUTABLE",
+        message: BIZ_CODE_MESSAGES.DEFAULT_PROJECT_IMMUTABLE
+      });
+    }
+    if (data.name && data.name !== existing.name) {
+      const dup = await repo._collection.findOne({ name: data.name }, { projection: { _id: 1 } });
+      if (dup) throw new ConflictError("project", `name conflict: ${data.name}`);
+    }
+    const patch = {};
+    if (data.name !== void 0) patch.name = data.name;
+    if (data.description !== void 0) patch.description = data.description;
+    if (data.status !== void 0) patch.status = data.status;
+    const project = await repo.update(id, patch);
+    if (!project) throw new NotFoundError("project", id);
+    return c.json(project);
+  });
+  return app;
+}
+
+// src/routes/skill.routes.ts
+import { Hono as Hono4 } from "hono";
+import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { z } from "zod";
+import {
+  createSkillRepo,
+  createProjectRepo as createProjectRepo2,
+  createEnumRegistryRepo,
+  SkillCreateSchema,
+  SkillUpdateSchema,
+  SkillCopySchema,
+  OBJECT_ID_HEX,
+  NotFoundError as NotFoundError2,
+  ConflictError as ConflictError2,
+  BadRequestError,
+  BIZ_CODE_MESSAGES as BIZ_CODE_MESSAGES2
+} from "@siming-org/core";
+var SkillListQuerySchema = z.object({
+  projectId: z.string().optional(),
+  scope: z.enum(["global", "project"]).optional()
+}).refine((q) => !(q.scope === "project" && !q.projectId), {
+  message: "scope=project requires projectId",
+  path: ["projectId"]
+});
+var SkillByNameQuerySchema = z.object({
+  scope: z.enum(["global", "project"]).optional(),
+  projectId: z.string().regex(OBJECT_ID_HEX).optional()
+}).superRefine((q, ctx) => {
+  if (q.scope === "project" && !q.projectId) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "scope=project requires projectId", path: ["projectId"] });
+  }
+});
+function createSkillRoutes(client) {
+  const app = new Hono4();
+  const repo = createSkillRepo(client.db());
+  const projectRepo = createProjectRepo2(client.db());
+  const enumRegistryRepo = createEnumRegistryRepo(client.db());
+  const assertCategoryValid = async (category) => {
+    const categories = await enumRegistryRepo.getEntries("skill_category");
+    if (!categories.some((e) => e.active && e.value === category)) {
+      const validValues = categories.filter((e) => e.active).map((e) => e.value).join(", ");
+      throw new BadRequestError(
+        `category '${category}' is not a valid active skill_category value. Valid values: ${validValues}`
+      );
+    }
+  };
+  app.get("/api/skills", zValidator2("query", SkillListQuerySchema), async (c) => {
+    const q = c.req.valid("query");
+    if (q.scope) {
+      return c.json(await repo.listSkillsByScopeFilter(q.scope, q.projectId));
+    }
+    return c.json(q.projectId ? await repo.listSkillsByScope(q.projectId) : await repo.list());
+  });
+  app.get("/api/skills/:name", zValidator2("query", SkillByNameQuerySchema), async (c) => {
+    const name = c.req.param("name");
+    const q = c.req.valid("query");
+    const skill = await resolveAssetByScope(repo, name, q);
+    if (!skill) throw new NotFoundError2("skill", name);
+    return c.json(skill);
+  });
+  app.post("/api/skills", zValidator2("json", SkillCreateSchema), async (c) => {
+    const data = c.req.valid("json");
+    await assertCategoryValid(data.category);
+    if (data.scope === "project") await loadProjectForWrite(projectRepo, data.projectId);
+    return c.json(await repo.createSkill(data), 201);
+  });
+  app.put("/api/skills/:name", zValidator2("query", SkillByNameQuerySchema), zValidator2("json", SkillUpdateSchema), async (c) => {
+    const name = c.req.param("name");
+    const data = c.req.valid("json");
+    const q = c.req.valid("query");
+    const existing = await resolveAssetByScope(repo, name, q);
+    if (!existing) throw new NotFoundError2("skill", name);
+    if (data.category !== void 0) await assertCategoryValid(data.category);
+    if (isScopeMutation(existing, data)) {
+      throw new ConflictError2("skill", name, {
+        bizCode: "SCOPE_IMMUTABLE",
+        message: BIZ_CODE_MESSAGES2.SCOPE_IMMUTABLE
+      });
+    }
+    const effectiveProjectId = data.projectId ?? existing.projectId;
+    if ((data.scope ?? existing.scope) === "project" && effectiveProjectId) {
+      await loadProjectForWrite(projectRepo, effectiveProjectId);
+    }
+    const skill = await repo.updateByNameScoped(name, q.scope ?? "global", q.projectId, data);
+    if (!skill) throw new NotFoundError2("skill", name);
+    return c.json(skill);
+  });
+  app.post("/api/skills/:name/copy", zValidator2("query", SkillByNameQuerySchema), zValidator2("json", SkillCopySchema), async (c) => {
+    const name = c.req.param("name");
+    const input = c.req.valid("json");
+    const q = c.req.valid("query");
+    const existing = await resolveAssetByScope(repo, name, q);
+    if (!existing) throw new NotFoundError2("skill", name);
+    if (input.newScope === "project") {
+      await loadProjectForWrite(projectRepo, input.targetProjectId);
+    }
+    const copy = await repo.copySkill(
+      name,
+      { scope: q.scope ?? "global", ...q.projectId ? { projectId: q.projectId } : {} },
+      { scope: input.newScope, ...input.targetProjectId ? { projectId: input.targetProjectId } : {} },
+      input.newName
+    );
+    return c.json(copy, 201);
+  });
+  app.delete("/api/skills/:name", zValidator2("query", SkillByNameQuerySchema), async (c) => {
+    const name = c.req.param("name");
+    const q = c.req.valid("query");
+    const existing = await resolveAssetByScope(repo, name, q);
+    if (!existing) throw new NotFoundError2("skill", name);
+    const deleted = await repo.deleteByNameScoped(name, q.scope ?? "global", q.projectId);
+    if (!deleted) throw new NotFoundError2("skill", name);
+    return c.body(null, 204);
+  });
+  return app;
+}
+function isScopeMutation(existing, patch) {
+  if (patch.scope !== void 0 && patch.scope !== existing.scope) return true;
+  if (patch.projectId !== void 0 && patch.projectId !== existing.projectId) return true;
+  return false;
+}
+async function resolveAssetByScope(repo, name, q) {
+  return repo.getByNameScoped(name, q.scope ?? "global", q.projectId);
+}
+
+// src/routes/agent.routes.ts
+import { Hono as Hono5 } from "hono";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { z as z2 } from "zod";
+import {
+  createAgentRepo,
+  createSkillRepo as createSkillRepo2,
+  createProjectRepo as createProjectRepo3,
+  createModelAliasRepo,
+  AgentCreateSchema,
+  AgentUpdateSchema,
+  AgentCopySchema,
+  NotFoundError as NotFoundError3,
+  ConflictError as ConflictError3,
+  BIZ_CODE_MESSAGES as BIZ_CODE_MESSAGES3,
+  assertBoundSkillsCompatible,
+  assertModelAliasExists
+} from "@siming-org/core";
+var AgentListQuerySchema = z2.object({
+  projectId: z2.string().optional(),
+  scope: z2.enum(["global", "project"]).optional()
+}).refine((q) => !(q.scope === "project" && !q.projectId), {
+  message: "scope=project requires projectId",
+  path: ["projectId"]
+});
+function createAgentRoutes(client) {
+  const app = new Hono5();
+  const repo = createAgentRepo(client.db());
+  const skillRepo = createSkillRepo2(client.db());
+  const projectRepo = createProjectRepo3(client.db());
+  const aliasRepo = createModelAliasRepo(client.db());
+  app.get("/api/agents", zValidator3("query", AgentListQuerySchema), async (c) => {
+    const q = c.req.valid("query");
+    if (q.scope) {
+      return c.json(await repo.listAgentsByScopeFilter(q.scope, q.projectId));
+    }
+    return c.json(q.projectId ? await repo.listAgentsByScope(q.projectId) : await repo.list());
+  });
+  app.get("/api/agents/:name", zValidator3("query", SkillByNameQuerySchema), async (c) => {
+    const name = c.req.param("name");
+    const q = c.req.valid("query");
+    const agent = await resolveAssetByScope(repo, name, q);
+    if (!agent) throw new NotFoundError3("agent", name);
+    return c.json(agent);
+  });
+  app.post("/api/agents", zValidator3("json", AgentCreateSchema), async (c) => {
+    const data = c.req.valid("json");
+    if (data.scope === "project") await loadProjectForWrite(projectRepo, data.projectId);
+    await assertBoundSkillsCompatible(skillRepo, data.scope, data.projectId, data.boundSkills);
+    await assertModelAliasExists(aliasRepo, data.model);
+    return c.json(await repo.createAgent(data), 201);
+  });
+  app.put("/api/agents/:name", zValidator3("query", SkillByNameQuerySchema), zValidator3("json", AgentUpdateSchema), async (c) => {
+    const name = c.req.param("name");
+    const data = c.req.valid("json");
+    const q = c.req.valid("query");
+    const existing = await resolveAssetByScope(repo, name, q);
+    if (!existing) throw new NotFoundError3("agent", name);
+    if (isScopeMutation(existing, data)) {
+      throw new ConflictError3("agent", name, {
+        bizCode: "SCOPE_IMMUTABLE",
+        message: BIZ_CODE_MESSAGES3.SCOPE_IMMUTABLE
+      });
+    }
+    const effectiveProjectId = data.projectId ?? existing.projectId;
+    if ((data.scope ?? existing.scope) === "project" && effectiveProjectId) {
+      await loadProjectForWrite(projectRepo, effectiveProjectId);
+    }
+    if (data.boundSkills !== void 0) {
+      await assertBoundSkillsCompatible(
+        skillRepo,
+        existing.scope,
+        effectiveProjectId,
+        data.boundSkills
+      );
+    }
+    if (data.model !== void 0) {
+      await assertModelAliasExists(aliasRepo, data.model);
+    }
+    const agent = await repo.updateByNameScoped(name, q.scope ?? "global", q.projectId, data);
+    if (!agent) throw new NotFoundError3("agent", name);
+    return c.json(agent);
+  });
+  app.post("/api/agents/:name/copy", zValidator3("query", SkillByNameQuerySchema), zValidator3("json", AgentCopySchema), async (c) => {
+    const name = c.req.param("name");
+    const input = c.req.valid("json");
+    const q = c.req.valid("query");
+    const existing = await resolveAssetByScope(repo, name, q);
+    if (!existing) throw new NotFoundError3("agent", name);
+    if (input.newScope === "project") {
+      await loadProjectForWrite(projectRepo, input.targetProjectId);
+    }
+    const copy = await repo.copyAgent(
+      name,
+      { scope: q.scope ?? "global", ...q.projectId ? { projectId: q.projectId } : {} },
+      { scope: input.newScope, ...input.targetProjectId ? { projectId: input.targetProjectId } : {} },
+      input.newName,
+      skillRepo
+    );
+    return c.json(copy, 201);
+  });
+  app.delete("/api/agents/:name", zValidator3("query", SkillByNameQuerySchema), async (c) => {
+    const name = c.req.param("name");
+    const q = c.req.valid("query");
+    const existing = await resolveAssetByScope(repo, name, q);
+    if (!existing) throw new NotFoundError3("agent", name);
+    const deleted = await repo.deleteByNameScoped(name, q.scope ?? "global", q.projectId);
+    if (!deleted) throw new NotFoundError3("agent", name);
+    return c.body(null, 204);
+  });
+  return app;
+}
+
+// src/routes/model-alias.routes.ts
+import { Hono as Hono6 } from "hono";
+import { zValidator as zValidator4 } from "@hono/zod-validator";
+import {
+  createModelAliasRepo as createModelAliasRepo2,
+  ModelAliasCreateSchema,
+  ModelAliasUpdateSchema,
+  NotFoundError as NotFoundError4,
+  ConflictError as ConflictError4,
+  BIZ_CODE_MESSAGES as BIZ_CODE_MESSAGES4
+} from "@siming-org/core";
+function createModelAliasRoutes(client) {
+  const app = new Hono6();
+  const repo = createModelAliasRepo2(client.db());
+  app.get("/api/model-aliases", async (c) => {
+    return c.json(await repo.listWithRefCount());
+  });
+  app.post("/api/model-aliases", zValidator4("json", ModelAliasCreateSchema), async (c) => {
+    const data = c.req.valid("json");
+    const dup = await repo.getByCode(data.code);
+    if (dup) {
+      throw new ConflictError4("model-alias", data.code, {
+        bizCode: "MODEL_CODE_EXISTS",
+        message: BIZ_CODE_MESSAGES4.MODEL_CODE_EXISTS
+      });
+    }
+    return c.json(await repo.createModelAlias(data), 201);
+  });
+  app.put("/api/model-aliases/:code", zValidator4("json", ModelAliasUpdateSchema), async (c) => {
+    const code = c.req.param("code");
+    const data = c.req.valid("json");
+    const existing = await repo.getByCode(code);
+    if (!existing) throw new NotFoundError4("model-alias", code);
+    if (data.code !== void 0 && data.code !== code) {
+      throw new ConflictError4("model-alias", code, {
+        bizCode: "MODEL_CODE_IMMUTABLE",
+        message: BIZ_CODE_MESSAGES4.MODEL_CODE_IMMUTABLE
+      });
+    }
+    const patch = {};
+    if (data.name !== void 0) patch.name = data.name;
+    if (data.realModel !== void 0) patch.realModel = data.realModel;
+    const alias = await repo.updateByCode(code, patch);
+    if (!alias) throw new NotFoundError4("model-alias", code);
+    return c.json(alias);
+  });
+  app.delete("/api/model-aliases/:code", async (c) => {
+    const code = c.req.param("code");
+    const deleted = await repo.deleteByCode(code);
+    if (!deleted) throw new NotFoundError4("model-alias", code);
+    return c.body(null, 204);
+  });
+  return app;
+}
+
+// src/routes/dag-template.routes.ts
+import { Hono as Hono7 } from "hono";
+import { zValidator as zValidator5 } from "@hono/zod-validator";
+import { z as z3 } from "zod";
+import {
+  createDagTemplateRepo,
+  createProjectRepo as createProjectRepo4,
+  DagTemplateCreateSchema,
+  DagTemplateCopySchema,
+  DagTemplateUpdateSchema,
+  NotFoundError as NotFoundError5,
+  ConflictError as ConflictError5,
+  BIZ_CODE_MESSAGES as BIZ_CODE_MESSAGES5
+} from "@siming-org/core";
+var DagTemplateListQuerySchema = z3.object({
+  projectId: z3.string().optional(),
+  name: z3.string().optional()
+});
+function createDagTemplateRoutes(client) {
+  const app = new Hono7();
+  const repo = createDagTemplateRepo(client.db());
+  const projectRepo = createProjectRepo4(client.db());
+  app.get("/api/dag/templates", zValidator5("query", DagTemplateListQuerySchema), async (c) => {
+    const q = c.req.valid("query");
+    return c.json(
+      await repo.listDagTemplates({
+        ...q.projectId ? { projectId: q.projectId } : {},
+        ...q.name ? { name: q.name } : {}
+      })
+    );
+  });
+  app.get("/api/dag/templates/:id", async (c) => {
+    const id = c.req.param("id");
+    const template = await repo.getById(id);
+    if (!template) throw new NotFoundError5("dag-template", id);
+    return c.json(template);
+  });
+  app.post("/api/dag/templates", zValidator5("json", DagTemplateCreateSchema), async (c) => {
+    const data = c.req.valid("json");
+    await loadProjectForWrite(projectRepo, data.projectId);
+    return c.json(await repo.createDagTemplate(data), 201);
+  });
+  app.put("/api/dag/templates/:id", zValidator5("json", DagTemplateUpdateSchema), async (c) => {
+    const id = c.req.param("id");
+    const data = c.req.valid("json");
+    const existing = await repo.getById(id);
+    if (!existing) throw new NotFoundError5("dag-template", id);
+    if (data.projectId !== void 0 && data.projectId !== existing.projectId) {
+      throw new ConflictError5("dag-template", id, {
+        bizCode: "TEMPLATE_PROJECT_IMMUTABLE",
+        message: BIZ_CODE_MESSAGES5.TEMPLATE_PROJECT_IMMUTABLE
+      });
+    }
+    await loadProjectForWrite(projectRepo, existing.projectId);
+    if (data.name !== void 0 && data.name !== existing.name) {
+      const dup = await repo._collection.findOne(
+        { projectId: existing.projectId, name: data.name },
+        { projection: { _id: 1 } }
+      );
+      if (dup) {
+        throw new ConflictError5("dag-template", `name conflict: ${data.name}`, {
+          bizCode: "TEMPLATE_NAME_CONFLICT",
+          message: BIZ_CODE_MESSAGES5.TEMPLATE_NAME_CONFLICT
+        });
+      }
+    }
+    const template = await repo.update(id, data);
+    if (!template) throw new NotFoundError5("dag-template", id);
+    return c.json(template);
+  });
+  app.post("/api/dag/templates/:id/copy", zValidator5("json", DagTemplateCopySchema), async (c) => {
+    const id = c.req.param("id");
+    const input = c.req.valid("json");
+    const existing = await repo.getById(id);
+    if (!existing) throw new NotFoundError5("dag-template", id);
+    await loadProjectForWrite(projectRepo, input.targetProjectId);
+    const dup = await repo._collection.findOne(
+      { projectId: input.targetProjectId, name: input.newName },
+      { projection: { _id: 1 } }
+    );
+    if (dup) {
+      throw new ConflictError5("dag-template", `name conflict: ${input.newName}`, {
+        bizCode: "TEMPLATE_NAME_CONFLICT",
+        message: BIZ_CODE_MESSAGES5.TEMPLATE_NAME_CONFLICT
+      });
+    }
+    const copy = await repo.copyDagTemplate(id, input.targetProjectId, input.newName);
+    return c.json(copy, 201);
+  });
+  app.delete("/api/dag/templates/:id", async (c) => {
+    const id = c.req.param("id");
+    const deleted = await repo.delete(id);
+    if (!deleted) throw new NotFoundError5("dag-template", id);
+    return c.body(null, 204);
+  });
+  return app;
+}
+
+// src/routes/task.routes.ts
+import { Hono as Hono8 } from "hono";
+import { zValidator as zValidator6 } from "@hono/zod-validator";
+import { z as z4 } from "zod";
+import {
+  createTaskRepo,
+  createDagTemplateRepo as createDagTemplateRepo2,
+  createProjectRepo as createProjectRepo5,
+  TaskCreateInputSchema,
+  AdvanceRequestSchema,
+  ApproveRequestSchema,
+  PauseRequestSchema,
+  ResumeRequestSchema,
+  ARTIFACT_TYPES,
+  NODE_ID_PATTERN,
+  createEnumRegistryRepo as createEnumRegistryRepo2,
+  NotFoundError as NotFoundError6,
+  ConflictError as ConflictError6,
+  BadRequestError as BadRequestError2,
+  ValidationError,
+  BIZ_CODE_MESSAGES as BIZ_CODE_MESSAGES6,
+  advanceTask,
+  approveTask,
+  pauseTask,
+  resumeTask,
+  renderPrompt,
+  toNodeInfo,
+  toTaskPublic,
+  findNextEdge,
+  generateEntryId
+} from "@siming-org/core";
+var TaskListQuerySchema = z4.object({
+  status: z4.string().optional(),
+  track: z4.string().optional(),
+  projectId: z4.string().optional(),
+  page: z4.coerce.number().int().min(1).default(1),
+  limit: z4.coerce.number().int().min(1).max(500).default(20),
+  sort: z4.enum(["progress", "createdAt", "updatedAt"]).optional()
+});
+var TaskPatchSchema = z4.object({
+  title: z4.string().min(1).optional()
+});
+var TaskDocSetSchema = z4.object({
+  what: z4.string().min(1).max(2e3).optional(),
+  why: z4.string().min(1).max(2e3).optional(),
+  trackNote: z4.string().max(2e3).optional()
+});
+var TextItemSchema = z4.object({ text: z4.string().min(1).max(2e3) });
+var RecordSummarySchema = z4.object({ summary: z4.string().min(1).max(2e3) });
+var CheckAddSchema = z4.object({ item: z4.string().min(1).max(2e3), passed: z4.boolean().optional() });
+var CheckPatchSchema = z4.object({ passed: z4.boolean() });
+var ArtifactAddSchema = z4.object({
+  type: z4.enum(ARTIFACT_TYPES),
+  path: z4.string().min(1).max(2e3),
+  note: z4.string().max(2e3).optional(),
+  /** 全文快照（CLI --file 读文件后传入；≤200k——续跑会话凭 context 自足） */
+  content: z4.string().max(2e5).optional()
+});
+var ConfirmAddSchema = z4.object({ quote: z4.string().min(1).max(2e3) });
+var DecisionAddSchema = z4.object({
+  topic: z4.string().min(1).max(2e3),
+  decision: z4.string().min(1).max(2e3)
+});
+var ReviewSetSchema = z4.object({
+  verdict: z4.enum(["pass", "fail"]),
+  rounds: z4.number().int().min(1),
+  critical: z4.number().int().min(0)
+});
+function normalizeTaskDoc(doc) {
+  if (!doc) return null;
+  return { ...doc, acceptance: doc.acceptance ?? [], nonGoals: doc.nonGoals ?? [] };
+}
+function normalizeNodeRecords(records) {
+  const src = records ?? {};
+  const out = {};
+  for (const [nodeId, record] of Object.entries(src)) {
+    if (!record) continue;
+    out[nodeId] = {
+      ...record,
+      checks: record.checks ?? [],
+      artifacts: record.artifacts ?? [],
+      confirmations: record.confirmations ?? [],
+      decisions: record.decisions ?? []
+    };
+  }
+  return out;
+}
+function createTaskRoutes(client) {
+  const app = new Hono8();
+  const repo = createTaskRepo(client.db());
+  const templateRepo = createDagTemplateRepo2(client.db());
+  const projectRepo = createProjectRepo5(client.db());
+  const enumRegistryRepo = createEnumRegistryRepo2(client.db());
+  app.get("/api/tasks", zValidator6("query", TaskListQuerySchema), async (c) => {
+    const q = c.req.valid("query");
+    const { items, total } = await repo.listTasks({
+      ...q.status ? { status: q.status } : {},
+      ...q.track ? { track: q.track } : {},
+      ...q.projectId ? { projectId: q.projectId } : {},
+      page: q.page,
+      limit: q.limit,
+      ...q.sort ? { sort: q.sort } : {}
+    });
+    return c.json({ items, total, page: q.page, limit: q.limit });
+  });
+  app.get("/api/tasks/:taskId", async (c) => {
+    const taskId = c.req.param("taskId");
+    const task = await repo.getByTaskId(taskId);
+    if (!task) throw new NotFoundError6("task", taskId);
+    return c.json(task);
+  });
+  app.post("/api/tasks", zValidator6("json", TaskCreateInputSchema), async (c) => {
+    const input = c.req.valid("json");
+    const dagTracks = (await enumRegistryRepo.getEntries("dag_track")).filter(
+      (e) => e.active && e.value !== "all"
+    );
+    if (!dagTracks.some((e) => e.value === input.track)) {
+      const validValues = dagTracks.map((e) => e.value).join(", ");
+      throw new BadRequestError2(
+        `track '${input.track}' is not a valid active dag_track value. Valid values: ${validValues}`
+      );
+    }
+    assertTypeTrackCompatible(input.type, input.track);
+    const template = await templateRepo.getById(input.dagTemplateId);
+    if (!template) throw new NotFoundError6("dag-template", input.dagTemplateId);
+    if (input.projectId && input.projectId !== template.projectId) {
+      throw new ConflictError6("task", input.dagTemplateId, {
+        bizCode: "TEMPLATE_PROJECT_MISMATCH",
+        message: BIZ_CODE_MESSAGES6.TEMPLATE_PROJECT_MISMATCH
+      });
+    }
+    const resolvedProjectId = input.projectId ?? template.projectId;
+    await loadProjectForWrite(projectRepo, resolvedProjectId);
+    return c.json(await repo.createTask(input, template, resolvedProjectId), 201);
+  });
+  app.patch("/api/tasks/:taskId", zValidator6("json", TaskPatchSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    await assertTaskProjectActive(repo, projectRepo, taskId);
+    const patch = {
+      ...body.title !== void 0 ? { title: body.title } : {}
+    };
+    return c.json(await repo.updateTask(taskId, patch));
+  });
+  app.post("/api/tasks/:taskId/advance", zValidator6("json", AdvanceRequestSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    await assertTaskProjectActive(repo, projectRepo, taskId);
+    const deps = mkDeps(repo);
+    const result = await advanceTask(deps, taskId, {
+      ...body.note !== void 0 ? { note: body.note } : {},
+      ...body.summary !== void 0 ? { summary: body.summary } : {}
+    });
+    return c.json(result, 200);
+  });
+  app.post("/api/tasks/:taskId/approve", zValidator6("json", ApproveRequestSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    await assertTaskProjectActive(repo, projectRepo, taskId);
+    const deps = mkDeps(repo);
+    const result = await approveTask(deps, taskId, body);
+    return c.json(result, 200);
+  });
+  app.post("/api/tasks/:taskId/pause", zValidator6("json", PauseRequestSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    await assertTaskProjectActive(repo, projectRepo, taskId);
+    const result = await pauseTask(mkDeps(repo), taskId, body.reason);
+    return c.json(result, 200);
+  });
+  app.post("/api/tasks/:taskId/resume", zValidator6("json", ResumeRequestSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    await assertTaskProjectActive(repo, projectRepo, taskId);
+    const result = await resumeTask(mkDeps(repo), taskId, body.decision);
+    return c.json(result, 200);
+  });
+  app.get("/api/tasks/:taskId/history", async (c) => {
+    const taskId = c.req.param("taskId");
+    const task = await repo.getByTaskId(taskId);
+    if (!task) throw new NotFoundError6("task", taskId);
+    return c.json(task.history);
+  });
+  app.get("/api/tasks/:taskId/node/:nodeId", async (c) => {
+    const taskId = c.req.param("taskId");
+    const nodeId = c.req.param("nodeId");
+    const task = await repo.getByTaskId(taskId);
+    if (!task) throw new NotFoundError6("task", taskId);
+    const node = task.dagInstance.nodes.find((n) => n.id === nodeId);
+    if (!node) throw new NotFoundError6("node", nodeId);
+    return c.json({ ...node, prompt: renderPrompt(node.prompt, task) });
+  });
+  app.get("/api/tasks/:taskId/context", async (c) => {
+    const taskId = c.req.param("taskId");
+    const task = await repo.getByTaskId(taskId);
+    if (!task) throw new NotFoundError6("task", taskId);
+    const currentNodeActive = task.status === "active" ? task.dagInstance.nodes.find((n) => n.id === task.currentNode) : void 0;
+    let pausedAtEdge = null;
+    if (task.status === "paused" && task.pausedAt !== null) {
+      const edge = findNextEdge(task.dagInstance.edges, task.dagInstance.nodes, task.pausedAt, task.track);
+      if (edge?.pausePoint) {
+        pausedAtEdge = { from: edge.from, to: edge.to, pausePoint: edge.pausePoint };
+      }
+    }
+    const context = {
+      task: toTaskPublic(task),
+      currentNode: currentNodeActive ? {
+        ...toNodeInfo(currentNodeActive, task),
+        phase: currentNodeActive.phase
+      } : null,
+      pausedAtEdge,
+      nodes: task.dagInstance.nodes.map((n) => {
+        const state = task.dagInstance.nodeStates[n.id];
+        return {
+          nodeId: n.id,
+          label: n.label,
+          status: state?.status ?? "pending",
+          enteredAt: state?.enteredAt ?? null,
+          completedAt: state?.completedAt ?? null
+        };
+      }),
+      // N020 D1：结构化全景（断点续跑数据源）；?? 容错迁移前旧文档与小步写入的部分形态
+      // （toEntity 不跑 parse 补 default——点路径 $set/$push 只写触及字段，record/doc 内数组
+      // 可能缺键，读侧按字段归一到 schema 目标形状，Web/CLI 消费方拿到的恒为完整形）
+      taskDoc: normalizeTaskDoc(task.doc),
+      nodeRecords: normalizeNodeRecords(task.nodeRecords),
+      archNotes: task.archNotes ?? []
+    };
+    return c.json(context);
+  });
+  app.patch("/api/tasks/:taskId/doc", zValidator6("json", TaskDocSetSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    await loadTaskForRecordWrite(repo, projectRepo, taskId);
+    const sets = {};
+    if (body.what !== void 0) sets["doc.what"] = body.what;
+    if (body.why !== void 0) sets["doc.why"] = body.why;
+    if (body.trackNote !== void 0) sets["doc.trackNote"] = body.trackNote;
+    return c.json(await repo.updateTaskPaths(taskId, { sets }));
+  });
+  app.post("/api/tasks/:taskId/doc/acceptance", zValidator6("json", TextItemSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    await loadTaskForRecordWrite(repo, projectRepo, taskId);
+    return c.json(await repo.updateTaskPaths(taskId, { pushes: { "doc.acceptance": body.text } }));
+  });
+  app.post("/api/tasks/:taskId/doc/non-goal", zValidator6("json", TextItemSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    await loadTaskForRecordWrite(repo, projectRepo, taskId);
+    return c.json(await repo.updateTaskPaths(taskId, { pushes: { "doc.nonGoals": body.text } }));
+  });
+  app.patch("/api/tasks/:taskId/records/:nodeId/summary", zValidator6("json", RecordSummarySchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const nodeId = c.req.param("nodeId");
+    const body = c.req.valid("json");
+    await loadTaskForRecordWrite(repo, projectRepo, taskId, nodeId);
+    return c.json(await repo.updateTaskPaths(taskId, {
+      sets: { [`nodeRecords.${nodeId}.summary`]: body.summary }
+    }));
+  });
+  app.post("/api/tasks/:taskId/records/:nodeId/checks", zValidator6("json", CheckAddSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const nodeId = c.req.param("nodeId");
+    const body = c.req.valid("json");
+    const task = await loadTaskForRecordWrite(repo, projectRepo, taskId, nodeId);
+    const existing = (task.nodeRecords ?? {})[nodeId]?.checks ?? [];
+    const check = {
+      id: generateEntryId(existing.map((ch) => ch.id)),
+      item: body.item,
+      passed: body.passed ?? true
+    };
+    return c.json(await repo.updateTaskPaths(taskId, {
+      pushes: { [`nodeRecords.${nodeId}.checks`]: check }
+    }));
+  });
+  app.patch("/api/tasks/:taskId/records/:nodeId/checks/:checkId", zValidator6("json", CheckPatchSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const nodeId = c.req.param("nodeId");
+    const checkId = c.req.param("checkId");
+    const body = c.req.valid("json");
+    const task = await loadTaskForRecordWrite(repo, projectRepo, taskId, nodeId);
+    const check = ((task.nodeRecords ?? {})[nodeId]?.checks ?? []).find((ch) => ch.id === checkId);
+    if (!check) {
+      throw new NotFoundError6("check", checkId, {
+        bizCode: "CHECK_NOT_FOUND",
+        message: `${BIZ_CODE_MESSAGES6.CHECK_NOT_FOUND}\uFF08node ${nodeId}, check ${checkId}\uFF09`
+      });
+    }
+    return c.json(await repo.updateTaskPaths(taskId, {
+      sets: { [`nodeRecords.${nodeId}.checks.$[e].passed`]: body.passed },
+      arrayFilters: [{ "e.id": checkId }]
+    }));
+  });
+  app.post("/api/tasks/:taskId/records/:nodeId/artifacts", zValidator6("json", ArtifactAddSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const nodeId = c.req.param("nodeId");
+    const body = c.req.valid("json");
+    const task = await loadTaskForRecordWrite(repo, projectRepo, taskId, nodeId);
+    const artifact = {
+      id: generateEntryId(((task.nodeRecords ?? {})[nodeId]?.artifacts ?? []).map((a) => a.id)),
+      type: body.type,
+      path: body.path,
+      ...body.note !== void 0 ? { note: body.note } : {},
+      ...body.content !== void 0 ? { content: body.content } : {}
+    };
+    return c.json(await repo.updateTaskPaths(taskId, {
+      pushes: { [`nodeRecords.${nodeId}.artifacts`]: artifact }
+    }));
+  });
+  app.post("/api/tasks/:taskId/records/:nodeId/confirmations", zValidator6("json", ConfirmAddSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const nodeId = c.req.param("nodeId");
+    const body = c.req.valid("json");
+    const task = await loadTaskForRecordWrite(repo, projectRepo, taskId, nodeId);
+    const confirmation = {
+      id: generateEntryId(((task.nodeRecords ?? {})[nodeId]?.confirmations ?? []).map((cf) => cf.id)),
+      quote: body.quote,
+      at: /* @__PURE__ */ new Date()
+    };
+    return c.json(await repo.updateTaskPaths(taskId, {
+      pushes: { [`nodeRecords.${nodeId}.confirmations`]: confirmation }
+    }));
+  });
+  app.post("/api/tasks/:taskId/records/:nodeId/decisions", zValidator6("json", DecisionAddSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const nodeId = c.req.param("nodeId");
+    const body = c.req.valid("json");
+    const task = await loadTaskForRecordWrite(repo, projectRepo, taskId, nodeId);
+    const decision = {
+      id: generateEntryId(((task.nodeRecords ?? {})[nodeId]?.decisions ?? []).map((d) => d.id)),
+      topic: body.topic,
+      decision: body.decision
+    };
+    return c.json(await repo.updateTaskPaths(taskId, {
+      pushes: { [`nodeRecords.${nodeId}.decisions`]: decision }
+    }));
+  });
+  app.put("/api/tasks/:taskId/records/:nodeId/review", zValidator6("json", ReviewSetSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const nodeId = c.req.param("nodeId");
+    const body = c.req.valid("json");
+    await loadTaskForRecordWrite(repo, projectRepo, taskId, nodeId);
+    return c.json(await repo.updateTaskPaths(taskId, {
+      sets: { [`nodeRecords.${nodeId}.review`]: body }
+    }));
+  });
+  app.post("/api/tasks/:taskId/archnotes", zValidator6("json", TextItemSchema), async (c) => {
+    const taskId = c.req.param("taskId");
+    const body = c.req.valid("json");
+    const task = await loadTaskForRecordWrite(repo, projectRepo, taskId);
+    const note = { id: generateEntryId((task.archNotes ?? []).map((n) => n.id)), text: body.text, at: /* @__PURE__ */ new Date() };
+    return c.json(await repo.updateTaskPaths(taskId, { pushes: { archNotes: note } }));
+  });
+  return app;
+}
+function assertTypeTrackCompatible(type, track) {
+  const mismatch = (reason) => new ValidationError(
+    reason,
+    [{ code: "custom", path: ["type"], message: reason }],
+    { bizCode: "TASK_TYPE_TRACK_MISMATCH", message: reason }
+  );
+  if (track === "research") {
+    if (type !== "research") {
+      throw mismatch(`track=research \u4E3A\u8C03\u7814\u7C7B\u578B\u4E13\u7528\u8F68\u9053\u503C\uFF0C\u987B\u914D --type research\uFF08\u5F53\u524D type=${type ?? "\u672A\u6307\u5B9A"}\uFF09`);
+    }
+    return;
+  }
+  if (type === void 0) return;
+  if (type === "research") {
+    throw mismatch(`type=research \u987B\u914D track=research\uFF08\u5F53\u524D track=${track}\uFF09`);
+  }
+  if (type === "ui-tweak" && track !== "ui") {
+    throw mismatch(`UI \u5FAE\u8C03\uFF08ui-tweak\uFF09\u4EC5\u9002\u7528 ui \u8F68\u9053\uFF08\u5F53\u524D track=${track}\uFF09`);
+  }
+}
+function mkDeps(repo) {
+  return {
+    getTask: repo.getByTaskId.bind(repo),
+    updateTask: repo.updateTask.bind(repo)
+  };
+}
+async function assertTaskProjectActive(repo, projectRepo, taskId) {
+  const task = await repo.getByTaskId(taskId);
+  if (!task) throw new NotFoundError6("task", taskId);
+  await loadProjectForWrite(projectRepo, task.projectId);
+}
+async function loadTaskForRecordWrite(repo, projectRepo, taskId, nodeId) {
+  const task = await repo.getByTaskId(taskId);
+  if (!task) throw new NotFoundError6("task", taskId);
+  await loadProjectForWrite(projectRepo, task.projectId);
+  if (task.status === "completed" || task.status === "cancelled") {
+    throw new BadRequestError2(
+      `Task '${taskId}' is ${task.status} \u2014 task records are read-only after termination`,
+      void 0,
+      { bizCode: "TASK_TERMINATED", message: `${BIZ_CODE_MESSAGES6.TASK_TERMINATED}\uFF08status: ${task.status}\uFF09` }
+    );
+  }
+  if (nodeId === void 0) return task;
+  if (!NODE_ID_PATTERN.test(nodeId)) {
+    throw new BadRequestError2(`nodeId '${nodeId}' \u975E\u6CD5\uFF08\u53EA\u5141\u8BB8\u5B57\u6BCD/\u6570\u5B57/\u4E0B\u5212\u7EBF/\u8FDE\u5B57\u7B26\uFF09`, "nodeId");
+  }
+  const node = task.dagInstance.nodes.find((n) => n.id === nodeId);
+  if (!node) {
+    throw new NotFoundError6("node", nodeId, {
+      bizCode: "NODE_NOT_IN_INSTANCE",
+      message: `${BIZ_CODE_MESSAGES6.NODE_NOT_IN_INSTANCE}\uFF08nodeId: ${nodeId}\uFF09`
+    });
+  }
+  const state = task.dagInstance.nodeStates[nodeId];
+  if (state?.status !== "active" && state?.status !== "completed") {
+    throw new BadRequestError2(
+      `Node '${nodeId}' record is not writable (state '${state?.status ?? "pending"}') \u2014 flow has not reached this node`,
+      void 0,
+      {
+        bizCode: "NODE_RECORD_NOT_WRITABLE",
+        message: `${BIZ_CODE_MESSAGES6.NODE_RECORD_NOT_WRITABLE}\uFF08${nodeId}: ${state?.status ?? "pending"}\uFF09`
+      }
+    );
+  }
+  return task;
+}
+
+// src/routes/settings.routes.ts
+import { Hono as Hono9 } from "hono";
+import { zValidator as zValidator7 } from "@hono/zod-validator";
+import { z as z5 } from "zod";
+import {
+  createEnumRegistryRepo as createEnumRegistryRepo3,
+  EnumRegistryUpdateSchema,
+  NotFoundError as NotFoundError7
+} from "@siming-org/core";
+function createSettingsRoutes(client) {
+  const app = new Hono9();
+  const repo = createEnumRegistryRepo3(client.db());
+  app.get("/api/settings/enums", async (c) => {
+    return c.json(await repo.listRegistries());
+  });
+  app.get(
+    "/api/settings/enums/:category",
+    zValidator7("param", z5.object({ category: z5.string() })),
+    async (c) => {
+      const { category } = c.req.valid("param");
+      const registry = await repo.getRegistry(category);
+      if (!registry) throw new NotFoundError7("enum-registry", category);
+      return c.json(registry);
+    }
+  );
+  app.put(
+    "/api/settings/enums/:category",
+    zValidator7("param", z5.object({ category: z5.string() })),
+    zValidator7("json", EnumRegistryUpdateSchema),
+    async (c) => {
+      const { category } = c.req.valid("param");
+      const data = c.req.valid("json");
+      const registry = await repo.updateRegistry(category, data);
+      if (!registry) throw new NotFoundError7("enum-registry", category);
+      return c.json(registry);
+    }
+  );
+  app.delete(
+    "/api/settings/enums/:category/entries/:value",
+    zValidator7("param", z5.object({ category: z5.string(), value: z5.string().min(1) })),
+    async (c) => {
+      const { category, value } = c.req.valid("param");
+      const deleted = await repo.deleteEntry(category, value);
+      if (!deleted) throw new NotFoundError7("enum-registry", category);
+      return c.body(null, 204);
+    }
+  );
+  return app;
+}
+
+// src/routes/index.ts
+function createRoutes(client) {
+  const router = new Hono10();
+  router.route("/", createHealth(client));
+  router.route("/", createProjectRoutes(client));
+  router.route("/", createSkillRoutes(client));
+  router.route("/", createAgentRoutes(client));
+  router.route("/", createModelAliasRoutes(client));
+  router.route("/", createDagTemplateRoutes(client));
+  router.route("/", createTaskRoutes(client));
+  router.route("/", createSettingsRoutes(client));
+  return router;
+}
+
+// src/app.ts
+function createApp(client, opts = {}) {
+  const app = new Hono11();
+  setupErrorHandler(app);
+  app.route("/", createRoutes(client));
+  const webRoot = opts.webRoot !== void 0 ? opts.webRoot : resolveWebDistRoot();
+  app.route("/", createStaticRoutes(webRoot));
+  return app;
+}
+
+// src/start-server.ts
+import { serve } from "@hono/node-server";
+import { createMongoClient } from "@siming-org/core";
+
+// src/ensure-collections.ts
+import { EnumRegistrySchema } from "@siming-org/core";
+async function ensureCollections(client) {
+  const db = client.db();
+  await Promise.all([
+    ensureProjectCollection(db),
+    ensureSkillCollection(db),
+    ensureAgentCollection(db),
+    ensureDagTemplateCollection(db),
+    ensureTaskCollection(db),
+    ensureModelAliasCollection(db),
+    ensureEnumRegistryCollection(db)
+  ]);
+  await migrateProjectSentinelData(db);
+  await migrateGateRemovalData(db);
+  await migrateTaskRecordData(db);
+  await migrateDagTrackTaskValues(db);
+  await ensurePostMigrationIndexes(db);
+}
+var ENUM_REGISTRY_SEEDS = {
+  dag_phase: [
+    { value: "entry", label: "\u5165\u53E3", builtin: false },
+    { value: "track", label: "\u8F68\u9053", builtin: false },
+    { value: "test", label: "\u6D4B\u8BD5", builtin: false },
+    { value: "exit", label: "\u51FA\u53E3", builtin: false }
+  ],
+  dag_track: [
+    { value: "backend", label: "\u540E\u7AEF", builtin: true },
+    { value: "ui", label: "\u524D\u7AEF", builtin: true },
+    { value: "all", label: "\u5168\u90E8", builtin: true },
+    // T202608240003：任务级轨道专用值（非节点 track 值）——mixed=双链串行、research=调研任务；
+    // 存量库 doc 已存在（seed 类缺失才插入），由 M11 迁移合并（缺 M11 会测试绿+生产 400）
+    { value: "mixed", label: "\u6DF7\u5408\uFF08\u524D\u540E\u7AEF\uFF09", builtin: true },
+    { value: "research", label: "\u8C03\u7814\uFF08\u5185\u90E8\u503C\uFF0C\u968F\u7C7B\u578B\u81EA\u52A8\u8BBE\u7F6E\uFF09", builtin: true }
+  ],
+  pause_type: [
+    { value: "human_approval", label: "\u4EBA\u5DE5\u5BA1\u6279", builtin: false },
+    { value: "checkpoint", label: "\u68C0\u67E5\u70B9", builtin: false }
+  ],
+  task_status: [
+    { value: "active", label: "\u8FDB\u884C\u4E2D", builtin: true },
+    { value: "paused", label: "\u6682\u505C", builtin: true },
+    { value: "completed", label: "\u5DF2\u5B8C\u6210", builtin: true },
+    { value: "cancelled", label: "\u5DF2\u53D6\u6D88", builtin: true }
+  ],
+  node_status: [
+    { value: "pending", label: "\u5F85\u6267\u884C", builtin: true },
+    { value: "active", label: "\u8FDB\u884C\u4E2D", builtin: true },
+    { value: "completed", label: "\u5DF2\u5B8C\u6210", builtin: true },
+    { value: "skipped", label: "\u5DF2\u8DF3\u8FC7", builtin: true }
+  ],
+  skill_category: [
+    { value: "process", label: "\u6D41\u7A0B", builtin: false },
+    { value: "domain", label: "\u9886\u57DF", builtin: false },
+    { value: "tooling", label: "\u5DE5\u5177", builtin: false }
+  ],
+  scope: [
+    { value: "global", label: "\u5168\u5C40", builtin: true },
+    { value: "project", label: "\u9879\u76EE", builtin: true }
+  ]
+};
+function buildSeedEntries(seeds) {
+  return seeds.map((s, i) => ({
+    value: s.value,
+    label: s.label,
+    builtin: s.builtin,
+    order: i,
+    active: true,
+    ...s.color ? { color: s.color } : {}
+  }));
+}
+async function ensureEnumRegistryCollection(db) {
+  const collections = await db.listCollections({ name: "enum_registry" }).toArray();
+  if (collections.length === 0) {
+    await db.createCollection("enum_registry");
+  }
+  await db.collection("enum_registry").createIndex({ category: 1 }, { unique: true });
+  const coll = db.collection("enum_registry");
+  for (const [category, seeds] of Object.entries(ENUM_REGISTRY_SEEDS)) {
+    const existing = await coll.findOne({ category });
+    if (!existing) {
+      const doc = {
+        category,
+        entries: buildSeedEntries(seeds),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await coll.insertOne(doc);
+    }
+  }
+}
+async function ensureModelAliasCollection(db) {
+  const validator = { $jsonSchema: {
+    bsonType: "object",
+    required: ["code", "name", "realModel"],
+    properties: {
+      code: { bsonType: "string", pattern: "^[a-z0-9]+(-[a-z0-9]+)*$" },
+      name: { bsonType: "string" },
+      realModel: { bsonType: "string" },
+      createdAt: { bsonType: "date" },
+      updatedAt: { bsonType: "date" }
+    }
+  } };
+  const collections = await db.listCollections({ name: "model_aliases" }).toArray();
+  if (collections.length === 0) {
+    await db.createCollection("model_aliases", { validator });
+  }
+  await db.collection("model_aliases").createIndex({ code: 1 }, { unique: true });
+}
+async function ensureProjectCollection(db) {
+  const collections = await db.listCollections({ name: "projects" }).toArray();
+  if (collections.length === 0) {
+    await db.createCollection("projects", { validator: projectValidator() });
+  }
+  await db.collection("projects").createIndex({ key: 1 }, { unique: true });
+  await db.collection("projects").createIndex({ name: 1 }, { unique: true });
+  await db.collection("projects").createIndex({ status: 1 });
+}
+function projectValidator() {
+  return { $jsonSchema: {
+    bsonType: "object",
+    required: ["key", "name", "status"],
+    properties: {
+      key: { bsonType: "string", pattern: "^[a-z0-9][a-z0-9-]{1,30}$" },
+      name: { bsonType: "string" },
+      description: { bsonType: "string" },
+      status: { enum: ["active", "archived"] },
+      createdAt: { bsonType: "date" },
+      updatedAt: { bsonType: "date" }
+    }
+  } };
+}
+async function ensureSkillCollection(db) {
+  const validator = { $jsonSchema: {
+    bsonType: "object",
+    required: ["name", "description", "content", "category", "scope"],
+    properties: {
+      // name 不设 pattern：create 侧 kebab 由应用层 Zod 把守（SkillCreateSchema），DB 层放宽以允许
+      // validator 部署前的 CJK 存量记录被更新（否则 findOneAndUpdate 触发 code 121 拒绝合法编辑，N013 SKILL_EDIT_008）
+      name: { bsonType: "string", minLength: 1 },
+      description: { bsonType: "string" },
+      content: { bsonType: "string" },
+      // N016 F9：category 放宽为任意字符串（枚举注册表为运行时权威，DB 只做类型兜底）
+      category: { bsonType: "string" },
+      // N012 F7：作用域字段（全局 / 项目专用）；projectId 仅 scope=project 携带
+      scope: { enum: ["global", "project"] },
+      projectId: { bsonType: "string" },
+      version: { bsonType: "string" },
+      createdAt: { bsonType: "date" },
+      updatedAt: { bsonType: "date" }
+    }
+  } };
+  const collections = await db.listCollections({ name: "skills" }).toArray();
+  if (collections.length === 0) {
+    await db.createCollection("skills", { validator });
+  } else {
+    await db.command({ collMod: "skills", validationLevel: "strict", validator });
+  }
+  await db.collection("skills").createIndex({ scope: 1, projectId: 1 });
+}
+async function ensureAgentCollection(db) {
+  const validator = { $jsonSchema: {
+    bsonType: "object",
+    required: ["name", "description", "systemPrompt", "model", "scope"],
+    properties: {
+      name: { bsonType: "string" },
+      description: { bsonType: "string" },
+      systemPrompt: { bsonType: "string" },
+      boundSkills: { bsonType: "array", items: { bsonType: "string" } },
+      model: { bsonType: "string" },
+      // N015：agent 资产版本（F13 版本对比）；存量回填走 M6 迁移
+      version: { bsonType: "string" },
+      tools: { bsonType: "array", items: { bsonType: "string" } },
+      permissions: { bsonType: "array", items: { bsonType: "string" } },
+      scope: { enum: ["global", "project"] },
+      projectId: { bsonType: "string" },
+      createdAt: { bsonType: "date" },
+      updatedAt: { bsonType: "date" }
+    }
+  } };
+  const collections = await db.listCollections({ name: "agents" }).toArray();
+  if (collections.length === 0) {
+    await db.createCollection("agents", { validator });
+  } else {
+    await db.command({ collMod: "agents", validationLevel: "strict", validator });
+  }
+  await db.collection("agents").createIndex({ scope: 1, projectId: 1 });
+}
+async function ensureDagTemplateCollection(db) {
+  const validator = { $jsonSchema: {
+    bsonType: "object",
+    // N017 F8：pausePoints 顶层字段退役（暂停点内联 edges.pausePoint）
+    required: ["name", "projectId", "description", "nodes", "edges", "isDefault", "version"],
+    properties: {
+      name: { bsonType: "string" },
+      projectId: { bsonType: "string" },
+      description: { bsonType: "string" },
+      nodes: { bsonType: "array" },
+      edges: { bsonType: "array" },
+      isDefault: { bsonType: "bool" },
+      version: { bsonType: "string" },
+      createdAt: { bsonType: "date" },
+      updatedAt: { bsonType: "date" }
+    }
+  } };
+  const collections = await db.listCollections({ name: "dag_templates" }).toArray();
+  if (collections.length === 0) {
+    await db.createCollection("dag_templates", { validator });
+  } else {
+    await db.command({ collMod: "dag_templates", validationLevel: "strict", validator });
+  }
+  await db.collection("dag_templates").createIndex({ projectId: 1 });
+  await db.collection("dag_templates").createIndex({ isDefault: 1 });
+}
+async function ensureTaskCollection(db) {
+  const validator = { $jsonSchema: {
+    bsonType: "object",
+    required: ["taskId", "title", "projectId", "dagTemplateId", "dagInstance", "currentNode", "currentPhase", "status", "track", "history"],
+    properties: {
+      taskId: { bsonType: "string" },
+      title: { bsonType: "string" },
+      projectId: { bsonType: "string" },
+      dagTemplateId: { bsonType: "string" },
+      dagInstance: { bsonType: "object" },
+      currentNode: { bsonType: "string" },
+      // N016 F06：枚举放宽（D3 注册表权威）——currentPhase/status 不再 DB 枚举硬限，由注册表/应用层把守
+      currentPhase: { bsonType: "string" },
+      status: { bsonType: "string" },
+      pausedAt: { bsonType: ["string", "null"] },
+      track: { bsonType: "string" },
+      // T202608240003：任务类型标签（可选，类型兜底——取值域归应用层 z.enum）
+      type: { bsonType: "string" },
+      // N020 D1：任务信息结构化三字段（可选——存量任务未迁移前缺省合法，M10 补齐）
+      doc: { bsonType: "object" },
+      nodeRecords: { bsonType: "object" },
+      archNotes: { bsonType: "array" },
+      history: { bsonType: "array" },
+      createdAt: { bsonType: "date" },
+      updatedAt: { bsonType: "date" }
+    }
+  } };
+  const collections = await db.listCollections({ name: "tasks" }).toArray();
+  if (collections.length === 0) {
+    await db.createCollection("tasks", { validator });
+  } else {
+    await db.command({ collMod: "tasks", validationLevel: "strict", validator });
+  }
+  await db.collection("tasks").createIndex({ taskId: 1 }, { unique: true });
+  await db.collection("tasks").createIndex({ status: 1 });
+  await db.collection("tasks").createIndex({ track: 1 });
+}
+async function migrateProjectSentinelData(db) {
+  const projects = db.collection("projects");
+  let defaultProject = await projects.findOne({ key: "default" });
+  if (!defaultProject) {
+    const now = /* @__PURE__ */ new Date();
+    await projects.insertOne({
+      key: "default",
+      name: "\u9ED8\u8BA4\u9879\u76EE",
+      description: "\u7CFB\u7EDF\u5185\u7F6E\u9879\u76EE\uFF08\u5B58\u91CF\u8D44\u4EA7\u4E0E\u672A\u6307\u5B9A\u5F52\u5C5E\u8D44\u4EA7\u7684\u843D\u70B9\uFF0C\u4E0D\u53EF\u505C\u7528\uFF09",
+      status: "active",
+      createdAt: now,
+      updatedAt: now
+    });
+    defaultProject = await projects.findOne({ key: "default" });
+  }
+  if (!defaultProject) {
+    throw new Error("N012 M1 \u8FC1\u79FB\u5931\u8D25\uFF1A\u9ED8\u8BA4\u9879\u76EE seed \u540E\u4ECD\u65E0\u6CD5\u8BFB\u53D6");
+  }
+  const defaultProjectId = defaultProject._id.toString();
+  await db.collection("tasks").updateMany({ projectId: "default" }, { $set: { projectId: defaultProjectId } }, { bypassDocumentValidation: true });
+  await db.collection("dag_templates").updateMany({ projectId: "default" }, { $set: { projectId: defaultProjectId } }, { bypassDocumentValidation: true });
+  await db.collection("skills").updateMany({ scope: { $exists: false } }, { $set: { scope: "global" } });
+  await db.collection("agents").updateMany({ scope: { $exists: false } }, { $set: { scope: "global" } });
+  await db.collection("agents").updateMany({ version: { $exists: false } }, { $set: { version: "1.0.0" } });
+}
+async function migrateGateRemovalData(db) {
+  await db.collection("enum_registry").deleteOne({ category: "gate_type" });
+  const legacyTemplates = await db.collection("dag_templates").find(
+    { $or: [{ "nodes.gates": { $exists: true } }, { pausePoints: { $exists: true } }] },
+    { projection: { name: 1 } }
+  ).toArray();
+  if (legacyTemplates.length > 0) {
+    console.log(`[siming] N017 M8\uFF1A\u5220\u9664\u65E7\u7ED3\u6784 DAG \u6A21\u677F ${legacyTemplates.length} \u4E2A\uFF08\u91CD\u5BFC\u65B0 YAML\uFF09\uFF1A${legacyTemplates.map((t) => `${t.name}(${t._id})`).join(", ")}`);
+    await db.collection("dag_templates").deleteMany({
+      _id: { $in: legacyTemplates.map((t) => t._id) }
+    });
+  }
+  const legacyTasks = await db.collection("tasks").find(
+    { "dagInstance.pausePoints": { $exists: true } },
+    { projection: { taskId: 1 } }
+  ).toArray();
+  if (legacyTasks.length > 0) {
+    console.log(`[siming] N017 M9\uFF1A\u5220\u9664\u65E7\u7ED3\u6784\u4EFB\u52A1 ${legacyTasks.length} \u4E2A\uFF1A${legacyTasks.map((t) => t.taskId).join(", ")}`);
+    await db.collection("tasks").deleteMany({
+      _id: { $in: legacyTasks.map((t) => t._id) }
+    });
+  }
+}
+async function migrateTaskRecordData(db) {
+  await db.collection("tasks").updateMany(
+    { nodeRecords: { $exists: false } },
+    { $set: { nodeRecords: {} } },
+    { bypassDocumentValidation: true }
+  );
+  await db.collection("tasks").updateMany(
+    { archNotes: { $exists: false } },
+    { $set: { archNotes: [] } },
+    { bypassDocumentValidation: true }
+  );
+}
+async function migrateDagTrackTaskValues(db) {
+  const coll = db.collection("enum_registry");
+  const doc = await coll.findOne({ category: "dag_track" });
+  if (!doc) return;
+  const parsed = EnumRegistrySchema.safeParse({ category: "dag_track", ...doc, entries: doc.entries ?? [] });
+  if (!parsed.success) {
+    throw new Error(`T202608240003 M11 \u8FC1\u79FB\u5931\u8D25\uFF1A\u5B58\u91CF dag_track entries \u5F62\u72B6\u975E\u6CD5\uFF08${JSON.stringify(parsed.error.issues[0]?.message)}\uFF09`);
+  }
+  const entries = parsed.data.entries;
+  const existingValues = new Set(entries.map((e) => e.value));
+  const maxOrder = entries.reduce((max, e) => Math.max(max, e.order), -1);
+  const additions = ENUM_REGISTRY_SEEDS.dag_track.filter((s) => !existingValues.has(s.value)).map((s, i) => ({
+    value: s.value,
+    label: s.label,
+    builtin: s.builtin,
+    order: maxOrder + 1 + i,
+    active: true
+  }));
+  if (additions.length === 0) return;
+  const result = await coll.updateOne(
+    { _id: doc._id },
+    { $set: { entries: [...entries, ...additions], updatedAt: /* @__PURE__ */ new Date() } }
+  );
+  if (result.matchedCount === 0) {
+    throw new Error("T202608240003 M11 \u8FC1\u79FB\u5931\u8D25\uFF1Adag_track doc \u66F4\u65B0\u672A\u547D\u4E2D\uFF08\u542F\u52A8\u671F\u4E0D\u5E94\u53D1\u751F\uFF09");
+  }
+}
+async function ensurePostMigrationIndexes(db) {
+  const tasks = db.collection("tasks");
+  const taskIndexes = await tasks.listIndexes().toArray();
+  const legacySingle = taskIndexes.find(
+    (idx) => idx.name === "projectId_1" && Object.keys(idx.key).length === 1
+  );
+  if (legacySingle) {
+    await tasks.dropIndex("projectId_1");
+  }
+  await tasks.createIndex({ projectId: 1, status: 1 });
+  const templates = db.collection("dag_templates");
+  const seen = /* @__PURE__ */ new Map();
+  const docs = await templates.find({}, { projection: { projectId: 1, name: 1 } }).toArray();
+  for (const doc of docs) {
+    const key = `${String(doc.projectId)}\0${String(doc.name)}`;
+    const ids = seen.get(key) ?? [];
+    ids.push(doc._id.toString());
+    seen.set(key, ids);
+  }
+  const conflicts = [...seen.entries()].filter(([, ids]) => ids.length > 1);
+  if (conflicts.length > 0) {
+    const detail = conflicts.map(([key, ids]) => {
+      const [projectId, name] = key.split("\0");
+      return `projectId=${projectId} name="${name}" \xD7${ids.length} (_id: ${ids.join(", ")})`;
+    }).join("; ");
+    throw new Error(`dag_templates \u5B58\u5728\u540C\u9879\u76EE\u91CD\u540D\u6A21\u677F\uFF0C\u65E0\u6CD5\u5EFA\u7ACB (projectId,name) \u552F\u4E00\u7D22\u5F15\uFF0C\u8BF7\u5148\u4EBA\u5DE5\u5F52\u5E76\uFF1A${detail}`);
+  }
+  await templates.createIndex({ projectId: 1, name: 1 }, { unique: true });
+  await db.collection("agents").createIndex({ model: 1 });
+  await migrateNameUniquenessIndexes(db);
+}
+async function migrateNameUniquenessIndexes(db) {
+  const assertNoProjectNameConflict = async (collectionName) => {
+    const coll = db.collection(collectionName);
+    const seen = /* @__PURE__ */ new Map();
+    const docs = await coll.find({ scope: "project" }, { projection: { projectId: 1, name: 1 } }).toArray();
+    for (const doc of docs) {
+      const key = `${String(doc.projectId)}\0${String(doc.name)}`;
+      const ids = seen.get(key) ?? [];
+      ids.push(doc._id.toString());
+      seen.set(key, ids);
+    }
+    const conflicts = [...seen.entries()].filter(([, ids]) => ids.length > 1);
+    if (conflicts.length > 0) {
+      const detail = conflicts.map(([key, ids]) => {
+        const [projectId, name] = key.split("\0");
+        return `projectId=${projectId} name="${name}" \xD7${ids.length} (_id: ${ids.join(", ")})`;
+      }).join("; ");
+      throw new Error(`${collectionName} \u5B58\u5728\u540C\u9879\u76EE\u91CD\u540D\u8D44\u4EA7\uFF0C\u65E0\u6CD5\u5EFA\u7ACB (projectId,name) \u552F\u4E00\u7D22\u5F15\uFF0C\u8BF7\u5148\u4EBA\u5DE5\u5F52\u5E76\uFF1A${detail}`);
+    }
+  };
+  for (const name of ["skills", "agents"]) {
+    const coll = db.collection(name);
+    const indexes = await coll.listIndexes().toArray();
+    const legacyNameUnique = indexes.find(
+      (idx) => idx.name === "name_1" && idx.unique === true && Object.keys(idx.key).length === 1 && // N016 F04：partial 索引名也是 name_1，必须排除（否则每次启动误判 legacy → drop+重建 churn）
+      idx.partialFilterExpression === void 0
+    );
+    if (legacyNameUnique) {
+      await coll.dropIndex("name_1");
+    }
+    await assertNoProjectNameConflict(name);
+    await coll.createIndex(
+      { name: 1 },
+      { unique: true, partialFilterExpression: { scope: "global" } }
+    );
+    await coll.createIndex(
+      { projectId: 1, name: 1 },
+      { unique: true, partialFilterExpression: { scope: "project" } }
+    );
+  }
+}
+
+// src/start-server.ts
+var MONGO_PROBE_TIMEOUT_MS = 5e3;
+async function startServer(config) {
+  const client = await createMongoClient(config.mongoUri, {
+    serverSelectionTimeoutMS: MONGO_PROBE_TIMEOUT_MS
+  });
+  await ensureCollections(client);
+  const webRoot = resolveWebDistRoot();
+  const app = createApp(client, { webRoot });
+  let port = config.port;
+  const server = serve({ fetch: app.fetch, hostname: config.host, port: config.port }, (info) => {
+    port = info.port;
+    console.log(`[siming] server listening on http://${info.address}:${info.port}`);
+  });
+  console.log(webRoot === null ? "[siming] web ui not built \u2014 static disabled (API only)" : `[siming] web ui root: ${webRoot}`);
+  console.log(`[siming] config: port=${config.port} host=${config.host} logLevel=${config.logLevel}`);
+  const stop = async () => {
+    console.log("[siming] shutting down...");
+    server.close();
+    await client.close();
+  };
+  return { server, client, host: config.host, port, stop };
+}
+
+export {
+  resolveWebDistRoot,
+  createStaticRoutes,
+  createApp,
+  MONGO_PROBE_TIMEOUT_MS,
+  startServer
+};