superlab 0.1.49 → 0.1.51

package/lib/auto_contracts.cjs

@@ -7,6 +7,7 @@ const {
   isMeaningful,
   normalizeList,
   normalizeScalar,
+  parseDurationMs,
   parseInteger,
   readFileIfExists,
   readWorkflowConfig,
@@ -29,6 +30,11 @@ const CAMPAIGN_KIND_DEFAULT_STAGES = {
   "experiment-loop": ["run", "iterate", "review", "report"],
   "report-polish": ["review", "report", "write"],
 };
+const LONG_POLL_AUTO_STAGES = new Set(["run", "iterate"]);
+const DEFAULT_SHORT_POLL_INTERVAL_MS = 15 * 1000;
+const DEFAULT_LONG_POLL_INTERVAL_MS = 2 * 60 * 1000;
+const DEFAULT_SHORT_PROGRESS_REPORT_INTERVAL_MS = 2 * 60 * 1000;
+const DEFAULT_LONG_PROGRESS_REPORT_INTERVAL_MS = 10 * 60 * 1000;
 const FROZEN_CORE_ALIASES = {
   mission: [path.join(".lab", "context", "mission.md")],
   framing: [
@@ -539,6 +545,22 @@ function resolveStageCommand(mode, stage, commandOverride = "") {
   return isMeaningful(commandOverride) ? commandOverride : mode.stageCommands[stage];
 }
 
+function resolveAutoPollIntervalMs({ configuredPollInterval = "", stage = "" }) {
+  const normalizedStage = normalizeScalar(stage).toLowerCase();
+  const defaultMs = LONG_POLL_AUTO_STAGES.has(normalizedStage)
+    ? DEFAULT_LONG_POLL_INTERVAL_MS
+    : DEFAULT_SHORT_POLL_INTERVAL_MS;
+  return parseDurationMs(configuredPollInterval, defaultMs);
+}
+
+function resolveAutoProgressReportIntervalMs({ configuredProgressReportInterval = "", stage = "" }) {
+  const normalizedStage = normalizeScalar(stage).toLowerCase();
+  const defaultMs = LONG_POLL_AUTO_STAGES.has(normalizedStage)
+    ? DEFAULT_LONG_PROGRESS_REPORT_INTERVAL_MS
+    : DEFAULT_SHORT_PROGRESS_REPORT_INTERVAL_MS;
+  return parseDurationMs(configuredProgressReportInterval, defaultMs);
+}
+
 module.exports = {
   ALLOWED_AUTO_STAGES,
   AUTO_LEVEL_STAGE_ENVELOPES,
@@ -558,6 +580,8 @@ module.exports = {
   inferCampaignKind,
   isLocalProcessAlive,
   normalizeRequestedAutoContract,
+  resolveAutoPollIntervalMs,
+  resolveAutoProgressReportIntervalMs,
   resolveRequestedAutonomyLevel,
   resolveFrozenCoreEntries,
   resolveStageCommand,

package/lib/auto_runner.cjs

@@ -15,6 +15,8 @@ const {
   inferCampaignKind,
   isLocalProcessAlive,
   normalizeRequestedAutoContract,
+  resolveAutoPollIntervalMs,
+  resolveAutoProgressReportIntervalMs,
   resolveRequestedAutonomyLevel,
   resolveStageCommand,
   snapshotFrozenCore,
@@ -141,6 +143,20 @@ function makeCampaignId({ requested, now }) {
   return raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
 
+function formatDurationLabel(ms) {
+  if (ms % (60 * 1000) === 0) {
+    return `${ms / (60 * 1000)}m`;
+  }
+  if (ms % 1000 === 0) {
+    return `${ms / 1000}s`;
+  }
+  return `${ms}ms`;
+}
+
+function buildContinueBoundary({ stage, pollIntervalMs, progressReportIntervalMs }) {
+  return `Keep polling while the active owner is alive. Emit a user-facing progress update only on a meaningful change (stage or rung transition, new checkpoint or artifact, owner exit, stop or escalation match, or anomaly) or once every ${formatDurationLabel(progressReportIntervalMs)} as a keepalive; do not ask the user to trigger the next poll. Internal poll cadence for ${stage || "auto"} is ${formatDurationLabel(pollIntervalMs)} unless the contract overrides it.`;
+}
+
 function archiveAutoArtifact(targetDir, relativePath, campaignId, now) {
   const absolutePath = path.join(targetDir, relativePath);
   if (!fs.existsSync(absolutePath)) {
@@ -184,6 +200,7 @@ function buildRolledOverAutoMode(mode, requested, now) {
     maxWallClockTime: mode.maxWallClockTime,
     maxFailures: mode.maxFailures,
     pollInterval: mode.pollInterval,
+    progressReportInterval: mode.progressReportInterval,
     stageCommands: {
       run: "",
       iterate: "",
@@ -554,7 +571,6 @@ async function startAutoMode({ targetDir, now = new Date(), requestedContract =
   writeAutoStatus(targetDir, status, { lang });
 
   const startedAt = status.startedAt;
-  const pollIntervalMs = parseDurationMs(mode.pollInterval, 1000);
   const maxWallClockMs = parseDurationMs(mode.maxWallClockTime, 60 * 60 * 1000);
   const deadlineMs = Date.now() + maxWallClockMs;
   const maxFailures = parseInteger(mode.maxFailures, 0);
@@ -572,6 +588,14 @@ async function startAutoMode({ targetDir, now = new Date(), requestedContract =
   let stopReason = "";
   let finalRung = "";
   const campaignId = resumePlan?.campaignId || `auto-${startedAt.replace(/[:.]/g, "-")}`;
+  const initialPollIntervalMs = resolveAutoPollIntervalMs({
+    configuredPollInterval: mode.pollInterval,
+    stage: status.currentStage,
+  });
+  const initialProgressReportIntervalMs = resolveAutoProgressReportIntervalMs({
+    configuredProgressReportInterval: mode.progressReportInterval,
+    stage: status.currentStage,
+  });
   let currentLedger = {
     campaignId,
     objective: mode.objective,
@@ -587,7 +611,11 @@ async function startAutoMode({ targetDir, now = new Date(), requestedContract =
     lastCheckpoint: resumePlan?.lastCheckpoint || "",
     checkpointSummary: resumePlan?.reason || "auto loop armed and waiting for the first owned command",
     nextTransition: resumePlan?.rungId || "",
-    continueBoundary: "Continue while the active owner is still running and no stop condition has matched.",
+    continueBoundary: buildContinueBoundary({
+      stage: status.currentStage,
+      pollIntervalMs: initialPollIntervalMs,
+      progressReportIntervalMs: initialProgressReportIntervalMs,
+    }),
     stopBoundary: mode.stopConditions,
     escalationBoundary: mode.escalationConditions,
     requiredReadSet: ".lab/context/eval-protocol.md, .lab/context/auto-mode.md, .lab/context/auto-status.md, .lab/context/auto-ledger.md, .lab/context/auto-outcome.md",
@@ -707,6 +735,14 @@ async function startAutoMode({ targetDir, now = new Date(), requestedContract =
     while (!stageCompleted) {
       try {
         const contract = stageContractSnapshot(targetDir, stage);
+        const pollIntervalMs = resolveAutoPollIntervalMs({
+          configuredPollInterval: mode.pollInterval,
+          stage,
+        });
+        const progressReportIntervalMs = resolveAutoProgressReportIntervalMs({
+          configuredProgressReportInterval: mode.progressReportInterval,
+          stage,
+        });
         await runCommandWithPolling({
           targetDir,
           stage,
@@ -720,7 +756,15 @@ async function startAutoMode({ targetDir, now = new Date(), requestedContract =
           watchTarget,
           nextRung,
           ownerInfo: { ownerType: "local-process" },
-          updateLedger: writeLedger,
+          updateLedger: (overrides = {}) =>
+            writeLedger({
+              continueBoundary: buildContinueBoundary({
+                stage,
+                pollIntervalMs,
+                progressReportIntervalMs,
+              }),
+              ...overrides,
+            }),
         });
         verifyStageContract({ stage, snapshot: contract.snapshot });
         executedStages.push(stage);
@@ -816,7 +860,10 @@ async function startAutoMode({ targetDir, now = new Date(), requestedContract =
       targetDir,
       stage: "promotion",
       command: mode.promotionCommand,
-      pollIntervalMs,
+      pollIntervalMs: resolveAutoPollIntervalMs({
+        configuredPollInterval: mode.pollInterval,
+        stage: "promotion",
+      }),
       deadlineMs,
       startedAt,
       status: currentStatus,

package/lib/auto_state.cjs

@@ -36,6 +36,7 @@ function parseAutoMode(targetDir) {
     maxWallClockTime: extractValue(text, ["Max wall-clock time", "最大运行时长"]),
     maxFailures: extractValue(text, ["Max failures", "最大失败次数"]),
     pollInterval: extractValue(text, ["Poll interval", "轮询间隔"]),
+    progressReportInterval: extractValue(text, ["Progress report interval", "进度汇报间隔"]),
     stageCommands: {
       run: extractValue(text, ["Run command", "运行命令"]),
       iterate: extractValue(text, ["Iterate command", "迭代命令"]),

package/lib/i18n.cjs

@@ -207,7 +207,7 @@ const ZH_SKILL_FILES = {
 - 本轮假设
 - 具体代码或配置改动
 - 标准化评估摘要
-- 书面 iteration report
+- 写入 \`.lab/iterations/\` 的书面 iteration report
 - 写入 \`results_root\` 的持久 run 输出
 - continue 或 stop 决策
 - 风险连续两轮升高时触发 diagnostic mode
@@ -235,6 +235,7 @@ const ZH_SKILL_FILES = {
 - 不要修改指标定义、baseline 语义或对比方法实现，除非评估协议已经记录了来源和与原始实现的偏差。
 - 如果要调整 ladder、样本量或升格 gate，必须继续锚定到带来源的评估协议，而不是靠聊天临时判断。
 - durable findings 和证据边界变化应写回 canonical context，再刷新派生的 \`state.md\` 快照；当前执行进度只写 \`workflow-state.md\`。
+- \`.lab/iterations/*.md\` 属于对外可读的 workflow artifact。如果 workflow language 是中文，iteration report、本轮摘要、阻塞点和 continue-or-stop 决策都应使用中文，除非文件路径、代码标识符或字面指标名必须保持原样。
 
 ## 交互约束
 
@@ -887,13 +888,13 @@ const ZH_SKILL_FILES = {
 - [ ] 产出 final report。
 `,
   [path.join(".lab", ".managed", "templates", "iteration-report.md")]:
-`# Iteration Report
+`# 迭代报告
 
 ## 轮次
 
-- Iteration number:
-- Run id:
-- Completion Promise:
+- 迭代编号:
+- 运行 id:
+- 完成承诺:
 
 ## 假设
 
@@ -905,27 +906,27 @@ const ZH_SKILL_FILES = {
 
 ## 评估摘要
 
-- Dataset:
-- Split:
-- Baseline:
-- Variant:
-- Primary metric:
-- Secondary metrics:
-- Failure count:
+- 数据集:
+- 划分:
+- 基线:
+- 变体:
+- 主指标:
+- 次级指标:
+- 失败次数:
 
 ## 专家批评
 
-- Main concerns:
-- Methodology concerns:
-- Interpretation concerns:
+- 主要关注点:
+- 方法论关注点:
+- 解释风险:
 - 是否进入 diagnostic mode:
 
 ## 决策
 
-- Continue or stop:
-- Next action:
-- Top blockers:
-- Next best actions:
+- 继续还是停止:
+- 下一步动作:
+- 主要阻塞点:
+- 次优后续动作:
 `,
   [path.join(".lab", ".managed", "templates", "review-checklist.md")]:
 `# Review Checklist
@@ -1597,6 +1598,9 @@ const ZH_SKILL_FILES = {
 - Max wall-clock time:
 - Max failures:
 - Poll interval:
+- 如果 \`Poll interval\` 留空，使用保守默认值：\`run\`/\`iterate\` 每 \`2m\` 轮询一次，其他 auto 轮询默认 \`15s\`。
+- Progress report interval:
+- 如果 \`Progress report interval\` 留空，只在出现有意义变化时对用户汇报；如果一直没有新变化，则 \`run\`/\`iterate\` 最多每 \`10m\` 发一次保活更新，其他 auto 轮询最多每 \`2m\` 发一次保活更新。
 
 ## 阶段命令
 
@@ -2180,7 +2184,7 @@ ZH_CONTENT[path.join(".codex", "prompts", "lab-data.md")] = codexPrompt(
 ZH_CONTENT[path.join(".codex", "prompts", "lab-auto.md")] = codexPrompt(
   "在已批准边界内编排自动实验循环",
   "auto mode objective",
-  "使用已安装的 `lab` 技能：`.codex/skills/lab/SKILL.md`。\n\n继续当前活动：`/lab-auto: 继续`。\n以最高执行级别继续当前活动：`/lab-auto: L3，继续`。\n\n立刻针对用户当前给出的参数执行 `/lab:auto`，不要只推荐别的 `/lab` 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\n\n先把用户请求规范化成可交给 CLI 的 auto contract 字段：objective、autonomy level、campaign kind、allowed stages，以及任何不改变范围就能明确的 terminal-goal 提示。\n如果用户没写级别，默认按 `L2` 处理；接受 `L1/L2/L3`、`l1/l2/l3` 这类短写，`最高级别`、`最高自治` 也按 `L3` 处理。\n如果用户只写了 `继续`，且当前已有 active 或可恢复 campaign，就直接继承当前 campaign 的级别，而不是要求用户重复写。\n如果你想沿用 runtime 里已存的 campaign 级别继续，就直接写 `/lab-auto: 继续`。\n只有当级别本身真的有歧义时，才停下来追问，例如 `第三层`、`phase 3`、`table 3`。\n已批准的 `L2` 和 `L3` 执行 campaign 默认进入执行模式。\n在执行模式里，不要进入 brainstorming，不要进入 spec review，也不要为了常规实现路径选择、helper script、路径修正、数据集适配、同 family 候选切换或普通自检而生成 reviewer、explorer 或其他子智能体循环。\n只有当用户明确要求设计或审阅帮助、contract fit 需要新 campaign，或 contract 的 escalation condition 明确要求独立复核时，才从执行模式切到设计或 reviewer 模式。\n你的第一步执行动作必须是对当前项目运行 `superlab auto start`，而不是自己直接改写 `.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 或 `.lab/context/auto-outcome.md`。\n把规范化后的字段通过 CLI 参数传下去，包括 `--objective`、`--campaign-kind`、`--allowed-stages`，以及在用户已明确或已隐含时传 `--autonomy-level`。\nCLI 返回后的 runtime 结果才是事实来源。如果 CLI 报 rollover、conflict、缺字段，或已经成功启动 campaign，就如实回报，不要绕过 CLI 自己做 prompt 侧写回。\n\n本命令运行 `/lab:auto` 阶段。它必须读取 `.lab/context/eval-protocol.md`、`.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 与 `.lab/context/auto-outcome.md`，先确认 autonomy level、approval status、terminal goal schema，以及 primary gate、secondary guard、promotion condition、stop reason、escalation reason，再把 eval-protocol 里的指标释义、主表计划、来源约束与结构化实验阶梯当作执行依据，在不修改 mission、framing 和核心 claims 的前提下编排已批准的 `run`、`iterate`、`review`、`report`，轮询长任务完成情况；如果声明了 rung，就保持会话活着并按 rung 转移继续推进。\n首个可见输出块必须是 `Auto preflight`。这个块必须列出已读取文件，并回显 `Autonomy level`、`Approval status`、`Allowed stages`、`Terminal goal`、`Primary gate` 和 `Secondary guard`，然后才能进入执行摘要或动作计划。\n如果 preflight 所需字段缺失、过期或彼此冲突，就必须在执行前停下，并明确指出到底是哪一个字段阻止了 loop 启动。\n当 loop 活着时，必须把当前 owner、观察状态、checkpoint 摘要、继续边界、停止边界和恢复读取集合写进 `.lab/context/auto-ledger.md`。\n如果仓库的 workflow language 是中文，摘要、清单条目、任务标签和进度更新都必须使用中文，除非某个文件路径、代码标识符或字面指标名必须保持原样。\n把 `Layer 3`、`Phase 1`、`Table 2` 这类表达视为论文范围目标；只有显式写成 `Autonomy level L3` 或 `自治级别 L3` 时，才把它当成执行权限级别。\n不要用 `sleep 30`、单次 `pgrep` 或一次性的 `metrics.json` 探针来代替真实长任务命令；当真实实验进程还活着时，只允许发进度更新并继续等待。"
+  "使用已安装的 `lab` 技能：`.codex/skills/lab/SKILL.md`。\n\n继续当前活动：`/lab-auto: 继续`。\n以最高执行级别继续当前活动：`/lab-auto: L3，继续`。\n\n立刻针对用户当前给出的参数执行 `/lab:auto`，不要只推荐别的 `/lab` 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\n\n先把用户请求规范化成可交给 CLI 的 auto contract 字段：objective、autonomy level、campaign kind、allowed stages，以及任何不改变范围就能明确的 terminal-goal 提示。\n如果用户没写级别，默认按 `L2` 处理；接受 `L1/L2/L3`、`l1/l2/l3` 这类短写，`最高级别`、`最高自治` 也按 `L3` 处理。\n如果用户只写了 `继续`，且当前已有 active 或可恢复 campaign，就直接继承当前 campaign 的级别，而不是要求用户重复写。\n如果你想沿用 runtime 里已存的 campaign 级别继续，就直接写 `/lab-auto: 继续`。\n只有当级别本身真的有歧义时，才停下来追问，例如 `第三层`、`phase 3`、`table 3`。\n已批准的 `L2` 和 `L3` 执行 campaign 默认进入执行模式。\n在执行模式里，不要进入 brainstorming，不要进入 spec review，也不要为了常规实现路径选择、helper script、路径修正、数据集适配、同 family 候选切换或普通自检而生成 reviewer、explorer 或其他子智能体循环。\n只有当用户明确要求设计或审阅帮助、contract fit 需要新 campaign，或 contract 的 escalation condition 明确要求独立复核时，才从执行模式切到设计或 reviewer 模式。\n你的第一步执行动作必须是对当前项目运行 `superlab auto start`，而不是自己直接改写 `.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 或 `.lab/context/auto-outcome.md`。\n把规范化后的字段通过 CLI 参数传下去，包括 `--objective`、`--campaign-kind`、`--allowed-stages`，以及在用户已明确或已隐含时传 `--autonomy-level`。\nCLI 返回后的 runtime 结果才是事实来源。如果 CLI 报 rollover、conflict、缺字段，或已经成功启动 campaign，就如实回报，不要绕过 CLI 自己做 prompt 侧写回。\n\n本命令运行 `/lab:auto` 阶段。它必须读取 `.lab/context/eval-protocol.md`、`.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 与 `.lab/context/auto-outcome.md`，先确认 autonomy level、approval status、terminal goal schema，以及 primary gate、secondary guard、promotion condition、stop reason、escalation reason，再把 eval-protocol 里的指标释义、主表计划、来源约束与结构化实验阶梯当作执行依据，在不修改 mission、framing 和核心 claims 的前提下编排已批准的 `run`、`iterate`、`review`、`report`，轮询长任务完成情况；如果声明了 rung，就保持会话活着并按 rung 转移继续推进。\n首个可见输出块必须是 `Auto preflight`。这个块必须列出已读取文件，并回显 `Autonomy level`、`Approval status`、`Allowed stages`、`Terminal goal`、`Primary gate` 和 `Secondary guard`，然后才能进入执行摘要或动作计划。\n如果 preflight 所需字段缺失、过期或彼此冲突，就必须在执行前停下，并明确指出到底是哪一个字段阻止了 loop 启动。\n当 loop 活着时，必须把当前 owner、观察状态、checkpoint 摘要、继续边界、停止边界和恢复读取集合写进 `.lab/context/auto-ledger.md`。\n如果仓库的 workflow language 是中文，摘要、清单条目、任务标签和进度更新都必须使用中文，除非某个文件路径、代码标识符或字面指标名必须保持原样。\n把 `Layer 3`、`Phase 1`、`Table 2` 这类表达视为论文范围目标；只有显式写成 `Autonomy level L3` 或 `自治级别 L3` 时，才把它当成执行权限级别。\n不要用 `sleep 30`、单次 `pgrep` 或一次性的 `metrics.json` 探针来代替真实长任务命令；当真实实验进程还活着时，只允许在出现有意义变化时发进度更新，并继续等待。没有新变化时，也只按保活节奏汇报，不要让用户触发下一次轮询。"
 );
 
 ZH_CONTENT[path.join(".claude", "commands", "lab.md")] = claudeCommand(
@@ -2201,7 +2205,7 @@ ZH_CONTENT[path.join(".claude", "commands", "lab-auto.md")] = claudeCommand(
   "lab-auto",
   "在已批准边界内编排自动实验循环",
   "auto mode objective",
-  "使用已安装的 `lab` 技能：`.claude/skills/lab/SKILL.md`。\n\n继续当前活动：`/lab-auto: 继续`。\n以最高执行级别继续当前活动：`/lab-auto: L3，继续`。\n\n立刻针对用户当前给出的参数执行 `auto` 阶段，不要只推荐别的 lab 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\n\n先把用户请求规范化成可交给 CLI 的 auto contract 字段：objective、autonomy level、campaign kind、allowed stages，以及任何不改变范围就能明确的 terminal-goal 提示。\n如果用户没写级别，默认按 `L2` 处理；接受 `L1/L2/L3`、`l1/l2/l3` 这类短写，`最高级别`、`最高自治` 也按 `L3` 处理。\n如果用户只写了 `继续`，且当前已有 active 或可恢复 campaign，就直接继承当前 campaign 的级别，而不是要求用户重复写。\n如果你想沿用 runtime 里已存的 campaign 级别继续，就直接写 `/lab-auto: 继续`。\n只有当级别本身真的有歧义时，才停下来追问，例如 `第三层`、`phase 3`、`table 3`。\n已批准的 `L2` 和 `L3` 执行 campaign 默认进入执行模式。\n在执行模式里，不要进入 brainstorming，不要进入 spec review，也不要为了常规实现路径选择、helper script、路径修正、数据集适配、同 family 候选切换或普通自检而生成 reviewer、explorer 或其他子智能体循环。\n只有当用户明确要求设计或审阅帮助、contract fit 需要新 campaign，或 contract 的 escalation condition 明确要求独立复核时，才从执行模式切到设计或 reviewer 模式。\n你的第一步执行动作必须是对当前项目运行 `superlab auto start`，而不是自己直接改写 `.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 或 `.lab/context/auto-outcome.md`。\n把规范化后的字段通过 CLI 参数传下去，包括 `--objective`、`--campaign-kind`、`--allowed-stages`，以及在用户已明确或已隐含时传 `--autonomy-level`。\nCLI 返回后的 runtime 结果才是事实来源。如果 CLI 报 rollover、conflict、缺字段，或已经成功启动 campaign，就如实回报，不要绕过 CLI 自己做 prompt 侧写回。\n\n本命令运行 lab workflow 的 `auto` 阶段。它必须读取 `.lab/context/eval-protocol.md`、`.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 与 `.lab/context/auto-outcome.md`，先确认 autonomy level、approval status、terminal goal schema，以及 primary gate、secondary guard、promotion condition、stop reason、escalation reason，再把 eval-protocol 里的指标释义、主表计划、来源约束与结构化实验阶梯当作执行依据，在不修改 mission、framing 和核心 claims 的前提下编排已批准的 `run`、`iterate`、`review`、`report`，轮询长任务完成情况；如果声明了 rung，就保持会话活着并按 rung 转移继续推进。\n首个可见输出块必须是 `Auto preflight`。这个块必须列出已读取文件，并回显 `Autonomy level`、`Approval status`、`Allowed stages`、`Terminal goal`、`Primary gate` 和 `Secondary guard`，然后才能进入执行摘要或动作计划。\n如果 preflight 所需字段缺失、过期或彼此冲突，就必须在执行前停下，并明确指出到底是哪一个字段阻止了 loop 启动。\n当 loop 活着时，必须把当前 owner、观察状态、checkpoint 摘要、继续边界、停止边界和恢复读取集合写进 `.lab/context/auto-ledger.md`。\n如果仓库的 workflow language 是中文，摘要、清单条目、任务标签和进度更新都必须使用中文，除非某个文件路径、代码标识符或字面指标名必须保持原样。\n把 `Layer 3`、`Phase 1`、`Table 2` 这类表达视为论文范围目标；只有显式写成 `Autonomy level L3` 或 `自治级别 L3` 时，才把它当成执行权限级别。\n不要用 `sleep 30`、单次 `pgrep` 或一次性的 `metrics.json` 探针来代替真实长任务命令；当真实实验进程还活着时，只允许发进度更新并继续等待。"
+  "使用已安装的 `lab` 技能：`.claude/skills/lab/SKILL.md`。\n\n继续当前活动：`/lab-auto: 继续`。\n以最高执行级别继续当前活动：`/lab-auto: L3，继续`。\n\n立刻针对用户当前给出的参数执行 `auto` 阶段，不要只推荐别的 lab 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\n\n先把用户请求规范化成可交给 CLI 的 auto contract 字段：objective、autonomy level、campaign kind、allowed stages，以及任何不改变范围就能明确的 terminal-goal 提示。\n如果用户没写级别，默认按 `L2` 处理；接受 `L1/L2/L3`、`l1/l2/l3` 这类短写，`最高级别`、`最高自治` 也按 `L3` 处理。\n如果用户只写了 `继续`，且当前已有 active 或可恢复 campaign，就直接继承当前 campaign 的级别，而不是要求用户重复写。\n如果你想沿用 runtime 里已存的 campaign 级别继续，就直接写 `/lab-auto: 继续`。\n只有当级别本身真的有歧义时，才停下来追问，例如 `第三层`、`phase 3`、`table 3`。\n已批准的 `L2` 和 `L3` 执行 campaign 默认进入执行模式。\n在执行模式里，不要进入 brainstorming，不要进入 spec review，也不要为了常规实现路径选择、helper script、路径修正、数据集适配、同 family 候选切换或普通自检而生成 reviewer、explorer 或其他子智能体循环。\n只有当用户明确要求设计或审阅帮助、contract fit 需要新 campaign，或 contract 的 escalation condition 明确要求独立复核时，才从执行模式切到设计或 reviewer 模式。\n你的第一步执行动作必须是对当前项目运行 `superlab auto start`，而不是自己直接改写 `.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 或 `.lab/context/auto-outcome.md`。\n把规范化后的字段通过 CLI 参数传下去，包括 `--objective`、`--campaign-kind`、`--allowed-stages`，以及在用户已明确或已隐含时传 `--autonomy-level`。\nCLI 返回后的 runtime 结果才是事实来源。如果 CLI 报 rollover、conflict、缺字段，或已经成功启动 campaign，就如实回报，不要绕过 CLI 自己做 prompt 侧写回。\n\n本命令运行 lab workflow 的 `auto` 阶段。它必须读取 `.lab/context/eval-protocol.md`、`.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 与 `.lab/context/auto-outcome.md`，先确认 autonomy level、approval status、terminal goal schema，以及 primary gate、secondary guard、promotion condition、stop reason、escalation reason，再把 eval-protocol 里的指标释义、主表计划、来源约束与结构化实验阶梯当作执行依据，在不修改 mission、framing 和核心 claims 的前提下编排已批准的 `run`、`iterate`、`review`、`report`，轮询长任务完成情况；如果声明了 rung，就保持会话活着并按 rung 转移继续推进。\n首个可见输出块必须是 `Auto preflight`。这个块必须列出已读取文件，并回显 `Autonomy level`、`Approval status`、`Allowed stages`、`Terminal goal`、`Primary gate` 和 `Secondary guard`，然后才能进入执行摘要或动作计划。\n如果 preflight 所需字段缺失、过期或彼此冲突，就必须在执行前停下，并明确指出到底是哪一个字段阻止了 loop 启动。\n当 loop 活着时，必须把当前 owner、观察状态、checkpoint 摘要、继续边界、停止边界和恢复读取集合写进 `.lab/context/auto-ledger.md`。\n如果仓库的 workflow language 是中文，摘要、清单条目、任务标签和进度更新都必须使用中文，除非某个文件路径、代码标识符或字面指标名必须保持原样。\n把 `Layer 3`、`Phase 1`、`Table 2` 这类表达视为论文范围目标；只有显式写成 `Autonomy level L3` 或 `自治级别 L3` 时，才把它当成执行权限级别。\n不要用 `sleep 30`、单次 `pgrep` 或一次性的 `metrics.json` 探针来代替真实长任务命令；当真实实验进程还活着时，只允许在出现有意义变化时发进度更新，并继续等待。没有新变化时，也只按保活节奏汇报，不要让用户触发下一次轮询。"
 );
 
 const zhAutoPriorityCodexLine =
@@ -2854,6 +2858,7 @@ ZH_CONTENT[path.join(".codex", "skills", "lab", "stages", "auto.md")] = `# \`/la
 - 如果用户显式调用 \`/lab:auto\` 或 \`/lab-auto\`，就保持在 auto 执行路径里；只要请求仍在已批准 execution envelope 内，即使目标听起来像 feature selection、baseline selection、离散化或 candidate sweep，也不要重新路由到 brainstorming 或 spec review。
 - 如果用户同时提了论文层、实验 phase 和自治级别，先用一句话重述：objective、自治级别、terminal goal、scope、allowed modifications。
 - 如果 workflow language 是中文，摘要、清单条目、任务标签和进度更新都应使用中文，除非文件路径、代码标识符或字面指标名必须保持原样。
+- 对 auto 写出的 \`.lab/iterations/*.md\` 也应用同样的 workflow-language 规则，包括本轮摘要、阻塞点、diagnostic notes 和 continue-or-stop 决策。
 - 当循环进入 \`report\` 时，要主动给出用户可读的白话总结，解释主指标、次级指标和主表作用；不要等用户额外发一句“解释这些指标”。
 - 当循环即将进入 \`write\`，且 \`paper_template_root\` 为空时：
   - 如果 \`paper_template_decision\` 是 \`unconfirmed\`，必须先追问一次：继续使用默认 scaffold，还是先接入模板目录

package/package-assets/claude/commands/lab.md

@@ -98,6 +98,8 @@ Treat all of these as equivalent stage requests:
 - That first visible output must show files read plus `Autonomy level`, `Allowed stages`, `Terminal goal`, `Primary gate`, and `Secondary guard`.
 - If the preflight block cannot be completed from `.lab/context/eval-protocol.md`, `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, and `.lab/context/auto-outcome.md`, `/lab auto` should stop instead of acting like the loop is armed.
 - While the loop is alive, `/lab auto` should keep `.lab/context/auto-ledger.md` updated with the active owner, observed state, and resume boundary.
+- Separate internal polling from user-facing progress reports.
+- While the loop is healthy, `/lab auto` should report to the user only on a meaningful change or at the keepalive cadence recorded in the current contract or runtime state, and it should not ask the user to trigger the next poll.
 
 - Treat `Autonomy level L1/L2/L3` as the execution privilege level, not as a paper layer, phase, or table number.
 - Treat `paper layer`, `phase`, and `table` as experiment targets. For example, `paper layer 3` or `Phase 1` should not be interpreted as `Autonomy level L3`.

package/package-assets/codex/prompts/lab.md

@@ -92,6 +92,8 @@ Treat all of these as equivalent stage requests:
 - That first visible output must show files read plus `Autonomy level`, `Allowed stages`, `Terminal goal`, `Primary gate`, and `Secondary guard`.
 - If the preflight block cannot be completed from `.lab/context/eval-protocol.md`, `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, and `.lab/context/auto-outcome.md`, `/lab:auto` should stop instead of acting like the loop is armed.
 - While the loop is alive, `/lab:auto` should keep `.lab/context/auto-ledger.md` updated with the active owner, observed state, and resume boundary.
+- Separate internal polling from user-facing progress reports.
+- While the loop is healthy, `/lab:auto` should report to the user only on a meaningful change or at the keepalive cadence recorded in the current contract or runtime state, and it should not ask the user to trigger the next poll.
 
 - Treat `Autonomy level L1/L2/L3` as the execution privilege level, not as a paper layer, phase, or table number.
 - Treat `paper layer`, `phase`, and `table` as experiment targets. For example, `paper layer 3` or `Phase 1` should not be interpreted as `Autonomy level L3`.

package/package-assets/shared/lab/context/auto-mode.md

@@ -40,6 +40,9 @@ Use `.lab/context/auto-ledger.md` as the live runtime ledger for ownership, chec
 - Max wall-clock time:
 - Max failures:
 - Poll interval:
+- Leave `Poll interval` blank to use conservative defaults: `run`/`iterate` poll every `2m`; other auto polling defaults to `15s`.
+- Progress report interval:
+- Leave `Progress report interval` blank to report to the user only on a meaningful change, plus a keepalive at most every `10m` for `run`/`iterate` and every `2m` for other auto polling.
 
 ## Stage Commands
 

package/package-assets/shared/skills/lab/SKILL.md

@@ -28,6 +28,7 @@ Use this skill when the user invokes `/lab:*` or asks for the structured researc
 - Use `.lab/context/eval-protocol.md` as the shared evaluation contract for run, iterate, auto, and report stages, including metric glossary and experiment ladder semantics.
 - Treat evaluation semantics as source-backed once evaluation planning starts: metrics, benchmark gates, baseline behavior, comparison implementations, and deviations should come from recorded sources, not memory.
 - Workflow artifacts should follow the installed workflow language.
+- Iteration artifacts under `.lab/iterations/` are workflow artifacts and should follow the installed workflow language.
 - Final paper output should default to LaTeX, and its manuscript language should be decided separately from the workflow language.
 - Separate sourced facts from model-generated hypotheses.
 - Preserve failed runs, failed ideas, and limitations.
@@ -174,6 +175,7 @@ Use this skill when the user invokes `/lab:*` or asks for the structured researc
 - Keep metric definitions, baseline behavior, and comparison implementations anchored to the source-backed evaluation protocol before changing thresholds, gates, or ladder transitions.
 - Switch to diagnostic mode if risk increases for two consecutive rounds.
 - Write round reports with `.lab/.managed/templates/iteration-report.md`.
+- Write round reports under `.lab/iterations/` with `.lab/.managed/templates/iteration-report.md`, and keep those iteration artifacts in the workflow language.
 - Update `.lab/context/workflow-state.md`, `.lab/context/decisions.md`, `.lab/context/evidence-index.md`, `.lab/context/open-questions.md`, and `.lab/context/eval-protocol.md` each round as needed, then refresh derived views.
 - Keep `.lab/context/eval-protocol.md` synchronized with accepted ladder changes, benchmark scope, and source-backed implementation deviations.
 - Stop at threshold success or iteration cap, and record blockers plus next-best actions when the campaign ends without success.

package/package-assets/shared/skills/lab/stages/auto.md

@@ -77,6 +77,10 @@
 - You may promote exploratory additions to the primary package only when the contract's promotion policy is satisfied and the promotion is written back into `data-decisions.md`, `decisions.md`, and `workflow-state.md`, then refresh derived views.
 - Poll long-running commands until they finish, hit a timeout, or hit a stop condition.
 - Keep a poll-based waiting loop instead of sleeping blindly.
+- When `Poll interval` is blank, use conservative defaults: `run` and `iterate` poll every `2m`; other auto polling defaults to `15s`.
+- Separate internal polling from user-facing progress reports.
+- When `Progress report interval` is blank, report to the user only on a meaningful change, plus a keepalive at most every `10m` for `run`/`iterate` and every `2m` for other auto polling.
+- A meaningful change means a stage or rung transition, a new checkpoint or artifact, an owner exit, a stop or escalation match, or an anomaly signal.
 - Do not treat a short watcher such as `sleep 30`, a one-shot `pgrep`, or a single `metrics.json` probe as the rung command when the real experiment is still running.
 - Bind each rung to the real long-running command or process that owns the experiment result.
 - Record the active owner as one of:
@@ -166,6 +170,7 @@
   - allowed modifications
 - Then ask at most one clarifying question if a blocking field is still missing.
 - If `.lab/config/workflow.json` sets the workflow language to Chinese, write summaries, options, checklist items, task labels, and progress updates in Chinese unless a file path, code identifier, or literal metric name must remain unchanged.
+- Apply the same workflow-language rule to auto-written iteration artifacts under `.lab/iterations/`, including round summaries, blocker lists, diagnostic notes, and continue-or-stop decisions.
 - When the loop reaches `report`, apply the same workflow-language rule to `report.md` and the managed `main-tables.md` artifact.
 - When the loop reaches `report`, proactively deliver a user-facing plain-language summary of the selected metrics, what they mean, what the tables prove, and what remains unproven. Do not wait for a separate user request asking for interpretation.
 - When the loop is about to enter `write` and `paper_template_root` is empty:
@@ -180,3 +185,4 @@
 - If the user chooses to keep the draft language, persist `paper_language_finalization_decision: keep-workflow-language`
 - If the user chooses to convert, persist `paper_language_finalization_decision: convert-to-paper-language`
 - While the real experiment process is still alive, emit only a progress update and keep waiting. Do not present a terminal summary for that rung until the process exits or the rung hits an explicit stop boundary.
+- While the loop is healthy, do not ask the user to trigger the next poll. Keep polling until a meaningful change, keepalive boundary, stop boundary, escalation boundary, or terminal boundary is reached.

package/package-assets/shared/skills/lab/stages/iterate.md

@@ -37,7 +37,7 @@ Declare and keep fixed:
 - round hypothesis
 - concrete code or config changes
 - normalized evaluation summary
-- written iteration report
+- written iteration report under `.lab/iterations/`
 - durable run outputs under `results_root`
 - continue or stop decision
 - diagnostic mode trigger when risk increases for two consecutive rounds
@@ -70,6 +70,7 @@ If the loop stops without success, record:
 - Re-run the `Sanity and Alternative-Explanation Checks` whenever a round produces anomaly signals, suspiciously unchanged results, impl/result mismatches, or other outcomes that could still have simpler explanations.
 - If a round reveals leakage risk, invalid scale comparisons, unsupported metric semantics, or overstated claim boundaries, treat that as a fatal methodological flaw instead of a normal failed iteration.
 - If anomaly signals remain unresolved after implementation reality checks and at least one cross-check, switch to diagnostic mode instead of continuing as if the interpretation were settled.
+- Keep `.lab/iterations/*.md` as reader-facing workflow artifacts. If `.lab/config/workflow.json` sets the workflow language to Chinese, write the iteration report, round summary, blocker list, and continue-or-stop decision in Chinese unless a file path, code identifier, or literal metric name must remain unchanged.
 
 ## Interaction Contract
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlab",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "description": "Strict /lab research workflow installer for Codex and Claude",
   "keywords": [
     "codex",