paseo-req-kit 1.13.0-beta.2 → 1.13.0-beta.4

package/engine/src/pipeline.ts

@@ -170,6 +170,45 @@ export function isTransientError(message: string): boolean {
   return TRANSIENT_ERROR.test(message);
 }
 
+/** 1.13: the requirement used its token budget (config budget); stops before the next step. */
+class BudgetReached extends Error {
+  constructor(
+    public readonly used: number,
+    public readonly allowance: number,
+  ) {
+    super(`token 用量 ${tokenText(used)} 已到预算 ${tokenText(allowance)}`);
+    this.name = "BudgetReached";
+  }
+}
+
+function tokenText(n: number): string {
+  return n >= 10_000 ? `${Math.round(n / 1000) / 10} 万` : String(n);
+}
+
+/** Tokens (input + output) of every step of the requirement so far, all attempts. */
+export function tokensUsed(state: Pick<PipelineState, "history">): number {
+  return state.history.reduce((sum, h) => sum + (h.usage?.inputTokens ?? 0) + (h.usage?.outputTokens ?? 0), 0);
+}
+
+/**
+ * Before a new step agent starts: warns once per budget level at warnPercent, and stops at the
+ * allowance (the step that crossed it is finished, the next one waits for a person).
+ */
+async function checkBudget(ctx: PipelineContext, stepTitle: string): Promise<void> {
+  const limit = ctx.config.budget.tokens;
+  if (limit === null) return;
+  const budget = (ctx.state.budget ??= { allowance: limit, warnedAt: null });
+  const used = tokensUsed(ctx.state);
+  if (used >= budget.allowance) throw new BudgetReached(used, budget.allowance);
+  if (used >= (budget.allowance * ctx.config.budget.warnPercent) / 100 && budget.warnedAt !== budget.allowance) {
+    budget.warnedAt = budget.allowance;
+    save(ctx);
+    const text = `【需求开发流水线通知】${shownFeatureDir(ctx)} 已用 ${tokenText(used)} tokens，到了预算 ${tokenText(budget.allowance)} 的 ${Math.round((used / budget.allowance) * 100)}%。流水线继续（下一步：${stepTitle}）；用完预算时会做完当前步骤后停下等你决定。这条消息只是告知，不需要处理。`;
+    await notifyOrigin(ctx, text);
+    await notifyExternal(ctx, "milestone", `需求 ${featureName(ctx.featureDir)} 的 token 用量已到预算的 ${ctx.config.budget.warnPercent}%`, { used, budget: budget.allowance });
+  }
+}
+
 class BusinessDecisionNeeded extends Error {
   constructor(
     public readonly questions: string[],
@@ -616,6 +655,12 @@ async function waitForTurn(ctx: PipelineContext, agent: StepAgent, def: StepDef,
       await ctx.sleep(Math.min(60_000, 5_000 * consecutiveErrors));
       continue;
     }
+    // 1.13: whether the step waits for a permission, for the plugin's "等你处理".
+    const waitingNow = outcome.status === "permission";
+    if (!waitingNow && ctx.state.waitingPermission) {
+      ctx.state.waitingPermission = null;
+      save(ctx);
+    }
     switch (outcome.status) {
       case "idle":
         return outcome.usage ?? null;
@@ -624,6 +669,12 @@ async function waitForTurn(ctx: PipelineContext, agent: StepAgent, def: StepDef,
       case "error":
         throw new AgentErrored(def.title, `agent 报告错误：${outcome.error ?? "未知错误"}`);
       case "permission": {
+        const requests = outcome.pendingPermissions.map((p) => p.title);
+        const w = ctx.state.waitingPermission;
+        if (!w || w.agentId !== agent.id || w.requests.join("\n") !== requests.join("\n")) {
+          ctx.state.waitingPermission = { agentId: agent.id, stepTitle: def.title, requests, since: w?.agentId === agent.id ? w.since : new Date().toISOString() };
+          save(ctx);
+        }
         const fresh = outcome.pendingPermissions.filter((p) => !notifiedPermissions.has(p.id));
         if (fresh.length > 0) {
           for (const p of fresh) notifiedPermissions.add(p.id);
@@ -768,6 +819,7 @@ async function runStepOnce(
   const agentTitle =
     `[${featureName(ctx.featureDir)}] ` +
     (extras.title ?? `${def.number}-${def.title}${round !== null && round > 1 ? ` 第${round}轮` : ""}${target ? `（${target.name}）` : ""}`);
+  if (!leftover.agent) await checkBudget(ctx, def.title);
   const record: StepRecord = {
     key,
     stepId: id,
@@ -788,6 +840,8 @@ async function runStepOnce(
   }
   ctx.log(leftover.agent ? `继续等待 ${key}（${def.title}）上一次的 agent ${leftover.agent.id}` : `开始 ${key}（${def.title}）`);
 
+  const stepProfile = extras.profile ?? phaseAgent(ctx, id) ?? ctx.config.agents[def.role];
+  if (!leftover.agent) record.agent = agentName(stepProfile);
   try {
     const agent = leftover.agent ?? await ctx.runtime.startAgent({
       role: def.role,
@@ -801,7 +855,7 @@ async function runStepOnce(
       },
       parentAgentId: ctx.config.attachToOriginChat ? ctx.state.originAgentId : null,
       // Always passed: the run's config has Paseo profile names resolved; the runtime's may not.
-      profile: extras.profile ?? phaseAgent(ctx, id) ?? ctx.config.agents[def.role],
+      profile: stepProfile,
       workspaceId: target ? target.workspaceId : (ctx.state.worktree?.workspaceId ?? null),
     });
     record.agentId = agent.id;
@@ -961,6 +1015,12 @@ function mergeExtras(
   return { contextLines: [...(a?.contextLines ?? []), ...(b?.contextLines ?? [])], sections: [...(a?.sections ?? []), ...(b?.sections ?? [])] };
 }
 
+/** How a step's agent is named in records and statistics (1.13). */
+export function agentName(profile: AgentProfile | null | undefined): string | undefined {
+  if (!profile) return undefined;
+  return profile.paseoProfile?.trim() || profile.provider?.trim() || undefined;
+}
+
 /** Steps that check the result the way a user would. */
 const BROWSER_STEPS: readonly StepId[] = ["verify", "defect_fix", "reverify"];
 
@@ -2215,6 +2275,34 @@ export async function runPipeline(ctx: PipelineContext): Promise<PipelineOutcome
       });
       return "waiting_for_business";
     }
+    if (error instanceof BudgetReached) {
+      // Continuing (req resume, or "继续开发") gives one more budget.
+      const limit = ctx.config.budget.tokens ?? error.allowance;
+      ctx.state.status = "failed";
+      ctx.state.stopKind = "budget";
+      ctx.state.stopReason = `${error.message}，已停下等你决定是否继续`;
+      ctx.state.budget = { allowance: error.allowance + limit, warnedAt: ctx.state.budget?.warnedAt ?? null };
+      save(ctx);
+      await notifyOrigin(
+        ctx,
+        [
+          "【需求开发流水线通知 · 用完 token 预算】",
+          "",
+          `功能目录：${shownFeatureDir(ctx)}`,
+          `情况：这个需求已用 ${tokenText(error.used)} tokens，到了预算 ${tokenText(error.allowance)}。已完成的步骤都保留，流水线停在下一步开始之前。`,
+          "",
+          "请这样处理：把用量告诉用户（可以运行查看进度的命令看各步骤），问是否继续。",
+          `- 继续：执行下面的命令，会再给一份预算（到 ${tokenText(error.allowance + limit)} 时再停）：\n\n${ctx.resumeCommand}`,
+          "- 不继续：不用执行任何命令；需要时可以缩小需求范围再继续。",
+        ].join("\n"),
+      );
+      await integrate(ctx, "failed");
+      await notifyExternal(ctx, "failed", `需求 ${featureName(ctx.featureDir)} 用完了 token 预算（${tokenText(error.used)}），已暂停等需求方决定`, {
+        reason: error.message,
+        resumeCommand: ctx.resumeCommand,
+      });
+      return "failed";
+    }
     const stepTitle = error instanceof StepFailure ? error.stepTitle : "流水线";
     ctx.state.status = "failed";
     ctx.state.stopReason = `${stepTitle}：${(error as Error).message}`;

package/engine/src/records.ts

@@ -134,6 +134,10 @@ export interface StepUsageRecord {
   inputTokens: number | null;
   outputTokens: number | null;
   costUsd: number | null;
+  /** 1.13: input tokens served from the prompt cache (part of inputTokens), when the agent reports them. */
+  cachedInputTokens?: number | null;
+  /** 1.13: the agent the step ran with (Paseo profile name or "provider/model"). */
+  agent?: string | null;
 }
 
 /** One pipeline run: a process from its start to its end (contracts/usage-record.md). */
@@ -217,6 +221,8 @@ export function runRecord(input: {
         inputTokens: h.usage?.inputTokens ?? null,
         outputTokens: h.usage?.outputTokens ?? null,
         costUsd: h.usage?.totalCostUsd ?? null,
+        cachedInputTokens: h.usage?.cachedInputTokens ?? null,
+        agent: h.agent ?? null,
       }),
     );
   const gateRuns = [...(state.gate?.runs ?? []), ...(state.joint ?? []).flatMap((j) => j.gate?.runs ?? [])].filter(

package/engine/src/review.ts

@@ -237,11 +237,22 @@ function inside(base: string, rel: string): string | null {
   return target === base || target.startsWith(base + path.sep) ? target : null;
 }
 
+// The page may be shown inside Paseo (the req-kit plugin embeds it): Paseo's web UI on this
+// machine, or, with REQ_KIT_REVIEW_HOST set for other computers, any page that has the token.
+function appCsp(): string {
+  const host = process.env.REQ_KIT_REVIEW_HOST?.trim();
+  const local = !host || host === "127.0.0.1" || host === "localhost" || host === "::1";
+  const custom = process.env.REQ_KIT_REVIEW_FRAME_ANCESTORS?.trim();
+  // 'self' always: the page shows the prototype in a frame of its own.
+  const ancestors = custom ? (custom.includes("'self'") || custom === "*" ? custom : `'self' ${custom}`) : local ? "'self' http://127.0.0.1:* http://localhost:* http://[::1]:*" : "*";
+  return `default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; frame-ancestors ${ancestors}`;
+}
+const APP_CSP = appCsp();
 // Prototypes are written by an agent (from text the requester or a card supplied) and are served
 // next to the page's own API, so nothing in them may run: the page reads them from outside.
-const PROTOTYPE_CSP =
-  "default-src 'none'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; media-src 'self' data:; script-src 'none'; form-action 'none'; frame-ancestors 'self'";
-const APP_CSP = "default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; frame-ancestors 'none'";
+// frame-ancestors is checked against every page above, so the prototype allows the same ones as
+// the review page (Paseo around it).
+const PROTOTYPE_CSP = `default-src 'none'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; media-src 'self' data:; script-src 'none'; form-action 'none'; ${APP_CSP.slice(APP_CSP.indexOf("frame-ancestors"))}`;
 
 function send(res: http.ServerResponse, status: number, body: string | Buffer, type = "text/plain; charset=utf-8", csp = APP_CSP) {
   res.writeHead(status, {

package/engine/src/state.ts

@@ -43,6 +43,7 @@ export type StopKind =
   | "transient"
   | "stopped"
   | "process_exit"
+  | "budget"
   | "other";
 
 /** Something the pipeline handled by itself (1.12). */
@@ -78,6 +79,16 @@ export interface StepRecord {
   reattached?: number;
   /** 1.12.1: the step's time limit was already given its one extra period (selfHeal); a later run waiting for the same agent gets none. */
   extendedTimeout?: boolean;
+  /** 1.13: the agent the step ran with: the Paseo profile name, or "provider/model". */
+  agent?: string;
+}
+
+/** 1.13: the requirement's token budget so far (config budget). */
+export interface BudgetState {
+  /** Tokens allowed before stopping: the budget, plus one more each time the person continued after a stop. */
+  allowance: number;
+  /** The allowance a warning was given for, so each level warns once. */
+  warnedAt: number | null;
 }
 
 export interface PipelineState {
@@ -97,6 +108,10 @@ export interface PipelineState {
   results: Record<string, Record<string, unknown>>;
   history: StepRecord[];
   stopReason: string | null;
+  /** 1.13: a step agent is waiting for someone to allow or deny an action; null otherwise. */
+  waitingPermission?: { agentId: string; stepTitle: string; requests: string[]; since: string } | null;
+  /** 1.13: token budget (config budget); absent until the first check. */
+  budget?: BudgetState;
   /** 1.12: why the run stopped for a person, as a code (contracts/usage-record.md); null while running or done. */
   stopKind?: StopKind | null;
   /** 1.12: what the pipeline handled by itself instead of stopping (retries, waiting longer, a fallback model…). */

package/engine/src/stats.ts

@@ -121,6 +121,7 @@ export const STOP_LABELS: Record<string, string> = {
   transient: "限流、网络等临时错误（自动重试用完）",
   stopped: "被手动停止",
   process_exit: "后台进程意外退出",
+  budget: "用完 token 预算",
   other: "其他中断",
 };
 
@@ -236,6 +237,8 @@ export interface StatsSummary {
   /** Average minutes per requirement that waited, by kind, in the period's runs. */
   waits: Array<{ kind: WaitKind; label: string; requirements: number; averageMinutes: number }>;
   usage: { agentMinutes: number; inputTokens: number | null; outputTokens: number | null; costUsd: number | null };
+  /** 1.13: where the tokens (input + output) of the period's runs went. */
+  tokens: TokenBreakdown;
   byBuilder: Array<{ builder: string; requirements: number; averageReviewRounds: number | null; averageCostUsd: number | null }>;
   /** 1.12: why the period's runs stopped for a person, most frequent first. */
   stops: Array<{ kind: string; label: string; necessary: boolean; runs: number }>;
@@ -255,6 +258,66 @@ export interface StatsSummary {
   requirements: RequirementStats[];
 }
 
+export interface TokenBreakdown {
+  /** Input + output of the period's steps that reported usage; null when none did. */
+  total: number | null;
+  /** Share of input tokens served from the prompt cache, when agents report it. */
+  cachedShare: number | null;
+  byStep: Array<{ stepId: string; title: string; steps: number; tokens: number; share: number }>;
+  byAgent: Array<{ agent: string; steps: number; tokens: number; share: number }>;
+  /** Fixing and re-checking: revisions, review fixes, defect fixes, re-verification, and review rounds after the first. */
+  rework: { tokens: number; share: number } | null;
+  /** Tokens per completed requirement (all its runs). */
+  perRequirement: { median: number | null; byProfile: Array<{ profile: string; requirements: number; median: number | null }> };
+}
+
+const REWORK_STEPS = new Set(["design_revise", "review_fix", "defect_fix", "reverify"]);
+
+export function isRework(s: { stepId: string; round: number | null }): boolean {
+  return REWORK_STEPS.has(s.stepId) || ((s.stepId === "design_review" || s.stepId === "code_review") && (s.round ?? 1) > 1);
+}
+
+const stepTokens = (s: { inputTokens: number | null; outputTokens: number | null }) =>
+  s.inputTokens === null && s.outputTokens === null ? null : (s.inputTokens ?? 0) + (s.outputTokens ?? 0);
+
+export function tokenBreakdown(steps: RunRecord["steps"], done: RequirementStats[]): TokenBreakdown {
+  const counted = steps.flatMap((s) => {
+    const t = stepTokens(s);
+    return t === null ? [] : [{ s, t }];
+  });
+  const total = counted.length ? counted.reduce((a, x) => a + x.t, 0) : null;
+  const share = (n: number) => (total ? Math.round((n / total) * 1000) / 1000 : 0);
+  const group = (key: (s: RunRecord["steps"][number]) => string) => {
+    const m = new Map<string, { steps: number; tokens: number }>();
+    for (const { s, t } of counted) {
+      const k = key(s);
+      const g = m.get(k) ?? { steps: 0, tokens: 0 };
+      m.set(k, { steps: g.steps + 1, tokens: g.tokens + t });
+    }
+    return [...m.entries()].sort((a, b) => b[1].tokens - a[1].tokens);
+  };
+  const reworkTokens = counted.filter(({ s }) => isRework(s)).reduce((a, x) => a + x.t, 0);
+  const input = steps.reduce((a, s) => a + (s.inputTokens ?? 0), 0);
+  const cached = steps.reduce<number | null>((a, s) => (typeof s.cachedInputTokens === "number" ? (a ?? 0) + s.cachedInputTokens : a), null);
+  const reqTokens = (q: RequirementStats) => (q.inputTokens === null && q.outputTokens === null ? null : (q.inputTokens ?? 0) + (q.outputTokens ?? 0));
+  const profiles = new Map<string, number[]>();
+  for (const q of done) {
+    const t = reqTokens(q);
+    if (t !== null) profiles.set(q.profile, [...(profiles.get(q.profile) ?? []), t]);
+  }
+  return {
+    total,
+    cachedShare: cached !== null && input > 0 ? Math.round((cached / input) * 1000) / 1000 : null,
+    byStep: group((s) => s.stepId).map(([stepId, g]) => ({ stepId, title: STEPS[stepId as StepId]?.title ?? stepId, steps: g.steps, tokens: g.tokens, share: share(g.tokens) })),
+    byAgent: group((s) => s.agent ?? "（未记录）").map(([agent, g]) => ({ agent, steps: g.steps, tokens: g.tokens, share: share(g.tokens) })),
+    rework: total ? { tokens: reworkTokens, share: share(reworkTokens) } : null,
+    perRequirement: {
+      median: median([...profiles.values()].flat()),
+      byProfile: [...profiles.entries()].map(([profile, ts]) => ({ profile, requirements: ts.length, median: median(ts) })),
+    },
+  };
+}
+
 /** The summary of a period from run records (any machines). */
 export function summarizeRuns(all: RunRecord[], period: Period): StatsSummary {
   const runs = dedupe(all);
@@ -341,6 +404,7 @@ export function summarizeRuns(all: RunRecord[], period: Period): StatsSummary {
       outputTokens: steps.reduce<number | null>((s, x) => add(s, x.outputTokens), null),
       costUsd: steps.reduce<number | null>((s, x) => add(s, x.costUsd), null),
     },
+    tokens: tokenBreakdown(steps, done),
     byBuilder: [...builders.entries()].map(([builder, qs]) => ({
       builder,
       requirements: qs.length,
@@ -411,6 +475,25 @@ export function describeStats(s: StatsSummary): string {
     `- 完成：${s.completed.total} 个（${list(s.completed.byOutcome, OUTCOME_LABELS)}）`,
     s.cycleHours.median !== null ? `- 交付周期（首次开始到完成）：中位数 ${s.cycleHours.median} 小时，平均 ${s.cycleHours.average} 小时` : "- 交付周期：这段时间没有完成的需求",
     `- agent 合计用时：${hours(s.usage.agentMinutes)}；输入 ${tokens(s.usage.inputTokens)} tokens，输出 ${tokens(s.usage.outputTokens)} tokens${s.usage.costUsd !== null ? `，约 $${s.usage.costUsd.toFixed(2)}` : ""}`,
+  );
+  const t = s.tokens;
+  if (t.total) {
+    const pct = (x: number) => `${Math.round(x * 100)}%`;
+    lines.push("", "## token 花在哪", "", `- 合计 ${tokens(t.total)} tokens（输入 + 输出）${t.cachedShare !== null ? `；输入中 ${pct(t.cachedShare)} 来自提示缓存` : ""}`);
+    if (t.rework) lines.push(`- 返工（方案修订、评审问题修复、缺陷修复、复验，以及第 2 轮起的审核和评审）：${tokens(t.rework.tokens)}，占 ${pct(t.rework.share)}`);
+    if (t.perRequirement.median !== null) {
+      lines.push(
+        `- 每个完成的需求：中位数 ${tokens(t.perRequirement.median)}${t.perRequirement.byProfile.length > 1 ? `（${t.perRequirement.byProfile.map((p) => `${p.profile === "quick" ? "快速档" : p.profile === "standard" ? "标准档" : p.profile} ${tokens(p.median)}，${p.requirements} 个`).join("；")}）` : ""}`,
+      );
+    }
+    lines.push("", "| 步骤 | 次数 | tokens | 占比 |", "| --- | --- | --- | --- |");
+    for (const r of t.byStep) lines.push(`| ${r.title} | ${r.steps} | ${tokens(r.tokens)} | ${pct(r.share)} |`);
+    if (t.byAgent.length > 1 || t.byAgent[0]?.agent !== "（未记录）") {
+      lines.push("", "| 模型 | 步骤数 | tokens | 占比 |", "| --- | --- | --- | --- |");
+      for (const r of t.byAgent) lines.push(`| ${r.agent} | ${r.steps} | ${tokens(r.tokens)} | ${pct(r.share)} |`);
+    }
+  }
+  lines.push(
     "",
     "## 返工",
     "",

package/engine/src/watchdog.ts

@@ -0,0 +1,105 @@
+// Continuing pipelines whose background process died (1.13), without asking a model: a plain
+// check of this machine's requirements that runs `req resume` for each one whose state says
+// "running" but whose process is gone. The Paseo plugin runs it every few minutes inside the
+// daemon (`req api watchdog`), and the card factory on each poll. Before 1.13 this was a Paseo
+// schedule that woke the chat agent every hour to look — a model turn each time, and a recovery
+// that depended on the model understanding the prompt.
+import fs from "node:fs";
+import path from "node:path";
+import { kitHome } from "./locations.js";
+import { readIndex } from "./records.js";
+import { isAlive, readState, statePath, writeState } from "./state.js";
+
+/** A run is left alone this long after its last write (it may be starting or finishing). */
+const SETTLE_MS = 2 * 60_000;
+/** At most this many automatic continuations per requirement per day. */
+const MAX_PER_DAY = 3;
+/** The plugin's watchdog counts as running when it checked within this time. */
+export const HEARTBEAT_FRESH_MS = 15 * 60_000;
+
+export const heartbeatFile = (env: NodeJS.ProcessEnv = process.env) => path.join(kitHome(env), "watchdog.json");
+
+interface Memory {
+  /** Last check, ISO time, and who ran it. */
+  at?: string;
+  by?: string;
+  /** Per requirement: the dead process already handled, and when continuations happened. */
+  handled?: Record<string, { pid: number; times: string[] }>;
+}
+
+function readMemory(env: NodeJS.ProcessEnv): Memory {
+  try {
+    return JSON.parse(fs.readFileSync(heartbeatFile(env), "utf8")) as Memory;
+  } catch {
+    return {};
+  }
+}
+
+function writeMemory(env: NodeJS.ProcessEnv, m: Memory): void {
+  try {
+    fs.mkdirSync(path.dirname(heartbeatFile(env)), { recursive: true });
+    const tmp = `${heartbeatFile(env)}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(m, null, 2));
+    fs.renameSync(tmp, heartbeatFile(env));
+  } catch {
+    // Best effort: the next check tries again.
+  }
+}
+
+/** Whether the plugin's watchdog has checked recently (so the pipeline need not ask the chat to). */
+export function watchdogActive(env: NodeJS.ProcessEnv = process.env, now = Date.now()): boolean {
+  const m = readMemory(env);
+  return m.by === "plugin" && !!m.at && now - new Date(m.at).getTime() < HEARTBEAT_FRESH_MS;
+}
+
+export interface WatchdogResult {
+  checked: number;
+  resumed: Array<{ featureDir: string; repo: string; message: string }>;
+  failed: Array<{ featureDir: string; repo: string; message: string }>;
+  skipped: Array<{ featureDir: string; reason: string }>;
+}
+
+export type Resume = (repo: string, featureDir: string) => { ok: boolean; message: string };
+
+export function watchdogPass(input: { env?: NodeJS.ProcessEnv; by: "plugin" | "factory" | "manual"; resume: Resume; now?: Date; dryRun?: boolean }): WatchdogResult {
+  const env = input.env ?? process.env;
+  const now = input.now ?? new Date();
+  const memory = readMemory(env);
+  const handled = memory.handled ?? {};
+  const result: WatchdogResult = { checked: 0, resumed: [], failed: [], skipped: [] };
+  for (const entry of readIndex(env)) {
+    if (!entry.present) continue;
+    const file = statePath(entry.repo, entry.featureDir);
+    const state = readState(file);
+    if (!state) continue;
+    result.checked++;
+    if (state.status !== "running" || isAlive(state.pid)) continue;
+    if (now.getTime() - new Date(state.updatedAt).getTime() < SETTLE_MS) continue;
+    const h = handled[entry.key];
+    if (h?.pid === state.pid) continue;
+    const recent = (h?.times ?? []).filter((t) => now.getTime() - new Date(t).getTime() < 24 * 3600_000);
+    if (recent.length >= MAX_PER_DAY) {
+      result.skipped.push({ featureDir: entry.featureDir, reason: `24 小时内已自动继续 ${recent.length} 次，不再自动继续，请人看一下日志` });
+      handled[entry.key] = { pid: state.pid, times: recent };
+      continue;
+    }
+    if (input.dryRun) {
+      result.resumed.push({ featureDir: entry.featureDir, repo: entry.repo, message: "（试运行，没有继续）" });
+      continue;
+    }
+    // Say why in the state first: the continued run reads it, and statistics count it.
+    state.stopKind = "process_exit";
+    state.stopReason = "后台进程意外退出";
+    state.recoveries = [...(state.recoveries ?? []), { at: now.toISOString(), key: "pipeline", kind: "auto_resume", detail: `后台进程 ${state.pid} 意外退出，${input.by === "plugin" ? "插件" : input.by === "factory" ? "接单器" : "检查"}自动继续` }];
+    try {
+      writeState(file, state);
+    } catch {
+      /* the resume still runs */
+    }
+    const r = input.resume(entry.sourceRepo ?? entry.repo, entry.featureDir);
+    handled[entry.key] = { pid: state.pid, times: [...recent, now.toISOString()] };
+    (r.ok ? result.resumed : result.failed).push({ featureDir: entry.featureDir, repo: entry.repo, message: r.message.split("\n").find((l) => l.trim()) ?? "" });
+  }
+  writeMemory(env, { at: now.toISOString(), by: input.by === "manual" ? (memory.by ?? "manual") : input.by, handled });
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-req-kit",
-  "version": "1.13.0-beta.2",
+  "version": "1.13.0-beta.4",
   "description": "req-kit: a requirement-development workflow for Paseo. /req aligns a requirement in chat; the engine runs design, implementation, review and verification as Paseo agents.",
   "type": "module",
   "license": "MIT",

package/paseo-plugin/client/detail.tsx

@@ -9,7 +9,7 @@ import type { Action, RequirementDetail, Step } from "../shared/contracts";
 import { useAction, useDocument, usePreferences, useRequirement, useRequirements } from "./data";
 import { ACTION_TEXT, actionsFor, ago, ATTENTION_LABELS, facts, FILE_LABELS, minutes, tokens } from "./format";
 import { Markdown, tsvToMarkdown } from "./markdown";
-import { ReviewLink } from "./review-link";
+import { ReviewButton } from "./review";
 import { Badge, Button, Chip, Status, useStyles } from "./ui";
 
 type Theme = PluginHostProps["theme"];
@@ -174,27 +174,35 @@ export function RequirementView({
         <View style={s.row}>
           <Text style={s.title}>{d.title}</Text>
           {d.attention ? (
-            <Badge theme={theme} tone={d.attention === "approval" || d.attention === "business" ? "warning" : "danger"}>
+            <Badge theme={theme} tone={d.attention === "approval" || d.attention === "business" || d.attention === "permission" ? "warning" : "danger"}>
               {ATTENTION_LABELS[d.attention]}
             </Badge>
           ) : null}
         </View>
         <Text style={s.muted}>{facts(d)}</Text>
         <Text style={s.text}>{d.stage}</Text>
+        {d.estimate && d.attention !== "approval" ? (
+          <Text style={s.muted}>
+            {d.estimate.over
+              ? `已超过同档位需求通常的用时（已用 ${minutes(d.estimate.usedAgentMinutes)}，通常 ${minutes(d.estimate.typicalAgentMinutes)}）`
+              : `预计还要约 ${minutes(Math.max(5, d.estimate.leftMinutes))}`}
+            {d.estimate.usedTokens !== null ? ` · 已用 ${tokens(d.estimate.usedTokens)} tokens${d.estimate.typicalTokens !== null ? `（通常 ${tokens(d.estimate.typicalTokens)}）` : ""}` : ""}
+            {` · 按本机最近 ${d.estimate.basis} 个同档位需求，不含等人的时间`}
+          </Text>
+        ) : null}
         {d.run?.stopReason && !d.running ? <Text style={s.danger}>{d.run.stopReason}</Text> : null}
         {d.attention === "business" ? <Text style={s.muted}>需求方的决定请在发起需求的对话中回答，回答后再继续。</Text> : null}
       </View>
 
-      {actions.length > 0 ? (
+      {actions.length > 0 || d.hasPrototype ? (
         <View style={s.row}>
+          {d.hasPrototype ? <ReviewButton theme={theme} repo={d.sourceRepo ?? d.repo} featureDir={d.featureDir} title={d.title} waiting={d.attention === "approval"} /> : null}
           {actions.map((a) => (
-            <Button key={a} theme={theme} primary={a !== "stop"} label={ACTION_TEXT[a].label} onPress={() => setAction(a)} />
+            <Button key={a} theme={theme} primary={a !== "stop" && !(a === "approve" && d.hasPrototype)} label={ACTION_TEXT[a].label} onPress={() => setAction(a)} />
           ))}
         </View>
       ) : null}
 
-      {d.hasPrototype ? <ReviewLink theme={theme} compact={layout.compact} repo={d.sourceRepo ?? d.repo} featureDir={d.featureDir} waiting={d.attention === "approval"} /> : null}
-
       {d.files.length > 0 ? (
         <View style={{ gap: 6 }}>
           <Text style={s.heading}>文档</Text>

package/paseo-plugin/client/format.ts

@@ -4,6 +4,7 @@ import type { Attention, Requirement } from "../shared/contracts";
 export const ATTENTION_LABELS: Record<Exclude<Attention, null>, string> = {
   approval: "等待确认方案",
   business: "等待需求方决定",
+  permission: "等待批准权限",
   interrupted: "已中断，可以继续",
   not_completed: "结束但未完成",
 };

package/paseo-plugin/client/inbox.tsx

@@ -8,7 +8,7 @@ import { Text, View } from "react-native";
 import type { Attention, Requirement } from "../shared/contracts";
 import { useAction, usePreferences } from "./data";
 import { facts } from "./format";
-import { ReviewLink } from "./review-link";
+import { ReviewButton } from "./review";
 import { Badge, Button, useStyles } from "./ui";
 
 type Theme = PluginHostProps["theme"];
@@ -17,6 +17,7 @@ type Layout = PluginHostProps["layout"];
 const KIND: Record<Exclude<Attention, null>, { label: string; tone: "warning" | "danger" | "muted"; todo: string }> = {
   approval: { label: "确认方案", tone: "warning", todo: "方案已通过审核。看一下“做完后会看到什么”，没问题就确认，开始写代码；要改就写下来。" },
   business: { label: "回答问题", tone: "warning", todo: "方案审核有问题只有你能决定，回答后开发会接着进行。" },
+  permission: { label: "批准权限", tone: "warning", todo: "有一个步骤在等你允许它做一项操作，批准前会一直停在这里。打开这个 agent，在它的对话里选择允许或拒绝；拿不准时请开发同事看一下。" },
   interrupted: { label: "已中断", tone: "danger", todo: "开发中断了，自动处理没能解决。看一下原因，能继续就继续。" },
   not_completed: { label: "没有完成", tone: "muted", todo: "流水线结束了，但有部分没有做完。完成报告里写了原因和建议。" },
 };
@@ -37,7 +38,7 @@ export function inboxItems(items: Requirement[]): Requirement[] {
     .sort((a, b) => (a.waiting?.since ?? a.updatedAt).localeCompare(b.waiting?.since ?? b.updatedAt));
 }
 
-function InboxCard({ theme, layout, item, open, readOnly }: { theme: Theme; layout: Layout; item: Requirement; open(): void; readOnly: boolean }) {
+function InboxCard({ theme, layout, item, open, readOnly, openAgent }: { theme: Theme; layout: Layout; item: Requirement; open(): void; readOnly: boolean; openAgent?: (agentId: string) => void }) {
   const s = useStyles(theme, layout.compact);
   const run = useAction();
   const toast = useToast();
@@ -77,8 +78,9 @@ function InboxCard({ theme, layout, item, open, readOnly }: { theme: Theme; layo
       </Text>
       <Text style={s.text}>{kind.todo}</Text>
 
-      {item.attention === "business" && w && w.questions.length > 0 ? (
+      {(item.attention === "business" || item.attention === "permission") && w && w.questions.length > 0 ? (
         <View style={{ gap: 4 }}>
+          {item.attention === "permission" ? <Text style={s.muted}>{w.reason}。要批准的操作：</Text> : null}
           {w.questions.map((q, i) => (
             <Text key={i} style={s.text}>
               {i + 1}. {q}
@@ -99,7 +101,7 @@ function InboxCard({ theme, layout, item, open, readOnly }: { theme: Theme; layo
         </View>
       ) : (
         <>
-          {item.attention === "approval" && item.hasPrototype ? <ReviewLink theme={theme} compact={layout.compact} repo={repo} featureDir={item.featureDir} waiting /> : null}
+          {item.attention === "approval" && item.hasPrototype ? <Text style={s.text}>这个方案有界面原型：在原型上点选要改的地方，比写文字说得清楚。</Text> : null}
           {writing && w?.canReply ? (
             <View style={{ gap: 8 }}>
               <TextInput
@@ -126,7 +128,8 @@ function InboxCard({ theme, layout, item, open, readOnly }: { theme: Theme; layo
           <View style={s.row}>
             {item.attention === "approval" ? (
               <>
-                <Button theme={theme} primary label={run.isPending ? "正在执行…" : "确认方案"} disabled={run.isPending} onPress={() => void act("approve")} />
+                {item.hasPrototype ? <ReviewButton theme={theme} repo={repo} featureDir={item.featureDir} title={item.title} waiting /> : null}
+                <Button theme={theme} primary={!item.hasPrototype} label={run.isPending ? "正在执行…" : "确认方案"} disabled={run.isPending} onPress={() => void act("approve")} />
                 {w?.canReply ? (
                   writing ? (
                     <Button theme={theme} label="发送修改意见" disabled={run.isPending || !text.trim()} onPress={() => void act("reply")} />
@@ -139,6 +142,7 @@ function InboxCard({ theme, layout, item, open, readOnly }: { theme: Theme; layo
             {item.attention === "business" && w?.canReply ? (
               <Button theme={theme} primary label={run.isPending ? "正在发送…" : "发送回答"} disabled={run.isPending || !text.trim()} onPress={() => void act("reply")} />
             ) : null}
+            {item.attention === "permission" && w?.agentId && openAgent ? <Button theme={theme} primary label="打开这个 agent" onPress={() => openAgent(w.agentId!)} /> : null}
             {item.attention === "interrupted" ? (
               <Button theme={theme} primary label={run.isPending ? "正在执行…" : "继续"} disabled={run.isPending} onPress={() => void act("resume")} />
             ) : null}
@@ -150,7 +154,7 @@ function InboxCard({ theme, layout, item, open, readOnly }: { theme: Theme; layo
   );
 }
 
-export function Inbox({ theme, layout, items, open }: { theme: Theme; layout: Layout; items: Requirement[]; open(item: Requirement): void }) {
+export function Inbox({ theme, layout, items, open, openAgent }: { theme: Theme; layout: Layout; items: Requirement[]; open(item: Requirement): void; openAgent?: (agentId: string) => void }) {
   const s = useStyles(theme, layout.compact);
   const { readOnly } = usePreferences();
   const waiting = inboxItems(items);
@@ -168,7 +172,7 @@ export function Inbox({ theme, layout, items, open }: { theme: Theme; layout: La
           <Text style={s.muted}>现在没有需要你处理的事。需要你确认或回答时，会出现在这里。</Text>
         </View>
       ) : (
-        waiting.map((item) => <InboxCard key={item.key} theme={theme} layout={layout} item={item} open={() => open(item)} readOnly={readOnly} />)
+        waiting.map((item) => <InboxCard key={item.key} theme={theme} layout={layout} item={item} open={() => open(item)} readOnly={readOnly} openAgent={openAgent} />)
       )}
     </View>
   );

package/paseo-plugin/client/nav.ts

@@ -0,0 +1,12 @@
+// Opening the plugin's screens from anywhere in it (screens themselves are not handed an opener).
+type Opener = (input: { screenId: string; params?: Record<string, string> }) => void;
+
+let opener: Opener | null = null;
+
+export function setScreenOpener(open: Opener): void {
+  opener = open;
+}
+
+export function openReview(input: { repo: string; featureDir: string; title: string }): void {
+  opener?.({ screenId: "review", params: { repo: input.repo, featureDir: input.featureDir, title: input.title } });
+}

package/paseo-plugin/client/overview.tsx

@@ -85,7 +85,7 @@ export function OverviewScreen(props: PluginScreenProps & { openScreen: ScreenOp
           error={query.error}
           empty={query.data && items.length === 0 ? "这台机器上还没有记录任何需求。在 Paseo 对话中用 /req 开始一个；1.9 之前运行过的需求，在项目目录运行 req index --rebuild。" : null}
         />
-        {query.data && items.length > 0 ? <Inbox theme={theme} layout={layout} items={shown} open={open} /> : null}
+        {query.data && items.length > 0 ? <Inbox theme={theme} layout={layout} items={shown} open={open} openAgent={props.navigation ? (agentId) => props.navigation!.openAgent({ agentId }) : undefined} /> : null}
         <RequirementGroups theme={theme} layout={layout} items={shown} open={open} skip={["attention"]} />
       </ScrollView>
     </View>