@siming-org/core 0.3.0

package/dist/index.js

@@ -0,0 +1,2096 @@
+// src/index.ts
+import { readFileSync } from "fs";
+import { z as z11 } from "zod";
+
+// src/store/client.ts
+import { MongoClient } from "mongodb";
+var DEFAULT_OPTIONS = {
+  retryWrites: true
+};
+function dbFromUri(uri) {
+  const match = uri.match(/\/\/[^/]+\/([^?]+)/);
+  return match?.[1];
+}
+async function createMongoClient(uri = "mongodb://localhost:27017", options = {}) {
+  const client = new MongoClient(uri, { ...DEFAULT_OPTIONS, ...options });
+  await client.connect();
+  await client.db().command({ ping: 1 });
+  const defaultDb = dbFromUri(uri) ?? "siming";
+  return {
+    db: (name) => client.db(name ?? defaultDb),
+    close: () => client.close(),
+    _underlying: client
+  };
+}
+async function withTransaction(client, fn) {
+  const session = client._underlying.startSession();
+  try {
+    session.startTransaction();
+    const result = await fn(session);
+    await session.commitTransaction();
+    return result;
+  } catch (err) {
+    if (session.inTransaction()) {
+      await session.abortTransaction();
+    }
+    throw err;
+  } finally {
+    session.endSession();
+  }
+}
+
+// src/store/repos/base.ts
+import { ObjectId } from "mongodb";
+function toEntity(doc) {
+  const { _id, ...rest } = doc;
+  return { ...rest, id: _id.toString() };
+}
+function createRepo(collection, options = {}) {
+  const { nameField } = options;
+  return {
+    async list(filter = {}) {
+      const docs = await collection.find(filter).toArray();
+      return docs.map((doc) => toEntity(doc));
+    },
+    async getById(id) {
+      if (!ObjectId.isValid(id)) return null;
+      const doc = await collection.findOne({ _id: new ObjectId(id) });
+      return doc ? toEntity(doc) : null;
+    },
+    async getByName(name) {
+      if (!nameField) return null;
+      const doc = await collection.findOne({ [nameField]: name });
+      return doc ? toEntity(doc) : null;
+    },
+    async create(data) {
+      const now = /* @__PURE__ */ new Date();
+      const result = await collection.insertOne({ ...data, createdAt: now, updatedAt: now });
+      return { ...data, createdAt: now, updatedAt: now, id: result.insertedId.toString() };
+    },
+    async update(id, patch) {
+      if (!ObjectId.isValid(id)) return null;
+      const now = /* @__PURE__ */ new Date();
+      const result = await collection.findOneAndUpdate(
+        { _id: new ObjectId(id) },
+        { $set: { ...patch, updatedAt: now } },
+        { returnDocument: "after" }
+      );
+      return result ? toEntity(result) : null;
+    },
+    async delete(id) {
+      if (!ObjectId.isValid(id)) return false;
+      const result = await collection.deleteOne({ _id: new ObjectId(id) });
+      return result.deletedCount > 0;
+    },
+    /** Raw collection access for entity-specific queries */
+    get _collection() {
+      return collection;
+    }
+  };
+}
+
+// src/errors.ts
+var BIZ_CODE_MESSAGES = {
+  PROJECT_ARCHIVED: "\u9879\u76EE\u5DF2\u505C\u7528\uFF0C\u65E0\u6CD5\u6267\u884C\u8BE5\u64CD\u4F5C",
+  TEMPLATE_PROJECT_MISMATCH: "\u6A21\u677F\u5F52\u5C5E\u4E8E\u5176\u4ED6\u9879\u76EE\uFF0C\u65E0\u6CD5\u7528\u4E8E\u8BE5\u9879\u76EE",
+  TEMPLATE_PROJECT_IMMUTABLE: "\u6A21\u677F\u5F52\u5C5E\u9879\u76EE\u521B\u5EFA\u540E\u4E0D\u53EF\u53D8\u66F4",
+  SCOPE_IMMUTABLE: "\u4F5C\u7528\u57DF\u521B\u5EFA\u540E\u4E0D\u53EF\u53D8\u66F4",
+  TASK_PROJECT_IMMUTABLE: "\u4EFB\u52A1\u5F52\u5C5E\u9879\u76EE\u521B\u5EFA\u540E\u4E0D\u53EF\u53D8\u66F4",
+  DEFAULT_PROJECT_IMMUTABLE: "\u9ED8\u8BA4\u9879\u76EE\u4E0D\u53EF\u505C\u7528",
+  TEMPLATE_NAME_CONFLICT: "\u76EE\u6807\u9879\u76EE\u5185\u5DF2\u5B58\u5728\u540C\u540D\u6A21\u677F",
+  // 仅覆盖 404 分支（不存在）；archived 走独立的 409 PROJECT_ARCHIVED，勿在此合并语义
+  PROJECT_NOT_FOUND: "\u9879\u76EE\u4E0D\u5B58\u5728",
+  AGENT_SKILL_SCOPE_CONFLICT: "Agent \u7ED1\u5B9A\u7684 Skill \u4F5C\u7528\u57DF\u4E0D\u517C\u5BB9\uFF08\u5168\u5C40 Agent \u4EC5\u53EF\u7ED1\u5B9A\u5168\u5C40 Skill\uFF09",
+  MODEL_CODE_EXISTS: "\u6A21\u578B code \u5DF2\u5B58\u5728",
+  MODEL_CODE_IMMUTABLE: "\u6A21\u578B code \u521B\u5EFA\u540E\u4E0D\u53EF\u53D8",
+  MODEL_ALIAS_IN_USE: "\u6A21\u578B\u6620\u5C04\u88AB Agent \u5F15\u7528\uFF0C\u7981\u6B62\u5220\u9664",
+  ENUM_ENTRY_BUILTIN: "\u5185\u7F6E\u679A\u4E3E\u503C\u7981\u6B62\u5220\u9664\u6216\u4FEE\u6539",
+  ENUM_ENTRY_IN_USE: "\u679A\u4E3E\u503C\u88AB\u8D44\u6E90\u5F15\u7528\uFF0C\u7981\u6B62\u5220\u9664",
+  ENUM_VALUE_CONFLICT: "\u679A\u4E3E\u503C\u5DF2\u5B58\u5728",
+  NAME_SCOPE_CONFLICT: "\u8BE5\u4F5C\u7528\u57DF\u5185\u5DF2\u5B58\u5728\u540C\u540D\u8D44\u6E90\uFF08\u5168\u5C40\u8D44\u6E90\u4E0E\u9879\u76EE\u8D44\u6E90\u4E0D\u53EF\u540C\u540D\uFF09",
+  TASK_DOC_NOT_SET: "\u4EFB\u52A1\u672A\u5173\u8054\u4EFB\u52A1\u6587\u4EF6",
+  TASK_DOC_NOT_FOUND: "\u4EFB\u52A1\u6587\u4EF6\u4E0D\u5B58\u5728",
+  TASK_DOC_SECTION_NOT_FOUND: "\u4EFB\u52A1\u6587\u4EF6\u4E2D\u672A\u627E\u5230\u5339\u914D\u6BB5\u843D",
+  TASK_AT_PAUSE_POINT: "\u4EFB\u52A1\u6682\u505C\u4E8E\u5BA1\u6279\u70B9\uFF0C\u9700\u5148\u5B8C\u6210\u5BA1\u6279",
+  TASK_NOT_AT_PAUSE_POINT: "\u4EFB\u52A1\u4E0D\u5728\u5BA1\u6279\u70B9\uFF0C\u65E0\u9700\u5BA1\u6279",
+  // N020 D1：记录写端点错误码（路由层校验前置顺序 ①-⑥ 对应）
+  NODE_NOT_IN_INSTANCE: "\u8282\u70B9\u4E0D\u5728\u4EFB\u52A1 DAG \u5B9E\u4F8B\u4E2D\uFF08\u5148 task context \u67E5\u8282\u70B9\u6E05\u5355\uFF09",
+  CHECK_NOT_FOUND: "\u5B8C\u6210\u5224\u5B9A\u6761\u76EE\u4E0D\u5B58\u5728\uFF08id \u5931\u6548\u6216\u5DF2\u88AB\u8986\u76D6\uFF0C\u91CD\u65B0 task context \u67E5\u770B\u6761\u76EE\uFF09",
+  NODE_RECORD_NOT_WRITABLE: "\u8282\u70B9\u8BB0\u5F55\u4E0D\u53EF\u5199\uFF08\u8282\u70B9\u672A\u6FC0\u6D3B/\u5DF2\u8DF3\u8FC7\u2014\u2014\u6D41\u7A0B\u672A\u63A8\u8FDB\u5230\u8BE5\u8282\u70B9\uFF09",
+  TASK_TERMINATED: "\u4EFB\u52A1\u5DF2\u5B8C\u7ED3\uFF08completed/cancelled\uFF09\uFF0C\u7981\u6B62\u5199\u5165",
+  // T202608240003：类型化任务节点路径（创建时剪枝 + 类型×轨道入口校验）
+  TASK_PRUNE_GRAPH_INVALID: "\u526A\u679D\u540E DAG \u56FE\u4E0D\u5B8C\u6574\uFF08\u8282\u70B9\u6E05\u5355\u4E0E\u6A21\u677F\u7ED3\u6784\u4E0D\u517C\u5BB9\uFF0C\u89C1\u9519\u8BEF\u8BE6\u60C5\uFF09",
+  TASK_SKIP_NODE_NOT_FOUND: "skip \u6E05\u5355\u542B\u6A21\u677F\u4E0D\u5B58\u5728\u7684\u8282\u70B9 id\uFF08\u89C1\u9519\u8BEF\u8BE6\u60C5\u7684\u5408\u6CD5\u8282\u70B9\u6E05\u5355\uFF09",
+  TASK_TYPE_TRACK_MISMATCH: "\u4EFB\u52A1\u7C7B\u578B\u4E0E\u8F68\u9053\u7EC4\u5408\u975E\u6CD5\uFF08research \u8F68\u9053\u4E3A\u8C03\u7814\u7C7B\u578B\u4E13\u7528\u503C\uFF1BUI \u5FAE\u8C03\u4EC5\u9002\u7528 ui \u8F68\u9053\uFF09"
+};
+var AppError = class extends Error {
+};
+var NotFoundError = class extends AppError {
+  constructor(resource, id, options) {
+    super(options?.message ?? `${resource} not found: ${id}`);
+    this.resource = resource;
+    this.id = id;
+    this.name = "NotFoundError";
+    if (options?.bizCode) {
+      this.bizCode = options.bizCode;
+    }
+  }
+  resource;
+  id;
+  statusCode = 404;
+  code = "not_found";
+  bizCode;
+  toResponse() {
+    return { error: this.bizCode ?? this.code, message: this.message, resource: this.resource, id: this.id };
+  }
+};
+var BadRequestError = class extends AppError {
+  constructor(message, field, options) {
+    super(options?.message ?? message);
+    this.field = field;
+    this.name = "BadRequestError";
+    if (options?.bizCode) {
+      this.bizCode = options.bizCode;
+    }
+  }
+  field;
+  statusCode = 400;
+  code = "bad_request";
+  bizCode;
+  toResponse() {
+    return { error: this.bizCode ?? this.code, message: this.message, ...this.field ? { field: this.field } : {} };
+  }
+};
+var ConflictError = class extends AppError {
+  constructor(resource, id, options) {
+    super(options?.message ?? `${resource} conflict: ${id}`);
+    this.resource = resource;
+    this.id = id;
+    this.name = "ConflictError";
+    if (options?.bizCode) {
+      this.bizCode = options.bizCode;
+    }
+  }
+  resource;
+  id;
+  statusCode = 409;
+  code = "conflict";
+  bizCode;
+  toResponse() {
+    return { error: this.bizCode ?? this.code, message: this.message, resource: this.resource, id: this.id };
+  }
+};
+var ValidationError = class extends AppError {
+  constructor(message, issues, options) {
+    super(options?.message ?? message);
+    this.issues = issues;
+    this.name = "ValidationError";
+    if (options?.bizCode) {
+      this.bizCode = options.bizCode;
+    }
+  }
+  issues;
+  statusCode = 422;
+  code = "validation_error";
+  bizCode;
+  toResponse() {
+    return { error: this.bizCode ?? this.code, message: this.message, issues: this.issues };
+  }
+};
+
+// src/store/repos/skill.repo.ts
+function createSkillRepo(db) {
+  const base = createRepo(db.collection("skills"), { nameField: "name" });
+  return {
+    ...base,
+    async createSkill(data) {
+      await assertNameScopeAvailable(base._collection, data.name, data.scope, data.projectId);
+      return base.create(data);
+    },
+    async updateByName(name, patch) {
+      const skill = await base.getByName(name);
+      if (!skill || !skill.id) return null;
+      return base.update(skill.id, patch);
+    },
+    async deleteByName(name) {
+      const skill = await base.getByName(name);
+      if (!skill || !skill.id) return false;
+      return base.delete(skill.id);
+    },
+    async updateByNameScoped(name, scope, projectId, patch) {
+      const skill = await this.getByNameScoped(name, scope, projectId);
+      if (!skill || !skill.id) return null;
+      return base.update(skill.id, patch);
+    },
+    async deleteByNameScoped(name, scope, projectId) {
+      const skill = await this.getByNameScoped(name, scope, projectId);
+      if (!skill || !skill.id) return false;
+      return base.delete(skill.id);
+    },
+    async getByNameScoped(name, scope, projectId) {
+      const doc = await base._collection.findOne(
+        scope === "project" ? { name, scope: "project", projectId } : { name, scope: "global" }
+      );
+      return doc ? toEntity(doc) : null;
+    },
+    async listSkillsByScope(projectId) {
+      return base.list({ $or: [{ scope: "global" }, { scope: "project", projectId }] });
+    },
+    async listSkillsByScopeFilter(scope, projectId) {
+      return base.list(scope === "project" ? { scope: "project", projectId } : { scope: "global" });
+    },
+    async listSkillsByNames(names, scope, projectId) {
+      if (names.length === 0) return /* @__PURE__ */ new Map();
+      const filter = scope === void 0 ? { name: { $in: names } } : scope === "project" ? { name: { $in: names }, $or: [{ scope: "global" }, { scope: "project", projectId }] } : { name: { $in: names }, scope: "global" };
+      const skills = await base.list(filter);
+      return new Map(skills.map((s) => [s.name, s]));
+    },
+    async copySkill(sourceName, source, target, newName) {
+      const src = await base._collection.findOne(
+        source.scope === "project" ? { name: sourceName, scope: "project", projectId: source.projectId } : { name: sourceName, scope: "global" }
+      );
+      if (!src) {
+        throw new ConflictError("skill", `copy source not found: ${sourceName}`);
+      }
+      const sourceEntity = toEntity(src);
+      const sameScopeDup = await base._collection.findOne(
+        target.scope === "project" ? { name: newName, scope: "project", projectId: target.projectId } : { name: newName, scope: "global" },
+        { projection: { _id: 1 } }
+      );
+      if (sameScopeDup) {
+        throw new ConflictError("skill", `name already exists: ${newName}`);
+      }
+      await assertNameScopeAvailable(base._collection, newName, target.scope, target.projectId);
+      const { id: _sourceId, createdAt: _ca, updatedAt: _ua, projectId: _sourceProjectId, scope: _sourceScope, ...rest } = sourceEntity;
+      const copy = {
+        ...JSON.parse(JSON.stringify(rest)),
+        name: newName,
+        scope: target.scope,
+        version: "1.0.0",
+        ...target.scope === "project" && target.projectId ? { projectId: target.projectId } : {}
+      };
+      return base.create(copy);
+    }
+  };
+}
+async function assertNameScopeAvailable(collection, name, scope, projectId) {
+  const clash = await collection.findOne(scope === "global" ? { name, scope: "project" } : { name, scope: "global" });
+  if (clash) {
+    throw new ConflictError("skill", name, {
+      bizCode: "NAME_SCOPE_CONFLICT",
+      message: BIZ_CODE_MESSAGES.NAME_SCOPE_CONFLICT
+    });
+  }
+}
+
+// src/store/repos/agent.repo.ts
+function createAgentRepo(db) {
+  const base = createRepo(db.collection("agents"), { nameField: "name" });
+  return {
+    ...base,
+    async createAgent(data) {
+      await assertNameScopeAvailable2(base._collection, data.name, data.scope, data.projectId);
+      return base.create(data);
+    },
+    async updateByName(name, patch) {
+      const agent = await base.getByName(name);
+      if (!agent || !agent.id) return null;
+      return base.update(agent.id, patch);
+    },
+    async deleteByName(name) {
+      const agent = await base.getByName(name);
+      if (!agent || !agent.id) return false;
+      return base.delete(agent.id);
+    },
+    async updateByNameScoped(name, scope, projectId, patch) {
+      const agent = await this.getByNameScoped(name, scope, projectId);
+      if (!agent || !agent.id) return null;
+      return base.update(agent.id, patch);
+    },
+    async deleteByNameScoped(name, scope, projectId) {
+      const agent = await this.getByNameScoped(name, scope, projectId);
+      if (!agent || !agent.id) return false;
+      return base.delete(agent.id);
+    },
+    async getByNameScoped(name, scope, projectId) {
+      const doc = await base._collection.findOne(
+        scope === "project" ? { name, scope: "project", projectId } : { name, scope: "global" }
+      );
+      return doc ? toEntity(doc) : null;
+    },
+    async listAgentsByScope(projectId) {
+      return base.list({ $or: [{ scope: "global" }, { scope: "project", projectId }] });
+    },
+    async listAgentsByScopeFilter(scope, projectId) {
+      return base.list(scope === "project" ? { scope: "project", projectId } : { scope: "global" });
+    },
+    async copyAgent(sourceName, source, target, newName, skillRepo) {
+      const src = await base._collection.findOne(
+        source.scope === "project" ? { name: sourceName, scope: "project", projectId: source.projectId } : { name: sourceName, scope: "global" }
+      );
+      if (!src) {
+        throw new ConflictError("agent", `copy source not found: ${sourceName}`);
+      }
+      const sourceEntity = toEntity(src);
+      const sameScopeDup = await base._collection.findOne(
+        target.scope === "project" ? { name: newName, scope: "project", projectId: target.projectId } : { name: newName, scope: "global" },
+        { projection: { _id: 1 } }
+      );
+      if (sameScopeDup) {
+        throw new ConflictError("agent", `name already exists: ${newName}`);
+      }
+      await assertNameScopeAvailable2(base._collection, newName, target.scope, target.projectId);
+      await assertBoundSkillsCompatible(skillRepo, target.scope, target.projectId, src.boundSkills ?? []);
+      const { id: _sourceId, createdAt: _ca, updatedAt: _ua, projectId: _sourceProjectId, scope: _sourceScope, ...rest } = sourceEntity;
+      const copy = {
+        ...JSON.parse(JSON.stringify(rest)),
+        name: newName,
+        scope: target.scope,
+        version: "1.0.0",
+        ...target.scope === "project" && target.projectId ? { projectId: target.projectId } : {}
+      };
+      return base.create(copy);
+    }
+  };
+}
+async function assertNameScopeAvailable2(collection, name, scope, projectId) {
+  const clash = await collection.findOne(scope === "global" ? { name, scope: "project" } : { name, scope: "global" });
+  if (clash) {
+    throw new ConflictError("agent", name, {
+      bizCode: "NAME_SCOPE_CONFLICT",
+      message: BIZ_CODE_MESSAGES.NAME_SCOPE_CONFLICT
+    });
+  }
+}
+async function assertBoundSkillsCompatible(skillRepo, agentScope, agentProjectId, boundSkills) {
+  if (boundSkills.length === 0) return;
+  const all = await skillRepo.listSkillsByNames(boundSkills);
+  for (const name of boundSkills) {
+    const skill = all.get(name);
+    if (!skill) {
+      throw new BadRequestError(`boundSkill not found: ${name}`, "boundSkills");
+    }
+    const compatible = skill.scope === "global" || agentScope === "project" && skill.scope === "project" && skill.projectId === agentProjectId;
+    if (!compatible) {
+      throw new ConflictError("agent", name, {
+        bizCode: "AGENT_SKILL_SCOPE_CONFLICT",
+        message: BIZ_CODE_MESSAGES.AGENT_SKILL_SCOPE_CONFLICT
+      });
+    }
+  }
+}
+
+// src/store/repos/dag-template.repo.ts
+function createDagTemplateRepo(db) {
+  const base = createRepo(db.collection("dag_templates"));
+  return {
+    ...base,
+    createDagTemplate(data) {
+      return base.create(data);
+    },
+    async listDagTemplates(filter) {
+      const query = {};
+      if (filter?.projectId) query.projectId = filter.projectId;
+      if (filter?.name) query.name = filter.name;
+      return base.list(query);
+    },
+    async copyDagTemplate(sourceId, targetProjectId, newName) {
+      const source = await base.getById(sourceId);
+      if (!source) {
+        throw new ConflictError("dagTemplate", `copy source not found: ${sourceId}`);
+      }
+      const dup = await base._collection.findOne(
+        { projectId: targetProjectId, name: newName },
+        { projection: { _id: 1 } }
+      );
+      if (dup) {
+        throw new ConflictError("dagTemplate", `name conflict in target project: ${newName}`);
+      }
+      const { id: _sourceId, createdAt: _ca, updatedAt: _ua, ...rest } = source;
+      const copy = {
+        ...rest,
+        name: newName,
+        projectId: targetProjectId,
+        isDefault: false,
+        version: "1.0.0"
+      };
+      return base.create(copy);
+    }
+  };
+}
+
+// src/schemas/task.ts
+import { z as z3 } from "zod";
+
+// src/schemas/skill.ts
+import { z } from "zod";
+var SkillScopeSchema = z.enum(["global", "project"]);
+var OBJECT_ID_HEX = /^[a-f0-9]{24}$/;
+var SkillScopeRefine = (val, ctx) => {
+  if (val.scope === "project" && !val.projectId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["projectId"],
+      message: "scope=project \u65F6 projectId \u5FC5\u586B"
+    });
+  }
+};
+var SkillShapeSchema = z.object({
+  id: z.string().optional(),
+  name: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "kebab-case only"),
+  description: z.string(),
+  content: z.string(),
+  category: z.string(),
+  version: z.string().default("1.0.0"),
+  /** 作用域：global=跨项目复用（默认，仅作存量迁移读侧兜底）/ project=项目专用（N012 D3） */
+  scope: SkillScopeSchema.default("global"),
+  /** 仅 scope=project 时必填且为合法 ObjectId hex（superRefine 保证） */
+  projectId: z.string().regex(OBJECT_ID_HEX, "projectId must be a valid ObjectId hex").optional(),
+  createdAt: z.date().optional(),
+  updatedAt: z.date().optional()
+});
+var SkillSchema = SkillShapeSchema.superRefine(SkillScopeRefine);
+var SkillCreateSchema = SkillShapeSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({ scope: SkillScopeSchema }).superRefine(SkillScopeRefine);
+var SkillUpdateSchema = SkillShapeSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
+  version: z.string().optional(),
+  scope: SkillScopeSchema.optional()
+}).partial().superRefine(SkillScopeRefine);
+var SkillCopySchema = z.object({
+  newName: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "kebab-case only"),
+  newScope: SkillScopeSchema,
+  targetProjectId: z.string().regex(OBJECT_ID_HEX, "projectId must be a valid ObjectId hex").optional()
+}).superRefine((val, ctx) => {
+  if (val.newScope === "project" && !val.targetProjectId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["targetProjectId"],
+      message: "newScope=project \u65F6 targetProjectId \u5FC5\u586B"
+    });
+  }
+});
+
+// src/schemas/dag-template.ts
+import { z as z2 } from "zod";
+var DagNodePhaseSchema = z2.string();
+var DagNodeTrackSchema = z2.string();
+var DAG_PHASES = ["entry", "track", "test", "exit"];
+var DAG_TRACKS = ["backend", "ui", "all"];
+var NODE_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+var DagNodeSchema = z2.object({
+  id: z2.string().regex(NODE_ID_PATTERN, "node id \u53EA\u5141\u8BB8\u5B57\u6BCD/\u6570\u5B57/\u4E0B\u5212\u7EBF/\u8FDE\u5B57\u7B26\uFF08\u70B9\u8DEF\u5F84\u62FC\u63A5\u5B89\u5168\u524D\u63D0\uFF09"),
+  label: z2.string(),
+  phase: DagNodePhaseSchema,
+  track: DagNodeTrackSchema,
+  prompt: z2.string(),
+  skills: z2.array(z2.string()).default([])
+});
+var PausePointTypeSchema = z2.enum(["human_approval", "checkpoint"]);
+var PAUSE_POINT_TYPES = ["human_approval", "checkpoint"];
+var EdgePausePointBaseSchema = z2.object({
+  type: PausePointTypeSchema,
+  description: z2.string(),
+  autoResume: z2.boolean().default(false)
+});
+var EdgePausePointSchema = EdgePausePointBaseSchema.superRefine((pp, ctx) => {
+  if (pp.type === "human_approval" && pp.autoResume) {
+    ctx.addIssue({
+      code: "custom",
+      message: "edge pausePoint \u7EC4\u5408\u975E\u6CD5\uFF1Ahuman_approval \u5FC5\u987B autoResume=false\uFF08\u4EBA\u5DE5\u5BA1\u6279\u5FC5\u987B\u505C\u7559\u7B49\u4EBA\u51B3\u7B56\uFF09"
+    });
+  }
+  if (pp.type === "checkpoint" && !pp.autoResume) {
+    ctx.addIssue({
+      code: "custom",
+      message: "edge pausePoint \u7EC4\u5408\u975E\u6CD5\uFF1Acheckpoint \u5FC5\u987B autoResume=true\uFF08\u68C0\u67E5\u70B9\u4EC5\u8BB0\u5F55\u4E0D\u505C\u7559\uFF0C\u5199\u6B7B\u5728\u7EC4\u5408\u7EA6\u675F\u91CC\uFF09"
+    });
+  }
+});
+var DagEdgeSchema = z2.object({
+  from: z2.string(),
+  to: z2.string(),
+  condition: z2.string().optional(),
+  /** N017 D1：边暂停点（可选）。human_approval=人工审批门（advance 落 paused 等 approve）；checkpoint=检查点（仅记录直接流转） */
+  pausePoint: EdgePausePointSchema.optional()
+});
+var DagTemplateSchema = z2.object({
+  id: z2.string().optional(),
+  name: z2.string(),
+  /** 归属项目 id（N012：实体层去哨兵 default，由路由层解析写入——校验项目存在且 active 后落库） */
+  projectId: z2.string(),
+  description: z2.string(),
+  nodes: z2.array(DagNodeSchema),
+  edges: z2.array(DagEdgeSchema),
+  /** UI 布局坐标（nodeId → {x,y}）。UI 关注点，advance 引擎零感知；旧模板无此字段 → 前端 dagre 兜底布局（N008 D2） */
+  layout: z2.record(z2.string(), z2.object({ x: z2.number(), y: z2.number() })).optional(),
+  isDefault: z2.boolean().default(false),
+  version: z2.string().default("1.0.0"),
+  createdAt: z2.date().optional(),
+  updatedAt: z2.date().optional()
+});
+var DagTemplateCreateSchema = DagTemplateSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+});
+var DagTemplateUpdateSchema = DagTemplateCreateSchema.extend({
+  isDefault: z2.boolean().optional(),
+  version: z2.string().optional()
+}).partial();
+var DagTemplateCopySchema = z2.object({
+  newName: z2.string().min(1),
+  targetProjectId: z2.string().regex(OBJECT_ID_HEX, "projectId must be a valid ObjectId hex")
+});
+
+// src/schemas/task.ts
+var TASK_TYPES = ["feature", "bugfix", "ui-tweak", "research"];
+var ENTRY_ID_REGEX = /^[a-z0-9]{6}$/;
+var CheckItemSchema = z3.object({
+  id: z3.string().regex(ENTRY_ID_REGEX),
+  item: z3.string().min(1),
+  passed: z3.boolean()
+});
+var ARTIFACT_TYPES = ["prd", "tech", "code", "test", "doc", "other"];
+var ArtifactSchema = z3.object({
+  id: z3.string().regex(ENTRY_ID_REGEX),
+  type: z3.enum(ARTIFACT_TYPES),
+  path: z3.string().min(1),
+  note: z3.string().optional(),
+  content: z3.string().max(2e5).optional()
+});
+var ConfirmationSchema = z3.object({
+  id: z3.string().regex(ENTRY_ID_REGEX),
+  quote: z3.string().min(1).max(2e3),
+  at: z3.date()
+});
+var DecisionSchema = z3.object({
+  id: z3.string().regex(ENTRY_ID_REGEX),
+  topic: z3.string().min(1),
+  decision: z3.string().min(1)
+});
+var ReviewSummarySchema = z3.object({
+  verdict: z3.enum(["pass", "fail"]),
+  rounds: z3.number().int().min(1),
+  critical: z3.number().int().min(0)
+});
+var NodeRecordSchema = z3.object({
+  summary: z3.string().optional(),
+  checks: z3.array(CheckItemSchema).default([]),
+  artifacts: z3.array(ArtifactSchema).default([]),
+  confirmations: z3.array(ConfirmationSchema).default([]),
+  decisions: z3.array(DecisionSchema).default([]),
+  review: ReviewSummarySchema.optional()
+});
+var TaskDocContentSchema = z3.object({
+  what: z3.string().min(1),
+  why: z3.string().min(1),
+  acceptance: z3.array(z3.string()).default([]),
+  nonGoals: z3.array(z3.string()).default([]),
+  trackNote: z3.string().optional()
+});
+var ArchNoteSchema = z3.object({
+  id: z3.string().regex(ENTRY_ID_REGEX),
+  text: z3.string().min(1).max(2e3),
+  at: z3.date()
+});
+var NodeStatusSchema = z3.string();
+var NODE_STATUSES = ["pending", "active", "completed", "skipped"];
+var NodeStateSchema = z3.object({
+  status: NodeStatusSchema,
+  enteredAt: z3.date().nullable().default(null),
+  completedAt: z3.date().nullable().default(null)
+});
+var DagInstanceSchema = z3.object({
+  templateId: z3.string(),
+  templateVersion: z3.string(),
+  nodes: z3.array(z3.object({
+    id: z3.string(),
+    label: z3.string(),
+    // N016 F9：枚举放宽（注册表权威）
+    phase: z3.string(),
+    track: z3.string(),
+    prompt: z3.string(),
+    skills: z3.array(z3.string()).default([])
+  })),
+  // N017 D1：暂停点内联到边（human_approval=审批门 / checkpoint=检查点），顶层数组删除
+  edges: z3.array(z3.object({
+    from: z3.string(),
+    to: z3.string(),
+    condition: z3.string().optional(),
+    pausePoint: EdgePausePointBaseSchema.optional()
+  })),
+  prunedNodes: z3.array(z3.string()),
+  nodeStates: z3.record(z3.string(), NodeStateSchema)
+});
+var HistoryActionSchema = z3.enum(["entered", "advanced", "paused", "resumed", "approved", "rejected", "completed", "cancelled"]);
+var HistoryEntrySchema = z3.object({
+  nodeId: z3.string(),
+  action: HistoryActionSchema,
+  timestamp: z3.date().default(() => /* @__PURE__ */ new Date()),
+  details: z3.record(z3.string(), z3.unknown()).default({})
+});
+var TaskStatusSchema = z3.string();
+var TaskPhaseSchema = z3.string();
+var TASK_STATUSES = ["active", "paused", "completed", "cancelled"];
+var TASK_PHASES = ["entry", "track", "test", "exit"];
+var TaskSchema = z3.object({
+  id: z3.string().optional(),
+  taskId: z3.string(),
+  title: z3.string(),
+  /**
+   * 任务类型标签（T202608240003）：创建时确定、此后不可变（PATCH 白名单不含 type）。
+   * 入参与落库同源 enum——持久层防脏值，模板 PRD 调研变体判定依赖精确值。
+   */
+  type: z3.enum(TASK_TYPES).optional(),
+  /** 归属项目 id（N012：实体层去哨兵 default，由 repo 显式写入——路由层解析：显式携带校验一致性 / 缺省继承模板 projectId） */
+  projectId: z3.string(),
+  dagTemplateId: z3.string(),
+  dagInstance: DagInstanceSchema,
+  currentNode: z3.string(),
+  currentPhase: TaskPhaseSchema,
+  status: TaskStatusSchema,
+  /** 暂停位置：from 节点 id（暂停点暂停，approve 经 findNextEdge 重推导边）/ null（手动暂停） */
+  pausedAt: z3.string().nullable().default(null),
+  track: z3.string(),
+  /**
+   * N020 D1：任务级结构化文档（未写时字段缺省——语义即「未写」，不做 null 占位）。
+   * 写入口：PATCH /api/tasks/:id/doc（字段级 $set + acceptance/nonGoals 条目 $push）。
+   */
+  doc: TaskDocContentSchema.optional(),
+  /**
+   * N020 D1：节点级执行记录（nodeId → record）。$push 到不存在的嵌套路径时
+   * MongoDB 自动创建中间对象，故单条目字段可能先于容器整体存在——读侧对
+   * record 内数组字段按 `?? []` 容错（toEntity 不跑 parse 补 default）。
+   */
+  nodeRecords: z3.record(z3.string(), NodeRecordSchema).default({}),
+  /** N020 D1：跨节点累积素材（架构信息收集条目，服务端生成 id/at） */
+  archNotes: z3.array(ArchNoteSchema).default([]),
+  history: z3.array(HistoryEntrySchema).default([]),
+  createdAt: z3.date().optional(),
+  updatedAt: z3.date().optional()
+});
+var TaskCreateInputSchema = z3.object({
+  title: z3.string(),
+  track: z3.string(),
+  dagTemplateId: z3.string(),
+  /**
+   * T202608240003 创建时剪枝：显式剔除的节点 id（在轨道自动剔除之外）。
+   * 清单来源约束 = task-create skill 的类型×轨道映射矩阵（skip 只允许来自映射，禁止自由发挥）；
+   * 剪枝算法与图校验见 core/task/prune.ts。
+   */
+  skipNodes: z3.array(z3.string().regex(NODE_ID_PATTERN, "skipNodes \u6761\u76EE\u987B\u4E3A\u5408\u6CD5\u8282\u70B9 id")).optional(),
+  /** 任务类型标签（见 TASK_TYPES；与 track 的合法组合由 server 入口校验） */
+  type: z3.enum(TASK_TYPES).optional(),
+  /** 归属项目：可选（缺省 → 继承模板 projectId，D2；显式携带且 ≠ 模板 → 409 TEMPLATE_PROJECT_MISMATCH） */
+  projectId: z3.string().regex(OBJECT_ID_HEX, "projectId must be a valid ObjectId hex").optional()
+});
+
+// src/task/track-match.ts
+function trackMatchSet(taskTrack) {
+  if (taskTrack === "mixed") return /* @__PURE__ */ new Set(["backend", "ui", "all"]);
+  return /* @__PURE__ */ new Set([taskTrack, "all"]);
+}
+
+// src/task/prompt-renderer.ts
+function renderPrompt(template, task) {
+  return template.replaceAll("{{task.title}}", task.title).replaceAll("{{task.taskId}}", task.taskId).replaceAll("{{task.projectId}}", task.projectId).replaceAll("{{task.track}}", task.track).replaceAll("{{task.currentNode}}", task.currentNode);
+}
+
+// src/task/advance-engine.ts
+async function advanceTask(deps, taskId, input) {
+  const task = await deps.getTask(taskId);
+  if (!task) throw new NotFoundError("task", taskId);
+  if (task.status === "paused" && task.pausedAt !== null) {
+    throw new BadRequestError(
+      `Task is paused at a pause point (after node '${task.pausedAt}'). Use approve (POST /api/tasks/${taskId}/approve) with decision approved|rejected.`,
+      void 0,
+      { bizCode: "TASK_AT_PAUSE_POINT", message: `\u4EFB\u52A1\u6682\u505C\u4E8E\u5BA1\u6279\u70B9\uFF08${task.pausedAt} \u4E4B\u540E\uFF09\uFF0C\u9700\u5148\u8C03\u7528 approve \u5B8C\u6210\u5BA1\u6279` }
+    );
+  }
+  if (task.status !== "active") {
+    throw new BadRequestError(
+      `Task status is '${task.status}'. Use resume() for manually paused tasks.`
+    );
+  }
+  const currentNode = task.dagInstance.nodes.find((n) => n.id === task.currentNode);
+  if (!currentNode) throw new NotFoundError("node", task.currentNode);
+  const now = /* @__PURE__ */ new Date();
+  const existingState = task.dagInstance.nodeStates[currentNode.id];
+  const completedState = {
+    status: "completed",
+    enteredAt: existingState?.enteredAt ?? now,
+    completedAt: now
+  };
+  const noteDetails = input?.note ? { note: input.note } : {};
+  const wantsSummary = input?.summary !== void 0;
+  if (wantsSummary && !NODE_ID_PATTERN.test(currentNode.id)) {
+    throw new BadRequestError(
+      `node id '${currentNode.id}' \u542B\u975E\u6CD5\u5B57\u7B26\uFF0Csummary \u70B9\u8DEF\u5F84\u5199\u5165\u4E0D\u5B89\u5168\uFF08\u6A21\u677F\u5C42 pattern \u5E94\u5DF2\u62E6\u622A\u2014\u2014\u5B9E\u4F8B\u6570\u636E\u5F02\u5E38\uFF09`
+    );
+  }
+  const summaryPatch = wantsSummary ? { [`nodeRecords.${currentNode.id}.summary`]: input.summary } : {};
+  const nextEdge = findNextEdge(
+    task.dagInstance.edges,
+    task.dagInstance.nodes,
+    currentNode.id,
+    task.track
+  );
+  if (!nextEdge) {
+    if (checkTermination(task.dagInstance.nodes, task.dagInstance.edges, task.dagInstance.nodeStates, completedState, currentNode.id, task.track)) {
+      const patch2 = {
+        status: "completed",
+        ...summaryPatch,
+        history: [...task.history, mkHistory(currentNode.id, "completed", noteDetails)],
+        dagInstance: {
+          ...task.dagInstance,
+          nodeStates: {
+            ...task.dagInstance.nodeStates,
+            [currentNode.id]: completedState
+          }
+        }
+      };
+      const updated2 = await deps.updateTask(taskId, patch2, {
+        expectedStatus: task.status,
+        expectedCurrentNode: task.currentNode
+      });
+      return {
+        status: "completed",
+        task: toTaskPublic(updated2)
+      };
+    }
+    throw new BadRequestError("No next node found but not all terminal nodes are completed");
+  }
+  const pausePoint = nextEdge.pausePoint;
+  if (pausePoint && pausePoint.type === "human_approval" && !pausePoint.autoResume) {
+    const patch2 = {
+      status: "paused",
+      pausedAt: currentNode.id,
+      ...summaryPatch,
+      history: [
+        ...task.history,
+        mkHistory(currentNode.id, "completed", noteDetails),
+        mkHistory(currentNode.id, "paused", { pausePoint: pausePoint.description })
+      ],
+      dagInstance: {
+        ...task.dagInstance,
+        nodeStates: {
+          ...task.dagInstance.nodeStates,
+          [currentNode.id]: completedState
+        }
+      }
+    };
+    const updated2 = await deps.updateTask(taskId, patch2, {
+      expectedStatus: task.status,
+      expectedCurrentNode: task.currentNode
+    });
+    return {
+      status: "paused",
+      task: toTaskPublic(updated2),
+      pausePoint,
+      guidance: pausePoint.description
+    };
+  }
+  const nextNode = task.dagInstance.nodes.find((n) => n.id === nextEdge.to);
+  if (!nextNode) throw new NotFoundError("node", nextEdge.to);
+  const nextNodeState = {
+    status: "active",
+    enteredAt: now,
+    completedAt: null
+  };
+  const checkpointDetails = {
+    ...pausePoint ? { checkpoint: pausePoint.description, autoResume: true } : {},
+    ...noteDetails
+  };
+  const patch = {
+    currentNode: nextNode.id,
+    currentPhase: nextNode.phase,
+    status: "active",
+    pausedAt: null,
+    ...summaryPatch,
+    history: [
+      ...task.history,
+      mkHistory(currentNode.id, "completed", noteDetails),
+      mkHistory(nextNode.id, "advanced", checkpointDetails)
+    ],
+    dagInstance: {
+      ...task.dagInstance,
+      nodeStates: {
+        ...task.dagInstance.nodeStates,
+        [currentNode.id]: completedState,
+        [nextNode.id]: nextNodeState
+      }
+    }
+  };
+  const updated = await deps.updateTask(taskId, patch, {
+    expectedStatus: task.status,
+    expectedCurrentNode: task.currentNode
+  });
+  return {
+    status: "advanced",
+    task: toTaskPublic(updated),
+    nextNode: toNodeInfo(nextNode, updated)
+  };
+}
+async function approveTask(deps, taskId, request) {
+  const task = await deps.getTask(taskId);
+  if (!task) throw new NotFoundError("task", taskId);
+  if (task.status !== "paused" || task.pausedAt === null) {
+    throw new BadRequestError(
+      `Task is not paused at a pause point (status '${task.status}'). Use advance to complete the current node.`,
+      void 0,
+      { bizCode: "TASK_NOT_AT_PAUSE_POINT", message: `\u4EFB\u52A1\u4E0D\u5728\u5BA1\u6279\u70B9\uFF08status '${task.status}'\uFF09\uFF0C\u65E0\u9700\u5BA1\u6279\u2014\u2014\u7528 advance \u63A8\u8FDB\u5F53\u524D\u8282\u70B9` }
+    );
+  }
+  const pausedNodeId = task.pausedAt;
+  const nextEdge = findNextEdge(
+    task.dagInstance.edges,
+    task.dagInstance.nodes,
+    pausedNodeId,
+    task.track
+  );
+  if (!nextEdge) {
+    throw new Error(
+      `invariant violation: pause-point edge not found for node '${pausedNodeId}' (track '${task.track}') \u2014 task ${taskId}`
+    );
+  }
+  const commentDetails = request.comment ? { comment: request.comment } : {};
+  if (request.decision === "rejected") {
+    const patch2 = {
+      history: [...task.history, mkHistory(pausedNodeId, "rejected", commentDetails)]
+    };
+    const updated2 = await deps.updateTask(taskId, patch2, {
+      expectedStatus: task.status,
+      expectedCurrentNode: task.currentNode
+    });
+    return {
+      status: "rejected",
+      task: toTaskPublic(updated2),
+      guidance: "\u5BA1\u6279\u9A73\u56DE\uFF1A\u4EFB\u52A1\u4FDD\u6301\u6682\u505C\u3002\u5904\u7406\u9A73\u56DE\u610F\u89C1\u540E\u53EF\u518D\u6B21\u5BA1\u6279\uFF08approve approved\uFF09\u3002"
+    };
+  }
+  const nextNode = task.dagInstance.nodes.find((n) => n.id === nextEdge.to);
+  if (!nextNode) throw new NotFoundError("node", nextEdge.to);
+  const now = /* @__PURE__ */ new Date();
+  const nextNodeState = {
+    status: "active",
+    enteredAt: now,
+    completedAt: null
+  };
+  const patch = {
+    currentNode: nextNode.id,
+    currentPhase: nextNode.phase,
+    status: "active",
+    pausedAt: null,
+    history: [
+      ...task.history,
+      mkHistory(pausedNodeId, "approved", commentDetails),
+      mkHistory(nextNode.id, "advanced", {})
+    ],
+    dagInstance: {
+      ...task.dagInstance,
+      nodeStates: {
+        ...task.dagInstance.nodeStates,
+        [nextNode.id]: nextNodeState
+      }
+    }
+  };
+  const updated = await deps.updateTask(taskId, patch, {
+    expectedStatus: task.status,
+    expectedCurrentNode: task.currentNode
+  });
+  return {
+    status: "advanced",
+    task: toTaskPublic(updated),
+    nextNode: toNodeInfo(nextNode, updated)
+  };
+}
+async function pauseTask(deps, taskId, reason) {
+  const task = await deps.getTask(taskId);
+  if (!task) throw new NotFoundError("task", taskId);
+  if (task.status !== "active") {
+    throw new BadRequestError(`Cannot pause: task status is '${task.status}'`);
+  }
+  const patch = {
+    status: "paused",
+    pausedAt: null,
+    // null = manual pause (vs. nodeId = pause-point pause)
+    history: [...task.history, mkHistory(task.currentNode, "paused", { reason: reason ?? "manual" })]
+  };
+  return deps.updateTask(taskId, patch, {
+    expectedStatus: task.status,
+    expectedCurrentNode: task.currentNode
+  });
+}
+async function resumeTask(deps, taskId, decision) {
+  const task = await deps.getTask(taskId);
+  if (!task) throw new NotFoundError("task", taskId);
+  if (task.status !== "paused") {
+    throw new BadRequestError(`Cannot resume: task status is '${task.status}'`);
+  }
+  if (task.pausedAt !== null) {
+    throw new BadRequestError(
+      `Task is paused at a pause point (after node '${task.pausedAt}'). Use approve (POST /api/tasks/${taskId}/approve) instead.`
+    );
+  }
+  const patch = {
+    status: "active",
+    history: [...task.history, mkHistory(task.currentNode, "resumed", { decision: decision ?? "manual" })]
+  };
+  return deps.updateTask(taskId, patch, {
+    expectedStatus: task.status,
+    expectedCurrentNode: task.currentNode
+  });
+}
+function findNextEdge(edges, nodes, fromNodeId, track) {
+  const outEdges = edges.filter((e) => e.from === fromNodeId);
+  const matchSet = trackMatchSet(track);
+  const matching = outEdges.filter((e) => {
+    const target = nodes.find((n) => n.id === e.to);
+    if (!target) return false;
+    return matchSet.has(target.track);
+  });
+  if (matching.length > 1) {
+    const byTargetTrack = /* @__PURE__ */ new Map();
+    for (const edge of matching) {
+      const target = nodes.find((n) => n.id === edge.to);
+      const key = target?.track ?? "";
+      const group = byTargetTrack.get(key) ?? [];
+      group.push(edge);
+      byTargetTrack.set(key, group);
+    }
+    for (const [targetTrack, group] of byTargetTrack) {
+      if (group.length > 1) {
+        throw new BadRequestError(
+          `Multiple matching edges from node "${fromNodeId}" for track "${track}" \u2014 DAG template has a same-track fork (target track "${targetTrack}")`
+        );
+      }
+    }
+    const dedicated = matching.filter((e) => {
+      const target = nodes.find((n) => n.id === e.to);
+      return target?.track !== "all";
+    });
+    return dedicated[0] ?? matching[0];
+  }
+  return matching[0] ?? null;
+}
+function checkTermination(nodes, edges, nodeStates, upcomingCompletedState, upcomingCompletedNodeId, track) {
+  const matchSet = trackMatchSet(track);
+  const trackFilter = (n) => matchSet.has(n.track);
+  const terminalNodes = nodes.filter(
+    (n) => trackFilter(n) && !edges.some((e) => e.from === n.id)
+  );
+  return terminalNodes.every((n) => {
+    if (n.id === upcomingCompletedNodeId) {
+      return upcomingCompletedState.status === "completed" || upcomingCompletedState.status === "skipped";
+    }
+    const state = nodeStates[n.id];
+    return state?.status === "completed" || state?.status === "skipped";
+  });
+}
+function toTaskPublic(task) {
+  return {
+    taskId: task.taskId,
+    title: task.title,
+    // T202608240003：type 进 context/advance 公共投影（模板 PRD 调研变体判定依赖 context 可见）
+    ...task.type !== void 0 ? { type: task.type } : {},
+    currentNode: task.currentNode,
+    currentPhase: task.currentPhase,
+    status: task.status,
+    pausedAt: task.pausedAt,
+    track: task.track
+  };
+}
+function toNodeInfo(node, task) {
+  const nextEdge = findNextEdge(
+    task.dagInstance.edges,
+    task.dagInstance.nodes,
+    node.id,
+    task.track
+  );
+  return {
+    nodeId: node.id,
+    label: node.label,
+    track: node.track,
+    prompt: renderPrompt(node.prompt, task),
+    skills: node.skills,
+    upcomingPause: nextEdge?.pausePoint?.description ?? null
+  };
+}
+function mkHistory(nodeId, action, details) {
+  return { nodeId, action, timestamp: /* @__PURE__ */ new Date(), details };
+}
+
+// src/task/prune.ts
+function assertSkipNodesExist(template, skipNodeIds) {
+  const known = new Set(template.nodes.map((n) => n.id));
+  const unknown = skipNodeIds.filter((id) => !known.has(id));
+  if (unknown.length > 0) {
+    throw new BadRequestError(
+      `skipNodes \u542B\u6A21\u677F\u4E0D\u5B58\u5728\u7684\u8282\u70B9 id\uFF1A${unknown.join(", ")}\u3002\u6A21\u677F\u300C${template.name}\u300D\u5408\u6CD5\u8282\u70B9\uFF1A${[...known].join(", ")}`,
+      void 0,
+      { bizCode: "TASK_SKIP_NODE_NOT_FOUND" }
+    );
+  }
+}
+function graphInvalid(reason) {
+  throw new ValidationError(
+    `\u526A\u679D\u540E DAG \u56FE\u4E0D\u5B8C\u6574\uFF1A${reason}`,
+    [{ code: "custom", path: ["skipNodes"], message: reason }],
+    { bizCode: "TASK_PRUNE_GRAPH_INVALID", message: `\u526A\u679D\u540E DAG \u56FE\u4E0D\u5B8C\u6574\uFF08${reason}\uFF09\u2014\u2014\u68C0\u67E5 skip \u6E05\u5355\u4E0E\u6A21\u677F\u7ED3\u6784\u517C\u5BB9\u6027` }
+  );
+}
+function pruneInstance(template, taskTrack, skipNodeIds) {
+  if (skipNodeIds.length > 0) assertSkipNodesExist(template, skipNodeIds);
+  const skipSet = new Set(skipNodeIds);
+  const matchSet = trackMatchSet(taskTrack);
+  const keptNodes = template.nodes.filter((n) => !skipSet.has(n.id) && matchSet.has(n.track));
+  const prunedNodes = template.nodes.filter((n) => skipSet.has(n.id) || !matchSet.has(n.track)).map((n) => n.id);
+  const keptIds = new Set(keptNodes.map((n) => n.id));
+  const keptEdges = template.edges.filter((e) => keptIds.has(e.from) && keptIds.has(e.to));
+  const edges = keptEdges.map((e) => ({ ...e }));
+  const templateTerminalIds = new Set(
+    template.nodes.filter((n) => !template.edges.some((e) => e.from === n.id)).map((n) => n.id)
+  );
+  const outDegree = /* @__PURE__ */ new Map();
+  for (const e of edges) outDegree.set(e.from, (outDegree.get(e.from) ?? 0) + 1);
+  for (const node of keptNodes) {
+    if (outDegree.get(node.id) !== void 0) continue;
+    if (templateTerminalIds.has(node.id)) continue;
+    const nearestActive = findNearestActiveDescendant(template, node.id, keptIds);
+    if (!nearestActive) {
+      graphInvalid(`\u8282\u70B9\u300C${node.id}\u300D\u526A\u679D\u540E\u51FA\u5EA6\u4E3A 0 \u4E14\u6CBF\u6A21\u677F\u540E\u4EE3\u65E0\u6FC0\u6D3B\u8282\u70B9\uFF08\u8DEF\u5F84\u65AD\u88C2\uFF09`);
+    }
+    const firstTemplateOutEdge = template.edges.find((e) => e.from === node.id);
+    edges.push({
+      from: node.id,
+      to: nearestActive,
+      ...firstTemplateOutEdge?.pausePoint ? { pausePoint: { ...firstTemplateOutEdge.pausePoint } } : {}
+    });
+  }
+  if (keptNodes.length < 2) {
+    graphInvalid(`\u526A\u540E\u4EC5\u5269 ${keptNodes.length} \u4E2A\u8282\u70B9\uFF08\u987B \u2265 2\uFF09\u2014\u2014skip \u6E05\u5355/\u8F68\u9053\u5254\u9664\u8FC7\u91CD`);
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const e of edges) inDegree.set(e.to, (inDegree.get(e.to) ?? 0) + 1);
+  const entryNodes = keptNodes.filter((n) => !inDegree.has(n.id));
+  if (entryNodes.length !== 1) {
+    graphInvalid(`\u526A\u540E\u5165\u5EA6 0 \u8282\u70B9 ${entryNodes.length} \u4E2A\uFF08\u987B\u6070\u597D 1 \u4E2A entry\uFF09\uFF1A${entryNodes.map((n) => n.id).join(", ") || "\u65E0"}`);
+  }
+  const entry = entryNodes[0];
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const list = adjacency.get(e.from) ?? [];
+    list.push(e.to);
+    adjacency.set(e.from, list);
+  }
+  const visited = /* @__PURE__ */ new Set([entry.id]);
+  const queue = [entry.id];
+  while (queue.length > 0) {
+    const cur = queue.shift();
+    for (const next of adjacency.get(cur) ?? []) {
+      if (!visited.has(next)) {
+        visited.add(next);
+        queue.push(next);
+      }
+    }
+  }
+  const unreachable = keptNodes.filter((n) => !visited.has(n.id));
+  if (unreachable.length > 0) {
+    graphInvalid(`\u8282\u70B9\u4E0D\u53EF\u8FBE\uFF08\u4ECE entry\u300C${entry.id}\u300D\uFF09\uFF1A${unreachable.map((n) => n.id).join(", ")}`);
+  }
+  const terminals = keptNodes.filter((n) => !adjacency.has(n.id) || (adjacency.get(n.id)?.length ?? 0) === 0);
+  if (terminals.length === 0) {
+    graphInvalid("\u526A\u540E\u65E0\u51FA\u5EA6 0 \u8282\u70B9\uFF08\u65E0 terminal\uFF0C\u6D41\u7A0B\u4E0D\u53EF\u6536\u655B\uFF09");
+  }
+  const dangling = keptNodes.filter(
+    (n) => !terminals.some((t) => t.id === n.id) && (adjacency.get(n.id)?.length ?? 0) === 0
+  );
+  if (dangling.length > 0) {
+    graphInvalid(`\u975E terminal \u8282\u70B9\u51FA\u5EA6\u4E3A 0\uFF1A${dangling.map((n) => n.id).join(", ")}`);
+  }
+  const visitedByEngine = /* @__PURE__ */ new Set([entry.id]);
+  let cursor = entry.id;
+  for (let hop = 0; hop <= keptNodes.length && cursor !== null; hop++) {
+    if (hop === keptNodes.length) {
+      graphInvalid("\u5F15\u64CE\u8DEF\u5F84\u6A21\u62DF\u8D85\u6B65\u6570\u4E0A\u9650\uFF08\u56FE\u4E2D\u5B58\u5728\u73AF\uFF09");
+    }
+    let nextEdge;
+    try {
+      nextEdge = findNextEdge(edges, keptNodes, cursor, taskTrack);
+    } catch (err) {
+      const reason = err instanceof BadRequestError ? err.message : String(err);
+      graphInvalid(`\u5F15\u64CE\u8DEF\u7531\u65E0\u6CD5\u6D88\u6B67\uFF08${reason}\uFF09`);
+    }
+    if (nextEdge === null) break;
+    cursor = nextEdge.to;
+    visitedByEngine.add(cursor);
+  }
+  const unreachableByEngine = keptNodes.filter((n) => !visitedByEngine.has(n.id));
+  if (unreachableByEngine.length > 0) {
+    graphInvalid(
+      `\u6FC0\u6D3B\u8282\u70B9\u4E0D\u5728\u5F15\u64CE\u8DEF\u5F84\u4E0A\uFF08\u5C06\u6C38\u4E45 pending\uFF0C\u68C0\u67E5\u7C7B\u578B\xD7\u8F68\u9053\u4E0E\u6A21\u677F\u7ED3\u6784\u5339\u914D\u2014\u2014\u5982 mixed \u9700\u6A21\u677F\u542B\u94FE\u95F4\u4E32\u884C\u6865\u8FB9\u3001research \u9700 skip \u6389\u4E0D\u88AB\u884C\u8D70\u7684\u5206\u652F\uFF09\uFF1A${unreachableByEngine.map((n) => n.id).join(", ")}`
+    );
+  }
+  return { nodes: keptNodes, edges, prunedNodes, entryNode: entry };
+}
+function findNearestActiveDescendant(template, fromNodeId, keptIds) {
+  const templateAdjacency = /* @__PURE__ */ new Map();
+  for (const e of template.edges) {
+    const list = templateAdjacency.get(e.from) ?? [];
+    list.push(e.to);
+    templateAdjacency.set(e.from, list);
+  }
+  const visited = /* @__PURE__ */ new Set([fromNodeId]);
+  let frontier = templateAdjacency.get(fromNodeId) ?? [];
+  while (frontier.length > 0) {
+    const next = [];
+    for (const candidate of frontier) {
+      if (visited.has(candidate)) continue;
+      visited.add(candidate);
+      if (keptIds.has(candidate)) return candidate;
+      next.push(...templateAdjacency.get(candidate) ?? []);
+    }
+    frontier = next;
+  }
+  return null;
+}
+
+// src/store/repos/task.repo.ts
+function createTaskRepo(db) {
+  const base = createRepo(db.collection("tasks"));
+  return {
+    ...base,
+    async listTasks(filter) {
+      const match = {};
+      if (filter?.status) match.status = filter.status;
+      if (filter?.track) match.track = filter.track;
+      if (filter?.projectId) match.projectId = filter.projectId;
+      const page = filter?.page ?? 1;
+      const limit = filter?.limit ?? 20;
+      const skip = (page - 1) * limit;
+      const sortSpec = filter?.sort === "createdAt" ? { createdAt: -1 } : filter?.sort === "updatedAt" ? { updatedAt: -1 } : (
+        // progress（默认）：终态组（completed/cancelled，状态机无 archived）置底，
+        // 组内终态按 updatedAt 倒排、非终态按进度倒排（sortProgress 键保证终态组内 updatedAt 生效）
+        { isTerminal: 1, sortProgress: -1, updatedAt: -1 }
+      );
+      const pipeline = [
+        { $match: match },
+        {
+          $addFields: {
+            // 已完成节点数（nodeStates 中 status='completed'）
+            completedCount: {
+              $size: {
+                $filter: {
+                  input: { $objectToArray: "$dagInstance.nodeStates" },
+                  as: "st",
+                  cond: { $eq: ["$$st.v.status", "completed"] }
+                }
+              }
+            },
+            // 参与流转节点数 = nodes 长度 - skipped 节点数（裁剪节点不计分母）
+            totalCount: {
+              $subtract: [
+                { $size: "$dagInstance.nodes" },
+                {
+                  $size: {
+                    $filter: {
+                      input: { $objectToArray: "$dagInstance.nodeStates" },
+                      as: "st",
+                      cond: { $eq: ["$$st.v.status", "skipped"] }
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        },
+        {
+          $addFields: {
+            // 零除防护：totalCount=0 时进度置 0（MongoDB $divide 遇零除会报错）
+            progressSort: {
+              $cond: {
+                if: { $eq: ["$totalCount", 0] },
+                then: 0,
+                else: { $divide: ["$completedCount", "$totalCount"] }
+              }
+            },
+            isTerminal: {
+              $cond: { if: { $in: ["$status", ["completed", "cancelled"]] }, then: 1, else: 0 }
+            }
+          }
+        },
+        {
+          $addFields: {
+            // 终态组组内不按进度排（PRD F5 行为 1：终态组按更新时间倒排）——组内进度键置 0
+            sortProgress: { $cond: { if: { $eq: ["$isTerminal", 1] }, then: 0, else: "$progressSort" } }
+          }
+        },
+        { $sort: sortSpec },
+        { $skip: skip },
+        { $limit: limit }
+      ];
+      const [items, total] = await Promise.all([
+        base._collection.aggregate(pipeline).toArray(),
+        base._collection.countDocuments(match)
+      ]);
+      return {
+        // N017 D6：列表 = 概要——剥离 dagInstance（11 节点 prompt 全文）与 history；
+        // createdAt/updatedAt 必须保留（web TaskTable 消费 createdAt 列且为默认降序排序键）
+        items: items.map((doc) => {
+          const task = toEntity(doc);
+          const summary = {
+            taskId: task.taskId,
+            title: task.title,
+            ...task.type !== void 0 ? { type: task.type } : {},
+            projectId: task.projectId,
+            dagTemplateId: task.dagTemplateId,
+            currentNode: task.currentNode,
+            currentPhase: task.currentPhase,
+            status: task.status,
+            pausedAt: task.pausedAt,
+            track: task.track,
+            progress: { completed: doc.completedCount, total: doc.totalCount },
+            ...task.createdAt ? { createdAt: task.createdAt } : {},
+            ...task.updatedAt ? { updatedAt: task.updatedAt } : {}
+          };
+          return summary;
+        }),
+        total
+      };
+    },
+    async getByTaskId(taskId) {
+      const doc = await base._collection.findOne({ taskId });
+      if (!doc) return null;
+      return base.getById(doc._id.toString());
+    },
+    async updateTask(taskId, patch, cas) {
+      for (const banned of ["nodeRecords", "doc", "archNotes"]) {
+        if (banned in patch) {
+          throw new BadRequestError(
+            `updateTask \u7981\u6B62\u6574\u5BF9\u8C61\u5199\u5165 '${banned}'\u2014\u2014\u7528\u70B9\u8DEF\u5F84 key\uFF08\u5982 "nodeRecords.TECH.summary"\uFF09\u6216 updateTaskPaths`,
+            banned
+          );
+        }
+      }
+      const filter = { taskId };
+      if (cas) {
+        filter.status = cas.expectedStatus;
+        filter.currentNode = cas.expectedCurrentNode;
+      }
+      const result = await base._collection.findOneAndUpdate(
+        filter,
+        { $set: { ...patch, updatedAt: /* @__PURE__ */ new Date() } },
+        { returnDocument: "after" }
+      );
+      if (!result) {
+        throw new ConflictError("task", `CAS mismatch or not found: ${taskId}`);
+      }
+      return toEntity(result);
+    },
+    /**
+     * N020 D1：小步原子写——$set/$push/arrayFilters 在同一条 findOneAndUpdate
+     * 内生效（含 updatedAt）。前置存在性/权限校验归路由层（repo 只管写）。
+     */
+    async updateTaskPaths(taskId, update) {
+      const operators = {
+        $set: { ...update.sets ?? {}, updatedAt: /* @__PURE__ */ new Date() }
+      };
+      const pushes = update.pushes ?? {};
+      if (Object.keys(pushes).length > 0) {
+        operators.$push = pushes;
+      }
+      const result = await base._collection.findOneAndUpdate(
+        { taskId },
+        operators,
+        {
+          returnDocument: "after",
+          ...update.arrayFilters ? { arrayFilters: update.arrayFilters } : {}
+        }
+      );
+      if (!result) {
+        throw new NotFoundError("task", taskId);
+      }
+      return toEntity(result);
+    },
+    async createTask(input, template, resolvedProjectId) {
+      if (!input.track) {
+        throw new BadRequestError(`track is required`);
+      }
+      const pruned = pruneInstance(template, input.track, input.skipNodes ?? []);
+      const firstNode = pruned.entryNode;
+      const dagInstance = {
+        templateId: template.id ?? "",
+        templateVersion: template.version,
+        nodes: pruned.nodes.map(deepCopyNode),
+        edges: pruned.edges.map(deepCopyEdge),
+        prunedNodes: pruned.prunedNodes,
+        nodeStates: initNodeStates(pruned.nodes, firstNode.id)
+      };
+      if (!template.id) {
+        throw new BadRequestError("DagTemplate has no id");
+      }
+      let taskId = null;
+      let seq = await base._collection.countDocuments({
+        taskId: { $regex: `^T${getDatePrefix()}` }
+      });
+      for (let attempt = 0; attempt < 3; attempt++) {
+        seq++;
+        taskId = generateTaskId(seq);
+        const exists = await base._collection.findOne({ taskId }, { projection: { _id: 1 } });
+        if (!exists) break;
+        taskId = null;
+      }
+      if (!taskId) {
+        throw new ConflictError("task", "taskId generation failed after 3 retries");
+      }
+      const now = /* @__PURE__ */ new Date();
+      const task = {
+        taskId,
+        title: input.title,
+        ...input.type !== void 0 ? { type: input.type } : {},
+        projectId: resolvedProjectId,
+        dagTemplateId: template.id,
+        dagInstance,
+        currentNode: firstNode.id,
+        currentPhase: firstNode.phase,
+        status: "active",
+        pausedAt: null,
+        track: input.track,
+        nodeRecords: {},
+        archNotes: [],
+        history: [{
+          nodeId: firstNode.id,
+          action: "entered",
+          timestamp: now,
+          details: {}
+        }]
+      };
+      const result = TaskSchema.safeParse(task);
+      if (!result.success) {
+        throw new ValidationError("Task validation failed", result.error.issues);
+      }
+      return base.create(result.data);
+    }
+  };
+}
+function getDatePrefix() {
+  const d = /* @__PURE__ */ new Date();
+  return d.getFullYear().toString() + (d.getMonth() + 1).toString().padStart(2, "0") + d.getDate().toString().padStart(2, "0");
+}
+function generateTaskId(seq) {
+  return `T${getDatePrefix()}${seq.toString().padStart(4, "0")}`;
+}
+function initNodeStates(nodes, firstNodeId) {
+  const now = /* @__PURE__ */ new Date();
+  const states = {};
+  for (const node of nodes) {
+    states[node.id] = node.id === firstNodeId ? { status: "active", enteredAt: now, completedAt: null } : { status: "pending", enteredAt: null, completedAt: null };
+  }
+  return states;
+}
+function deepCopyNode(node) {
+  return {
+    id: node.id,
+    label: node.label,
+    phase: node.phase,
+    track: node.track,
+    prompt: node.prompt,
+    skills: [...node.skills]
+  };
+}
+function deepCopyEdge(edge) {
+  return {
+    from: edge.from,
+    to: edge.to,
+    ...edge.condition ? { condition: edge.condition } : {},
+    ...edge.pausePoint ? { pausePoint: { ...edge.pausePoint } } : {}
+  };
+}
+
+// src/store/repos/project.repo.ts
+import { ObjectId as ObjectId2 } from "mongodb";
+var DEFAULT_PROJECT_KEY = "default";
+function projectCreateBody(data, key) {
+  return {
+    key,
+    name: data.name,
+    ...data.description ? { description: data.description } : {},
+    status: "active"
+  };
+}
+function generateProjectKey(name) {
+  const kebab = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 31).replace(/-+$/g, "");
+  if (kebab.length >= 2) return kebab;
+  return `project-${new ObjectId2().toHexString().slice(0, 8)}`;
+}
+function createProjectRepo(db) {
+  const base = createRepo(db.collection("projects"));
+  return {
+    ...base,
+    async getByKey(key) {
+      const doc = await base._collection.findOne({ key });
+      return doc ? toEntity(doc) : null;
+    },
+    async createProject(data) {
+      if (data.key) {
+        const dup = await base._collection.findOne({ key: data.key }, { projection: { _id: 1 } });
+        if (dup) {
+          throw new ConflictError("project", `key already exists: ${data.key}`);
+        }
+        return base.create({ ...projectCreateBody(data, data.key) });
+      }
+      const baseKey = generateProjectKey(data.name);
+      for (let attempt = 0; attempt < 3; attempt++) {
+        const candidate = attempt === 0 ? baseKey : `${baseKey.slice(0, 28).replace(/-+$/g, "")}-${attempt + 1}`;
+        const exists = await base._collection.findOne({ key: candidate }, { projection: { _id: 1 } });
+        if (!exists) {
+          return base.create({ ...projectCreateBody(data, candidate) });
+        }
+      }
+      throw new ConflictError("project", `key generation exhausted for name: ${data.name}`);
+    }
+  };
+}
+
+// src/store/repos/model-alias.repo.ts
+import { MongoServerError } from "mongodb";
+var AGENTS_COLLECTION = "agents";
+var MODEL_FIELD = "model";
+function createModelAliasRepo(db) {
+  const base = createRepo(db.collection("model_aliases"), { nameField: "code" });
+  return {
+    ...base,
+    async listWithRefCount() {
+      const docs = await base._collection.aggregate([
+        {
+          $lookup: {
+            from: AGENTS_COLLECTION,
+            localField: "code",
+            foreignField: MODEL_FIELD,
+            as: "refs"
+          }
+        },
+        { $addFields: { refCount: { $size: "$refs" } } },
+        { $project: { refs: 0 } }
+      ]).toArray();
+      return docs.map((doc) => {
+        const { refCount, ...rest } = doc;
+        return { ...toEntity(rest), refCount };
+      });
+    },
+    async getByCode(code) {
+      return base.getByName(code);
+    },
+    async createModelAlias(data) {
+      try {
+        return await base.create(data);
+      } catch (err) {
+        if (err instanceof MongoServerError && err.code === 11e3) {
+          throw new ConflictError("model-alias", data.code, {
+            bizCode: "MODEL_CODE_EXISTS",
+            message: BIZ_CODE_MESSAGES.MODEL_CODE_EXISTS
+          });
+        }
+        throw err;
+      }
+    },
+    async updateByCode(code, patch) {
+      const alias = await base.getByName(code);
+      if (!alias || !alias.id) return null;
+      return base.update(alias.id, patch);
+    },
+    async deleteByCode(code) {
+      const refCount = await db.collection(AGENTS_COLLECTION).countDocuments({ [MODEL_FIELD]: code });
+      if (refCount > 0) {
+        throw new ConflictError("model-alias", code, {
+          bizCode: "MODEL_ALIAS_IN_USE",
+          message: `\u6A21\u578B\u6620\u5C04\u88AB ${refCount} \u4E2A Agent \u5F15\u7528\uFF0C\u7981\u6B62\u5220\u9664`
+        });
+      }
+      const alias = await base.getByName(code);
+      if (!alias || !alias.id) return false;
+      return base.delete(alias.id);
+    }
+  };
+}
+async function assertModelAliasExists(repo, code) {
+  const alias = await repo.getByCode(code);
+  if (!alias) {
+    throw new NotFoundError("model-alias", code);
+  }
+}
+
+// src/store/repos/enum-registry.repo.ts
+var REFERENCE_CHECKS = {
+  dag_phase: { collection: "dag_templates", query: (v) => ({ "nodes.phase": v }) },
+  dag_track: { collection: "dag_templates", query: (v) => ({ "nodes.track": v }) },
+  pause_type: { collection: "dag_templates", query: (v) => ({ "edges.pausePoint.type": v }) },
+  task_status: { collection: "tasks", query: (v) => ({ status: v }) },
+  node_status: { collection: "tasks", query: (v) => ({ "dagInstance.nodeStates.status": v }) },
+  skill_category: { collection: "skills", query: (v) => ({ category: v }) },
+  scope: void 0
+};
+function createEnumRegistryRepo(db) {
+  const base = createRepo(db.collection("enum_registry"), { nameField: "category" });
+  return {
+    ...base,
+    async listRegistries() {
+      return base.list();
+    },
+    async getRegistry(category) {
+      return base.getByName(category);
+    },
+    async getEntries(category) {
+      const registry = await base.getByName(category);
+      return registry?.entries ?? [];
+    },
+    async updateRegistry(category, patch) {
+      const existing = await base.getByName(category);
+      if (!existing || !existing.id) return null;
+      const existingByValue = new Map(existing.entries.map((e) => [e.value, e]));
+      const incomingByValue = new Map(patch.entries.map((e) => [e.value, e]));
+      for (const prev of existing.entries) {
+        if (prev.builtin && !incomingByValue.has(prev.value)) {
+          throw new ConflictError("enum-registry", `${category}/${prev.value}`, {
+            bizCode: "ENUM_ENTRY_BUILTIN",
+            message: BIZ_CODE_MESSAGES.ENUM_ENTRY_BUILTIN
+          });
+        }
+      }
+      for (const incoming of patch.entries) {
+        const prev = existingByValue.get(incoming.value);
+        if (!prev && incoming.builtin) {
+          throw new ConflictError("enum-registry", `${category}/${incoming.value}`, {
+            bizCode: "ENUM_ENTRY_BUILTIN",
+            message: BIZ_CODE_MESSAGES.ENUM_ENTRY_BUILTIN
+          });
+        }
+        if (prev && prev.builtin === false && incoming.builtin) {
+          throw new ConflictError("enum-registry", `${category}/${incoming.value}`, {
+            bizCode: "ENUM_ENTRY_BUILTIN",
+            message: BIZ_CODE_MESSAGES.ENUM_ENTRY_BUILTIN
+          });
+        }
+        if (prev?.builtin === true && incoming.builtin !== true) {
+          throw new ConflictError("enum-registry", `${category}/${incoming.value}`, {
+            bizCode: "ENUM_ENTRY_BUILTIN",
+            message: BIZ_CODE_MESSAGES.ENUM_ENTRY_BUILTIN
+          });
+        }
+        if (prev?.active === true && incoming.active === false) {
+          const ref = REFERENCE_CHECKS[category];
+          if (ref) {
+            const count = await db.collection(ref.collection).countDocuments(ref.query(incoming.value));
+            if (count > 0) {
+              throw new ConflictError("enum-registry", `${category}/${incoming.value}`, {
+                bizCode: "ENUM_ENTRY_IN_USE",
+                message: `${BIZ_CODE_MESSAGES.ENUM_ENTRY_IN_USE}\uFF08${count} \u4E2A\u8D44\u6E90\u5F15\u7528\uFF09`
+              });
+            }
+          }
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const e of patch.entries) {
+        if (seen.has(e.value)) {
+          throw new ConflictError("enum-registry", `${category}/${e.value}`, {
+            bizCode: "ENUM_VALUE_CONFLICT",
+            message: BIZ_CODE_MESSAGES.ENUM_VALUE_CONFLICT
+          });
+        }
+        seen.add(e.value);
+      }
+      return base.update(existing.id, { entries: patch.entries });
+    },
+    async deleteEntry(category, value) {
+      const existing = await base.getByName(category);
+      if (!existing || !existing.id) return false;
+      const entry = existing.entries.find((e) => e.value === value);
+      if (!entry) throw new NotFoundError("enum-entry", `${category}/${value}`);
+      if (entry.builtin) {
+        throw new ConflictError("enum-registry", `${category}/${value}`, {
+          bizCode: "ENUM_ENTRY_BUILTIN",
+          message: BIZ_CODE_MESSAGES.ENUM_ENTRY_BUILTIN
+        });
+      }
+      const ref = REFERENCE_CHECKS[category];
+      if (ref) {
+        const count = await db.collection(ref.collection).countDocuments(ref.query(value));
+        if (count > 0) {
+          throw new ConflictError("enum-registry", `${category}/${value}`, {
+            bizCode: "ENUM_ENTRY_IN_USE",
+            message: `${BIZ_CODE_MESSAGES.ENUM_ENTRY_IN_USE}\uFF08${count} \u4E2A\u8D44\u6E90\u5F15\u7528\uFF09`
+          });
+        }
+      }
+      const remaining = existing.entries.filter((e) => e.value !== value);
+      return await base.update(existing.id, { entries: remaining }) !== null;
+    }
+  };
+}
+
+// src/schemas/agent.ts
+import { z as z5 } from "zod";
+
+// src/schemas/model-alias.ts
+import { z as z4 } from "zod";
+var SIMING_CODE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var ModelAliasShapeSchema = z4.object({
+  id: z4.string().optional(),
+  /** siming code：创建后不可变（PUT 显式拒绝 MODEL_CODE_IMMUTABLE，非静默剥离） */
+  code: z4.string().regex(SIMING_CODE_REGEX, "code \u5FC5\u987B\u4E3A kebab-case\uFF08\u5982 primary\u3001fast-model\uFF09"),
+  /** 展示名（如「主力模型」） */
+  name: z4.string().min(1, "\u5C55\u793A\u540D\u4E0D\u80FD\u4E3A\u7A7A"),
+  /** 真实模型标识（如 zhipuai/glm-5.3；改此处 = 引用方全局替换生效） */
+  realModel: z4.string().min(1, "\u771F\u5B9E\u6A21\u578B\u6807\u8BC6\u4E0D\u80FD\u4E3A\u7A7A"),
+  createdAt: z4.date().optional(),
+  updatedAt: z4.date().optional()
+});
+var ModelAliasSchema = ModelAliasShapeSchema;
+var ModelAliasCreateSchema = ModelAliasShapeSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+});
+var ModelAliasUpdateSchema = z4.object({
+  code: z4.string().regex(SIMING_CODE_REGEX).optional(),
+  name: z4.string().min(1).optional(),
+  realModel: z4.string().min(1).optional()
+});
+var ModelAliasWithRefCountSchema = ModelAliasShapeSchema.extend({
+  refCount: z4.number().int().min(0)
+});
+
+// src/schemas/agent.ts
+var AgentScopeSchema = z5.enum(["global", "project"]);
+var AgentScopeRefine = (val, ctx) => {
+  if (val.scope === "project" && !val.projectId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["projectId"],
+      message: "scope=project \u65F6 projectId \u5FC5\u586B"
+    });
+  }
+};
+var AgentShapeSchema = z5.object({
+  id: z5.string().optional(),
+  name: z5.string(),
+  description: z5.string(),
+  systemPrompt: z5.string(),
+  boundSkills: z5.array(z5.string()).default([]),
+  model: z5.string(),
+  /** 资产版本（N015 F13）：install/export 版本对比依据；default 仅读侧兜底（createRepo 不做读侧解析，存量回填走 M6 迁移） */
+  version: z5.string().default("1.0.0"),
+  tools: z5.array(z5.string()).default([]),
+  permissions: z5.array(z5.string()).default([]),
+  /** 作用域：global=跨项目复用（默认，仅作存量迁移读侧兜底）/ project=项目专用（N012 D3） */
+  scope: AgentScopeSchema.default("global"),
+  /** 仅 scope=project 时必填且为合法 ObjectId hex（superRefine 保证） */
+  projectId: z5.string().regex(OBJECT_ID_HEX, "projectId must be a valid ObjectId hex").optional(),
+  createdAt: z5.date().optional(),
+  updatedAt: z5.date().optional()
+});
+var AgentSchema = AgentShapeSchema.superRefine(AgentScopeRefine);
+var AgentCreateSchema = AgentShapeSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({ scope: AgentScopeSchema }).extend({ model: z5.string().regex(SIMING_CODE_REGEX, "model \u5FC5\u987B\u662F siming code\uFF08kebab-case\uFF09") }).superRefine(AgentScopeRefine);
+var AgentUpdateSchema = AgentShapeSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
+  boundSkills: z5.array(z5.string()).optional(),
+  // N015：version 放行（export apply 版本递增随 PUT 携带）；optional 剥离实体层 default 避免 partial 空 body 注入
+  version: z5.string().optional(),
+  tools: z5.array(z5.string()).optional(),
+  permissions: z5.array(z5.string()).optional(),
+  scope: AgentScopeSchema.optional(),
+  // N013：model 收紧为 siming code 格式（存在性校验在 handler 层；undefined = 不更新该字段）
+  model: z5.string().regex(SIMING_CODE_REGEX, "model \u5FC5\u987B\u662F siming code\uFF08kebab-case\uFF09").optional()
+}).partial().superRefine(AgentScopeRefine);
+var AgentCopySchema = z5.object({
+  newName: z5.string(),
+  newScope: AgentScopeSchema,
+  targetProjectId: z5.string().regex(OBJECT_ID_HEX, "projectId must be a valid ObjectId hex").optional()
+}).superRefine((val, ctx) => {
+  if (val.newScope === "project" && !val.targetProjectId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["targetProjectId"],
+      message: "newScope=project \u65F6 targetProjectId \u5FC5\u586B"
+    });
+  }
+});
+
+// src/schemas/advance.ts
+import { z as z6 } from "zod";
+var AdvanceRequestSchema = z6.object({
+  note: z6.string().optional(),
+  /** min(1).max(2000) 与 record summary 端点对齐（同一 $set 目标，两入口校验强度一致） */
+  summary: z6.string().min(1).max(2e3).optional()
+});
+var ApproveRequestSchema = z6.object({
+  decision: z6.enum(["approved", "rejected"]),
+  comment: z6.string().optional()
+});
+var TaskPublicSchema = z6.object({
+  taskId: z6.string(),
+  title: z6.string(),
+  // T202608240003：任务类型标签（缺省 = 裸任务/旧任务；模板 PRD 调研变体判定消费）
+  type: z6.enum(TASK_TYPES).optional(),
+  currentNode: z6.string(),
+  currentPhase: z6.string(),
+  status: z6.string(),
+  pausedAt: z6.string().nullable(),
+  track: z6.string()
+});
+var NodeInfoSchema = z6.object({
+  nodeId: z6.string(),
+  label: z6.string(),
+  track: z6.string(),
+  prompt: z6.string(),
+  skills: z6.array(z6.string()),
+  upcomingPause: z6.string().nullable()
+});
+var AdvanceResponseSchema = z6.discriminatedUnion("status", [
+  z6.object({
+    status: z6.literal("advanced"),
+    task: TaskPublicSchema,
+    nextNode: NodeInfoSchema
+  }),
+  z6.object({
+    status: z6.literal("paused"),
+    task: TaskPublicSchema,
+    pausePoint: EdgePausePointSchema,
+    guidance: z6.string()
+  }),
+  z6.object({
+    status: z6.literal("completed"),
+    task: TaskPublicSchema
+  })
+]);
+var ApproveResponseSchema = z6.discriminatedUnion("status", [
+  z6.object({
+    status: z6.literal("advanced"),
+    task: TaskPublicSchema,
+    nextNode: NodeInfoSchema
+  }),
+  z6.object({
+    status: z6.literal("rejected"),
+    task: TaskPublicSchema,
+    guidance: z6.string()
+  }),
+  // 「completed」分支当前引擎不可达（approve 从 paused 流转必有下一节点，技术方案 §2.2
+  // 已删 paused→completed 直达路径）——按方案 §2.1 契约保留作前向兼容预留
+  z6.object({
+    status: z6.literal("completed"),
+    task: TaskPublicSchema
+  })
+]);
+var PauseRequestSchema = z6.object({
+  reason: z6.string().optional()
+});
+var ResumeRequestSchema = z6.object({
+  decision: z6.string().optional()
+});
+
+// src/schemas/task-doc.ts
+import { z as z7 } from "zod";
+var TaskContextSchema = z7.object({
+  task: z7.object({
+    taskId: z7.string(),
+    title: z7.string(),
+    // T202608240003：与 TaskPublicSchema 同步（toTaskPublic 运行时已产出，schema 声明漂移会导致 typed 消费方 strip 掉 type）
+    type: z7.enum(TASK_TYPES).optional(),
+    currentNode: z7.string(),
+    currentPhase: z7.string(),
+    status: z7.string(),
+    pausedAt: z7.string().nullable(),
+    track: z7.string()
+  }),
+  currentNode: z7.object({
+    nodeId: z7.string(),
+    label: z7.string(),
+    phase: z7.string(),
+    track: z7.string(),
+    /** renderPrompt 渲染后（AI 推进任务的直接输入） */
+    prompt: z7.string(),
+    skills: z7.array(z7.string()),
+    /** 完成当前节点后出边上的暂停点描述（经 findNextEdge 按轨选边） */
+    upcomingPause: z7.string().nullable()
+  }).nullable(),
+  pausedAtEdge: z7.object({
+    from: z7.string(),
+    to: z7.string(),
+    pausePoint: EdgePausePointBaseSchema
+  }).nullable(),
+  /** 全节点实时状态清单 */
+  nodes: z7.array(z7.object({
+    nodeId: z7.string(),
+    label: z7.string(),
+    status: z7.string(),
+    enteredAt: z7.date().nullable(),
+    completedAt: z7.date().nullable()
+  })),
+  /** N020 D1：任务级结构化文档（未写时 null） */
+  taskDoc: TaskDocContentSchema.nullable(),
+  /** N020 D1：节点执行记录（仅含已写记录的 nodeId） */
+  nodeRecords: z7.record(z7.string(), NodeRecordSchema),
+  /** N020 D1：跨节点累积素材（架构信息收集条目） */
+  archNotes: z7.array(ArchNoteSchema)
+});
+var TaskSummarySchema = z7.object({
+  taskId: z7.string(),
+  title: z7.string(),
+  // T202608240003：任务类型标签（缺省 = 裸任务/旧任务）
+  type: z7.enum(TASK_TYPES).optional(),
+  projectId: z7.string(),
+  dagTemplateId: z7.string(),
+  currentNode: z7.string(),
+  currentPhase: z7.string(),
+  status: z7.string(),
+  pausedAt: z7.string().nullable(),
+  track: z7.string(),
+  progress: z7.object({
+    completed: z7.number(),
+    total: z7.number()
+  }),
+  createdAt: z7.date().optional(),
+  updatedAt: z7.date().optional()
+});
+
+// src/schemas/project.ts
+import { z as z8 } from "zod";
+var ProjectStatusSchema = z8.enum(["active", "archived"]);
+var ProjectSchema = z8.object({
+  id: z8.string().optional(),
+  key: z8.string().regex(/^[a-z0-9][a-z0-9-]{1,30}$/, "key \u5FC5\u987B\u4E3A kebab-case\uFF082-31 \u5B57\u7B26\uFF09"),
+  name: z8.string().min(1).max(50),
+  description: z8.string().max(500).optional(),
+  status: ProjectStatusSchema.default("active"),
+  createdAt: z8.date().optional(),
+  updatedAt: z8.date().optional()
+});
+var ProjectCreateSchema = z8.object({
+  key: z8.string().regex(/^[a-z0-9][a-z0-9-]{1,30}$/, "key \u5FC5\u987B\u4E3A kebab-case\uFF082-31 \u5B57\u7B26\uFF09").optional(),
+  name: z8.string().min(1).max(50),
+  description: z8.string().max(500).optional()
+});
+var ProjectUpdateSchema = z8.object({
+  name: z8.string().min(1).max(50).optional(),
+  description: z8.string().max(500).optional(),
+  status: ProjectStatusSchema.optional()
+});
+
+// src/schemas/enum-registry.ts
+import { z as z9 } from "zod";
+var EnumRegistryCategorySchema = z9.enum([
+  "dag_phase",
+  "dag_track",
+  "pause_type",
+  "task_status",
+  "node_status",
+  "skill_category",
+  "scope"
+]);
+var EnumEntrySchema = z9.object({
+  /** 领域层存库的原始枚举值（不可臆造；builtin 值 engine/DB 强依赖；kebab 约束与 skill name 对齐，保证 DELETE /entries/:value 可寻址） */
+  value: z9.string().regex(/^[a-z0-9][a-z0-9_-]*$/, "value \u4EC5\u652F\u6301\u5C0F\u5199\u5B57\u6BCD/\u6570\u5B57/\u4E0B\u5212\u7EBF/\u8FDE\u5B57\u7B26\uFF08kebab-case\uFF09"),
+  /** 展示文案（消费端下拉直接取用） */
+  label: z9.string().min(1, "label \u4E0D\u80FD\u4E3A\u7A7A"),
+  /** 可选语义色 token（如 --success / --warning），消费端映射到 UI */
+  color: z9.string().optional(),
+  /** 下拉排序（升序） */
+  order: z9.number().int().default(0),
+  /** 内置值：禁删 + label/color 可改但 value 不可改（D8）；seed 时标记 */
+  builtin: z9.boolean().default(false),
+  /** 启停：false = 下拉禁用展示（历史数据仍可读，新选择不可用） */
+  active: z9.boolean().default(true)
+});
+var EnumRegistrySchema = z9.object({
+  id: z9.string().optional(),
+  category: EnumRegistryCategorySchema,
+  entries: z9.array(EnumEntrySchema).default([]),
+  updatedAt: z9.date().optional()
+});
+var EnumRegistryUpdateSchema = z9.object({
+  entries: z9.array(EnumEntrySchema)
+});
+
+// src/config/server-config.ts
+import { z as z10 } from "zod";
+var SimingLogLevelSchema = z10.enum(["debug", "info", "warn", "error"]);
+var SimingConfigSchema = z10.object({
+  mongoUri: z10.string().min(1).default("mongodb://localhost:27017"),
+  port: z10.coerce.number().int().min(1).max(65535).default(7777),
+  /**
+   * N018 D8：默认仅绑定本机回环（安全默认）；远程/局域接入（F7）显式配置 host。
+   * 超出 PRD V1 配置清单的新增项，依据见技术方案 §3.4「超范围扩展标注」。
+   */
+  host: z10.string().min(1).default("127.0.0.1"),
+  logLevel: SimingLogLevelSchema.default("info"),
+  /**
+   * F6 预留字段（V2 远程部署）：宽松形态——出现即接受、形状不校验、运行时不读取。
+   * 严格满足 PRD「配置中出现预留字段时不报错」；V2 落地时收紧为类型化 schema。
+   */
+  auth: z10.unknown().optional(),
+  cors: z10.unknown().optional()
+});
+var SIMING_CONFIG_KEYS = ["mongoUri", "port", "host", "logLevel"];
+var SIMING_CONFIG_ENV_KEYS = {
+  mongoUri: "SIMING_MONGO_URI",
+  port: "PORT",
+  host: "SIMING_HOST",
+  logLevel: "SIMING_LOG_LEVEL"
+};
+
+// src/task/entry-id.ts
+var ENTRY_ID_LENGTH = 6;
+var BASE36_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+function generateEntryId(existing) {
+  const taken = new Set(existing);
+  for (let attempt = 0; attempt < 32; attempt++) {
+    let id = "";
+    for (let i = 0; i < ENTRY_ID_LENGTH; i++) {
+      id += BASE36_ALPHABET[Math.floor(Math.random() * BASE36_ALPHABET.length)];
+    }
+    if (!taken.has(id)) return id;
+  }
+  throw new Error(`entry id generation failed after 32 attempts (existing: ${existing.length})`);
+}
+
+// src/index.ts
+var PackageJsonSchema = z11.object({ version: z11.string().min(1) });
+var packageJsonParsed = PackageJsonSchema.safeParse(
+  JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"))
+);
+if (!packageJsonParsed.success) {
+  throw new Error("core VERSION \u521D\u59CB\u5316\u5931\u8D25\uFF1A\u5305\u6839 package.json \u7F3A\u5C11\u5408\u6CD5 version \u5B57\u6BB5");
+}
+var VERSION = packageJsonParsed.data.version;
+function ping() {
+  return "pong";
+}
+export {
+  ARTIFACT_TYPES,
+  AdvanceRequestSchema,
+  AdvanceResponseSchema,
+  AgentCopySchema,
+  AgentCreateSchema,
+  AgentSchema,
+  AgentScopeSchema,
+  AgentUpdateSchema,
+  AppError,
+  ApproveRequestSchema,
+  ApproveResponseSchema,
+  ArchNoteSchema,
+  ArtifactSchema,
+  BIZ_CODE_MESSAGES,
+  BadRequestError,
+  CheckItemSchema,
+  ConfirmationSchema,
+  ConflictError,
+  DAG_PHASES,
+  DAG_TRACKS,
+  DEFAULT_PROJECT_KEY,
+  DagEdgeSchema,
+  DagInstanceSchema,
+  DagNodePhaseSchema,
+  DagNodeSchema,
+  DagNodeTrackSchema,
+  DagTemplateCopySchema,
+  DagTemplateCreateSchema,
+  DagTemplateSchema,
+  DagTemplateUpdateSchema,
+  DecisionSchema,
+  ENTRY_ID_REGEX,
+  EdgePausePointBaseSchema,
+  EdgePausePointSchema,
+  EnumEntrySchema,
+  EnumRegistryCategorySchema,
+  EnumRegistrySchema,
+  EnumRegistryUpdateSchema,
+  HistoryActionSchema,
+  HistoryEntrySchema,
+  ModelAliasCreateSchema,
+  ModelAliasSchema,
+  ModelAliasShapeSchema,
+  ModelAliasUpdateSchema,
+  ModelAliasWithRefCountSchema,
+  NODE_ID_PATTERN,
+  NODE_STATUSES,
+  NodeInfoSchema,
+  NodeRecordSchema,
+  NodeStateSchema,
+  NodeStatusSchema,
+  NotFoundError,
+  OBJECT_ID_HEX,
+  PAUSE_POINT_TYPES,
+  PausePointTypeSchema,
+  PauseRequestSchema,
+  ProjectCreateSchema,
+  ProjectSchema,
+  ProjectStatusSchema,
+  ProjectUpdateSchema,
+  ResumeRequestSchema,
+  ReviewSummarySchema,
+  SIMING_CODE_REGEX,
+  SIMING_CONFIG_ENV_KEYS,
+  SIMING_CONFIG_KEYS,
+  SimingConfigSchema,
+  SimingLogLevelSchema,
+  SkillCopySchema,
+  SkillCreateSchema,
+  SkillSchema,
+  SkillScopeSchema,
+  SkillUpdateSchema,
+  TASK_PHASES,
+  TASK_STATUSES,
+  TASK_TYPES,
+  TaskContextSchema,
+  TaskCreateInputSchema,
+  TaskDocContentSchema,
+  TaskPhaseSchema,
+  TaskPublicSchema,
+  TaskSchema,
+  TaskStatusSchema,
+  TaskSummarySchema,
+  VERSION,
+  ValidationError,
+  advanceTask,
+  approveTask,
+  assertBoundSkillsCompatible,
+  assertModelAliasExists,
+  checkTermination,
+  createAgentRepo,
+  createDagTemplateRepo,
+  createEnumRegistryRepo,
+  createModelAliasRepo,
+  createMongoClient,
+  createProjectRepo,
+  createRepo,
+  createSkillRepo,
+  createTaskRepo,
+  findNextEdge,
+  generateEntryId,
+  generateProjectKey,
+  mkHistory,
+  pauseTask,
+  ping,
+  pruneInstance,
+  renderPrompt,
+  resumeTask,
+  toNodeInfo,
+  toTaskPublic,
+  trackMatchSet,
+  withTransaction
+};