paseo-req-kit 1.14.0-beta.4 → 1.14.0

package/engine/src/messages.ts

@@ -54,6 +54,24 @@ export function permissionMessage(input: {
   ].join("\n");
 }
 
+/** 1.14: a step agent ran (or started) a dangerous command; the pipeline stopped it. */
+export function dangerNotice(input: { stepTitle: string; agentTitle: string; command: string; label: string; ran: boolean }): string {
+  const one = input.command.replace(/\s+/g, " ").trim();
+  return [
+    HEADER,
+    "",
+    `流水线的「${input.stepTitle}」步骤里，agent ${input.ran ? "运行了" : "开始运行"}一条不允许的命令（${input.label}），${input.ran ? "流水线发现时它已经运行完" : "流水线已经打断了它"}：`,
+    "",
+    "```text",
+    one.length > 300 ? `${one.slice(0, 299)}…` : one,
+    "```",
+    "",
+    input.ran
+      ? `请告诉用户这件事，并请用户检查它有没有改动仓库以外或远程的东西（例如远程分支、制品仓库、集群、其他机器、数据库）。需要撤销的由用户处理；不要自己去撤销。agent「${input.agentTitle}」已被告知不要再这样做，流水线继续。`
+      : `请告诉用户这件事。agent「${input.agentTitle}」已被告知不要再这样做，流水线继续；如果这条命令其实是允许的，可以在配置 dangerGuard.allow 里放行。`,
+  ].join("\n");
+}
+
 export function failedMessage(input: {
   stepTitle: string;
   reason: string;
@@ -427,3 +445,14 @@ export function pluginReplyMessage(input: { featureDir: string; waitingFor: "bus
       : "请这样处理：按 /req 中\"需要需求方决定\"的做法，把回答记入 alignment.md 并更新 spec.md；回答已经覆盖全部问题时，向用户简要复述后执行继续命令；还缺的，在对话里接着问。",
   ].join("\n");
 }
+
+/** 1.14: the requirement's chat is reminded once that a confirmed spec has not started development. */
+export function notStartedNotice(featureDir: string): string {
+  return [
+    "【需求开发流水线提示】这条消息来自 req-kit 的后台检查，不是用户发的。",
+    "",
+    `需求 ${featureDir} 的需求说明已经确认超过 30 分钟，但开发流水线还没有启动。`,
+    "如果用户确实要开发它：请按 /req 的手册启动开发（或者告诉用户可以在插件\"等你处理\"里点\"开始开发\"）。",
+    "如果是用户有意先不开发、还要再改需求，或者已经在别处开始了：用一句话确认即可，不需要其他操作。这个提醒只发一次。",
+  ].join("\n");
+}

package/engine/src/outcomes.ts

@@ -0,0 +1,145 @@
+// What happened after the run (1.14): whether each requirement's change reached the main line,
+// and problems found after that. Recorded as events in the usage records (records.ts), so
+// `req stats` can report merges and post-merge problems next to the runs. Merges are found
+// from what is already in the local repository (no fetch): the requirement's pipeline files
+// (implementation.md, report.md, …) are in the main line's tree. A defect requirement whose spec
+// says "- 引入问题的需求：<目录名或标题>" counts as a problem of that requirement.
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { PIPELINE_OUTPUTS } from "./features.js";
+import { appendEvent, type EventRecord, type IndexEntry, readEvents, readIndex, requirementRef, runsFile } from "./records.js";
+
+function git(repo: string, args: string[]): string | null {
+  try {
+    return execFileSync("git", args, { cwd: repo, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+  } catch {
+    return null;
+  }
+}
+
+/** The main line of a repository as known locally: origin's default branch, else main or master. */
+export function mainLine(repo: string): string | null {
+  const head = git(repo, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"])?.trim();
+  for (const ref of [head, "origin/main", "origin/master", "main", "master"]) {
+    if (ref && git(repo, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]) !== null) return ref;
+  }
+  return null;
+}
+
+/** Whether the requirement's change is in the main line, with the commit that brought it there. */
+export function mergeOf(repo: string, featureDir: string): NonNullable<EventRecord["merge"]> | null {
+  const ref = mainLine(repo);
+  if (!ref) return null;
+  const fd = featureDir.split(path.sep).join("/");
+  const marker = PIPELINE_OUTPUTS.find((f) => git(repo, ["cat-file", "-e", `${ref}:${fd}/${f}`]) !== null);
+  if (!marker) return null;
+  const line = git(repo, ["log", "--first-parent", "--diff-filter=A", "-1", "--format=%H%x09%cI", ref, "--", `${fd}/${marker}`])?.trim() ?? "";
+  const [commit, at] = line.split("\t");
+  return { into: ref, commit: commit ? commit.slice(0, 12) : null, mergedAt: at || null, how: "files" };
+}
+
+/** The spec of a requirement: in its directory, or (worktree removed) in the main line. */
+function specOf(entry: IndexEntry): string | null {
+  const file = path.join(entry.repo, entry.featureDir, "spec.md");
+  if (fs.existsSync(file)) return fs.readFileSync(file, "utf8");
+  const repo = [entry.sourceRepo, entry.repo].find((r): r is string => !!r && fs.existsSync(r));
+  const ref = repo ? mainLine(repo) : null;
+  return repo && ref ? git(repo, ["show", `${ref}:${entry.featureDir}/spec.md`]) : null;
+}
+
+const CAUSED_BY = /^\s*[-*]\s*引入问题的需求[:：]\s*(.+?)\s*$/m;
+
+/**
+ * Looks at every requirement this machine knows (the index) and records what is new: merges
+ * into the main line, and defect requirements that name the requirement that caused them.
+ * Returns the events it added. Never throws.
+ */
+export function scanOutcomes(env: NodeJS.ProcessEnv = process.env): EventRecord[] {
+  const added: EventRecord[] = [];
+  try {
+    const events = readEvents(runsFile(env));
+    const merged = new Set(events.filter((e) => e.kind === "merge").map((e) => `${e.requirement.project}\0${e.requirement.key}`));
+    const issues = new Set(events.filter((e) => e.kind === "issue").map((e) => e.issue?.id));
+    const entries = readIndex(env);
+    for (const entry of entries) {
+      const repo = [entry.sourceRepo, entry.repo].find((r): r is string => !!r && fs.existsSync(r));
+      if (!repo) continue;
+      const ref = requirementRef(entry.repo, entry.featureDir, env);
+      if (!merged.has(`${ref.project}\0${ref.key}`)) {
+        const m = mergeOf(repo, entry.featureDir);
+        if (m) {
+          const e = { kind: "merge" as const, requirement: ref, merge: m };
+          appendEvent(e, env);
+          added.push({ schema: 1, machine: "", kitVersion: "", at: new Date().toISOString(), ...e });
+          merged.add(`${ref.project}\0${ref.key}`);
+        }
+      }
+      const cause = CAUSED_BY.exec(specOf(entry) ?? "")?.[1];
+      const id = `defect:${entry.key}`;
+      if (!cause || issues.has(id)) continue;
+      const target = entries.find((o) => o.key !== entry.key && (path.basename(o.featureDir) === cause || o.featureDir === cause || requirementRef(o.repo, o.featureDir, env).title === cause));
+      if (!target) continue;
+      const e = { kind: "issue" as const, requirement: requirementRef(target.repo, target.featureDir, env), issue: { text: ref.title, by: ref.name, id } };
+      appendEvent(e, env);
+      added.push({ schema: 1, machine: "", kitVersion: "", at: new Date().toISOString(), ...e });
+      issues.add(id);
+    }
+  } catch {
+    // Outcomes are a convenience for the statistics.
+  }
+  return added;
+}
+
+const USAGE = `用法：
+  req outcome                          查找已经合并进主干的需求、合并后发现的问题（缺陷需求里写了"引入问题的需求"），记入使用记录
+  req outcome <需求> --merged [--commit <提交>]   手动记一笔：这个需求已经合并（例如合并后删掉了需求目录）
+  req outcome <需求> --issue "<问题>"             手动记一笔：这个需求合并后发现的问题
+
+合并是从本机仓库里已有的分支判断的，判断前可以先 git fetch。结果在 req stats 里看。`;
+
+async function main(argv: string[]): Promise<number> {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(USAGE);
+    return 0;
+  }
+  const feature = argv.find((a, i) => !a.startsWith("--") && !["--issue", "--commit"].includes(argv[i - 1] ?? ""));
+  const value = (flag: string) => {
+    const i = argv.indexOf(flag);
+    return i >= 0 ? (argv[i + 1] ?? null) : null;
+  };
+  if (!feature) {
+    const added = scanOutcomes();
+    if (added.length === 0) console.log("没有新的合并或合并后问题。");
+    for (const e of added) {
+      console.log(e.kind === "merge" ? `已合并：${e.requirement.title}（${e.merge!.into}${e.merge!.commit ? `，${e.merge!.commit}` : ""}）` : `合并后的问题：${e.requirement.title} ← ${e.issue!.by}「${e.issue!.text}」`);
+    }
+    return 0;
+  }
+  const { locate } = await import("./api.js");
+  const { repo, featureDir } = locate(process.cwd(), feature);
+  const requirement = requirementRef(repo, featureDir);
+  if (argv.includes("--merged")) {
+    appendEvent({ kind: "merge", requirement, merge: { into: mainLine(repo) ?? "main", commit: value("--commit"), mergedAt: null, how: "manual" } });
+    console.log(`已记录：${requirement.title} 已合并。`);
+    return 0;
+  }
+  const text = value("--issue");
+  if (text && !text.startsWith("--")) {
+    appendEvent({ kind: "issue", requirement, issue: { text: text.slice(0, 500), by: null, id: `manual:${Date.now()}` } });
+    console.log(`已记录：${requirement.title} 合并后的问题「${text.slice(0, 80)}」。`);
+    return 0;
+  }
+  console.error(USAGE);
+  return 2;
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(import.meta.filename)) {
+  main(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (error: Error) => {
+      console.error(error.message);
+      process.exit(1);
+    },
+  );
+}

package/engine/src/paseo-runtime.ts

@@ -1,5 +1,5 @@
 import type { PaseoAgentHandle, PaseoClient } from "@getpaseo/client";
-import { runningToolOf, summarizeActivity } from "./activity.js";
+import { runningToolOf, toolCallsOf, summarizeActivity } from "./activity.js";
 import { type AgentProfile, isResolved, type PipelineConfig } from "./config.js";
 import { profilesFromDaemonConfig } from "./paseo-profiles.js";
 import { cronAt, localTimeZone } from "./schedule-time.js";
@@ -296,6 +296,14 @@ export function createRuntimeWithClient(
         return null;
       }
     },
+    async toolCalls(agentId) {
+      try {
+        const page = await client.agents.ref(agentId).timeline.refetch({ direction: "tail", limit: 200 });
+        return toolCallsOf(page.entries);
+      } catch {
+        return null;
+      }
+    },
     async createWorktree(request) {
       if (!client.workspaces) throw new Error("这个 Paseo 版本不支持新建工作区");
       const workspace = await client.workspaces.create({

package/engine/src/pipeline.ts

@@ -1,4 +1,6 @@
 import { judge as judgeScan } from "./scan-guard.js";
+import { dangerMessage, dangerOf } from "./danger-guard.js";
+import { describeFinding, scanChange, secretFollowUp } from "./secret-scan.js";
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
@@ -29,6 +31,7 @@ import {
   verifyStartPrompt,
   milestoneMessage,
   permissionMessage,
+  dangerNotice,
   resultFollowUp,
 } from "./messages.js";
 import { KIT_ROOT, kitVersion } from "./locations.js";
@@ -38,7 +41,7 @@ import { describeExternal, type IntegrationEvent, renderArgs, resolveCommand, ty
 import { cardSlug, planAppendix, publishCard, readSource } from "./card.js";
 import { principlesSection, projectAdditions, type PromptLocations, readToolPrompt } from "./prompts.js";
 import type { AgentRuntime, ManagedService, ServiceTarget, StepAgent, WaitOutcome } from "./runtime.js";
-import { type CheckOutcome, type GateRun, type JointRepo, type PhaseName, type PipelineState, type Recovery, type RunPhases, type StepRecord, type StopKind, writeState } from "./state.js";
+import { type CheckOutcome, type GateRun, type JointRepo, type PhaseName, type PipelineState, type Recovery, type SecretScanRun, type RunPhases, type StepRecord, type StopKind, writeState } from "./state.js";
 import { type PanelStep, STEPS, type StepDef, type StepId, stepKey, validateResult, VERIFY_PHASE_STEPS } from "./steps.js";
 
 export interface PipelineContext {
@@ -518,6 +521,15 @@ function pushBranch(ctx: PipelineContext): void {
   const at = new Date().toISOString();
   for (const repo of repos) {
     let error: string | null = null;
+    // 1.14: nothing with a secret in it leaves the machine.
+    const target = (ctx.state.joint ?? []).map((j) => ({ joint: j, repo: j.repo })).find((t) => t.repo === repo);
+    const secrets = ctx.config.secretScan.enabled ? scanChange(repo, secretBase(ctx, target as StepTarget | undefined), ctx.config.secretScan) : [];
+    if (secrets && secrets.length > 0) {
+      error = `发现 ${secrets.length} 处疑似密钥，没有推送（例如 ${describeFinding(secrets[0])}）；去掉后继续开发会再推送`;
+      ctx.log(`推送 ${repo} 的分支：${error}`);
+      ctx.state.pushed = [...(ctx.state.pushed ?? []).filter((p) => p.repo !== repo), { repo, remote: push.remote, branch, at, error, mergeRequest: ctx.state.pushed?.find((p) => p.repo === repo)?.mergeRequest ?? null }];
+      continue;
+    }
     try {
       execFileSync("git", ["push", push.remote, `HEAD:refs/heads/${branch}`], { cwd: repo, stdio: ["ignore", "pipe", "pipe"], timeout: 180_000, windowsHide: true });
     } catch (e) {
@@ -661,9 +673,57 @@ async function guardScan(ctx: PipelineContext, agent: StepAgent, def: StepDef, k
   recover(ctx, key, "stop_scan", `「${def.title}」的命令${verdict.reason}，已打断并告诉 agent 改用别的办法：${tool.text.replace(/\s+/g, " ").slice(0, 120)}`);
 }
 
+/** How often the danger guard looks at the agent's commands (it waits in chunks this long). */
+const DANGER_CHECK_SECONDS = 15;
+/** At most this many danger interruptions per turn. */
+const DANGER_MAX_INTERRUPTS = 5;
+
+/**
+ * 1.14: looks at the commands the step agent ran or is running; a dangerous one is recorded, the
+ * person is told, and the agent is interrupted (while its turn runs) with what to do instead.
+ * Each tool call is handled once, also across turns and pipeline restarts.
+ */
+async function guardDanger(ctx: PipelineContext, agent: StepAgent, def: StepDef, agentTitle: string, key: string, turnRunning: boolean, memory: { count: number }): Promise<void> {
+  const settings = ctx.config.dangerGuard;
+  if (!settings.enabled || !ctx.runtime.toolCalls) return;
+  const calls = await ctx.runtime.toolCalls(agent.id).catch(() => null);
+  if (!calls) return;
+  const seen = new Set((ctx.state.dangers ?? []).filter((d) => d.agentId === agent.id).map((d) => d.callId));
+  for (const call of calls) {
+    if (seen.has(call.callId) || !["shell", "fetch", "unknown"].includes(call.kind)) continue;
+    const danger = dangerOf(call.text, settings, { repo: agentRepo(ctx, agent) });
+    if (!danger) continue;
+    const ran = call.status !== "running";
+    seen.add(call.callId);
+    ctx.state.dangers = [...(ctx.state.dangers ?? []), { at: new Date().toISOString(), key, stepTitle: def.title, command: call.text.slice(0, 500), label: danger.label, ran, agentId: agent.id, callId: call.callId }].slice(-50);
+    save(ctx);
+    ctx.log(`危险命令（${key}）：${danger.label}，${ran ? "已运行完" : "正在运行，打断"}：${call.text.replace(/\s+/g, " ").slice(0, 160)}`);
+    if (turnRunning && memory.count < DANGER_MAX_INTERRUPTS) {
+      memory.count += 1;
+      await ctx.runtime.interruptAgent(agent.id, dangerMessage(call.text, danger, ran)).catch((error: Error) => ctx.log(`打断「${def.title}」失败：${error.message}`));
+    }
+    await notifyOrigin(ctx, dangerNotice({ stepTitle: def.title, agentTitle, command: call.text, label: danger.label, ran }));
+    await notifyExternal(ctx, "alert", `「${def.title}」步骤的 agent ${ran ? "运行了" : "开始运行"}不允许的命令（${danger.label}）${ran ? "，请检查有没有造成影响" : "，已打断"}。`, {
+      kind: "danger",
+      stepTitle: def.title,
+      command: call.text.slice(0, 500),
+      label: danger.label,
+      ran,
+    });
+  }
+}
+
+/** The directory the agent works in: the joint repository's worktree when it is one of theirs. */
+function agentRepo(ctx: PipelineContext, agent: StepAgent): string {
+  const record = ctx.state.history.find((h) => h.agentId === agent.id);
+  const slug = record?.key.includes("@") ? record.key.split("@").pop() : null;
+  return (slug && ctx.state.joint?.find((j) => j.slug === slug)?.repo) || ctx.repo;
+}
+
 async function waitForTurn(ctx: PipelineContext, agent: StepAgent, def: StepDef, agentTitle: string, deadline: Deadline): Promise<AgentUsage | null> {
   const notifiedPermissions = new Set<string>();
   const guard: ScanGuardMemory = { interrupted: new Set(), count: 0 };
+  const danger = { count: 0 };
   let consecutiveErrors = 0;
   for (;;) {
     let remaining = deadline.at - Date.now();
@@ -686,7 +746,9 @@ async function waitForTurn(ctx: PipelineContext, agent: StepAgent, def: StepDef,
     let outcome;
     try {
       // 1.13: with the scan guard on, look at the running tool call about once a minute.
-      const chunk = ctx.config.scanGuard.enabled ? Math.min(ctx.config.waitChunkSeconds, SCAN_CHECK_SECONDS) : ctx.config.waitChunkSeconds;
+      // 1.14: with the danger guard on, look at its commands every 15 seconds.
+      const guardSeconds = ctx.config.dangerGuard.enabled ? DANGER_CHECK_SECONDS : ctx.config.scanGuard.enabled ? SCAN_CHECK_SECONDS : Infinity;
+      const chunk = Math.min(ctx.config.waitChunkSeconds, guardSeconds);
       outcome = await agent.wait(Math.min(chunk * 1000, remaining));
       consecutiveErrors = 0;
     } catch (error) {
@@ -706,8 +768,10 @@ async function waitForTurn(ctx: PipelineContext, agent: StepAgent, def: StepDef,
     }
     switch (outcome.status) {
       case "idle":
+        await guardDanger(ctx, agent, def, agentTitle, deadline.key, false, danger);
         return outcome.usage ?? null;
       case "timeout":
+        await guardDanger(ctx, agent, def, agentTitle, deadline.key, true, danger);
         await guardScan(ctx, agent, def, deadline.key, guard);
         continue;
       case "error":
@@ -924,12 +988,14 @@ async function runStepOnce(
 
     if (extras.gate) {
       // The same agent fixes what its own change broke: it still has the context.
-      await qualityGate(ctx, key, target, async (text) => {
+      const fix = async (text: string) => {
         await agent.followUp(text);
         record.usage = (await waitForTurn(ctx, agent, def, agentTitle, deadline)) ?? record.usage ?? null;
         const again = readResultFile(resultAbs, def);
         if (again.ok) validation = again;
-      });
+      };
+      await qualityGate(ctx, key, target, fix);
+      await secretGate(ctx, key, target, fix);
     }
 
     record.outcome = "completed";
@@ -1703,6 +1769,69 @@ async function qualityGate(ctx: PipelineContext, key: string, target: StepTarget
   }
 }
 
+/** The commit the secret scan starts from: the attempt's code base, else where the branch left the main line. */
+function secretBase(ctx: PipelineContext, target?: StepTarget): string | null {
+  const repo = target?.repo ?? ctx.repo;
+  const recorded = codeBaseCommit(ctx, target);
+  if (recorded) return recorded;
+  for (const ref of ["origin/HEAD", "origin/main", "origin/master", "main", "master"]) {
+    try {
+      const mb = execFileSync("git", ["merge-base", "HEAD", ref], { cwd: repo, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
+      if (mb && mb !== headCommit(repo)) return mb;
+    } catch {
+      /* try the next */
+    }
+  }
+  return null;
+}
+
+/**
+ * 1.14: after a step that changed code, looks for secrets the requirement added (secret-scan.ts);
+ * what it finds goes back to the step's agent, like a failing check, up to qualityGate.fixAttempts
+ * times. The outcome is kept for the review, the report and the push.
+ */
+async function secretGate(ctx: PipelineContext, key: string, target: StepTarget | undefined, fix: (text: string) => Promise<void>): Promise<void> {
+  if (!ctx.config.secretScan.enabled) return;
+  const repo = target?.repo ?? ctx.repo;
+  const base = secretBase(ctx, target);
+  const max = ctx.config.qualityGate.fixAttempts;
+  for (let fixRounds = 0; ; fixRounds += 1) {
+    const findings = scanChange(repo, base, ctx.config.secretScan);
+    if (findings === null) {
+      ctx.log(`密钥扫描（${key} 之后）：找不到改动的起点，没有扫描`);
+      return;
+    }
+    if (findings.length === 0 || fixRounds >= max) {
+      const run: SecretScanRun = { key, attempt: ctx.state.attempt, at: new Date().toISOString(), findings, fixRounds, passed: findings.length === 0 };
+      ctx.state.secretScans = [...(ctx.state.secretScans ?? []).filter((r) => !(r.key === key && r.attempt === run.attempt)), run].slice(-30);
+      save(ctx);
+      ctx.log(`密钥扫描（${key} 之后）：${run.passed ? (fixRounds > 0 ? `要求处理 ${fixRounds} 次后没有发现` : "没有发现") : `要求处理 ${fixRounds} 次后仍有 ${findings.length} 处`}`);
+      if (!run.passed) {
+        await notifyOrigin(ctx, milestoneMessage(`「${key}」之后的密钥扫描仍发现 ${findings.length} 处疑似密钥（例如 ${describeFinding(findings[0])}）。这些提交不会被推送；请用户看一下是不是真实的密钥。`));
+      }
+      return;
+    }
+    ctx.log(`密钥扫描（${key} 之后）：发现 ${findings.length} 处疑似密钥，第 ${fixRounds + 1} 次要求处理`);
+    await fix(secretFollowUp({ findings, base: base!, round: fixRounds + 1, max }));
+  }
+}
+
+/** What the secret scan found in this attempt, for the code review and the report. */
+function secretLines(ctx: PipelineContext): string[] {
+  const runs = (ctx.state.secretScans ?? []).filter((r) => r.attempt === ctx.state.attempt);
+  const last = runs.at(-1);
+  if (!last) return [];
+  if (last.passed) return [`密钥扫描（${last.key} 之后，流水线运行）：没有发现疑似密钥${last.fixRounds > 0 ? `（要求处理 ${last.fixRounds} 次后）` : ""}`];
+  return [`密钥扫描（${last.key} 之后，流水线运行）：仍有 ${last.findings.length} 处疑似密钥，分支不会被推送：`, ...last.findings.slice(0, 10).map((f) => `- ${describeFinding(f)}`)];
+}
+
+/** Dangerous commands step agents ran in this run, for the report. */
+function dangerLines(ctx: PipelineContext): string[] {
+  const list = ctx.state.dangers ?? [];
+  if (list.length === 0) return [];
+  return [`流水线拦下的危险命令（${list.length} 次，已通知用户）：`, ...list.slice(-10).map((d) => `- 「${d.stepTitle}」${d.ran ? "运行了" : "开始运行（已打断）"}：${d.label}`)];
+}
+
 function describeGateRun(run: GateRun): string {
   const ran = run.checks.filter((c) => c.result !== "skipped");
   const skipped = run.checks.length - ran.length;
@@ -1963,7 +2092,7 @@ async function developPhase(ctx: PipelineContext): Promise<Record<string, unknow
 
   const reviewLoop = async (target?: StepTarget) => {
     for (let r = 1; r <= rounds.codeReview; r++) {
-      const lines = [...gateLines(ctx, target), ...(target ? [] : scopeLines(ctx)), ...acceptanceLines(ctx, target)];
+      const lines = [...gateLines(ctx, target), ...(target ? [] : [...secretLines(ctx), ...scopeLines(ctx)]), ...acceptanceLines(ctx, target)];
       const review = await runReview(ctx, "code_review", r, rounds.codeReview, lines, target);
       if (review.verdict === "pass") break;
       await runStep(ctx, "review_fix", r, rounds.codeReview, { gate: true, target });
@@ -2142,7 +2271,7 @@ function externalLines(ctx: PipelineContext): string[] {
 }
 
 function reportLines(ctx: PipelineContext): string[] {
-  const lines = [...usageLines(ctx), ...gateLines(ctx), ...scopeLines(ctx), ...acceptanceLines(ctx), ...jointLines(ctx), ...externalLines(ctx)];
+  const lines = [...usageLines(ctx), ...gateLines(ctx), ...secretLines(ctx), ...dangerLines(ctx), ...scopeLines(ctx), ...acceptanceLines(ctx), ...jointLines(ctx), ...externalLines(ctx)];
   if (ctx.config.checks.length === 0 && ctx.state.type !== "assessment") {
     lines.push("质量门：项目没有配置检查（checks），流水线没有自己运行检查，以各步骤记录的检查结果为准");
   }

package/engine/src/records.ts

@@ -6,6 +6,8 @@
 //                         on the machine. The overview itself is still read live (ADR 0010).
 //   usage/runs.jsonl      one line per pipeline run (a process from start to stop): steps,
 //                         time, usage, gate and review rounds. What `req stats` reports on.
+//                         1.14: also one line per event after the run: a person's code review,
+//                         the acceptance, the merge into the main line, a problem found after it.
 //
 // Recording never affects a run: every write is best effort. REQ_KIT_NO_RECORD=1 turns both
 // off (evaluation runs are not real requirements).
@@ -321,3 +323,72 @@ export function readRuns(file: string): RunRecord[] {
   }
   return out;
 }
+
+// ---------------------------------------------------------------------------
+// Events after the run (1.14)
+
+export type EventKind = "review" | "acceptance" | "merge" | "issue";
+
+/** Something that happened to a requirement outside its runs (contracts/usage-record.md). */
+export interface EventRecord {
+  schema: 1;
+  kind: EventKind;
+  machine: string;
+  kitVersion: string;
+  at: string;
+  requirement: { key: string; project: string; name: string; title: string };
+  /** A person's code review in the plugin. */
+  review?: { verdict: "approved" | "changes_requested"; reviewer: string; items: number; head: string | null };
+  /** The requester's acceptance on the checklist page. */
+  acceptance?: { verdict: "通过" | "不通过"; reviewer: string; total: number; passed: number; failed: number; unchecked: number };
+  /** The requirement's change reached the main line. how: found its files there ("files"), or a person said so ("manual"). */
+  merge?: { into: string; commit: string | null; mergedAt: string | null; how: "files" | "manual" };
+  /** A problem found after the merge: from a defect requirement that names this one, or a person's note. */
+  issue?: { text: string; by: string | null; id: string };
+}
+
+/** The requirement as events name it: the index entry when there is one (same key as its runs). */
+export function requirementRef(repo: string, featureDir: string, env: NodeJS.ProcessEnv = process.env): EventRecord["requirement"] {
+  const fd = featureDir.split(path.sep).join("/");
+  const r = real(repo);
+  const entry = readIndex(env).find((e) => e.featureDir === fd && (real(e.repo) === r || (e.sourceRepo && real(e.sourceRepo) === r)));
+  const source = entry?.sourceRepo ?? entry?.repo ?? repo;
+  let title = path.basename(fd);
+  try {
+    const m = /^#\s+(.+)$/m.exec(fs.readFileSync(path.join(entry?.repo ?? repo, fd, "spec.md"), "utf8"));
+    if (m) title = m[1].trim();
+  } catch {
+    /* no spec: the directory name */
+  }
+  return { key: entry?.key ?? requirementKey(source, fd), project: entry?.project ?? path.basename(real(source)), name: path.basename(fd), title };
+}
+
+/** Appends an event to the usage records. Never throws. */
+export function appendEvent(input: Omit<EventRecord, "schema" | "machine" | "kitVersion" | "at"> & { at?: string }, env: NodeJS.ProcessEnv = process.env): void {
+  if (recordingOff(env)) return;
+  const record: EventRecord = { schema: 1, machine: os.hostname(), kitVersion: kitVersion(), at: input.at ?? new Date().toISOString(), ...input } as EventRecord;
+  try {
+    fs.mkdirSync(usageDir(env), { recursive: true });
+    fs.appendFileSync(runsFile(env), `${JSON.stringify(record)}\n`);
+  } catch {
+    // Usage records are a convenience.
+  }
+}
+
+const EVENT_KINDS = new Set<string>(["review", "acceptance", "merge", "issue"]);
+
+/** Event records from a JSONL file (this machine's, or an export). */
+export function readEvents(file: string): EventRecord[] {
+  if (!fs.existsSync(file)) return [];
+  const out: EventRecord[] = [];
+  for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const r = JSON.parse(line) as EventRecord;
+      if (r && EVENT_KINDS.has(r.kind) && r.schema === RECORD_SCHEMA && r.requirement && typeof r.at === "string") out.push(r);
+    } catch {
+      // A torn line.
+    }
+  }
+  return out;
+}

package/engine/src/reply.ts

@@ -6,12 +6,15 @@ import { DEFAULT_CONFIG, loadConfig, type PipelineConfig } from "./config.js";
 import { defaultConfigPath } from "./locations.js";
 import { pluginReplyMessage } from "./messages.js";
 import { loadRuntimeFactory } from "./runtime-loader.js";
+import { readIndex } from "./records.js";
 import { readState, statePath } from "./state.js";
 
 async function main(argvIn: string[]): Promise<number> {
   // 1.14 --acceptance: the checklist page found problems; the text is the whole notice.
+  // 1.14 --notice: a notice of the background check (no run needed: the chat it was aligned in).
   const acceptance = argvIn.includes("--acceptance");
-  const argv = argvIn.filter((a) => a !== "--acceptance");
+  const notice = argvIn.includes("--notice");
+  const argv = argvIn.filter((a) => a !== "--acceptance" && a !== "--notice");
   const [feature, ...words] = argv;
   const text = words.join(" ").trim();
   if (!feature || !text) {
@@ -20,6 +23,14 @@ async function main(argvIn: string[]): Promise<number> {
   }
   const { repo, featureDir } = locate(process.cwd(), feature);
   const state = readState(statePath(repo, featureDir));
+  if (notice) {
+    const chat = state?.originAgentId ?? readIndex().find((e) => e.featureDir === featureDir && [e.repo, e.sourceRepo].includes(repo))?.chatAgentId ?? null;
+    if (!chat) {
+      console.error("这个需求没有登记过对话，没有可以转达的对话。");
+      return 1;
+    }
+    return deliver(repo, chat, text.slice(0, 8000), "已转给这个需求的对话。");
+  }
   if (!state || (!acceptance && state.status !== "waiting_for_business" && state.status !== "waiting_for_approval")) {
     console.error(`${featureDir} 现在没有在等待回答或确认，不用回复。`);
     return 1;
@@ -28,6 +39,22 @@ async function main(argvIn: string[]): Promise<number> {
     console.error("这个需求不是从 Paseo 对话中开始的，没有可以转达的对话。请在终端或卡片中处理。");
     return 1;
   }
+  return deliver(
+    repo,
+    state.originAgentId,
+    acceptance
+      ? text.slice(0, 8000)
+      : pluginReplyMessage({
+          featureDir,
+          waitingFor: state.status === "waiting_for_approval" ? "approval" : "business",
+          text: text.slice(0, 8000),
+          questions: state.pendingQuestions ?? [],
+        }),
+    acceptance ? "已转给这个需求的对话。" : "已转给这个需求的对话，它会按回复更新需求说明并继续开发。",
+  );
+}
+
+async function deliver(repo: string, chat: string, message: string, done: string): Promise<number> {
   let config: PipelineConfig;
   try {
     config = loadConfig(defaultConfigPath(), repo).config;
@@ -37,19 +64,11 @@ async function main(argvIn: string[]): Promise<number> {
   }
   const runtime = await (await loadRuntimeFactory())({ config, log: () => undefined });
   try {
-    await runtime.notifyAgent(
-      state.originAgentId,
-      acceptance ? text.slice(0, 8000) : pluginReplyMessage({
-        featureDir,
-        waitingFor: state.status === "waiting_for_approval" ? "approval" : "business",
-        text: text.slice(0, 8000),
-        questions: state.pendingQuestions ?? [],
-      }),
-    );
+    await runtime.notifyAgent(chat, message);
   } finally {
     await runtime.close().catch(() => undefined);
   }
-  console.log(acceptance ? "已转给这个需求的对话。" : "已转给这个需求的对话，它会按回复更新需求说明并继续开发。");
+  console.log(done);
   return 0;
 }
 

package/engine/src/review.ts

@@ -17,7 +17,7 @@ import path from "node:path";
 import { ENGINE_DIR, KIT_ROOT, kitHome, kitVersion } from "./locations.js";
 import { buildCodeReview, recordHumanReview, startReviewFix, type Submission } from "./code-review.js";
 import { type Answer, acceptanceFailMessage, acceptanceText, buildChecklist, recordAcceptance, verdictOf } from "./checklist.js";
-import { readIndex } from "./records.js";
+import { appendEvent, readIndex, requirementRef } from "./records.js";
 import { readState, statePath } from "./state.js";
 
 const ASSETS = path.join(ENGINE_DIR, "src", "review-assets");
@@ -546,6 +546,20 @@ export function createReviewServer(opts: ReviewServerOptions): http.Server {
       const text = acceptanceText(list, answers, { verdict: v.verdict, reviewer: reviewer.slice(0, 60), date: new Date().toISOString().slice(0, 10), previous });
       const { committed } = recordAcceptance(entry.repo, entry.featureDir, text);
       fs.rmSync(path.join(checkDir, "draft.json"), { force: true });
+      // 1.14: the acceptance also goes into the usage records, for req stats.
+      const marks = new Map(answers.map((a) => [a.id, a.mark]));
+      appendEvent({
+        kind: "acceptance",
+        requirement: requirementRef(entry.repo, entry.featureDir),
+        acceptance: {
+          verdict: v.verdict,
+          reviewer: reviewer.slice(0, 60),
+          total: list.items.length,
+          passed: list.items.filter((i) => marks.get(i.id) === "pass").length,
+          failed: list.items.filter((i) => marks.get(i.id) === "fail").length,
+          unchecked: list.items.filter((i) => !marks.get(i.id) || marks.get(i.id) === "skip").length,
+        },
+      });
       if (v.verdict === "通过") {
         return json(res, 200, { ok: true, verdict: v.verdict, committed, message: `已记录：验收通过${committed ? "，验收记录已提交" : ""}。下一步请开发同事审阅代码并合并。` });
       }

package/engine/src/runtime.ts

@@ -145,6 +145,8 @@ export interface AgentRuntime {
   recentActivity(agentId: string, limit: number): Promise<ActivityItem[] | null>;
   /** 1.13: the tool call the agent is running now (the latest one still running), or null. */
   runningTool(agentId: string): Promise<import("./scan-guard.js").RunningTool | null>;
+  /** 1.14: the agent's latest tool calls, running or done (for the danger guard); null when they cannot be read. */
+  toolCalls?(agentId: string): Promise<import("./danger-guard.js").ToolCall[] | null>;
   /** Which Paseo tools step agents get (Settings → Agents); null when unknown. */
   capabilities(): Promise<{ paseoTools: boolean; browser: boolean } | null>;
   /** 1.12: whether each agent provider is installed and logged in ("ready"); null when the daemon does not say. */