superlab 0.1.50 → 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

@@ -1598,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\` 发一次保活更新。
 
 ## 阶段命令
 
@@ -2181,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(
@@ -2202,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 =

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/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:
@@ -181,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.json

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