@stofone/dsh-agent-roster 0.7.0 → 0.8.1

package/lib/organization.js

@@ -0,0 +1,331 @@
+/**
+ * 组织档案（organization）：一座档案库的"目录页"。
+ *
+ * 为什么需要它：档案库只能回答"这一份档案写了什么"，回答不了"这些档案是什么关系、
+ * 哪份是生产、哪份是归档、谁维护"。当一座库里放二十份来自不同来源的档案时，
+ * 缺了这层就只能靠目录名猜。
+ *
+ * 边界（与 capabilities.yaml 同一条纪律）：
+ * - 组织只做**声明与核对**：声明库里有哪几份档案、各自什么状态；
+ *   它不创建团队、不改档案、不进 `agent_teams_add_member`。
+ * - 它**能被机械核对**：声明了但目录不在 = error，目录在却没声明 = warn，
+ *   已归档却仍在用 = info。核对不了的字段一律不收（未知键即错误）。
+ * - 位置即身份：`organization` 必须等于所在目录名，和 `roster` 的规则一致。
+ *
+ * @module dsh-agent-roster/organization
+ */
+
+/** 组织文件的 `kind`。与 roster / registry / capabilities 并列，互不冒充。 */
+export const ORGANIZATION_KIND = "dsh-agent-roster-organization/v1";
+
+/** 组织文件允许的文件名，按优先级排列。 */
+export const ORGANIZATION_FILE_NAMES = ["organization.yaml", "organization.yml", "organization.json"];
+
+/** 档案在组织里的状态。刻意只有两档：归档不等于删除，删除就是没有这个目录。 */
+export const ORGANIZATION_STATUSES = ["active", "archived"];
+
+/** 长度上限：与档案的 LIMITS 同一套口径，超了就报错而不是截断。 */
+export const LIMITS = {
+  rosters: 64,
+  titleChars: 120,
+  descriptionChars: 500,
+  licenseChars: 120,
+  homepageChars: 200,
+  maintainers: 16,
+  maintainerChars: 120,
+  noteChars: 300,
+};
+
+/** 组织 id 与档案 id 同形：小写、连字符、首字符必须是字母或数字。 */
+export const ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,63}$/;
+
+const ROOT_FIELDS = new Set([
+  "kind",
+  "organization",
+  "title",
+  "description",
+  "license",
+  "homepage",
+  "maintainers",
+  "rosters",
+]);
+
+const ROSTER_FIELDS = new Set(["id", "title", "status", "origin", "note"]);
+
+/** 顶层字段清单（供 schema 对齐测试反向钉住，避免两处各写一份）。 */
+export const ORGANIZATION_FIELDS = Object.freeze([...ROOT_FIELDS]);
+
+/** 每条登记项的字段清单。 */
+export const ORGANIZATION_ROSTER_FIELDS = Object.freeze([...ROSTER_FIELDS]);
+
+/**
+ * 一条诊断。形状与 `lib/validate.js` 保持一致，好让 render / panel / CLI 用同一套渲染。
+ *
+ * @param {"error"|"warn"|"info"} severity
+ * @param {string} code
+ * @param {string} file
+ * @param {string} reason
+ * @returns {{severity: string, code: string, path: string, file: string, reason: string}}
+ */
+function diagnose(severity, code, file, reason) {
+  return { severity, code, path: "", file, reason };
+}
+
+/**
+ * 校验一份组织档案。
+ *
+ * 与 roster 的校验同一条纪律：**能核对的才收**。`homepage` 只校验是不是 http(s)，
+ * 不联网；`maintainers` 只校验形态，不校验这个人存在不存在。
+ *
+ * @param {unknown} value 解析后的 JSON/YAML 值
+ * @param {{file?: string, expectedId?: string|null}} [options]
+ * @returns {{ok: boolean, organization: object|null, diagnostics: object[]}}
+ */
+export function validateOrganization(value, options = {}) {
+  const file = options.file ?? ORGANIZATION_FILE_NAMES[0];
+  const expectedId = options.expectedId ?? null;
+  /** @type {object[]} */
+  const diagnostics = [];
+
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    diagnostics.push(diagnose("error", "organization-not-object", file, "组织文件必须是一个对象（键值对）。"));
+    return { ok: false, organization: null, diagnostics };
+  }
+
+  for (const key of Object.keys(value)) {
+    if (!ROOT_FIELDS.has(key)) {
+      diagnostics.push(
+        diagnose(
+          "error",
+          "unknown-field",
+          file,
+          `未知字段 "${key}"。组织文件只收 ${[...ROOT_FIELDS].join(" / ")}：` +
+            "核对不了的字段不收——写了也不会被任何人验证，只会被误当成事实。",
+        ),
+      );
+    }
+  }
+
+  if (value.kind !== ORGANIZATION_KIND) {
+    diagnostics.push(
+      diagnose("error", "organization-kind", file, `kind 必须是 "${ORGANIZATION_KIND}"，实际是 ${JSON.stringify(value.kind)}。`),
+    );
+  }
+
+  const id = value.organization;
+  if (typeof id !== "string" || !ID_PATTERN.test(id)) {
+    diagnostics.push(
+      diagnose("error", "organization-id", file, "organization 必须是 2–64 位小写字母/数字/连字符，且以字母或数字开头。"),
+    );
+  } else if (expectedId !== null && id !== expectedId) {
+    diagnostics.push(
+      diagnose(
+        "error",
+        "organization-id-mismatch",
+        file,
+        `organization 是 "${id}"，但所在目录叫 "${expectedId}"。位置即身份：组织 id 必须等于目录名。`,
+      ),
+    );
+  }
+
+  const title = optionalString(value, "title", LIMITS.titleChars, diagnostics, file, "organization-title");
+  optionalString(value, "description", LIMITS.descriptionChars, diagnostics, file, "organization-description");
+  optionalString(value, "license", LIMITS.licenseChars, diagnostics, file, "organization-license");
+
+  if (value.homepage !== undefined) {
+    const homepage = optionalString(value, "homepage", LIMITS.homepageChars, diagnostics, file, "organization-homepage");
+    if (typeof homepage === "string" && !/^https?:\/\/\S+$/i.test(homepage)) {
+      diagnostics.push(
+        diagnose("error", "organization-homepage", file, "homepage 只收 http(s) 地址：别的写法既打不开也核对不了。"),
+      );
+    }
+  }
+
+  if (value.maintainers !== undefined) {
+    if (!Array.isArray(value.maintainers)) {
+      diagnostics.push(diagnose("error", "organization-maintainers", file, "maintainers 必须是字符串数组。"));
+    } else if (value.maintainers.length > LIMITS.maintainers) {
+      diagnostics.push(
+        diagnose("error", "organization-maintainers", file, `maintainers 最多 ${LIMITS.maintainers} 项。`),
+      );
+    } else {
+      for (const who of value.maintainers) {
+        if (typeof who !== "string" || who.length === 0 || who.length > LIMITS.maintainerChars) {
+          diagnostics.push(
+            diagnose("error", "organization-maintainer", file, `维护者名字必须是 1–${LIMITS.maintainerChars} 个字符的字符串。`),
+          );
+          break;
+        }
+      }
+    }
+  }
+
+  const rosters = [];
+  const rawRosters = value.rosters;
+  if (!Array.isArray(rawRosters) || rawRosters.length === 0) {
+    diagnostics.push(diagnose("error", "organization-rosters", file, "rosters 必须是非空数组：组织的意义就是登记这些档案。"));
+  } else if (rawRosters.length > LIMITS.rosters) {
+    diagnostics.push(diagnose("error", "organization-rosters", file, `rosters 最多 ${LIMITS.rosters} 项。`));
+  } else {
+    const seen = new Set();
+    rawRosters.forEach((item, index) => {
+      const where = `rosters[${index}]`;
+      if (item === null || typeof item !== "object" || Array.isArray(item)) {
+        diagnostics.push(diagnose("error", "organization-roster-not-object", file, `${where} 必须是对象。`));
+        return;
+      }
+      for (const key of Object.keys(item)) {
+        if (!ROSTER_FIELDS.has(key)) {
+          diagnostics.push(
+            diagnose("error", "unknown-field", file, `${where} 的未知字段 "${key}"（只收 ${[...ROSTER_FIELDS].join(" / ")}）。`),
+          );
+        }
+      }
+      if (typeof item.id !== "string" || !ID_PATTERN.test(item.id)) {
+        diagnostics.push(diagnose("error", "organization-roster-id", file, `${where}.id 必须是合法档案 id。`));
+        return;
+      }
+      if (seen.has(item.id)) {
+        diagnostics.push(
+          diagnose("error", "organization-duplicate-roster", file, `档案 "${item.id}" 在组织里登记了两次。`),
+        );
+        return;
+      }
+      seen.add(item.id);
+      const status = item.status ?? "active";
+      if (!ORGANIZATION_STATUSES.includes(status)) {
+        diagnostics.push(
+          diagnose("error", "organization-roster-status", file, `${where}.status 只能是 ${ORGANIZATION_STATUSES.join(" / ")}。`),
+        );
+      }
+      const entryTitle = optionalString(item, "title", LIMITS.titleChars, diagnostics, file, "organization-roster-title", where);
+      const origin = optionalString(item, "origin", LIMITS.titleChars, diagnostics, file, "organization-roster-origin", where);
+      const note = optionalString(item, "note", LIMITS.noteChars, diagnostics, file, "organization-roster-note", where);
+      rosters.push({
+        id: item.id,
+        title: entryTitle ?? "",
+        status,
+        origin: origin ?? "",
+        note: note ?? "",
+      });
+    });
+  }
+
+  if (diagnostics.some((item) => item.severity === "error")) {
+    return { ok: false, organization: null, diagnostics };
+  }
+
+  return {
+    ok: true,
+    organization: {
+      kind: ORGANIZATION_KIND,
+      id,
+      title: title ?? "",
+      description: value.description ?? "",
+      license: value.license ?? "",
+      homepage: value.homepage ?? "",
+      maintainers: Array.isArray(value.maintainers) ? [...value.maintainers] : [],
+      rosters,
+    },
+    diagnostics,
+  };
+}
+
+/**
+ * 读一个可选字符串字段并钉住上限。
+ *
+ * @param {object} source
+ * @param {string} key
+ * @param {number} max
+ * @param {object[]} diagnostics
+ * @param {string} file
+ * @param {string} code
+ * @param {string} [where]
+ * @returns {string|undefined}
+ */
+function optionalString(source, key, max, diagnostics, file, code, where = "") {
+  const value = source[key];
+  if (value === undefined) return undefined;
+  const label = where === "" ? key : `${where}.${key}`;
+  if (typeof value !== "string" || value.length > max) {
+    diagnostics.push(diagnose("error", code, file, `${label} 必须是长度不超过 ${max} 的字符串。`));
+    return undefined;
+  }
+  return value;
+}
+
+/**
+ * 组织声明与磁盘实际情况的交叉核对。
+ *
+ * 三件事分开说，因为它们的严重度不同：
+ * - **缺**（声明了却找不到目录）：error。组织页在撒谎，比没有组织页更糟。
+ * - **多**（目录在却没登记）：warn。不是错误，但意味着有人绕过组织加了档案。
+ * - **归档仍在**：info。归档是声明，不是删除；提醒一句即可。
+ *
+ * @param {object|null} organization
+ * @param {string[]} rosterIds 磁盘上真正通过校验的档案 id
+ * @returns {{declared: number, present: number, missing: string[], undeclared: string[], archived: string[], status: string}}
+ */
+export function checkOrganization(organization, rosterIds) {
+  const onDisk = new Set(rosterIds);
+  const declared = new Set(organization === null ? [] : organization.rosters.map((item) => item.id));
+  const missing = [...declared].filter((id) => !onDisk.has(id)).sort();
+  const undeclared = [...onDisk].filter((id) => !declared.has(id)).sort();
+  const archived = organization === null
+    ? []
+    : organization.rosters.filter((item) => item.status === "archived" && onDisk.has(item.id)).map((item) => item.id).sort();
+  return {
+    declared: declared.size,
+    present: onDisk.size,
+    missing,
+    undeclared,
+    archived,
+    status: organization === null ? "absent" : missing.length > 0 ? "incomplete" : "ok",
+  };
+}
+
+/**
+ * 把交叉核对结果折成诊断。
+ *
+ * @param {object|null} organization
+ * @param {object} check {@link checkOrganization} 的返回值
+ * @param {string} file 组织文件相对路径
+ * @returns {object[]}
+ */
+export function organizationDiagnostics(organization, check, file) {
+  const diagnostics = [];
+  if (organization === null) return diagnostics;
+  if (check.missing.length > 0) {
+    diagnostics.push(
+      diagnose(
+        "error",
+        "organization-roster-missing",
+        file,
+        `组织声明了 ${check.missing.length} 份档案但库里找不到：${check.missing.join(", ")}。` +
+          "要么把目录加回来，要么把它们从 organization 里删掉——组织页不能比磁盘更乐观。",
+      ),
+    );
+  }
+  if (check.undeclared.length > 0) {
+    diagnostics.push(
+      diagnose(
+        "warn",
+        "organization-roster-undeclared",
+        file,
+        `库里有 ${check.undeclared.length} 份档案没在组织里登记：${check.undeclared.join(", ")}。` +
+          "它们仍会被加载，但组织页看不到它们——补一行登记，或确认它们不该在这里。",
+      ),
+    );
+  }
+  if (check.archived.length > 0) {
+    diagnostics.push(
+      diagnose(
+        "info",
+        "organization-roster-archived",
+        file,
+        `已归档但仍在库里的档案：${check.archived.join(", ")}。归档只是声明，不影响加载。`,
+      ),
+    );
+  }
+  return diagnostics;
+}

package/lib/registry.js

@@ -27,6 +27,12 @@ import nodePath from "node:path";
 import { CAPABILITIES_FILE_NAMES, validateCapabilities } from "./capabilities.js";
 import { sha256Hex } from "./digest.js";
 import { MEMBER_FILE_NAMES } from "./format.js";
+import {
+  ORGANIZATION_FILE_NAMES,
+  checkOrganization,
+  organizationDiagnostics,
+  validateOrganization,
+} from "./organization.js";
 import { parseDocumentText } from "./parse.js";
 import { validateRoster } from "./validate.js";
 
@@ -57,6 +63,9 @@ export function scanRosterLibrary({ rootDir, knownToolPolicies = null }) {
   const capabilities = {};
   /** 档案 id → 能力要求的文件名（诊断要指到具体那份文件）。 */
   const capabilityFiles = {};
+  /** 组织档案（organization.yaml）与它的交叉核对结果。 */
+  let organization = null;
+  let organizationFile = null;
   const stats = {
     total: 0,
     ok: 0,
@@ -82,6 +91,8 @@ export function scanRosterLibrary({ rootDir, knownToolPolicies = null }) {
       if (child.name.startsWith(".") || SKIP_DIRS.has(child.name) || child.isSymbolicLink()) continue;
 
       if (!child.isDirectory()) {
+        // 库根上的 organization.yaml 是合法的：它是这座库的目录页，不是散落的档案。
+        if (ORGANIZATION_FILE_NAMES.includes(child.name)) continue;
         // 散落的 *.yaml 曾经是另一种布局；现在只认目录，必须明确告知而不是忽略。
         diagnostics.push({
           severity: "warn",
@@ -125,6 +136,17 @@ export function scanRosterLibrary({ rootDir, knownToolPolicies = null }) {
     }
   }
 
+  // 组织档案在目录扫完之后读：它的交叉核对需要知道磁盘上到底有哪些档案。
+  const wantedOrganization = loadOrganization(rootDir, nodePath.basename(rootDir));
+  organization = wantedOrganization.organization;
+  organizationFile = wantedOrganization.file;
+  diagnostics.push(...wantedOrganization.diagnostics);
+  const organizationCheck = checkOrganization(
+    organization,
+    rosters.map((item) => item.id),
+  );
+  diagnostics.push(...organizationDiagnostics(organization, organizationCheck, organizationFile ?? ORGANIZATION_FILE_NAMES[0]));
+
   if (stats.total > 0 && rosters.length === 0) {
     diagnostics.push({
       severity: "error",
@@ -165,7 +187,19 @@ export function scanRosterLibrary({ rootDir, knownToolPolicies = null }) {
       String(left.file ?? "").localeCompare(String(right.file ?? "")),
   );
 
-  return { rootDir, missing: childDirs === null, entries, rosters, capabilities, capabilityFiles, stats, diagnostics };
+  return {
+    rootDir,
+    missing: childDirs === null,
+    entries,
+    rosters,
+    capabilities,
+    capabilityFiles,
+    organization,
+    organizationFile,
+    organizationCheck,
+    stats,
+    diagnostics,
+  };
 }
 
 /**
@@ -280,6 +314,54 @@ function loadDocument(found, expectedId, { knownToolPolicies }, rawText = null)
  * @param {string} dirName 目录名（同时也是期望的 `roster` 字段）
  * @returns {{ capabilities: object | null, file: string | null, diagnostics: object[] }}
  */
+export function loadOrganization(rootDir, dirName) {
+  let names;
+  try {
+    names = readdirSync(rootDir);
+  } catch {
+    return { organization: null, file: null, diagnostics: [] };
+  }
+  const present = ORGANIZATION_FILE_NAMES.filter((name) => names.includes(name));
+  if (present.length === 0) return { organization: null, file: null, diagnostics: [] };
+
+  const diagnostics = [];
+  const relative = present[0];
+  if (present.length > 1) {
+    diagnostics.push({
+      severity: "warn",
+      code: "multiple-organization-files",
+      path: "",
+      file: relative,
+      reason:
+        `档案库同时存在 ${present.join("、")}，只读 ${present[0]}；` +
+        "请删掉多余文件，否则另一份永远不会生效。",
+    });
+  }
+
+  let raw;
+  try {
+    raw = readFileSync(nodePath.join(rootDir, relative), "utf8");
+  } catch (error) {
+    diagnostics.push({
+      severity: "error",
+      code: "unreadable-file",
+      path: "",
+      file: relative,
+      reason: `文件不可读：${messageOf(error)}`,
+    });
+    return { organization: null, file: relative, diagnostics };
+  }
+
+  const format = relative.endsWith(".json") ? "json" : "yaml";
+  const parsed = parseDocumentText(raw, { file: relative, format });
+  if (!parsed.ok) return { organization: null, file: relative, diagnostics: [...diagnostics, ...parsed.diagnostics] };
+
+  const validated = validateOrganization(parsed.value, { file: relative, expectedId: dirName });
+  diagnostics.push(...validated.diagnostics);
+  if (!validated.ok) return { organization: null, file: relative, diagnostics };
+  return { organization: validated.organization, file: relative, diagnostics };
+}
+
 export function loadCapabilities(dirPath, dirName) {
   let names;
   try {

package/lib/remote.js

@@ -42,7 +42,7 @@ export const MIN_REFRESH_MS = 60 * 1000;
 
 /** 官方 registry 地址（本仓库的 `index/registry.json`，合并 PR 即更新）。 */
 export const DEFAULT_REGISTRY_URL =
-  "https://raw.githubusercontent.com/STofone/dsh-agent-roster/main/index/registry.json";
+  "https://raw.githubusercontent.com/dsh-agent-roster/dsh-agent-roster/main/index/registry.json";
 
 /** 缓存目录名，放在档案库根下，跟着 `$DSH_HOME` 走。 */
 export const CACHE_DIR_NAME = ".index-cache";

package/lib/render.js

@@ -89,6 +89,21 @@ export function renderRosterList(scan) {
   const { entries, stats, rootDir } = scan;
   const lines = [];
   lines.push(`档案库  ${rootDir}`);
+  const organization = scan.organization ?? null;
+  if (organization !== null) {
+    const check = scan.organizationCheck ?? { declared: 0, present: 0, missing: [], undeclared: [], archived: [] };
+    lines.push(`组织    ${organization.id}  ${organization.title}`);
+    if (organization.description !== "") lines.push(`        ${organization.description}`);
+    const parts = [
+      `登记 ${check.declared}`,
+      `在库 ${check.present}`,
+      `缺 ${check.missing.length}`,
+      `未登记 ${check.undeclared.length}`,
+    ];
+    if (check.archived.length > 0) parts.push(`已归档 ${check.archived.length}`);
+    if (organization.maintainers.length > 0) parts.push(`维护者 ${organization.maintainers.join(", ")}`);
+    lines.push(`        ${parts.join(" · ")}`);
+  }
   if (entries.length === 0) {
     lines.push("");
     lines.push(scan.missing === true ? "（目录尚未创建：保存第一份档案时会自动建）" : "（空：没有任何 roster 目录）");

package/lib/tools.js

@@ -94,6 +94,7 @@ export function registerRosterTools(ctx, config, meta) {
             const text = [
               statusLine("roster_list", {
                 rootDir: rosterDir,
+                organization: scan.organization === null ? "none" : scan.organization.id,
                 total: scan.stats.total,
                 ok: scan.stats.ok,
                 failed: scan.stats.failed,
@@ -106,6 +107,8 @@ export function registerRosterTools(ctx, config, meta) {
               workspace,
               rootDir: rosterDir,
               stats: scan.stats,
+              organization: scan.organization,
+              organizationCheck: scan.organizationCheck,
               rosters: scan.rosters.map((roster) => ({
                 id: roster.id,
                 version: roster.version,

package/orgs/agent-roster-collective/api-design/roster.yaml

@@ -0,0 +1,67 @@
+# API 设计评审组
+#
+# 本档案由本项目自撰（未复制任何上游文本），用于演示同一座档案库里的多种团队形态。
+# 目录约定：<root>/<roster-id>/roster.yaml，且 roster 必须等于目录名。
+kind: dsh-agent-roster/v1
+roster: api-design
+version: 1.0.0
+title: API 设计评审组
+description: 在写第一行实现之前，把接口的形状、演进与失败语义定下来。
+license: MIT
+maintainers:
+  - STofone
+tags:
+  - api
+  - design
+  - review
+
+defaults:
+  provider: deepseek
+  model: deepseek-v4.1-flash
+  reasoningEffort: high
+
+members:
+  - name: lead
+    role: 接口负责人
+    title: 决定这版接口要不要开工
+    description: 定资源模型与边界，只在两方僵持时裁决；不写实现。
+    systemPrompt: |
+      你负责这次接口评审的编排：先把资源模型、边界与调用方列清楚，再分给两名评审者，最后合并成一份结论。
+      不要自己写实现，也不要替调用方假设需求；需求不明就明确写“需要调用方确认”，不要补全。
+      结论必须能直接贴进设计文档：决定在前、理由在后，每条都注明是哪位评审者的证据。
+      证据不足时给出“暂不定”的选项，并写清还差哪一条信息才能定。
+    tags:
+      - orchestration
+  - name: schema
+    role: 结构与演进评审
+    title: 看命名、分页、错误码与兼容性
+    description: 只关心结构能不能长期演进：字段命名、分页、幂等、版本与弃用路径。
+    toolScope:
+      allow:
+        - read
+        - grep
+        - glob
+    systemPrompt: |
+      你只看结构层面：字段命名是否自解释、分页与过滤是否可组合、写操作是否幂等、错误码能否让调用方分辨“重试有用/没用”。
+      不评论实现细节与性能数据，那是另一个人的事；也不要提议重写整个资源模型。
+      每条问题给出最小修改方向，并标注它是“现在改”还是“下个版本改”。
+      对兼容性拿不准时，写成“破坏性：是/不确定”，不要默认无害。
+    tags:
+      - schema
+      - compatibility
+  - name: failure-mode
+    role: 失败语义评审
+    title: 想清楚超时、重试与部分成功
+    description: 逐个接口问“失败时调用方看到什么”，把部分成功与重试放大写进契约。
+    toolScope:
+      allow:
+        - read
+        - grep
+        - glob
+    systemPrompt: |
+      你只问一件事：这个接口失败时调用方看到什么、能不能安全重试、会不会把一次失败放大成多次副作用。
+      不讨论字段命名与版本策略；只输出失败场景、可观测信号与契约要求。
+      每条场景写成“触发条件 → 调用方看到的状态 → 要求实现方保证什么”。
+      无法判定是否幂等的接口，直接要求补幂等键，不要用“一般来说”糊过去。
+    tags:
+      - reliability

package/orgs/agent-roster-collective/content-ops/roster.yaml

@@ -0,0 +1,55 @@
+# 内容运营组
+#
+# 本档案由本项目自撰（未复制任何上游文本），用于演示同一座档案库里的多种团队形态。
+# 目录约定：<root>/<roster-id>/roster.yaml，且 roster 必须等于目录名。
+kind: dsh-agent-roster/v1
+roster: content-ops
+version: 1.0.0
+title: 内容运营组
+description: 一次发布：选题、成稿、分发，三件事各有验收。
+license: MIT
+maintainers:
+  - STofone
+tags:
+  - content
+  - publishing
+
+defaults:
+  provider: deepseek
+  model: deepseek-v4.1-flash
+  reasoningEffort: high
+
+members:
+  - name: lead
+    role: 内容负责人
+    title: 定选题与验收
+    description: 决定写给谁、解决什么、发到哪里；不写正文。
+    systemPrompt: |
+      你定选题：读者是谁、读完能带走什么、发在哪个渠道，以及每项的验收。
+      不写正文，也不做排版；你负责取舍与排期。
+      产出是一页 brief：读者 · 主张 · 证据要求 · 渠道 · 截止。
+      选题无法说清“读者为什么要读”时，换题而不是硬写。
+    tags:
+      - brief
+  - name: editor
+    role: 成稿编辑
+    title: 让主张站得住、句子能被读完
+    description: 砍掉形容词，补上证据；每段只做一件事。
+    systemPrompt: |
+      你编辑成稿：每段一个意思，删掉无法验证的形容词，给每个主张补证据或删除。
+      不改事实，也不加未经验证的数据；发现缺证据就标出来让对方补。
+      交付改后稿 + 一段“我删了什么、为什么”。
+      拿不准的事实一律降级为“据说/待确认”，不要保留确定性语气。
+    tags:
+      - editing
+  - name: distributor
+    role: 分发与回读
+    title: 让内容被该看到的人看到
+    description: 按渠道改写首段与标题，发布后回收读数。
+    systemPrompt: |
+      你按渠道改写标题与首段（同一主张不同入口），并规划发布时间与配套动作。
+      不改正文主张；只调整入口表达与分发节奏。
+      发布后回收读数：曝光、点击、读完率，并说明哪些指标不可得。
+      读数缺失时如实写“无法获取”，不要用估算值冒充实测。
+    tags:
+      - distribution

package/orgs/agent-roster-collective/contract-review/roster.yaml

@@ -0,0 +1,58 @@
+# 合同审阅组
+#
+# 本档案由本项目自撰（未复制任何上游文本），用于演示同一座档案库里的多种团队形态。
+# 目录约定：<root>/<roster-id>/roster.yaml，且 roster 必须等于目录名。
+kind: dsh-agent-roster/v1
+roster: contract-review
+version: 1.0.0
+title: 合同审阅组
+description: 找到会让你赔钱、被锁定或无法退出的条款。
+license: MIT
+maintainers:
+  - STofone
+tags:
+  - legal
+  - contract
+
+defaults:
+  provider: deepseek
+  model: deepseek-v4.1-flash
+  reasoningEffort: high
+
+members:
+  - name: lead
+    role: 审阅负责人
+    title: 定立场与红线
+    description: 确认我方角色、可接受与不可接受的条款；不逐条读。
+    systemPrompt: |
+      你先确认我方角色与商业目标，再定红线：哪些条款出现就不签。
+      不逐条解释条款；你负责范围与最终建议（签 / 改 / 不签）。
+      产出是红线清单 + 建议的谈判顺序。
+      立场不明时先问“最坏情况下我们能承受什么”，不要默认接受。
+    tags:
+      - position
+  - name: clause-reader
+    role: 条款识别
+    title: 把关键条款摘出来并定位
+    description: 找责任限制、赔偿、终止、续约、知识产权、争议解决。
+    toolScope:
+      allow:
+        - read
+    systemPrompt: |
+      你摘出关键条款：责任上限、赔偿、终止与续约、知识产权归属、保密、争议解决。
+      不做商业判断；每条必须给条款编号与原文摘录。
+      输出“条款 · 原文 · 位置 · 对我方的影响（有利/中性/不利）”。
+      条款缺失同样重要：明确写“未见某类条款”，不要当作默认有利。
+    tags:
+      - clauses
+  - name: risk-note
+    role: 风险提示
+    title: 把条款翻译成钱的后果
+    description: 用最坏情形估算敞口，给出可接受的修改方向。
+    systemPrompt: |
+      你把条款翻译成后果：最坏情形下赔多少、被锁定多久、退出成本多少。
+      不写法律意见书，也不替代律师；你给的是量化提示与修改方向。
+      输出“风险 · 触发条件 · 最坏敞口 · 建议改法（一句话）”。
+      无法量化时给区间并说明假设，不要给“风险较低”这种结论。
+    tags:
+      - risk