@archsight/aios 1.2.0 → 1.3.1

package/scripts/validate-prompt-model-outputs.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+
+const root = fs.realpathSync(process.cwd());
+const errors = [];
+
+const defaultOutputPath = "prompts/evaluations/engineering-business-basic-model-output.example.json";
+const args = parseArgs(process.argv.slice(2));
+const outputPath = args.file ?? repoPath(defaultOutputPath);
+const fixturePath = repoPath("prompts/evaluations/engineering-business-basic-fixtures.json");
+const fixture = readJson(fixturePath);
+const outputFile = args.init ? undefined : readJson(outputPath);
+
+const sensitiveTerms = [
+  "立信",
+  "费敏",
+  "闻总",
+  "谭总",
+  "茅盾中学",
+  "鸿益",
+  "太鑫",
+  "飞双",
+  "魔毯",
+  "客户内部",
+  "培训演示",
+  "基础内测",
+  "内测模式",
+  "内测包"
+];
+
+function repoPath(...parts) {
+  const target = path.join(root, ...parts);
+  const relative = path.relative(root, target);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`Path traversal detected: ${target}`);
+  }
+  return target;
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    file: undefined,
+    init: undefined,
+    force: false
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--file") {
+      const value = argv[index + 1];
+      if (!value) {
+        errors.push("--file requires a path");
+      } else {
+        parsed.file = repoPath(value);
+        index += 1;
+      }
+    } else if (arg === "--init") {
+      const value = argv[index + 1];
+      if (!value) {
+        errors.push("--init requires a path");
+      } else {
+        parsed.init = repoPath(value);
+        index += 1;
+      }
+    } else if (arg === "--force") {
+      parsed.force = true;
+    } else {
+      errors.push(`Unknown argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    errors.push(`${path.relative(root, filePath)}: invalid JSON (${error.message})`);
+    return undefined;
+  }
+}
+
+function check(condition, message) {
+  if (!condition) errors.push(message);
+}
+
+function includesSensitiveTerm(value) {
+  const raw = typeof value === "string" ? value : JSON.stringify(value);
+  return sensitiveTerms.filter((term) => raw.includes(term));
+}
+
+function outputText(value) {
+  if (Array.isArray(value)) return value.join("\n");
+  if (typeof value === "string") return value;
+  return "";
+}
+
+function createOutputTemplate() {
+  if (!fixture) return;
+
+  if (fs.existsSync(args.init) && !args.force) {
+    errors.push(`${path.relative(root, args.init)} already exists; pass --force to overwrite`);
+    return;
+  }
+
+  const template = {
+    schema: 1,
+    name: "engineering-business-basic-model-output-run",
+    version: fixture.version ?? "0.1",
+    fixture: "prompts/evaluations/engineering-business-basic-fixtures.json",
+    isExample: false,
+    dataBoundary:
+      "Fill this file with de-identified model outputs only. Do not include customer names, contacts, project names, exact amounts, or raw source documents.",
+    outputs: (fixture.cases ?? []).map((item) => ({
+      caseId: item.id,
+      promptVersion: fixture.version ?? "0.1",
+      model: "",
+      ranAt: "",
+      notes: "",
+      promptPath: item.promptPath,
+      scenario: item.scenario,
+      expectedSections: item.expectedStrongSections,
+      bannedClaims: item.bannedClaims,
+      output: []
+    }))
+  };
+
+  fs.mkdirSync(path.dirname(args.init), { recursive: true });
+  fs.writeFileSync(args.init, `${JSON.stringify(template, null, 2)}\n`, "utf8");
+  console.log(`Prompt model output template written: ${path.relative(root, args.init)}`);
+}
+
+if (args.init) {
+  if (errors.length === 0) createOutputTemplate();
+  if (errors.length > 0) {
+    console.error(`Prompt model output validation failed with ${errors.length} error(s):`);
+    for (const error of errors) console.error(`- ${error}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+if (fixture && outputFile) {
+  check(outputFile.schema === 1, "model output file: schema must be 1");
+  check(typeof outputFile.version === "string" && outputFile.version.length > 0, "model output file: version must be a string");
+  check(Array.isArray(outputFile.outputs), "model output file: outputs must be an array");
+  check(
+    outputFile.fixture === "prompts/evaluations/engineering-business-basic-fixtures.json",
+    "model output file: fixture path mismatch"
+  );
+
+  const casesById = new Map((fixture.cases ?? []).map((item) => [item.id, item]));
+  const expectedIds = [...casesById.keys()].sort();
+  const actualIds = (outputFile.outputs ?? []).map((item) => item.caseId).sort();
+
+  check(JSON.stringify(actualIds) === JSON.stringify(expectedIds), "model output file: case coverage mismatch");
+
+  const seenIds = new Set();
+  for (const item of outputFile.outputs ?? []) {
+    check(typeof item.caseId === "string" && item.caseId.length > 0, "model output item: missing caseId");
+    check(!seenIds.has(item.caseId), `${item.caseId}: duplicate model output`);
+    seenIds.add(item.caseId);
+
+    const sourceCase = casesById.get(item.caseId);
+    check(Boolean(sourceCase), `${item.caseId}: caseId not found in fixtures`);
+
+    check(typeof item.promptVersion === "string" && item.promptVersion.length > 0, `${item.caseId}: missing promptVersion`);
+    check(item.promptVersion === fixture.version, `${item.caseId}: promptVersion must match fixture version ${fixture.version}`);
+    check(typeof item.model === "string" && item.model.length > 0, `${item.caseId}: missing model`);
+    check(typeof item.ranAt === "string" && item.ranAt.length > 0, `${item.caseId}: missing ranAt`);
+    check(!Number.isNaN(Date.parse(item.ranAt)), `${item.caseId}: ranAt must be a parseable timestamp`);
+    check(typeof item.notes === "string", `${item.caseId}: notes must be a string`);
+    if (outputFile.isExample !== true) {
+      check(item.model !== "example-skeleton", `${item.caseId}: non-example output must use a real model identifier`);
+    }
+
+    const text = outputText(item.output);
+    check(text.length > 0, `${item.caseId}: output must be a non-empty string or string array`);
+
+    const sensitiveHits = includesSensitiveTerm(item);
+    check(sensitiveHits.length === 0, `${item.caseId}: sensitive terms leaked (${sensitiveHits.join(", ")})`);
+
+    for (const section of sourceCase?.expectedStrongSections ?? []) {
+      check(text.includes(section), `${item.caseId}: output missing expected section "${section}"`);
+    }
+    for (const bannedClaim of sourceCase?.bannedClaims ?? []) {
+      check(!text.includes(bannedClaim), `${item.caseId}: output contains prohibited claim "${bannedClaim}"`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error(`Prompt model output validation failed with ${errors.length} error(s):`);
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Prompt model output validation passed.");

package/scripts/validate-prompt-run-results.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+
+const root = fs.realpathSync(process.cwd());
+const errors = [];
+const diagnostics = [];
+
+const fixturePath = repoPath("prompts/evaluations/engineering-business-basic-fixtures.json");
+const fixture = readJson(fixturePath);
+const args = parseArgs(process.argv.slice(2));
+
+const sensitiveTerms = [
+  "立信",
+  "费敏",
+  "闻总",
+  "谭总",
+  "茅盾中学",
+  "鸿益",
+  "太鑫",
+  "飞双",
+  "魔毯",
+  "客户内部",
+  "培训演示",
+  "基础内测",
+  "内测模式",
+  "内测包"
+];
+
+function repoPath(...parts) {
+  const target = path.join(root, ...parts);
+  const relative = path.relative(root, target);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`Path traversal detected: ${target}`);
+  }
+  return target;
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    file: undefined,
+    init: undefined,
+    force: false,
+    checkTemplate: argv.length === 0
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--file") {
+      const value = argv[index + 1];
+      if (!value) {
+        errors.push("--file requires a path");
+      } else {
+        parsed.file = repoPath(value);
+        index += 1;
+      }
+    } else if (arg === "--init") {
+      const value = argv[index + 1];
+      if (!value) {
+        errors.push("--init requires a path");
+      } else {
+        parsed.init = repoPath(value);
+        index += 1;
+      }
+    } else if (arg === "--force") {
+      parsed.force = true;
+    } else if (arg === "--check-template") {
+      parsed.checkTemplate = true;
+    } else {
+      errors.push(`Unknown argument: ${arg}`);
+    }
+  }
+
+  if ([parsed.file, parsed.init, parsed.checkTemplate].filter(Boolean).length > 1) {
+    errors.push("Use only one mode: --file, --init, or --check-template");
+  }
+
+  return parsed;
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    errors.push(`${path.relative(root, filePath)}: invalid JSON (${error.message})`);
+    return undefined;
+  }
+}
+
+function check(condition, message) {
+  if (!condition) errors.push(message);
+}
+
+function includesSensitiveTerm(value) {
+  const raw = typeof value === "string" ? value : JSON.stringify(value);
+  return sensitiveTerms.filter((term) => raw.includes(term));
+}
+
+function outputText(value) {
+  if (Array.isArray(value)) return value.join("\n");
+  if (typeof value === "string") return value;
+  return "";
+}
+
+function expectedRuns() {
+  if (!fixture) return [];
+
+  return (fixture.cases ?? []).flatMap((item) => [
+    {
+      runId: `${item.id}::weak`,
+      caseId: item.id,
+      variant: "weak",
+      promptSource: "fixture.weakPrompt",
+      promptVersion: fixture.version,
+      expectedStrongSections: item.expectedStrongSections,
+      bannedClaims: item.bannedClaims,
+      weakFailureModes: item.weakFailureModes
+    },
+    {
+      runId: `${item.id}::basic`,
+      caseId: item.id,
+      variant: "basic",
+      promptSource: item.promptPath,
+      promptVersion: fixture.version,
+      expectedStrongSections: item.expectedStrongSections,
+      bannedClaims: item.bannedClaims,
+      weakFailureModes: item.weakFailureModes
+    }
+  ]);
+}
+
+function createTemplate() {
+  return {
+    schema: 1,
+    name: "engineering-business-basic-run-results",
+    version: fixture?.version ?? "0.1",
+    fixture: "prompts/evaluations/engineering-business-basic-fixtures.json",
+    runPack: "prompts/evaluations/engineering-business-basic-run-pack.generated.json",
+    isExample: false,
+    dataBoundary:
+      "Fill this file with de-identified weak/basic model outputs only. Do not include customer names, contacts, project names, exact amounts, or raw source documents.",
+    outputs: expectedRuns().map((item) => ({
+      runId: item.runId,
+      caseId: item.caseId,
+      variant: item.variant,
+      promptVersion: item.promptVersion,
+      model: "",
+      ranAt: "",
+      notes: "",
+      promptSource: item.promptSource,
+      expectedStrongSections: item.expectedStrongSections,
+      bannedClaims: item.bannedClaims,
+      weakFailureModes: item.weakFailureModes,
+      output: []
+    }))
+  };
+}
+
+function validateTemplateShape(template) {
+  check(template.schema === 1, "run results: schema must be 1");
+  check(template.version === fixture?.version, `run results: version must match fixture version ${fixture?.version}`);
+  check(template.fixture === "prompts/evaluations/engineering-business-basic-fixtures.json", "run results: fixture path mismatch");
+  check(Array.isArray(template.outputs), "run results: outputs must be an array");
+  check(template.outputs?.length === expectedRuns().length, "run results: output count must match weak/basic run count");
+
+  const sensitiveHits = includesSensitiveTerm(template);
+  check(sensitiveHits.length === 0, `run results: sensitive terms leaked (${sensitiveHits.join(", ")})`);
+
+  const expectedByRunId = new Map(expectedRuns().map((item) => [item.runId, item]));
+  const actualRunIds = (template.outputs ?? []).map((item) => item.runId).sort();
+  const expectedRunIds = [...expectedByRunId.keys()].sort();
+  check(JSON.stringify(actualRunIds) === JSON.stringify(expectedRunIds), "run results: runId coverage mismatch");
+
+  const seen = new Set();
+  for (const item of template.outputs ?? []) {
+    const expected = expectedByRunId.get(item.runId);
+    check(!seen.has(item.runId), `${item.runId}: duplicate output`);
+    seen.add(item.runId);
+    check(Boolean(expected), `${item.runId}: runId not found in expected run pack`);
+    check(item.caseId === expected?.caseId, `${item.runId}: caseId mismatch`);
+    check(item.variant === expected?.variant, `${item.runId}: variant mismatch`);
+    check(item.promptVersion === expected?.promptVersion, `${item.runId}: promptVersion mismatch`);
+    check(item.promptSource === expected?.promptSource, `${item.runId}: promptSource mismatch`);
+    check(Array.isArray(item.expectedStrongSections), `${item.runId}: expectedStrongSections must be an array`);
+    check(Array.isArray(item.bannedClaims), `${item.runId}: bannedClaims must be an array`);
+    check(Array.isArray(item.weakFailureModes), `${item.runId}: weakFailureModes must be an array`);
+  }
+}
+
+function validateRunResults(results) {
+  validateTemplateShape(results);
+
+  for (const item of results.outputs ?? []) {
+    check(typeof item.model === "string" && item.model.length > 0, `${item.runId}: missing model`);
+    check(item.model !== "example-skeleton", `${item.runId}: model must be a real model identifier`);
+    check(typeof item.ranAt === "string" && item.ranAt.length > 0, `${item.runId}: missing ranAt`);
+    check(!Number.isNaN(Date.parse(item.ranAt)), `${item.runId}: ranAt must be a parseable timestamp`);
+    check(typeof item.notes === "string", `${item.runId}: notes must be a string`);
+
+    const text = outputText(item.output);
+    check(text.length > 0, `${item.runId}: output must be a non-empty string or string array`);
+
+    const sensitiveHits = includesSensitiveTerm(item);
+    check(sensitiveHits.length === 0, `${item.runId}: sensitive terms leaked (${sensitiveHits.join(", ")})`);
+
+    const missingSections = (item.expectedStrongSections ?? []).filter((section) => !text.includes(section));
+    const prohibitedClaims = (item.bannedClaims ?? []).filter((claim) => text.includes(claim));
+
+    if (item.variant === "basic") {
+      for (const section of missingSections) {
+        errors.push(`${item.runId}: basic output missing expected section "${section}"`);
+      }
+      for (const claim of prohibitedClaims) {
+        errors.push(`${item.runId}: basic output contains prohibited claim "${claim}"`);
+      }
+    } else if (missingSections.length > 0 || prohibitedClaims.length > 0) {
+      diagnostics.push({
+        runId: item.runId,
+        missingSections,
+        prohibitedClaims
+      });
+    }
+  }
+}
+
+if (args.init) {
+  const template = createTemplate();
+  validateTemplateShape(template);
+  if (fs.existsSync(args.init) && !args.force) {
+    errors.push(`${path.relative(root, args.init)} already exists; pass --force to overwrite`);
+  }
+  if (errors.length === 0) {
+    fs.mkdirSync(path.dirname(args.init), { recursive: true });
+    fs.writeFileSync(args.init, `${JSON.stringify(template, null, 2)}\n`, "utf8");
+    console.log(`Prompt run results template written: ${path.relative(root, args.init)}`);
+    process.exit(0);
+  }
+} else if (args.file) {
+  const results = readJson(args.file);
+  if (results) validateRunResults(results);
+} else {
+  validateTemplateShape(createTemplate());
+  if (errors.length === 0) {
+    console.log("Prompt run results template validation passed.");
+    process.exit(0);
+  }
+}
+
+if (errors.length > 0) {
+  console.error(`Prompt run results validation failed with ${errors.length} error(s):`);
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Prompt run results validation passed.");
+if (diagnostics.length > 0) {
+  console.log(`Weak output diagnostics: ${diagnostics.length} run(s) need comparison review.`);
+}

package/scripts/validate-prompt-scorecard.mjs

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+
+const root = fs.realpathSync(process.cwd());
+const errors = [];
+
+const fixturePath = repoPath("prompts/evaluations/engineering-business-basic-fixtures.json");
+const scorecardPath = repoPath("prompts/evaluations/engineering-business-basic-scorecard.json");
+const fixture = readJson(fixturePath);
+const scorecard = readJson(scorecardPath);
+
+const sensitiveTerms = [
+  "立信",
+  "费敏",
+  "闻总",
+  "谭总",
+  "茅盾中学",
+  "鸿益",
+  "太鑫",
+  "飞双",
+  "魔毯",
+  "客户内部",
+  "培训演示",
+  "基础内测",
+  "内测模式",
+  "内测包"
+];
+
+function repoPath(...parts) {
+  const target = path.join(root, ...parts);
+  const relative = path.relative(root, target);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`Path traversal detected: ${target}`);
+  }
+  return target;
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    errors.push(`${path.relative(root, filePath)}: invalid JSON (${error.message})`);
+    return undefined;
+  }
+}
+
+function check(condition, message) {
+  if (!condition) errors.push(message);
+}
+
+function includesSensitiveTerm(value) {
+  const raw = typeof value === "string" ? value : JSON.stringify(value);
+  return sensitiveTerms.filter((term) => raw.includes(term));
+}
+
+function weightedScore(scores, criteria) {
+  const totalWeight = criteria.reduce((sum, item) => sum + item.weight, 0);
+  return (
+    criteria.reduce((sum, item) => {
+      return sum + scores[item.id] * item.weight;
+    }, 0) / totalWeight
+  );
+}
+
+if (fixture && scorecard) {
+  check(scorecard.schema === 1, "scorecard: schema must be 1");
+  check(scorecard.version === fixture.version, `scorecard: version must match fixture version ${fixture.version}`);
+  check(scorecard.fixture === "prompts/evaluations/engineering-business-basic-fixtures.json", "scorecard: fixture path mismatch");
+  check(Array.isArray(scorecard.criteria) && scorecard.criteria.length > 0, "scorecard: criteria must be a non-empty array");
+  check(Array.isArray(scorecard.cases) && scorecard.cases.length === fixture.cases.length, "scorecard: case count mismatch");
+
+  const sensitiveHits = includesSensitiveTerm(scorecard);
+  check(sensitiveHits.length === 0, `scorecard: sensitive terms leaked (${sensitiveHits.join(", ")})`);
+
+  const criteriaIds = new Set();
+  let totalWeight = 0;
+  for (const criterion of scorecard.criteria ?? []) {
+    check(/^[a-z0-9_]+$/.test(criterion.id), `${criterion.id ?? "unknown"}: invalid criterion id`);
+    check(!criteriaIds.has(criterion.id), `${criterion.id}: duplicate criterion`);
+    criteriaIds.add(criterion.id);
+    check(Number.isInteger(criterion.weight) && criterion.weight > 0, `${criterion.id}: weight must be a positive integer`);
+    totalWeight += criterion.weight ?? 0;
+    check(typeof criterion.description === "string" && criterion.description.length > 0, `${criterion.id}: missing description`);
+  }
+  check(totalWeight === 100, `scorecard: criteria weights must total 100, got ${totalWeight}`);
+
+  const fixtureById = new Map((fixture.cases ?? []).map((item) => [item.id, item]));
+  const expectedIds = [...fixtureById.keys()].sort();
+  const actualIds = (scorecard.cases ?? []).map((item) => item.caseId).sort();
+  check(JSON.stringify(actualIds) === JSON.stringify(expectedIds), "scorecard: case coverage mismatch");
+
+  for (const item of scorecard.cases ?? []) {
+    const sourceCase = fixtureById.get(item.caseId);
+    check(Boolean(sourceCase), `${item.caseId}: caseId not found in fixtures`);
+    check(item.winner === "basic", `${item.caseId}: winner must be basic`);
+    check(typeof item.decisionBasis === "string" && item.decisionBasis.length > 0, `${item.caseId}: missing decisionBasis`);
+    check(Array.isArray(item.basicPromptGains) && item.basicPromptGains.length > 0, `${item.caseId}: basicPromptGains must be non-empty`);
+    check(
+      JSON.stringify(item.observedWeakFailures ?? []) === JSON.stringify(sourceCase?.weakFailureModes ?? []),
+      `${item.caseId}: observedWeakFailures must match fixture weakFailureModes`
+    );
+
+    for (const scoreSetName of ["weakScores", "basicScores"]) {
+      const scoreSet = item[scoreSetName] ?? {};
+      const scoreIds = Object.keys(scoreSet).sort();
+      check(JSON.stringify(scoreIds) === JSON.stringify([...criteriaIds].sort()), `${item.caseId}: ${scoreSetName} coverage mismatch`);
+      for (const criterionId of criteriaIds) {
+        const value = scoreSet[criterionId];
+        check(Number.isInteger(value) && value >= 1 && value <= 5, `${item.caseId}: ${scoreSetName}.${criterionId} must be 1-5`);
+      }
+    }
+
+    const weakTotal = weightedScore(item.weakScores, scorecard.criteria);
+    const basicTotal = weightedScore(item.basicScores, scorecard.criteria);
+    check(
+      basicTotal - weakTotal >= scorecard.minimumWeightedDelta,
+      `${item.caseId}: weighted improvement ${Number(basicTotal - weakTotal).toFixed(2)} is below minimum ${scorecard.minimumWeightedDelta}`
+    );
+  }
+
+  check(scorecard.overallDecision?.winner === "basic", "scorecard: overall winner must be basic");
+  check(typeof scorecard.overallDecision?.notAClaim === "string", "scorecard: overallDecision.notAClaim is required");
+}
+
+if (errors.length > 0) {
+  console.error(`Prompt scorecard validation failed with ${errors.length} error(s):`);
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log("Prompt scorecard validation passed.");

package/scripts/validate-skills.mjs

@@ -5,6 +5,7 @@ import path from "node:path";
 
 const root = fs.realpathSync(process.cwd());
 const errors = [];
+const topLevelSkillNames = new Set(["aios", "archsight-aios"]);
 
 function repoPath(...parts) {
   const target = path.join(root, ...parts);
@@ -67,7 +68,7 @@ if (manifest) {
   const manifestSkillIds = new Set(manifest.skills.map((skill) => skill.id));
   const skillDirs = fs
     .readdirSync(repoPath("skills"), { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && entry.name.startsWith("aios-"))
+    .filter((entry) => entry.isDirectory() && (entry.name.startsWith("aios-") || topLevelSkillNames.has(entry.name)))
     .map((entry) => entry.name)
     .sort();
 
@@ -88,15 +89,19 @@ if (manifest) {
     check(frontmatter.name === skill.id, `${skillFile}: frontmatter name must be ${skill.id}`);
     check(Boolean(frontmatter.description), `${skillFile}: missing frontmatter description`);
   }
+
+  for (const requiredAsset of manifest.requiredAssets ?? []) {
+    check(exists(requiredAsset), `runtime/archsight-aios.manifest.json: required asset missing ${requiredAsset}`);
+  }
 }
 
 if (packageJson) {
-  const requiredFiles = ["skills/", "scripts/", ".claude-plugin/", "gemini-extension.json"];
+  const requiredFiles = ["skills/", "scripts/", ".claude-plugin/", "gemini-extension.json", "OPENCODE.md"];
   for (const requiredFile of requiredFiles) {
     check(packageJson.files?.includes(requiredFile), `package.json: files must include ${requiredFile}`);
   }
 
-  const requiredKeywords = ["agent-skills", "skills-sh", "gemini-cli", "claude-code", "workbuddy", "construction-ai"];
+  const requiredKeywords = ["agent-skills", "skills-sh", "gemini-cli", "claude-code", "workbuddy", "opencode", "construction-ai"];
   for (const keyword of requiredKeywords) {
     check(packageJson.keywords?.includes(keyword), `package.json: keywords must include ${keyword}`);
   }

package/skills/README.md

@@ -4,7 +4,7 @@
 
 每个 skill 应沉淀为可重复执行、可验证、可治理的工作单元，而不是一句 prompt。Skill 是项目工作目录中的实际作业方法，Agent 是角色身份和职责边界。
 
-AIOS Skill 的差异化目标是让通用 AI Coding 工具在建筑行业平台研发中获得更专业的默认判断。所有 `aios-*` Skill 都继承这个行业取向；Skill 名称只表示任务分工，不表示只有某一个 Skill 才面向建筑行业。
+AIOS Skill 的差异化目标是让通用 AI Coding 工具在建筑行业平台研发中获得更专业的默认判断。`aios` 和 `archsight-aios` 是总路由入口；其他 `aios-*` Skill 负责具体任务分工。Skill 名称只表示任务分工，不表示只有某一个 Skill 才面向建筑行业。
 
 当项目涉及 BIM / IFC、建筑规范、智能审图、图纸 / 模型处理、RAG / GraphRAG、任务编排、审计证据链、结构力学或长期平台演进时，`aios-ceo`、`aios-design`、`aios-plan`、`aios-exec`、`aios-review`、`aios-arch`、`aios-knowledge`、`aios-structural` 和 `aios-runtime` 都应把这些行业约束纳入判断。区别只是：`aios-ceo` 做建筑行业软件 / 系统的一把手深度评价，把产品定位、行业专业性、工程可信度、证据链和商业验证放到同一决策框架里；`aios-design` 判断界面方案能否支撑审查、定位、复核、追溯和交付，`aios-arch` 判断边界，`aios-knowledge` 判断行业语义，`aios-structural` 判断结构力学输入、求解链路和人工签审边界，`aios-runtime` 判断 AI / RAG 运行时，`aios-plan` 拆交付，`aios-review` 查风险，`aios-exec` 做受控实现。
 
@@ -16,7 +16,7 @@ AIOS 是建筑行业增强层，不是通用任务替代器。装了 AIOS 后，
 
 - 项目明确启用了 `bim-platform`、`construction-vision`、`rag-knowledge` 或其他建筑行业 profile。
 - 项目上下文、README、`.ai/project-context.md` 或用户任务明确涉及 BIM / IFC / Revit / CAD、建筑规范、智能审图、施工视觉、工程知识库、GraphRAG、图纸 / 模型处理、证据链、人工复核、审计留痕或建筑行业平台。
-- 用户明确要求使用 ArchSight AIOS、`aios-*` Skill 或建筑行业评审方法。
+- 用户明确要求使用 ArchSight AIOS、`aios`、`archsight-aios`、`aios-*` Skill 或建筑行业评审方法。
 
 不启用行业增强的情况：
 
@@ -49,9 +49,11 @@ Skill 可以继续用 `SKILL.md` 表达操作方法，但涉及确定性工具
 
 第一阶段核心技能包：
 
-| Skill | 用途 |
-| --- | --- |
-| `aios-ceo` | 建筑行业软件 / 系统深度评价：产品定位、行业专业性、工程可信度、证据链、商业验证、范围取舍和阶段路线。 |
+| Skill | 用途 |
+| --- | --- |
+| `aios` | AIOS 总路由入口：当用户只说“请用 AIOS 技能包分析该文档”时，先识别资料类型，再路由到合适的具体 Skill。 |
+| `archsight-aios` | `aios` 的品牌别名入口，用于 “ArchSight AIOS” 或 “AIOS 技能包” 这类自然调用。 |
+| `aios-ceo` | 建筑行业软件 / 系统深度评价：产品定位、行业专业性、工程可信度、证据链、商业验证、范围取舍和阶段路线。 |
 | `aios-design` | 建筑行业平台界面方案、工作台体验、证据定位、复核追溯和前端实现交接评审。 |
 | `aios-plan` | 交付计划、任务拆解、依赖和验证顺序。 |
 | `aios-exec` | 有边界地改代码、修 bug、更新文档、运行验证。 |
@@ -60,9 +62,13 @@ Skill 可以继续用 `SKILL.md` 表达操作方法，但涉及确定性工具
 | `aios-knowledge` | BIM、IFC、建筑规范、审图规则和知识结构化。 |
 | `aios-structural` | 结构力学、荷载、边界条件、FEM 和确定性求解链路评审。 |
 | `aios-runtime` | Prompt、Context、Memory、MCP/Tool、RAG/GraphRAG 和多 Agent Runtime 设计。 |
+| `aios-compare` | 文档专业度对比：比较两份文档、两个版本或两个 AI 输出哪份更专业、更可复核、更适合交付。 |
+| `aios-prompt-compare` | 内部 Prompt / Skill 测试工具：仅开发者明确调用时，对同一输入分别评估弱提示词、便携强提示词和真实 Skill 触发结果，判断是否应沉淀为 Skill。 |
 
 工程业务管理技能包 (Engineering Project Management)：
 
+工程业务管理场景可直接参考 [工程业务管理基础技能包](engineering-business-starter-kit.md)。该基础包提供 L0-L1 级通用提示词 / Skill 模板能力：把工程资料整理成矩阵、清单、台账和人工复核问题；不承诺系统建设、自动审批、专业结论或替代签审。
+
 | Skill | 用途 |
 | --- | --- |
 | `aios-commercial-tender` | 工程招投标响应证据链，用于提取评分点、资格条件、废标风险、资料缺口和人工复核事项。 |
@@ -72,4 +78,4 @@ Skill 可以继续用 `SKILL.md` 表达操作方法，但涉及确定性工具
 | `aios-commercial-variation` | 工程变更签证资料链审查，用于梳理联系单、纪要、图纸变更、合同流程和资料断点。 |
 | `aios-construction-scheme` | 专项施工方案证据链辅审，用于提取危险源、交底要点、规范核验点、计算书缺口和专家复核事项。 |
 
-工程业务管理 Skill 只处理建筑工程资料抽取、证据链整理、风险提示和人工复核分流，不替代法务、造价、监理、安全、项目经理、总工或专家签审。涉及规范、制度、结构计算、质量安全、金额、工期索赔或责任归属时，必须输出 `Claim / Evidence / Tool Result / Decision`；没有工具或人工证据时只能标注 `Need verify` 或 `Hold for human`。
+工程业务管理 Skill 只处理建筑工程资料抽取、证据链整理、风险提示和人工复核分流，不替代法务、造价、监理、安全、项目经理、总工或专家签审。涉及规范、制度、结构计算、质量安全、金额、工期索赔或责任归属时，必须输出中文化的 `判断事项 / 证据 / 工具结果 / 处理建议`；没有工具或人工证据时只能标注 `需核验` 或 `转人工复核`。