@archsight/aios 1.3.2 → 1.5.0

package/bin/archsight-aios.mjs

@@ -3,6 +3,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
+import crypto from "node:crypto";
+import readline from "node:readline";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
@@ -14,6 +16,7 @@ const home = os.homedir();
 const managedStart = "<!-- ARCHSIGHT-AIOS:START -->";
 const managedEnd = "<!-- ARCHSIGHT-AIOS:END -->";
 const antigravityPluginName = "archsight-aios";
+const aiosVersion = "1.5.0";
 
 const assetDirs = [
   "skills",
@@ -55,12 +58,24 @@ const skillAliases = {
     "archsight-ai-runtime-design"
   ],
   "aios-exec": ["aios-controlled-execution", "archsight-controlled-execution"],
-  "aios-commercial-tender": ["aios-tender", "archsight-tender"],
-  "aios-commercial-contract": ["aios-contract", "archsight-contract"],
+  "aios-tender": ["archsight-tender"],
+  "aios-tender-audit": ["aios-tender-review", "aios-bid-audit", "archsight-tender-audit"],
+  "aios-commercial-tender": ["aios-commercial-bid", "archsight-commercial-tender"],
+  "aios-tender-write": ["aios-bid-write", "archsight-bid-write", "aios-technical-bid-write"],
+  "aios-contract-audit": ["aios-contract", "aios-contract-review", "archsight-contract-audit"],
+  "aios-contract-draft": ["aios-contract-write", "aios-contract-letter", "archsight-contract-draft"],
+  "aios-commercial-contract": ["archsight-commercial-contract"],
   "aios-commercial-variation": ["aios-variation", "archsight-variation"],
-  "aios-construction-daily": ["aios-daily", "archsight-daily"],
-  "aios-construction-meeting": ["aios-meeting", "archsight-meeting"],
-  "aios-construction-scheme": ["aios-scheme", "archsight-scheme"]
+  "aios-daily": ["aios-site-daily", "archsight-daily"],
+  "aios-daily-write": ["aios-daily-report-write", "archsight-daily-write"],
+  "aios-construction-daily": ["archsight-construction-daily"],
+  "aios-meeting": ["aios-site-meeting", "archsight-meeting"],
+  "aios-meeting-write": ["aios-minutes-write", "archsight-meeting-write"],
+  "aios-construction-meeting": ["archsight-construction-meeting"],
+  "aios-scheme": ["archsight-scheme"],
+  "aios-scheme-audit": ["aios-scheme-review", "aios-construction-scheme-audit", "archsight-scheme-audit"],
+  "aios-construction-scheme": ["archsight-construction-scheme"],
+  "aios-scheme-write": ["aios-construction-scheme-write", "archsight-scheme-write"]
 };
 
 const profileDetectionRules = {
@@ -113,6 +128,8 @@ const profileDetectionRules = {
     "条文",
     "审图",
     "标准",
+    "knowledge pack",
+    "知识包",
     "检索",
     "向量",
     "embedding",
@@ -126,17 +143,29 @@ const skillDetectionRules = {
   "aios-design": ["界面", "ui", "ux", "工作台", "交互", "原型"],
   "aios-plan": ["计划", "排期", "里程碑", "任务拆解", "交付"],
   "aios-review": ["code review", "代码审查", "安全审查", "技术债"],
-  "aios-knowledge": ["bim", "ifc", "规范", "审图", "条文", "知识结构化"],
+  "aios-knowledge": ["bim", "ifc", "规范", "审图", "条文", "知识结构化", "knowledge pack", "知识包"],
   "aios-structural": ["结构", "荷载", "挠度", "fem", "有限元", "计算书"],
-  "aios-runtime": ["rag", "graphrag", "mcp", "tool calling", "memory", "agent runtime"],
+  "aios-runtime": ["rag", "graphrag", "mcp", "tool calling", "memory", "agent runtime", "reference runtime"],
   "aios-compare": ["aios-compare"],
   "aios-prompt-compare": ["aios-prompt-compare"],
+  "aios-tender": ["招标", "投标", "技术标", "商务标", "招采"],
+  "aios-tender-audit": ["读标", "评标办法", "评分", "废标", "资格", "响应性", "资料缺口", "技术标复核", "投标复核"],
   "aios-commercial-tender": ["招标", "投标", "技术标", "商务标", "评分", "废标", "招采", "资格"],
+  "aios-tender-write": ["标书编写", "技术标编写", "技术标生成", "技术标改写", "投标文件生成", "投标响应生成", "标书优化", "标书改写", "历史标书", "评分点响应"],
+  "aios-contract-audit": ["合同审核", "合同复核", "合同履约", "付款条件", "责任边界", "违约风险", "合同资料缺口", "补充协议复核"],
+  "aios-contract-draft": ["合同草拟", "补充协议草稿", "条款改写", "履约通知", "催款函", "回函", "合同交底", "合同函件"],
   "aios-commercial-contract": ["合同", "协议", "付款", "履约", "违约", "分包", "采购", "结算条款"],
+  "aios-daily": ["施工日报", "项目日报", "现场日报", "周报素材", "现场记录", "施工日志"],
+  "aios-daily-write": ["日报生成", "日报编写", "施工日报生成", "项目日报生成", "周报生成", "现场记录整理", "口述日报"],
   "aios-construction-daily": ["日报", "周报", "现场记录", "施工日志", "进度", "材料进场", "机械", "劳务"],
+  "aios-meeting": ["会议纪要", "工程会议", "例会", "协调会", "专题会", "交底会", "待办闭环"],
+  "aios-meeting-write": ["会议纪要生成", "会议纪要编写", "会议记录整理", "录音转写", "会议待办生成", "纪要草稿"],
   "aios-construction-meeting": ["会议纪要", "例会", "协调会", "专题会", "待办", "责任人"],
   "aios-commercial-variation": ["变更", "签证", "联系单", "索赔", "洽商", "工程量"],
-  "aios-construction-scheme": ["施工方案", "专项方案", "危大", "交底", "危险源", "专家论证"]
+  "aios-scheme": ["施工方案", "专项方案", "危大", "交底"],
+  "aios-scheme-audit": ["方案复核", "危险源", "计算书缺口", "专家意见回查", "专家论证", "交底要点", "规范核验"],
+  "aios-construction-scheme": ["施工方案", "专项方案", "危大", "交底", "危险源", "专家论证"],
+  "aios-scheme-write": ["方案编写", "方案生成", "施工方案生成", "专项施工方案生成", "方案改写", "施工方案改写", "方案优化", "历史方案", "专家意见回写", "施工方案初稿"]
 };
 
 const ignoredDetectionDirs = new Set([
@@ -164,6 +193,14 @@ function usage() {
     "  archsight-aios install --target <codex|agents|gemini|antigravity|workbuddy|opencode|claude-code|all> --scope user",
     "  archsight-aios doctor",
     "  archsight-aios init [--cwd <path>] [--mode <auto|full|linked|ai-only>] [--profile <auto|none|all|name>]",
+    "  archsight-aios writing:init [--cwd <path>] [--type <tender|scheme|general>] [--name <folder>] [--sample]",
+    "  archsight-aios writing:validate [--cwd <path>] [--name <folder>]",
+    "  archsight-aios knowledge:init [--cwd <path>] [--name <folder>] [--sample]",
+    "  archsight-aios knowledge:validate [--cwd <path>] [--name <folder>]",
+    "  archsight-aios knowledge:compile [--cwd <path>] [--name <folder>] [--out <json-file>]",
+    "  archsight-aios knowledge:inspect [--cwd <path>] [--name <folder>] [--pack <json-file>]",
+    "  archsight-aios knowledge:lookup --pack <json-file> --query <text> [--region <id>] [--discipline <id>] [--source-version <version>] [--project-condition <text>]",
+    "  archsight-aios knowledge:eval [--cwd <path>] [--name <folder>] [--pack <json-file>]",
     "  archsight-aios validate [--cwd <path>] [--profile <auto|none|all|name>] [--temp]",
     "  archsight-aios capability:call --capability <id> --agent <id> --skill <id> --input <json-file>",
     "  archsight-aios hermes:validate",
@@ -175,6 +212,9 @@ function usage() {
     "  install               Install AIOS assets into user-level assistant locations.",
     "  doctor                Check repository assets and user-level installation.",
     "  init                  Add AI rules and .ai governance files to a project.",
+    "  writing:init          Create a Markdown document-writing workbench.",
+    "  writing:validate      Check a Markdown document-writing workbench.",
+    "  knowledge:*           Create, compile, query, and evaluate AIOS Knowledge Packs.",
     "  validate              Validate the project AI template output.",
     "  capability:call       Authorize and call a registered local Capability adapter.",
     "  hermes:*              Validate or dry-run Hermes runtime prompt sync.",
@@ -186,6 +226,12 @@ function usage() {
     "  npx @archsight/aios install --target opencode --scope user",
     "  npx @archsight/aios install --target claude-code --scope user",
     "  npx @archsight/aios init",
+    "  npx @archsight/aios writing:init --type tender",
+    "  npx @archsight/aios writing:init --type scheme --sample --name scheme-sample",
+    "  npx @archsight/aios writing:validate --name document-writing",
+    "  npx @archsight/aios knowledge:init --sample --name scheme-review",
+    "  npx @archsight/aios knowledge:compile --name scheme-review",
+    "  npx @archsight/aios knowledge:lookup --pack scheme-review/compiled/knowledge-pack.json --query \"高支模方案是否应检查计算书\"",
     "  npx @archsight/aios validate --temp",
     "  npx @archsight/aios doctor"
   ].join("\n");
@@ -206,6 +252,16 @@ function parseArgs(argv) {
     capability: undefined,
     agent: undefined,
     skill: undefined,
+    documentType: "general",
+    workspaceName: "document-writing",
+    sample: false,
+    pack: undefined,
+    out: undefined,
+    query: undefined,
+    region: undefined,
+    discipline: undefined,
+    sourceVersion: undefined,
+    projectCondition: undefined,
     input: undefined,
     mcpCwd: undefined,
     mcpCommand: undefined,
@@ -233,6 +289,26 @@ function parseArgs(argv) {
       options.agent = rest[++i];
     } else if (arg === "--skill") {
       options.skill = rest[++i];
+    } else if (arg === "--type") {
+      options.documentType = rest[++i];
+    } else if (arg === "--name") {
+      options.workspaceName = rest[++i];
+    } else if (arg === "--sample") {
+      options.sample = true;
+    } else if (arg === "--pack") {
+      options.pack = path.resolve(rest[++i]);
+    } else if (arg === "--out") {
+      options.out = path.resolve(rest[++i]);
+    } else if (arg === "--query") {
+      options.query = rest[++i];
+    } else if (arg === "--region") {
+      options.region = rest[++i];
+    } else if (arg === "--discipline") {
+      options.discipline = rest[++i];
+    } else if (arg === "--source-version") {
+      options.sourceVersion = rest[++i];
+    } else if (arg === "--project-condition") {
+      options.projectCondition = rest[++i];
     } else if (arg === "--input") {
       options.input = path.resolve(rest[++i]);
     } else if (arg === "--mcp-cwd") {
@@ -353,7 +429,7 @@ async function readManifest() {
 
 async function readJson(filePath) {
   const raw = await fs.readFile(filePath, "utf8");
-  return JSON.parse(raw);
+  return JSON.parse(raw.replace(/^\uFEFF/, ""));
 }
 
 async function readCapabilityRegistry() {
@@ -625,7 +701,7 @@ function callMcpStdio({ command, args, cwd, toolName, input, timeoutMs }) {
       params: {
         protocolVersion: "2025-06-18",
         capabilities: {},
-        clientInfo: { name: "archsight-aios", version: "1.3.2" }
+        clientInfo: { name: "archsight-aios", version: aiosVersion }
       }
     };
     const callTool = {
@@ -971,15 +1047,32 @@ function confidenceFromScore(score) {
   return "low";
 }
 
-function scoreDetectionRules(ruleMap, signalText) {
+function detectionKeywordWeight(keyword, weighted) {
+  if (!weighted) {
+    return 1;
+  }
+
+  const length = normalizeSignal(keyword).trim().length;
+  if (length >= 8) {
+    return 4;
+  }
+  if (length >= 5) {
+    return 3;
+  }
+  return 1;
+}
+
+function scoreDetectionRules(ruleMap, signalText, options = {}) {
   const normalized = normalizeSignal(signalText);
   return Object.entries(ruleMap)
     .map(([id, keywords]) => {
       const matches = keywords.filter((keyword) => normalized.includes(normalizeSignal(keyword)));
+      const score = matches.reduce((sum, keyword) => sum + detectionKeywordWeight(keyword, options.weighted), 0);
       return {
         id,
-        score: matches.length,
-        confidence: matches.length > 0 ? confidenceFromScore(matches.length) : "none",
+        score,
+        matchCount: matches.length,
+        confidence: score > 0 ? confidenceFromScore(score) : "none",
         matches
       };
     })
@@ -1077,7 +1170,7 @@ async function collectProjectDiscovery(targetRoot) {
 
 function detectProjectContext(manifest, discovery) {
   const profileScores = scoreDetectionRules(profileDetectionRules, discovery.signalText);
-  const skillScores = scoreDetectionRules(skillDetectionRules, discovery.signalText);
+  const skillScores = scoreDetectionRules(skillDetectionRules, discovery.signalText, { weighted: true });
   const profileDescriptions = new Map((manifest.projectProfiles ?? []).map((profile) => [profile.id, profile.description]));
   const skillMetadata = new Map((manifest.skills ?? []).map((skill) => [skill.id, skill]));
 
@@ -1129,7 +1222,10 @@ function renderMatchList(scores, emptyText) {
 
   return scores.map((item) => {
     const matches = item.matches.slice(0, 8).join("、");
-    return `- \`${item.id}\`：${item.confidence}，命中 ${item.score} 项（${matches}）`;
+    const scoreText = item.matchCount && item.matchCount !== item.score
+      ? `命中 ${item.matchCount} 项，权重 ${item.score}`
+      : `命中 ${item.score} 项`;
+    return `- \`${item.id}\`：${item.confidence}，${scoreText}（${matches}）`;
   });
 }
 
@@ -1755,6 +1851,809 @@ async function initProject(options) {
   }
 }
 
+function resolveDocumentWritingType(value) {
+  const normalized = normalizeSignal(value ?? "general").replaceAll("_", "-");
+  const aliases = new Map([
+    ["general", "general"],
+    ["all", "general"],
+    ["通用", "general"],
+    ["tender", "tender"],
+    ["bid", "tender"],
+    ["technical-bid", "tender"],
+    ["标书", "tender"],
+    ["技术标", "tender"],
+    ["投标", "tender"],
+    ["scheme", "scheme"],
+    ["construction-scheme", "scheme"],
+    ["方案", "scheme"],
+    ["施工方案", "scheme"],
+    ["专项施工方案", "scheme"]
+  ]);
+
+  const type = aliases.get(normalized);
+  if (!type) {
+    throw new Error(`Unsupported writing workspace type: ${value}`);
+  }
+  return type;
+}
+
+function documentWritingTypeConfig(type) {
+  const configs = {
+    general: {
+      label: "工程文档写作",
+      skill: "aios-tender-write / aios-scheme-write",
+      gate: "aios-tender-audit / aios-scheme-audit",
+      firstStep: "先在 writing-brief.md 明确是标书、技术标、专项施工方案还是交底材料。"
+    },
+    tender: {
+      label: "标书 / 技术标写作",
+      skill: "aios-tender-write",
+      gate: "aios-tender-audit",
+      firstStep: "先把招标文件、评分办法、技术要求、用户初稿和历史标书索引写入工作母版。"
+    },
+    scheme: {
+      label: "专项施工方案写作",
+      skill: "aios-scheme-write",
+      gate: "aios-scheme-audit",
+      firstStep: "先把工程概况、方案初稿、历史方案、专家意见和计算书目录写入工作母版。"
+    }
+  };
+  return configs[type];
+}
+
+function renderDocumentWritingReadme(type) {
+  const config = documentWritingTypeConfig(type);
+  return [
+    "# AIOS Document Writing Workbench",
+    "",
+    `> 类型：${config.label}`,
+    "",
+    "## 使用顺序",
+    "",
+    "1. 在 `source-normalized.md` 中归一化输入资料，只写来源明确的事实。",
+    "2. 在 `material-index.md` 中登记历史素材、复用级别和不可复用原因。",
+    "3. 在 `writing-brief.md` 中明确写作任务、目标章节、人工复核岗位和禁止结论。",
+    "4. 使用对应写作 Skill 生成或改写 `draft.md`。",
+    "5. 把草稿交给审核门禁 Skill，审核结论写入 `review-notes.md`。",
+    "6. 人工确认后再整理 `final.md`，Word / PDF / PPT 只作为交付格式。",
+    "",
+    "## 推荐 Skill",
+    "",
+    `- 写作入口：\`${config.skill}\``,
+    `- 审核门禁：\`${config.gate}\``,
+    "",
+    "## 首步动作",
+    "",
+    config.firstStep,
+    "",
+    "## 边界",
+    "",
+    "- 不编造资质、业绩、人员、设备、工期、金额、奖项或项目事实。",
+    "- 缺少依据时写 `待补`、`需核验` 或 `转人工复核`。",
+    "- AI 输出是 Markdown 工作母版，不是正式交付定稿。",
+    ""
+  ].join("\n");
+}
+
+async function initDocumentWritingWorkspace(options) {
+  const targetRoot = path.resolve(options.cwd);
+  const workspaceName = options.workspaceName ?? "document-writing";
+  if (!workspaceName || path.isAbsolute(workspaceName)) {
+    throw new Error("--name must be a relative folder name");
+  }
+
+  const requestedType = resolveDocumentWritingType(options.documentType);
+  const type = options.sample && requestedType === "general" ? "tender" : requestedType;
+  const templateRoot = options.sample
+    ? path.join(repoRoot, "templates", "document-writing-samples", type)
+    : path.join(repoRoot, "templates", "document-writing");
+  const workspaceRoot = path.resolve(targetRoot, workspaceName);
+  assertInside(workspaceRoot, targetRoot);
+
+  await ensureDir(targetRoot);
+  await copyTreeMissing(templateRoot, workspaceRoot);
+
+  const readmePath = path.join(workspaceRoot, "README.md");
+  assertInside(readmePath, workspaceRoot);
+  if (await exists(readmePath)) {
+    console.log(`SKIP existing ${readmePath}`);
+  } else {
+    await fs.writeFile(readmePath, renderDocumentWritingReadme(type), "utf8");
+    console.log(`CREATE ${readmePath}`);
+  }
+
+  console.log(`WRITING ${type}: ${workspaceRoot}`);
+}
+
+const documentWritingFiles = [
+  "source-normalized.md",
+  "material-index.md",
+  "writing-brief.md",
+  "draft.md",
+  "review-notes.md",
+  "final.md"
+];
+
+async function resolveDocumentWritingWorkspaceRoot(options) {
+  const targetRoot = path.resolve(options.cwd);
+  const workspaceName = options.workspaceName ?? "document-writing";
+  if (!workspaceName || path.isAbsolute(workspaceName)) {
+    throw new Error("--name must be a relative folder name");
+  }
+
+  const namedRoot = path.resolve(targetRoot, workspaceName);
+  assertInside(namedRoot, targetRoot);
+  if (await exists(namedRoot)) {
+    return namedRoot;
+  }
+
+  let targetRootHasWorkbench = true;
+  for (const fileName of documentWritingFiles) {
+    if (!(await exists(path.join(targetRoot, fileName)))) {
+      targetRootHasWorkbench = false;
+      break;
+    }
+  }
+  if (targetRootHasWorkbench) {
+    return targetRoot;
+  }
+
+  return namedRoot;
+}
+
+async function validateDocumentWritingWorkspace(options) {
+  const workspaceRoot = await resolveDocumentWritingWorkspaceRoot(options);
+  const checks = [];
+
+  async function check(label, ok, detail = "") {
+    checks.push({ label, ok, detail });
+  }
+
+  await check("workspace directory", await exists(workspaceRoot), workspaceRoot);
+  for (const fileName of documentWritingFiles) {
+    const filePath = path.join(workspaceRoot, fileName);
+    const ok = await exists(filePath);
+    await check(`${fileName} exists`, ok, filePath);
+    if (!ok) {
+      continue;
+    }
+    const content = await fs.readFile(filePath, "utf8");
+    await check(`${fileName} is non-empty`, content.trim().length > 0, filePath);
+  }
+
+  const source = await readTextIfExists(path.join(workspaceRoot, "source-normalized.md"));
+  const materials = await readTextIfExists(path.join(workspaceRoot, "material-index.md"));
+  const brief = await readTextIfExists(path.join(workspaceRoot, "writing-brief.md"));
+  const draft = await readTextIfExists(path.join(workspaceRoot, "draft.md"));
+  const review = await readTextIfExists(path.join(workspaceRoot, "review-notes.md"));
+  const final = await readTextIfExists(path.join(workspaceRoot, "final.md"));
+
+  await check("source-normalized keeps source list", source.includes("资料来源清单"));
+  await check("material-index keeps reuse levels", materials.includes("复用级别"));
+  await check("writing-brief keeps banned claims", brief.includes("禁止承诺") || brief.includes("禁止结论"));
+  await check("draft keeps provenance placeholders", draft.includes("来源") && draft.includes("待补"));
+  await check(
+    "review-notes keeps audit gate",
+    review.includes("aios-tender-audit") ||
+      review.includes("aios-scheme-audit") ||
+      review.includes("aios-commercial-tender") ||
+      review.includes("aios-construction-scheme")
+  );
+  await check("final keeps manual confirmation", final.includes("人工") && final.includes("定稿"));
+
+  const failed = checks.filter((item) => !item.ok);
+  for (const item of checks) {
+    console.log(`${item.ok ? "OK " : "MISS"} ${item.label}${item.detail ? `: ${item.detail}` : ""}`);
+  }
+
+  if (failed.length > 0) {
+    process.exitCode = 1;
+    console.error(`Writing workbench validation failed: ${failed.length} issue(s).`);
+    return;
+  }
+
+  console.log(`Writing workbench validation passed: ${workspaceRoot}`);
+}
+
+const knowledgePackFiles = [
+  "knowledge-pack.source.json",
+  "source-register.md",
+  "standard-register.md",
+  "clause-map.md",
+  "entity-relation-map.md",
+  "eval-questions.md",
+  "review-notes.md"
+];
+
+function knowledgePackSourcePath(workspaceRoot) {
+  return path.join(workspaceRoot, "knowledge-pack.source.json");
+}
+
+function compiledKnowledgePackPath(workspaceRoot) {
+  return path.join(workspaceRoot, "compiled", "knowledge-pack.json");
+}
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function sha256(text) {
+  return crypto.createHash("sha256").update(text).digest("hex");
+}
+
+function collection(source, key) {
+  return Array.isArray(source?.[key]) ? source[key] : [];
+}
+
+function validateKnowledgePackSource(source) {
+  const checks = [];
+
+  function check(label, ok, detail = "") {
+    checks.push({ label, ok: Boolean(ok), detail });
+  }
+
+  check("source is object", isObject(source));
+  if (!isObject(source)) {
+    return checks;
+  }
+
+  check("schema is 1", source.schema === 1, "schema === 1");
+  check("pack metadata exists", isObject(source.pack));
+  check("pack.id exists", typeof source.pack?.id === "string" && source.pack.id.length > 0);
+  check("pack.title exists", typeof source.pack?.title === "string" && source.pack.title.length > 0);
+  check("pack.version exists", typeof source.pack?.version === "string" && source.pack.version.length > 0);
+  check("pack.status valid", ["draft", "reviewed", "blocked", "published"].includes(source.pack?.status));
+  check("pack.dataBoundary exists", typeof source.pack?.dataBoundary === "string" && source.pack.dataBoundary.length > 0);
+
+  for (const key of ["sources", "standards", "clauses", "entities", "relations", "lookupRules", "evalQuestions"]) {
+    check(`${key} is non-empty array`, Array.isArray(source[key]) && source[key].length > 0);
+  }
+
+  const idSets = new Map();
+  for (const key of ["sources", "standards", "clauses", "entities", "relations", "lookupRules", "evalQuestions"]) {
+    const ids = new Set();
+    for (const item of collection(source, key)) {
+      check(`${key} item has id`, typeof item.id === "string" && item.id.length > 0);
+      if (typeof item.id === "string") {
+        check(`${key} id unique ${item.id}`, !ids.has(item.id), item.id);
+        ids.add(item.id);
+      }
+    }
+    idSets.set(key, ids);
+  }
+
+  const sourceIds = idSets.get("sources") ?? new Set();
+  const standardIds = idSets.get("standards") ?? new Set();
+  const clauseIds = idSets.get("clauses") ?? new Set();
+  const entityIds = idSets.get("entities") ?? new Set();
+  const graphNodeIds = new Set([...entityIds, ...clauseIds]);
+
+  for (const sourceItem of collection(source, "sources")) {
+    check(`source ${sourceItem.id} authorization`, typeof sourceItem.authorization === "string" && sourceItem.authorization.length > 0);
+    check(`source ${sourceItem.id} version`, typeof sourceItem.version === "string" && sourceItem.version.length > 0);
+    check(`source ${sourceItem.id} reviewStatus`, typeof sourceItem.reviewStatus === "string" && sourceItem.reviewStatus.length > 0);
+  }
+
+  for (const standard of collection(source, "standards")) {
+    check(`standard ${standard.id} source exists`, sourceIds.has(standard.sourceId), standard.sourceId);
+    check(`standard ${standard.id} version`, typeof standard.version === "string" && standard.version.length > 0);
+    check(`standard ${standard.id} sourceVersion`, typeof standard.sourceVersion === "string" && standard.sourceVersion.length > 0);
+  }
+
+  for (const clause of collection(source, "clauses")) {
+    check(`clause ${clause.id} standard exists`, standardIds.has(clause.standardId), clause.standardId);
+    check(`clause ${clause.id} source exists`, sourceIds.has(clause.sourceId), clause.sourceId);
+    check(`clause ${clause.id} clauseNo`, typeof clause.clauseNo === "string" && clause.clauseNo.length > 0);
+    check(`clause ${clause.id} applicability`, ["applicable", "not_applicable", "need_context"].includes(clause.applicability));
+    check(`clause ${clause.id} pageRange`, typeof clause.pageRange === "string" && clause.pageRange.length > 0);
+    check(`clause ${clause.id} reviewStatus`, typeof clause.reviewStatus === "string" && clause.reviewStatus.length > 0);
+  }
+
+  for (const entity of collection(source, "entities")) {
+    check(`entity ${entity.id} type`, typeof entity.type === "string" && entity.type.length > 0);
+    check(`entity ${entity.id} confidence`, typeof entity.confidence === "number" && entity.confidence >= 0 && entity.confidence <= 1);
+    for (const ref of entity.sourceRefs ?? []) {
+      check(`entity ${entity.id} sourceRef exists ${ref}`, clauseIds.has(ref) || sourceIds.has(ref), ref);
+    }
+  }
+
+  for (const relation of collection(source, "relations")) {
+    check(`relation ${relation.id} from exists`, graphNodeIds.has(relation.from), relation.from);
+    check(`relation ${relation.id} to exists`, graphNodeIds.has(relation.to), relation.to);
+    check(`relation ${relation.id} type`, typeof relation.type === "string" && relation.type.length > 0);
+    check(`relation ${relation.id} confidence`, typeof relation.confidence === "number" && relation.confidence >= 0 && relation.confidence <= 1);
+  }
+
+  for (const rule of collection(source, "lookupRules")) {
+    check(`lookup ${rule.id} queryTerms`, Array.isArray(rule.queryTerms) && rule.queryTerms.length > 0);
+    check(`lookup ${rule.id} clauseIds`, Array.isArray(rule.clauseIds) && rule.clauseIds.length > 0);
+    for (const clauseId of rule.clauseIds ?? []) {
+      check(`lookup ${rule.id} clause exists ${clauseId}`, clauseIds.has(clauseId), clauseId);
+    }
+    check(`lookup ${rule.id} applicability`, ["applicable", "not_applicable", "need_context"].includes(rule.applicability));
+  }
+
+  for (const evalItem of collection(source, "evalQuestions")) {
+    check(`eval ${evalItem.id} question`, typeof evalItem.question === "string" && evalItem.question.length > 0);
+    check(`eval ${evalItem.id} expectedStatus`, ["found", "not_found", "conflict", "inapplicable", "error"].includes(evalItem.expectedStatus));
+    check(`eval ${evalItem.id} expectedApplicability`, ["applicable", "not_applicable", "need_context"].includes(evalItem.expectedApplicability));
+    check(`eval ${evalItem.id} expectedClauseIds`, Array.isArray(evalItem.expectedClauseIds));
+    for (const clauseId of evalItem.expectedClauseIds ?? []) {
+      check(`eval ${evalItem.id} clause exists ${clauseId}`, clauseIds.has(clauseId), clauseId);
+    }
+  }
+
+  check("review metadata exists", isObject(source.review));
+  check("review status valid", ["draft", "reviewed", "blocked", "published"].includes(source.review?.status));
+  return checks;
+}
+
+async function readKnowledgePackSource(workspaceRoot) {
+  const sourcePath = knowledgePackSourcePath(workspaceRoot);
+  const raw = await fs.readFile(sourcePath, "utf8");
+  return { source: JSON.parse(raw), raw, sourcePath };
+}
+
+async function initKnowledgePackWorkspace(options) {
+  const targetRoot = path.resolve(options.cwd);
+  const workspaceName = options.workspaceName ?? "knowledge-pack";
+  if (!workspaceName || path.isAbsolute(workspaceName)) {
+    throw new Error("--name must be a relative folder name");
+  }
+
+  const templateRoot = options.sample
+    ? path.join(repoRoot, "templates", "knowledge-pack-samples", "scheme-review")
+    : path.join(repoRoot, "templates", "knowledge-pack");
+  const workspaceRoot = path.resolve(targetRoot, workspaceName);
+  assertInside(workspaceRoot, targetRoot);
+
+  await ensureDir(targetRoot);
+  await copyTreeMissing(templateRoot, workspaceRoot);
+  console.log(`KNOWLEDGE ${options.sample ? "scheme-review" : "blank"}: ${workspaceRoot}`);
+}
+
+async function resolveKnowledgePackWorkspaceRoot(options) {
+  const targetRoot = path.resolve(options.cwd);
+  const workspaceName = options.workspaceName ?? "knowledge-pack";
+  if (!workspaceName || path.isAbsolute(workspaceName)) {
+    throw new Error("--name must be a relative folder name");
+  }
+
+  const namedRoot = path.resolve(targetRoot, workspaceName);
+  assertInside(namedRoot, targetRoot);
+  if (await exists(namedRoot)) {
+    return namedRoot;
+  }
+
+  let targetRootHasWorkbench = true;
+  for (const fileName of knowledgePackFiles) {
+    if (!(await exists(path.join(targetRoot, fileName)))) {
+      targetRootHasWorkbench = false;
+      break;
+    }
+  }
+  if (targetRootHasWorkbench) {
+    return targetRoot;
+  }
+
+  return namedRoot;
+}
+
+async function validateKnowledgePackWorkspace(options) {
+  const workspaceRoot = await resolveKnowledgePackWorkspaceRoot(options);
+  const checks = [];
+
+  function check(label, ok, detail = "") {
+    checks.push({ label, ok: Boolean(ok), detail });
+  }
+
+  check("workspace directory", await exists(workspaceRoot), workspaceRoot);
+  for (const fileName of knowledgePackFiles) {
+    const filePath = path.join(workspaceRoot, fileName);
+    const ok = await exists(filePath);
+    check(`${fileName} exists`, ok, filePath);
+    if (ok) {
+      const content = await fs.readFile(filePath, "utf8");
+      check(`${fileName} is non-empty`, content.trim().length > 0, filePath);
+    }
+  }
+
+  try {
+    const { source } = await readKnowledgePackSource(workspaceRoot);
+    checks.push(...validateKnowledgePackSource(source));
+  } catch (error) {
+    check("knowledge-pack.source.json parses", false, error.message);
+  }
+
+  const failed = checks.filter((item) => !item.ok);
+  for (const item of checks) {
+    console.log(`${item.ok ? "OK " : "MISS"} ${item.label}${item.detail ? `: ${item.detail}` : ""}`);
+  }
+
+  if (failed.length > 0) {
+    process.exitCode = 1;
+    console.error(`Knowledge Pack validation failed: ${failed.length} issue(s).`);
+    return;
+  }
+
+  console.log(`Knowledge Pack validation passed: ${workspaceRoot}`);
+}
+
+function compileKnowledgePackData(source, raw) {
+  const standardsById = new Map(collection(source, "standards").map((item) => [item.id, item]));
+  const sourcesById = new Map(collection(source, "sources").map((item) => [item.id, item]));
+  const compiledClauses = collection(source, "clauses").map((clause) => {
+    const standard = standardsById.get(clause.standardId) ?? {};
+    const sourceItem = sourcesById.get(clause.sourceId) ?? {};
+    return {
+      ...clause,
+      standard: {
+        id: standard.id,
+        name: standard.name,
+        code: standard.code,
+        version: standard.version,
+        region: standard.region,
+        discipline: standard.discipline,
+        sourceVersion: standard.sourceVersion
+      },
+      source: {
+        id: sourceItem.id,
+        name: sourceItem.name,
+        version: sourceItem.version,
+        authorization: sourceItem.authorization,
+        hash: sourceItem.hash
+      }
+    };
+  });
+
+  return {
+    schema: 1,
+    type: "archsight-aios.knowledge-pack",
+    compiledAt: new Date().toISOString(),
+    compiler: {
+      name: "archsight-aios",
+      version: aiosVersion
+    },
+    sourceDigest: `sha256:${sha256(raw)}`,
+    pack: source.pack,
+    sources: collection(source, "sources"),
+    standards: collection(source, "standards"),
+    clauses: compiledClauses,
+    graph: {
+      entities: collection(source, "entities"),
+      relations: collection(source, "relations")
+    },
+    runtime: {
+      capabilityId: "knowledge.norm_lookup",
+      lookupIndex: collection(source, "lookupRules")
+    },
+    evalQuestions: collection(source, "evalQuestions"),
+    review: source.review,
+    boundary: {
+      notOfficialStandardDatabase: true,
+      noAutomatedComplianceConclusion: true,
+      requiresHumanReviewForFormalUse: true
+    }
+  };
+}
+
+async function compileKnowledgePack(options, silent = false) {
+  const workspaceRoot = await resolveKnowledgePackWorkspaceRoot(options);
+  const { source, raw } = await readKnowledgePackSource(workspaceRoot);
+  const checks = validateKnowledgePackSource(source);
+  const failed = checks.filter((item) => !item.ok);
+  if (failed.length > 0) {
+    const details = failed.map((item) => item.label).join("; ");
+    throw new Error(`Knowledge Pack source is invalid: ${details}`);
+  }
+
+  const artifact = compileKnowledgePackData(source, raw);
+  const outPath = options.out ?? compiledKnowledgePackPath(workspaceRoot);
+  await ensureDir(path.dirname(outPath));
+  await fs.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
+
+  if (!silent) {
+    console.log(`KNOWLEDGE_PACK ${artifact.pack.id}: ${outPath}`);
+    console.log(`CLAUSES ${artifact.clauses.length}`);
+    console.log(`EVAL_QUESTIONS ${artifact.evalQuestions.length}`);
+  }
+
+  return { artifact, outPath, workspaceRoot };
+}
+
+async function resolveKnowledgePackArtifactPath(options) {
+  if (options.pack) {
+    return options.pack;
+  }
+  const workspaceRoot = await resolveKnowledgePackWorkspaceRoot(options);
+  return compiledKnowledgePackPath(workspaceRoot);
+}
+
+async function readCompiledKnowledgePack(optionsOrPath) {
+  const packPath = typeof optionsOrPath === "string"
+    ? path.resolve(optionsOrPath)
+    : await resolveKnowledgePackArtifactPath(optionsOrPath);
+  const pack = await readJson(packPath);
+  if (pack.schema !== 1 || pack.type !== "archsight-aios.knowledge-pack") {
+    throw new Error(`Invalid Knowledge Pack artifact: ${packPath}`);
+  }
+  return { pack, packPath };
+}
+
+async function inspectKnowledgePack(options) {
+  const { pack, packPath } = await readCompiledKnowledgePack(options);
+  const summary = {
+    schema: 1,
+    path: packPath,
+    packId: pack.pack?.id,
+    title: pack.pack?.title,
+    version: pack.pack?.version,
+    status: pack.pack?.status,
+    sourceDigest: pack.sourceDigest,
+    counts: {
+      sources: pack.sources?.length ?? 0,
+      standards: pack.standards?.length ?? 0,
+      clauses: pack.clauses?.length ?? 0,
+      entities: pack.graph?.entities?.length ?? 0,
+      relations: pack.graph?.relations?.length ?? 0,
+      lookupRules: pack.runtime?.lookupIndex?.length ?? 0,
+      evalQuestions: pack.evalQuestions?.length ?? 0
+    },
+    boundary: pack.boundary
+  };
+  console.log(JSON.stringify(summary, null, 2));
+}
+
+function citationForClause(clause) {
+  return {
+    sourceId: clause.source?.id ?? clause.sourceId,
+    sourceName: clause.source?.name,
+    standardId: clause.standard?.id ?? clause.standardId,
+    standardName: clause.standard?.name,
+    standardCode: clause.standard?.code,
+    sourceVersion: clause.standard?.sourceVersion ?? clause.source?.version,
+    clauseId: clause.id,
+    clauseNo: clause.clauseNo,
+    title: clause.title,
+    pageRange: clause.pageRange,
+    reviewStatus: clause.reviewStatus,
+    applicability: clause.applicability
+  };
+}
+
+function lookupRuleScore(rule, query) {
+  const normalizedQuery = normalizeSignal(query);
+  return (rule.queryTerms ?? []).reduce((score, term) => {
+    const normalizedTerm = normalizeSignal(term);
+    return normalizedTerm && normalizedQuery.includes(normalizedTerm)
+      ? score + Math.max(1, normalizedTerm.length)
+      : score;
+  }, 0);
+}
+
+function lookupKnowledgePack(pack, request) {
+  const query = request?.query ?? "";
+  const rules = pack.runtime?.lookupIndex ?? [];
+  const clausesById = new Map((pack.clauses ?? []).map((clause) => [clause.id, clause]));
+  const matchedRules = rules
+    .map((rule) => ({ rule, score: lookupRuleScore(rule, query) }))
+    .filter((item) => item.score > 0)
+    .sort((left, right) => right.score - left.score || left.rule.id.localeCompare(right.rule.id));
+
+  if (matchedRules.length === 0) {
+    return {
+      status: "not_found",
+      citations: [],
+      applicability: "need_context",
+      sourceVersion: request?.sourceVersion ?? pack.pack?.sourceVersion ?? "",
+      notes: "未命中当前 Knowledge Pack；不得把模型常识写成规范结论。"
+    };
+  }
+
+  const candidateClauses = [];
+  const seenClauseIds = new Set();
+  for (const { rule } of matchedRules) {
+    for (const clauseId of rule.clauseIds ?? []) {
+      if (seenClauseIds.has(clauseId)) {
+        continue;
+      }
+      const clause = clausesById.get(clauseId);
+      if (clause) {
+        candidateClauses.push(clause);
+        seenClauseIds.add(clauseId);
+      }
+    }
+  }
+
+  if (request?.sourceVersion) {
+    const versionMatches = candidateClauses.filter((clause) => {
+      const sourceVersion = clause.standard?.sourceVersion ?? clause.source?.version;
+      return sourceVersion === request.sourceVersion;
+    });
+    if (versionMatches.length === 0) {
+      return {
+        status: "inapplicable",
+        citations: [],
+        applicability: "not_applicable",
+        sourceVersion: request.sourceVersion,
+        notes: `请求版本 ${request.sourceVersion} 未命中当前 Knowledge Pack 的来源版本。`
+      };
+    }
+  }
+
+  const conflict = matchedRules.some((item) => item.rule.status === "conflict");
+  const citations = candidateClauses.map(citationForClause);
+  const firstRule = matchedRules[0].rule;
+  const applicability = conflict
+    ? "need_context"
+    : firstRule.applicability ?? candidateClauses[0]?.applicability ?? "need_context";
+  const sourceVersion = citations[0]?.sourceVersion ?? pack.pack?.sourceVersion ?? "";
+  const notes = matchedRules
+    .map((item) => item.rule.notes)
+    .filter(Boolean)
+    .join(" ");
+
+  return {
+    status: conflict ? "conflict" : "found",
+    citations,
+    applicability,
+    sourceVersion,
+    notes: notes || "已命中 Knowledge Pack；正式结论仍需结合项目条件和人工复核。"
+  };
+}
+
+async function lookupKnowledgePackCommand(options) {
+  if (!options.pack) {
+    throw new Error("--pack is required for knowledge:lookup");
+  }
+  if (!options.query) {
+    throw new Error("--query is required for knowledge:lookup");
+  }
+
+  const { pack } = await readCompiledKnowledgePack(options.pack);
+  const result = lookupKnowledgePack(pack, {
+    query: options.query,
+    region: options.region,
+    discipline: options.discipline,
+    sourceVersion: options.sourceVersion,
+    projectCondition: options.projectCondition
+  });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function evalKnowledgePack(options) {
+  let pack;
+  let packPath;
+  if (options.pack) {
+    ({ pack, packPath } = await readCompiledKnowledgePack(options.pack));
+  } else {
+    const compiled = await compileKnowledgePack(options, true);
+    pack = compiled.artifact;
+    packPath = compiled.outPath;
+  }
+
+  const cases = [];
+  for (const evalItem of pack.evalQuestions ?? []) {
+    const result = lookupKnowledgePack(pack, {
+      query: evalItem.question,
+      sourceVersion: evalItem.inputSourceVersion
+    });
+    const expectedClauseIds = new Set(evalItem.expectedClauseIds ?? []);
+    const actualClauseIds = new Set((result.citations ?? []).map((item) => item.clauseId));
+    const checks = [
+      {
+        label: "status",
+        ok: result.status === evalItem.expectedStatus,
+        expected: evalItem.expectedStatus,
+        actual: result.status
+      },
+      {
+        label: "applicability",
+        ok: result.applicability === evalItem.expectedApplicability,
+        expected: evalItem.expectedApplicability,
+        actual: result.applicability
+      },
+      {
+        label: "citations",
+        ok: [...expectedClauseIds].every((clauseId) => actualClauseIds.has(clauseId))
+          && (expectedClauseIds.size > 0 || actualClauseIds.size === 0),
+        expected: [...expectedClauseIds],
+        actual: [...actualClauseIds]
+      },
+      {
+        label: "sourceVersion",
+        ok: !evalItem.mustCiteSourceVersion || (result.sourceVersion && (result.citations ?? []).every((item) => item.sourceVersion)),
+        expected: "sourceVersion present when required",
+        actual: result.sourceVersion
+      },
+      {
+        label: "notes",
+        ok: (evalItem.expectedNotesContains ?? []).every((term) => result.notes.includes(term)),
+        expected: evalItem.expectedNotesContains ?? [],
+        actual: result.notes
+      }
+    ];
+    cases.push({
+      id: evalItem.id,
+      question: evalItem.question,
+      passed: checks.every((item) => item.ok),
+      checks,
+      result
+    });
+  }
+
+  const report = {
+    schema: 1,
+    packPath,
+    packId: pack.pack?.id,
+    total: cases.length,
+    passed: cases.filter((item) => item.passed).length,
+    failed: cases.filter((item) => !item.passed).length,
+    cases
+  };
+
+  console.log(JSON.stringify(report, null, 2));
+  if (report.failed > 0) {
+    process.exitCode = 1;
+  }
+}
+
+function knowledgePackPathFromMcpArgs(args) {
+  const value = args.knowledgePackPath ?? args.packPath;
+  if (typeof value === "string" && value.length > 0) {
+    return path.resolve(value);
+  }
+  return path.resolve(process.cwd(), "knowledge-pack", "compiled", "knowledge-pack.json");
+}
+
+async function runKnowledgeMcpServer() {
+  const rl = readline.createInterface({ input: process.stdin });
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    const request = JSON.parse(line);
+    if (request.method === "initialize") {
+      console.log(JSON.stringify({
+        jsonrpc: "2.0",
+        id: request.id,
+        result: {
+          protocolVersion: "2025-06-18",
+          serverInfo: { name: "archsight-aios-knowledge-reference", version: aiosVersion },
+          capabilities: { tools: {} }
+        }
+      }));
+      continue;
+    }
+    if (request.method === "tools/call") {
+      try {
+        const args = request.params?.arguments ?? {};
+        const toolName = request.params?.name;
+        if (!["norm_lookup", "knowledge.norm_lookup"].includes(toolName)) {
+          throw new Error(`Unknown knowledge tool: ${toolName}`);
+        }
+        const { pack } = await readCompiledKnowledgePack(knowledgePackPathFromMcpArgs(args));
+        const result = lookupKnowledgePack(pack, args);
+        console.log(JSON.stringify({
+          jsonrpc: "2.0",
+          id: request.id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            isError: false,
+            structuredContent: result
+          }
+        }));
+      } catch (error) {
+        console.log(JSON.stringify({
+          jsonrpc: "2.0",
+          id: request.id,
+          error: { code: -32000, message: error.message }
+        }));
+      }
+    }
+  }
+}
+
 async function validateProjectTemplate(options) {
   const manifest = await readManifest();
   const createdTemp = options.temp;
@@ -1949,6 +2848,24 @@ async function main() {
     await doctor();
   } else if (options.command === "init") {
     await initProject(options);
+  } else if (options.command === "writing:init") {
+    await initDocumentWritingWorkspace(options);
+  } else if (options.command === "writing:validate") {
+    await validateDocumentWritingWorkspace(options);
+  } else if (options.command === "knowledge:init") {
+    await initKnowledgePackWorkspace(options);
+  } else if (options.command === "knowledge:validate") {
+    await validateKnowledgePackWorkspace(options);
+  } else if (options.command === "knowledge:compile") {
+    await compileKnowledgePack(options);
+  } else if (options.command === "knowledge:inspect") {
+    await inspectKnowledgePack(options);
+  } else if (options.command === "knowledge:lookup") {
+    await lookupKnowledgePackCommand(options);
+  } else if (options.command === "knowledge:eval") {
+    await evalKnowledgePack(options);
+  } else if (options.command === "knowledge:mcp") {
+    await runKnowledgeMcpServer();
   } else if (options.command === "validate") {
     await validateProjectTemplate(options);
   } else if (options.command === "capability:call") {