@qlingzzy/qling 1.0.0 → 1.1.0

package/scripts/dep-layers.mjs

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+/**
+ * Phase 4.4 — 扫描 src 相对 import，输出分层依赖边（供架构文档/CI 门禁）
+ * Usage: node scripts/dep-layers.mjs [--json] [--strict]
+ *
+ * --strict: 若发现禁止的反向依赖边，exit 1
+ */
+import { readdir, readFile, mkdir, writeFile } from "fs/promises";
+import { join, relative, dirname, extname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..");
+const SRC = join(ROOT, "src");
+
+/** @typedef {'foundation'|'core-services'|'domain'|'agent-runtime'|'adapters'|'presentation'|'cli'|'other'} Layer */
+
+/**
+ * @param {string} rel posix path under src/
+ * @returns {Layer}
+ */
+export function layerOf(rel) {
+  const p = rel.replace(/\\/g, "/");
+  if (
+    p === "types.ts" ||
+    p === "config.ts" ||
+    p === "runtime-paths.ts" ||
+    p === "token-usage.ts" ||
+    p === "package-version.ts" ||
+    p === "output-style.ts" ||
+    p.startsWith("utils/") ||
+    p.startsWith("i18n/") ||
+    p.startsWith("providers/")
+  ) {
+    return "foundation";
+  }
+  if (
+    p.startsWith("pipeline/") ||
+    p.startsWith("guard/") ||
+    p === "guard.ts" ||
+    p.startsWith("lsp/") ||
+    p === "context-compactor.ts" ||
+    p === "context-tool-hygiene.ts" ||
+    p.startsWith("git/")
+  ) {
+    return "core-services";
+  }
+  if (
+    p.startsWith("memory/") ||
+    p === "memory.ts" ||
+    p.startsWith("session/") ||
+    p.startsWith("mission/") ||
+    p.startsWith("mcp/") ||
+    p.startsWith("channels/") ||
+    p.startsWith("skills/") ||
+    p.startsWith("metrics/") ||
+    p.startsWith("agents/") ||
+    p.startsWith("onboarding/") ||
+    p.startsWith("workflow-") ||
+    p === "discovery-registry.ts" ||
+    p === "discovery-types.ts" ||
+    p === "knowledge-agent.ts"
+  ) {
+    return "domain";
+  }
+  if (
+    p === "agent-loop.ts" ||
+    p.startsWith("agent/") ||
+    p.startsWith("tools/") ||
+    p === "repl.ts"
+  ) {
+    return "agent-runtime";
+  }
+  if (
+    p === "sdk.ts" ||
+    p === "daemon.ts" ||
+    p === "dashboard-server.ts" ||
+    p.endsWith("-report.ts") ||
+    p === "doctor.ts" ||
+    p === "statusline.ts" ||
+    p === "shortcuts.ts" ||
+    p === "help-topics.ts" ||
+    p === "recap.ts" ||
+    p.startsWith("session-") ||
+    p.startsWith("local-") ||
+    p.startsWith("eval/")
+  ) {
+    return "adapters";
+  }
+  if (p.startsWith("tui/")) return "presentation";
+  if (p === "index.ts" || p.startsWith("cli/") || p.startsWith("commands/")) {
+    return "cli";
+  }
+  return "other";
+}
+
+/** 允许的依赖方向：上层 → 下层（数字越小越底层） */
+export const LAYER_RANK = {
+  foundation: 0,
+  "core-services": 1,
+  domain: 2,
+  "agent-runtime": 3,
+  adapters: 4,
+  presentation: 5,
+  cli: 6,
+  other: 3,
+};
+
+/**
+ * 禁止的边：下层依赖上层
+ * @param {Layer} from
+ * @param {Layer} to
+ */
+export function isForbiddenEdge(from, to) {
+  if (from === to) return false;
+  const a = LAYER_RANK[from] ?? 99;
+  const b = LAYER_RANK[to] ?? 99;
+  // 允许同层外：from 只能依赖 rank <= from 的层（含向下）
+  // 禁止：from.rank < to.rank（下层依赖上层）—— 不对：
+  // foundation rank 0 依赖 cli rank 6 是禁止的 (0 < 6 且 from is lower)
+  // cli 依赖 foundation: 6 > 0 OK
+  // foundation 依赖 cli: 0 < 6 FORBIDDEN
+  return a < b;
+}
+
+async function walk(dir, acc = []) {
+  for (const e of await readdir(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) await walk(p, acc);
+    else if (e.isFile() && extname(e.name) === ".ts") acc.push(p);
+  }
+  return acc;
+}
+
+function resolveImport(fromFile, spec) {
+  let target = resolve(dirname(fromFile), spec);
+  target = target.replace(/\\/g, "/");
+  if (target.endsWith(".js")) target = target.slice(0, -3) + ".ts";
+  else if (!target.endsWith(".ts")) {
+    // bare directory index not common; try .ts
+    if (existsSync(target + ".ts")) target = target + ".ts";
+    else if (existsSync(join(target, "index.ts"))) target = join(target, "index.ts");
+    else target = target + ".ts";
+  }
+  return target;
+}
+
+export async function scanLayers() {
+  const files = await walk(SRC);
+  /** @type {Map<string, number>} */
+  const edgeCounts = new Map();
+  /** @type {Array<{from:string,to:string,fromLayer:string,toLayer:string}>} */
+  const forbidden = [];
+  /** @type {Record<string, number>} */
+  const layerCounts = {};
+
+  for (const f of files) {
+    const rel = relative(SRC, f).replace(/\\/g, "/");
+    const fromL = layerOf(rel);
+    layerCounts[fromL] = (layerCounts[fromL] || 0) + 1;
+    const text = await readFile(f, "utf8");
+    const re = /from\s+['"](\.[^'"]+)['"]/g;
+    let m;
+    while ((m = re.exec(text))) {
+      const targetAbs = resolveImport(f, m[1]);
+      const tRel = relative(SRC, targetAbs).replace(/\\/g, "/");
+      if (tRel.startsWith("..")) continue;
+      if (!tRel.endsWith(".ts") && !existsSync(join(SRC, tRel))) continue;
+      const toL = layerOf(tRel);
+      if (fromL === toL) continue;
+      const key = `${fromL}->${toL}`;
+      edgeCounts.set(key, (edgeCounts.get(key) || 0) + 1);
+      if (isForbiddenEdge(fromL, toL)) {
+        forbidden.push({
+          from: rel,
+          to: tRel,
+          fromLayer: fromL,
+          toLayer: toL,
+        });
+      }
+    }
+  }
+
+  return {
+    fileCount: files.length,
+    layerCounts,
+    edges: [...edgeCounts.entries()]
+      .map(([edge, count]) => ({ edge, count }))
+      .sort((a, b) => b.count - a.count),
+    forbidden: forbidden.slice(0, 200),
+    forbiddenCount: forbidden.length,
+  };
+}
+
+function formatMermaid(layerCounts, edges) {
+  const lines = ["```mermaid", "flowchart TB"];
+  const order = [
+    "foundation",
+    "core-services",
+    "domain",
+    "agent-runtime",
+    "adapters",
+    "presentation",
+    "cli",
+    "other",
+  ];
+  for (const l of order) {
+    if (layerCounts[l]) {
+      lines.push(`  ${l.replace(/-/g, "_")}["${l} (${layerCounts[l]})"]`);
+    }
+  }
+  // unique edges for diagram (not forbidden only — all)
+  const seen = new Set();
+  for (const { edge } of edges) {
+    const [a, b] = edge.split("->");
+    const id = `${a}->${b}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const fa = a.replace(/-/g, "_");
+    const fb = b.replace(/-/g, "_");
+    const bad = isForbiddenEdge(/** @type {any} */ (a), /** @type {any} */ (b));
+    lines.push(`  ${fa} ${bad ? "-.->|forbidden|" : "-->"} ${fb}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+
+const asJson = process.argv.includes("--json");
+const strict = process.argv.includes("--strict");
+const writeDoc = process.argv.includes("--write-doc");
+
+const result = await scanLayers();
+
+if (asJson) {
+  process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+} else {
+  console.log(`src files: ${result.fileCount}`);
+  console.log("layer counts:", result.layerCounts);
+  console.log("cross-layer edges:");
+  for (const e of result.edges) console.log(`  ${e.count}\t${e.edge}`);
+  console.log(`forbidden reverse edges: ${result.forbiddenCount}`);
+  if (result.forbiddenCount > 0) {
+    console.log("sample forbidden (up to 15):");
+    for (const f of result.forbidden.slice(0, 15)) {
+      console.log(`  ${f.fromLayer} -> ${f.toLayer}: ${f.from} imports ${f.to}`);
+    }
+  }
+  console.log("\n" + formatMermaid(result.layerCounts, result.edges));
+}
+
+if (writeDoc) {
+  const outDir = join(ROOT, "docs");
+  await mkdir(outDir, { recursive: true });
+  // doc written by separate architecture file; optional snapshot
+  const snap = join(outDir, "dependency-layers.snapshot.json");
+  await writeFile(
+    snap,
+    JSON.stringify(
+      {
+        generatedAt: new Date().toISOString(),
+        ...result,
+        forbidden: result.forbidden.slice(0, 50),
+      },
+      null,
+      2
+    ),
+    "utf8"
+  );
+  console.error(`[dep-layers] wrote ${snap}`);
+}
+
+if (strict && result.forbiddenCount > 0) {
+  process.exit(1);
+}

package/scripts/eval-llm.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * 可选 LLM 评测：默认 skip，不进入 ci:check
+ * Usage:
+ *   QLING_EVAL_LLM=1 DEEPSEEK_API_KEY=... node scripts/eval-llm.mjs
+ *   npm run eval:llm
+ */
+import {
+  runEvalSuite,
+  formatEvalReport,
+  evalReportToJson,
+} from "../dist/eval/runner.js";
+import { buildEvalLlmTasks } from "../dist/eval/llm-tasks.js";
+
+const asJson = process.argv.includes("--json");
+const report = await runEvalSuite({ tasks: buildEvalLlmTasks() });
+
+if (asJson) {
+  process.stdout.write(evalReportToJson(report) + "\n");
+} else {
+  process.stdout.write(
+    formatEvalReport(report, { title: "🧪 Qling eval:llm (optional)" }).join("\n") + "\n"
+  );
+}
+
+// skip 全部视为成功；仅 fail 导致非 0
+process.exit(report.fail === 0 ? 0 : 1);

package/scripts/eval-recovery.mjs

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { classifyFailure } from "../dist/execution/failure-classifier.js";
+import { RecoveryController } from "../dist/execution/recovery-controller.js";
+import { RecoveryStrategyPlanner } from "../dist/execution/recovery-strategy-planner.js";
+import { calculateRecoveryMetrics } from "../dist/execution/recovery-metrics.js";
+
+const fixtures = [
+  [Object.assign(new Error("rate limited"), { status: 429 }), "provider_transient"],
+  [new Error("approval_required"), "permission_required"],
+  [new Error("sandbox denied outside workspace"), "sandbox_denied"],
+  [new Error("command not found"), "tool_not_found"],
+  [new Error("maximum context length exhausted"), "context_exhausted"],
+  [new Error("permission denied"), "permission_denied"],
+  [new Error("duplicate tool call repeated action"), "repeated_action"],
+  [new Error("invalid tool arguments: missing required field"), "invalid_tool_arguments"],
+  [new Error("verification command exited with code 1"), "verification_failed"],
+];
+
+for (const [error, expected] of fixtures) {
+  assert.equal(classifyFailure(error).category, expected);
+}
+
+// Same fingerprint without progress -> pause
+const controller = new RecoveryController();
+controller.startRun({ runId: "eval_run", sessionId: "eval_session", originalTask: "deterministic fixture" });
+const failure = { category: "verification_failed", message: "tests failed", fingerprint: "same" };
+assert.equal(controller.recordFailure(failure, { diffHash: "a", failingTests: ["one"] }).action, "recover");
+assert.equal(controller.recordFailure(failure, { diffHash: "a", failingTests: ["one"] }).action, "pause");
+
+// Progress between same fingerprint failures still allows recover with next strategy
+const improved = new RecoveryController();
+improved.startRun({ runId: "eval_improved", sessionId: "eval_session", originalTask: "deterministic fixture" });
+assert.equal(improved.recordFailure(
+  { category: "verification_failed", message: "tests failed", fingerprint: "improved" },
+  { diffHash: "a", failingTests: ["one", "two"] }
+).recommendedStrategy, "targeted_verification_repair");
+assert.equal(improved.recordFailure(
+  { category: "verification_failed", message: "tests failed", fingerprint: "improved" },
+  { diffHash: "b", failingTests: ["two"] }
+).recommendedStrategy, "narrow_verification_scope");
+
+// Hard-stop categories pause immediately
+const stopped = new RecoveryController();
+stopped.startRun({ runId: "eval_stopped", sessionId: "eval_session", originalTask: "deterministic fixture" });
+assert.equal(stopped.recordFailure(
+  { category: "sandbox_denied", message: "outside workspace", fingerprint: "sandbox" },
+  {}
+).action, "pause");
+assert.equal(stopped.recordFailure(
+  { category: "permission_required", message: "approval_required", fingerprint: "approval" },
+  {}
+).action, "pause");
+
+// Context compaction strategy is single-use
+const ctx = new RecoveryController();
+ctx.startRun({ runId: "eval_ctx", sessionId: "eval_session", originalTask: "deterministic fixture" });
+assert.equal(ctx.recordFailure(
+  { category: "context_exhausted", message: "context exhausted", fingerprint: "ctx" },
+  {}
+).recommendedStrategy, "compact_context_once");
+assert.equal(ctx.recordFailure(
+  { category: "context_exhausted", message: "context exhausted", fingerprint: "ctx2" },
+  { changed: true }
+).reason, "no_recovery_strategy");
+
+// User next strategy after pause
+const planner = new RecoveryStrategyPlanner();
+assert.deepEqual(planner.list("invalid_tool_arguments"), [
+  "repair_tool_arguments",
+  "return_tool_schema",
+]);
+const args = new RecoveryController({ planner });
+args.startRun({ runId: "eval_args", sessionId: "eval_session", originalTask: "deterministic fixture" });
+args.recordFailure(
+  { category: "invalid_tool_arguments", message: "invalid arguments", fingerprint: "args" },
+  {}
+);
+args.recordFailure(
+  { category: "invalid_tool_arguments", message: "invalid arguments", fingerprint: "args" },
+  {}
+);
+assert.equal(args.getRecoveryState().status, "paused");
+assert.equal(args.applyAction("next").currentStrategy, "return_tool_schema");
+assert.equal(args.applyAction("cancel").status, "canceled");
+
+// Trajectory replay metrics from redacted JSONL-like events (no prompt/tool body)
+const metrics = calculateRecoveryMetrics([
+  { eventId: "e1", runId: "eval_improved", type: "attempt_completed", status: "failed", timestamp: 1 },
+  { eventId: "e2", runId: "eval_improved", type: "recovery_started", status: "recovering", timestamp: 2, recoveryAction: "targeted_verification_repair" },
+  { eventId: "e3", runId: "eval_improved", type: "attempt_completed", status: "succeeded", timestamp: 3 },
+  { eventId: "e4", runId: "eval_improved", type: "run_completed", status: "succeeded", timestamp: 4 },
+]);
+assert.equal(metrics.finalSuccessRate, 1);
+assert.ok(metrics.automaticRecoverySuccessRate >= 0);
+
+console.log(JSON.stringify({
+  ok: true,
+  fixtures: fixtures.length + 6,
+  metrics,
+  mode: "deterministic-no-model",
+}));

package/scripts/eval-tasks.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * 本地 repo fixture 评测（不依赖外部 LLM / API key）
+ * Usage: node scripts/eval-tasks.mjs [--json]
+ */
+import { runEvalSuite, formatEvalReport, evalReportToJson } from "../dist/eval/runner.js";
+import { buildEvalRepoTasks } from "../dist/eval/repo-tasks.js";
+
+const asJson = process.argv.includes("--json");
+
+const report = await runEvalSuite({ tasks: buildEvalRepoTasks() });
+if (asJson) {
+  process.stdout.write(evalReportToJson(report) + "\n");
+} else {
+  process.stdout.write(
+    formatEvalReport(report, { title: "🧪 Qling eval:tasks (repo fixtures)" }).join("\n") + "\n"
+  );
+}
+
+process.exit(report.fail === 0 ? 0 : 1);

package/scripts/validate-packaging.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * Validate Scoop / winget draft manifests align with package.json version.
+ * Usage: node scripts/validate-packaging.mjs
+ */
+import { readFile } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const errors = [];
+
+const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+const version = pkg.version;
+
+const scoopRaw = await readFile(join(root, "packaging", "scoop", "qling.json"), "utf8");
+const scoop = JSON.parse(scoopRaw);
+if (scoop.version !== version) {
+  errors.push(`scoop version ${scoop.version} != package ${version}`);
+}
+if (!String(scoop.url || "").includes(version)) {
+  errors.push(`scoop url does not pin ${version}: ${scoop.url}`);
+}
+if (!Array.isArray(scoop.notes) || !scoop.notes.some((n) => /DRAFT|draft/i.test(n))) {
+  errors.push("scoop notes should mark DRAFT status");
+}
+
+const winget = await readFile(
+  join(root, "packaging", "winget", "Zzy-min.qling.yaml"),
+  "utf8"
+);
+if (!winget.includes(`PackageVersion: ${version}`)) {
+  errors.push(`winget PackageVersion missing ${version}`);
+}
+if (!winget.includes("PackageIdentifier: Zzy-min.qling")) {
+  errors.push("winget PackageIdentifier missing");
+}
+if (!/DRAFT|not submitted/i.test(winget)) {
+  errors.push("winget should remain marked as DRAFT");
+}
+
+if (errors.length) {
+  console.error("validate-packaging FAILED:");
+  for (const e of errors) console.error(" -", e);
+  process.exit(1);
+}
+
+console.log(`validate-packaging OK (version ${version})`);
+console.log("  scoop:", scoop.url);
+console.log("  winget: Zzy-min.qling @", version);
+console.log("  note: still drafts — not published to official catalogs");

package/skills/examples/README.md

@@ -0,0 +1,23 @@
+# Example skills pack
+
+Bundled under `skills/examples/` and discovered by Qling's progressive skill loader.
+
+| Skill | Purpose |
+|-------|---------|
+| `repo-triage` | Map an unfamiliar repository quickly |
+| `fix-failing-test` | Reproduce, patch, and re-verify a red test |
+| `add-function` | Add an exported function with minimal diff |
+| `pr-summary` | Draft PR / release notes from git history |
+
+## Usage
+
+```text
+/skill list
+/skill fix-failing-test
+/skill add-function
+/skill pr-summary
+```
+
+Copy the template at `skills/templates/SKILL.md` to create your own under `~/.qling/skills/` or the project `skills/` directory.
+
+See [docs/skills.md](../../docs/skills.md).

package/skills/examples/add-function/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: add-function
+description: 在现有模块中增量添加导出函数：对齐风格、补调用点、补测试
+tags: [example, coding, refactor]
+triggers: [加函数, add function, export, 新增 API]
+---
+
+# Add Function
+
+## 何时使用
+
+用户要求「加一个函数」「导出 xxx」「补一个工具方法」时加载。
+
+## 步骤
+
+1. **读现有模块** — 风格、命名、错误处理、导入习惯
+2. **设计签名** — 参数/返回值/边界；与相邻 API 一致
+3. **实现** — `patch` 或 `write` 最小增量
+4. **调用点** — 若用户给了使用场景，同步更新调用处
+5. **测试** — 能测则加/改测试；不能测则给手动验证步骤
+
+## 约束
+
+- 不引入新依赖，除非用户同意
+- 不顺手大重构
+- 公开 API 变更要在回复里写清楚
+
+## 验收
+
+- [ ] 新符号可 import / 可调用
+- [ ] 有验证命令或测试

package/skills/examples/fix-failing-test/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: fix-failing-test
+description: 定位并修复失败的单元测试：读错误、最小改动、再跑验证
+tags: [example, testing, coding]
+triggers: [修测试, failing test, unit test, 红灯, assert]
+---
+
+# Fix Failing Test
+
+## 何时使用
+
+用户说「测试挂了」「帮我修这个 unit test」「红了」时加载。
+
+## 步骤
+
+1. **复现** — 用 `bash` 跑失败命令（`npm test` / `node --test path`），保存完整错误
+2. **定位** — `read` 失败文件与被测实现；`search` 相关符号
+3. **假设** — 区分「断言错了」vs「实现错了」vs「环境/路径」
+4. **最小修复** — `patch` 只改必要行；避免无关重构
+5. **验证** — 再跑同一命令；必要时补一条窄测试
+
+## 约束
+
+- 不要为了让测试变绿而删除断言（除非用户明确要求）
+- 不要改 `.env` / 密钥文件
+- Plan Mode 下只输出计划
+
+## 验收
+
+- [ ] 失败命令现已通过
+- [ ] diff 可读、范围小
+- [ ] 说明根因一句话

package/skills/examples/pr-summary/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: pr-summary
+description: 根据 git diff / 最近提交写中英 PR 摘要与测试计划
+tags: [example, git, docs, shipping]
+triggers: [PR 摘要, pull request, changelog, 发布说明]
+---
+
+# PR Summary
+
+## 何时使用
+
+用户要「写 PR 描述」「总结这次改动」「release notes」时加载。
+
+## 步骤
+
+1. `bash`：`git status` / `git log --oneline -15` / `git diff`（或 `git diff main...HEAD`）
+2. 按 **Why / What / How to test** 组织
+3. 标出 breaking change / 迁移注意（若有）
+4. 中文主描述 + 可选英文一节
+
+## 输出模板
+
+```markdown
+## Summary
+- …
+
+## Test plan
+- [ ] …
+```
+
+## 约束
+
+- 不编造未出现的文件或测试结果
+- 密钥/token 不得写入摘要

package/skills/lifecycle-build/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: lifecycle-build
+description: 按计划增量实现：小步修改、每步可验证。触发：开始写代码、实现功能。
+tags: [lifecycle, build, implement]
+triggers: [实现, 编码, 写代码, /build]
+---
+
+# 生命周期 · 实现（Build）
+
+## 步骤
+
+1. 只实现 **当前计划中的下一步**，不偷跑范围外需求。
+2. 优先 `read` / `search` 理解现有模式，再 `patch`/`write`。
+3. 每完成一步：跑最小相关测试或命令；失败先修再前进。
+4. 保持 diff 小而可读；大文件用 patch。
+5. 进度用 todo 标记；中断可 checkpoint。
+
+## 不要
+
+- 不要无读就大范围改。
+- 不要静默吞掉测试失败。
+- 不要在 Plan Mode 下写文件（先 `/plan off`）。

package/skills/lifecycle-plan/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: lifecycle-plan
+description: 把已确认规格拆成小而可验证的实现任务。触发：已有 Spec、要排期、/plan。
+tags: [lifecycle, plan]
+triggers: [实施计划, 任务拆分, 排期, /plan]
+---
+
+# 生命周期 · 计划（Plan）
+
+## 步骤
+
+1. 重述 Spec 中的验收标准（不得改写成功定义）。
+2. 拆成 **原子任务**（每步可独立验证，通常 15–45 分钟量级）。
+3. 标注依赖顺序与可并行只读探索。
+4. 标明将触碰的文件路径（估计即可）。
+5. 写出 **测试计划**：先写什么测、如何证明完成。
+6. 风险与回滚点。
+
+## 输出格式
+
+```markdown
+## Plan
+1. [ ] 任务… — 文件… — 验证…
+2. [ ] …
+## 风险
+- …
+```
+
+## 不要
+
+- 不要跳过测试步骤。
+- 不要一次计划「重写整个仓库」。

package/skills/lifecycle-review/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: lifecycle-review
+description: 合并前代码健康检查：正确性、安全、可维护性。触发：准备提交、CR、/review。
+tags: [lifecycle, review, quality]
+triggers: [代码审查, review, 合并前, /review]
+---
+
+# 生命周期 · 审查（Review）
+
+## 五轴快速检查
+
+1. **正确性**：是否满足 Spec 验收？边界？
+2. **安全**：密钥、注入、路径穿越、危险 bash？
+3. **可维护性**：命名、重复、文件是否过大？
+4. **可观测/错误**：失败是否诚实、是否吞异常？
+5. **测试**：关键路径是否有证据？
+
+## 输出
+
+- CRITICAL / HIGH / MEDIUM / LOW 列表 + 建议修复顺序。
+- 无问题也写「已核对验收条款」。
+
+## 不要
+
+- 不要只夸「看起来不错」而无检查清单。