superlab 0.1.42 → 0.1.44

package/lib/auto_contracts.cjs

@@ -134,6 +134,11 @@ function validateAutoMode(mode, status = null, evalProtocol = null) {
     ["terminal goal type", mode.terminalGoalType],
     ["terminal goal target", mode.terminalGoalTarget],
     ["required terminal artifact", mode.requiredTerminalArtifact],
+    ["primary gate", mode.primaryGate],
+    ["secondary guard", mode.secondaryGuard],
+    ["promotion condition", mode.promotionCondition],
+    ["stop reason", mode.stopReason],
+    ["escalation reason", mode.escalationReason],
     ["max iterations", mode.maxIterations],
     ["max wall-clock time", mode.maxWallClockTime],
     ["max failures", mode.maxFailures],

package/lib/auto_runner.cjs

@@ -21,10 +21,13 @@ const {
   verifyStageContract,
 } = require("./auto_contracts.cjs");
 const {
+  listMissingCurrentAutoModeFields,
+  parseAutoLedger,
   parseAutoMode,
   parseAutoStatus,
   readWorkflowLanguage,
   resolveRequiredArtifact,
+  writeAutoLedger,
   writeAutoOutcome,
   writeAutoStatus,
 } = require("./auto_state.cjs");
@@ -33,6 +36,10 @@ function normalizeTransition(value) {
   return (value || "").trim();
 }
 
+function normalizeObservedState(value) {
+  return (value || "").trim().toLowerCase();
+}
+
 function isSuccessTransition(value) {
   return ["success", "terminal-success", "campaign-success"].includes((value || "").trim().toLowerCase());
 }
@@ -41,6 +48,101 @@ function isStopTransition(value) {
   return ["stop", "campaign-stop", "terminal-stop"].includes((value || "").trim().toLowerCase());
 }
 
+function isLocalProcessAlive(ownerId) {
+  const pid = parseInteger(ownerId, null);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error && error.code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+
+function resolveResumePlan({ mode, evalProtocol, status, ledger, now }) {
+  const hasLedgerState = [
+    ledger.campaignId,
+    ledger.observedState,
+    ledger.activeRung,
+    ledger.nextTransition,
+    ledger.ownerId,
+  ].some((value) => isMeaningful(value));
+  if (!hasLedgerState) {
+    return { blockingIssue: "", resumePlan: null };
+  }
+
+  if ((ledger.ownerType || "").trim().toLowerCase() === "local-process" && isLocalProcessAlive(ledger.ownerId)) {
+    return {
+      blockingIssue: `auto campaign already has a live local owner: ${ledger.ownerId}`,
+      resumePlan: null,
+    };
+  }
+
+  const startedAt = isMeaningful(status.startedAt) ? status.startedAt : now.toISOString();
+  const campaignId = isMeaningful(ledger.campaignId)
+    ? ledger.campaignId
+    : `auto-${startedAt.replace(/[:.]/g, "-")}`;
+  const iterationCount = parseInteger(status.iterationCount, 0);
+  const observedState = normalizeObservedState(ledger.observedState);
+
+  if (evalProtocol.experimentRungs.length > 0) {
+    const rungMap = new Map(evalProtocol.experimentRungs.map((rung) => [rung.id, rung]));
+    const nextTransition = normalizeTransition(ledger.nextTransition || status.nextRung);
+    if (
+      isMeaningful(nextTransition) &&
+      !isSuccessTransition(nextTransition) &&
+      !isStopTransition(nextTransition) &&
+      rungMap.has(nextTransition)
+    ) {
+      const rung = rungMap.get(nextTransition);
+      return {
+        blockingIssue: "",
+        resumePlan: {
+          kind: "ladder",
+          rungId: nextTransition,
+          stage: rung.stage,
+          watchTarget: rung.watch,
+          campaignId,
+          startedAt,
+          iterationsCompleted: iterationCount,
+          lastCheckpoint: ledger.lastCheckpoint || status.lastCheckpoint || "",
+          reason: `resuming at next rung ${nextTransition}`,
+        },
+      };
+    }
+
+    const activeRung = normalizeTransition(ledger.activeRung || status.currentRung);
+    if (
+      ["running", "retrying"].includes(observedState) &&
+      isMeaningful(activeRung) &&
+      rungMap.has(activeRung)
+    ) {
+      const rung = rungMap.get(activeRung);
+      return {
+        blockingIssue: "",
+        resumePlan: {
+          kind: "ladder",
+          rungId: activeRung,
+          stage: rung.stage,
+          watchTarget: rung.watch,
+          campaignId,
+          startedAt,
+          iterationsCompleted: Math.max(0, iterationCount - 1),
+          lastCheckpoint: ledger.lastCheckpoint || status.lastCheckpoint || "",
+          reason: `restarting active rung ${activeRung} after owner exit`,
+        },
+      };
+    }
+  }
+
+  return { blockingIssue: "", resumePlan: null };
+}
+
 async function runCommandWithPolling({
   targetDir,
   stage,
@@ -53,6 +155,8 @@ async function runCommandWithPolling({
   rungId = "",
   watchTarget = "",
   nextRung = "",
+  ownerInfo = null,
+  updateLedger = null,
 }) {
   const child = spawn(command, {
     cwd: targetDir,
@@ -106,6 +210,20 @@ async function runCommandWithPolling({
       },
       { lang }
     );
+    if (typeof updateLedger === "function") {
+      updateLedger({
+        ownerType: ownerInfo?.ownerType || "local-process",
+        ownerId: String(child.pid || ownerInfo?.ownerId || ""),
+        command,
+        watchTarget,
+        activeStage: stage,
+        activeRung: rungId,
+        startedAt,
+        lastObservedAt: new Date().toISOString(),
+        observedState: "running",
+        nextTransition: nextRung || "",
+      });
+    }
     await sleep(pollIntervalMs);
   }
 
@@ -217,7 +335,15 @@ async function evaluateTerminalGoal({ mode, iteration, targetDir, deadlineMs })
 
 async function startAutoMode({ targetDir, now = new Date() }) {
   const mode = parseAutoMode(targetDir);
+  const existingStatus = parseAutoStatus(targetDir);
+  const existingLedger = parseAutoLedger(targetDir);
   const evalProtocol = parseEvalProtocol(targetDir);
+  const missingSchemaFields = listMissingCurrentAutoModeFields(mode);
+  if (missingSchemaFields.length > 0) {
+    throw new Error(
+      `auto-mode.md is missing current contract fields: ${missingSchemaFields.join(", ")}; run \`superlab update --target ${targetDir}\` to apply the managed schema migration, then fill the new fields before starting auto mode`
+    );
+  }
   const issues = validateAutoMode(mode, null, evalProtocol);
   if (issues.length > 0) {
     throw new Error(issues.join(" | "));
@@ -229,20 +355,30 @@ async function startAutoMode({ targetDir, now = new Date() }) {
   if (mode.approvalStatus !== "approved") {
     throw new Error(`approval status must be approved before auto mode can start (current: ${mode.approvalStatus || "missing"})`);
   }
+  const { blockingIssue, resumePlan } = resolveResumePlan({
+    mode,
+    evalProtocol,
+    status: existingStatus,
+    ledger: existingLedger,
+    now,
+  });
+  if (blockingIssue) {
+    throw new Error(blockingIssue);
+  }
 
   const lang = readWorkflowLanguage(targetDir);
   const timestamp = now.toISOString();
   const status = {
     status: "running",
-    currentStage: mode.allowedStages[0] || "run",
+    currentStage: resumePlan?.stage || mode.allowedStages[0] || "run",
     currentCommand: "",
     activeRunId: "",
-    iterationCount: "0",
-    startedAt: timestamp,
+    iterationCount: String(resumePlan?.iterationsCompleted || 0),
+    startedAt: resumePlan?.startedAt || timestamp,
     lastHeartbeat: timestamp,
-    lastCheckpoint: "",
-    lastSummary: "",
-    decision: "armed for bounded auto orchestration",
+    lastCheckpoint: resumePlan?.lastCheckpoint || "",
+    lastSummary: resumePlan?.reason || "",
+    decision: resumePlan?.reason || "armed for bounded auto orchestration",
   };
   writeAutoStatus(targetDir, status, { lang });
 
@@ -257,13 +393,36 @@ async function startAutoMode({ targetDir, now = new Date() }) {
   const { loopStages, finalStages } = splitAutoStages(mode.allowedStages);
   const executedStages = [];
   let failureCount = 0;
-  let iterationsCompleted = 0;
+  let iterationsCompleted = resumePlan?.iterationsCompleted || 0;
   let currentStatus = { ...status };
   let successReached = false;
   let stopMatched = false;
   let promotionApplied = false;
   let stopReason = "";
   let finalRung = "";
+  const campaignId = resumePlan?.campaignId || `auto-${startedAt.replace(/[:.]/g, "-")}`;
+  let currentLedger = {
+    campaignId,
+    objective: mode.objective,
+    activeStage: status.currentStage,
+    activeRung: resumePlan?.rungId || "",
+    ownerType: "",
+    ownerId: "",
+    command: "",
+    watchTarget: resumePlan?.watchTarget || "",
+    startedAt,
+    lastObservedAt: timestamp,
+    observedState: resumePlan ? "resuming" : "armed",
+    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.",
+    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",
+    resumeCommand: "",
+  };
+  writeAutoLedger(targetDir, currentLedger, { lang });
   const outcomeProtocolFields = {
     primaryMetrics: evalProtocol.primaryMetrics,
     secondaryMetrics: evalProtocol.secondaryMetrics,
@@ -305,6 +464,22 @@ async function startAutoMode({ targetDir, now = new Date() }) {
     writeAutoStatus(targetDir, currentStatus, { lang });
   };
 
+  const writeLedger = (overrides = {}) => {
+    currentLedger = {
+      ...currentLedger,
+      activeStage: currentStatus.currentStage || currentLedger.activeStage,
+      activeRung: currentStatus.currentRung || currentLedger.activeRung,
+      watchTarget: currentStatus.watchTarget || currentLedger.watchTarget,
+      lastCheckpoint: currentStatus.lastCheckpoint || currentLedger.lastCheckpoint,
+      checkpointSummary: currentStatus.lastSummary || currentLedger.checkpointSummary,
+      lastObservedAt: new Date().toISOString(),
+      stopBoundary: mode.stopConditions,
+      escalationBoundary: mode.escalationConditions,
+      ...overrides,
+    };
+    writeAutoLedger(targetDir, currentLedger, { lang });
+  };
+
   const failAutoMode = (message) => {
     currentStatus = {
       ...currentStatus,
@@ -313,6 +488,13 @@ async function startAutoMode({ targetDir, now = new Date() }) {
       decision: message,
     };
     writeAutoStatus(targetDir, currentStatus, { lang });
+    writeLedger({
+      observedState: "failed",
+      ownerType: currentLedger.ownerType || "local-process",
+      checkpointSummary: message,
+      nextTransition: "terminal-failure",
+      resumeCommand: "",
+    });
     writeAutoOutcome(
       targetDir,
       {
@@ -366,6 +548,8 @@ async function startAutoMode({ targetDir, now = new Date() }) {
           rungId,
           watchTarget,
           nextRung,
+          ownerInfo: { ownerType: "local-process" },
+          updateLedger: writeLedger,
         });
         verifyStageContract({ stage, snapshot: contract.snapshot });
         executedStages.push(stage);
@@ -378,6 +562,18 @@ async function startAutoMode({ targetDir, now = new Date() }) {
           nextRung,
           decision: rungId ? `completed rung ${rungId}` : `completed stage ${stage}`,
         });
+        writeLedger({
+          ownerType: "local-process",
+          observedState: "checkpointed",
+          command,
+          watchTarget,
+          activeStage: stage,
+          activeRung: rungId || currentStatus.currentRung,
+          ownerId: currentLedger.ownerId,
+          checkpointSummary: rungId ? `completed rung ${rungId}` : `completed stage ${stage}`,
+          nextTransition: nextRung || "",
+          resumeCommand: command,
+        });
         const frozenCoreChanges = detectFrozenCoreChanges(frozenCoreSnapshot);
         if (frozenCoreChanges.length > 0) {
           failAutoMode(`frozen core changed: ${frozenCoreChanges.join(", ")}`);
@@ -412,6 +608,17 @@ async function startAutoMode({ targetDir, now = new Date() }) {
           nextRung,
           decision: `retrying ${rungId || stage} after failure ${failureCount}`,
         });
+        writeLedger({
+          ownerType: "local-process",
+          observedState: "retrying",
+          command,
+          watchTarget,
+          activeStage: stage,
+          activeRung: rungId || currentStatus.currentRung,
+          checkpointSummary: `retrying ${rungId || stage} after failure ${failureCount}`,
+          nextTransition: rungId || stage,
+          resumeCommand: command,
+        });
       }
     }
   };
@@ -451,6 +658,14 @@ async function startAutoMode({ targetDir, now = new Date() }) {
       currentCommand: mode.promotionCommand,
       decision: `promotion policy matched after ${label}`,
     });
+    writeLedger({
+      ownerType: "local-process",
+      command: mode.promotionCommand,
+      observedState: "checkpointed",
+      checkpointSummary: `promotion policy matched after ${label}`,
+      nextTransition: "post-promotion refresh",
+      resumeCommand: mode.promotionCommand,
+    });
     promotionApplied = true;
     const frozenCoreChangesAfterPromotion = detectFrozenCoreChanges(frozenCoreSnapshot);
     if (frozenCoreChangesAfterPromotion.length > 0) {
@@ -463,7 +678,12 @@ async function startAutoMode({ targetDir, now = new Date() }) {
 
   if (evalProtocol.experimentRungs.length > 0) {
     const rungMap = new Map(evalProtocol.experimentRungs.map((rung) => [rung.id, rung]));
-    let currentRung = evalProtocol.experimentRungs[0];
+    let currentRung = resumePlan?.kind === "ladder"
+      ? rungMap.get(resumePlan.rungId)
+      : evalProtocol.experimentRungs[0];
+    if (!currentRung) {
+      failAutoMode(`resume rung is missing from the current experiment ladder: ${resumePlan?.rungId || ""}`);
+    }
 
     while (currentRung && iterationsCompleted < Math.max(1, maxIterations)) {
       if (!mode.allowedStages.includes(currentRung.stage)) {
@@ -618,6 +838,12 @@ async function startAutoMode({ targetDir, now = new Date() }) {
       decision: stopReason || "stopped by stop condition",
     };
     writeAutoStatus(targetDir, currentStatus, { lang });
+    writeLedger({
+      observedState: "stopped",
+      checkpointSummary: stopReason || "stopped by stop condition",
+      nextTransition: "terminal-stop",
+      resumeCommand: "",
+    });
     writeAutoOutcome(
       targetDir,
       {
@@ -670,6 +896,12 @@ async function startAutoMode({ targetDir, now = new Date() }) {
           decision: stopReason || "stopped by stop condition",
         };
         writeAutoStatus(targetDir, currentStatus, { lang });
+        writeLedger({
+          observedState: "stopped",
+          checkpointSummary: stopReason || "stopped by stop condition",
+          nextTransition: "terminal-stop",
+          resumeCommand: "",
+        });
         writeAutoOutcome(
           targetDir,
           {
@@ -724,6 +956,12 @@ async function startAutoMode({ targetDir, now = new Date() }) {
     decision: successReached ? "completed configured auto goal" : "completed configured stages",
   };
   writeAutoStatus(targetDir, currentStatus, { lang });
+  writeLedger({
+    observedState: "completed",
+    checkpointSummary: successReached ? "completed configured auto goal" : "completed configured stages",
+    nextTransition: "terminal-success",
+    resumeCommand: "",
+  });
   writeAutoOutcome(
     targetDir,
     {
@@ -805,6 +1043,31 @@ function stopAutoMode({ targetDir, now = new Date() }) {
     decision: "stopped by operator",
   };
   writeAutoStatus(targetDir, status, { lang });
+  writeAutoLedger(
+    targetDir,
+    {
+      campaignId: existing.startedAt ? `auto-${existing.startedAt.replace(/[:.]/g, "-")}` : `auto-${now.toISOString().replace(/[:.]/g, "-")}`,
+      objective: mode.objective,
+      activeStage: existing.currentStage || "",
+      activeRung: existing.currentRung || "",
+      ownerType: "local-process",
+      ownerId: "",
+      command: existing.currentCommand || "",
+      watchTarget: existing.watchTarget || "",
+      startedAt: existing.startedAt || now.toISOString(),
+      lastObservedAt: now.toISOString(),
+      observedState: "stopped",
+      lastCheckpoint: existing.lastCheckpoint || "",
+      checkpointSummary: "stopped by operator",
+      nextTransition: "terminal-stop",
+      continueBoundary: "No further automatic progress is allowed until a new approved auto run starts.",
+      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",
+      resumeCommand: "",
+    },
+    { lang }
+  );
   writeAutoOutcome(
     targetDir,
     {

package/lib/auto_state.cjs

@@ -24,6 +24,11 @@ function parseAutoMode(targetDir) {
     terminalGoalType: normalizeScalar(extractValue(text, ["Terminal goal type", "终止目标类型"])),
     terminalGoalTarget: extractValue(text, ["Terminal goal target", "终止目标目标值"]),
     requiredTerminalArtifact: extractValue(text, ["Required terminal artifact", "终止目标工件"]),
+    primaryGate: extractValue(text, ["Primary gate", "主 gate"]),
+    secondaryGuard: extractValue(text, ["Secondary guard", "次级 guard"]),
+    promotionCondition: extractValue(text, ["Promotion condition", "升格条件"]),
+    stopReason: extractValue(text, ["Stop reason", "停止原因"]),
+    escalationReason: extractValue(text, ["Escalation reason", "升级原因"]),
     maxIterations: extractValue(text, ["Max iterations", "最大迭代轮次"]),
     maxWallClockTime: extractValue(text, ["Max wall-clock time", "最大运行时长"]),
     maxFailures: extractValue(text, ["Max failures", "最大失败次数"]),
@@ -47,6 +52,25 @@ function parseAutoMode(targetDir) {
   };
 }
 
+const CURRENT_AUTO_MODE_SCHEMA_FIELDS = [
+  ["Autonomy level", "autonomyLevel"],
+  ["Approval status", "approvalStatus"],
+  ["Terminal goal type", "terminalGoalType"],
+  ["Terminal goal target", "terminalGoalTarget"],
+  ["Required terminal artifact", "requiredTerminalArtifact"],
+  ["Primary gate", "primaryGate"],
+  ["Secondary guard", "secondaryGuard"],
+  ["Promotion condition", "promotionCondition"],
+  ["Stop reason", "stopReason"],
+  ["Escalation reason", "escalationReason"],
+];
+
+function listMissingCurrentAutoModeFields(mode) {
+  return CURRENT_AUTO_MODE_SCHEMA_FIELDS
+    .filter(([, key]) => !isMeaningful(mode[key]))
+    .map(([label]) => label);
+}
+
 function parseAutoStatus(targetDir) {
   const text = readFileIfExists(contextFile(targetDir, "auto-status.md"));
   return {
@@ -68,6 +92,33 @@ function parseAutoStatus(targetDir) {
   };
 }
 
+function parseAutoLedger(targetDir) {
+  const text = readFileIfExists(contextFile(targetDir, "auto-ledger.md"));
+  return {
+    path: contextFile(targetDir, "auto-ledger.md"),
+    text,
+    campaignId: extractValue(text, ["Campaign id", "Campaign ID", "活动 id"]),
+    objective: extractValue(text, ["Objective", "目标"]),
+    activeStage: extractValue(text, ["Active stage", "当前阶段"]),
+    activeRung: extractValue(text, ["Active rung", "当前 rung"]),
+    ownerType: extractValue(text, ["Owner type", "Owner 类型"]),
+    ownerId: extractValue(text, ["Owner id", "Owner ID"]),
+    command: extractValue(text, ["Command", "命令"]),
+    watchTarget: extractValue(text, ["Watch target", "监视目标"]),
+    startedAt: extractValue(text, ["Started at", "开始时间"]),
+    lastObservedAt: extractValue(text, ["Last observed at", "最近观察时间"]),
+    observedState: extractValue(text, ["Observed state", "观察状态"]),
+    lastCheckpoint: extractValue(text, ["Last checkpoint", "最近 checkpoint"]),
+    checkpointSummary: extractValue(text, ["Checkpoint summary", "Checkpoint 摘要"]),
+    nextTransition: extractValue(text, ["Next transition", "下一转换"]),
+    continueBoundary: extractValue(text, ["Continue boundary", "继续边界"]),
+    stopBoundary: extractValue(text, ["Stop boundary", "停止边界"]),
+    escalationBoundary: extractValue(text, ["Escalation boundary", "升级边界"]),
+    requiredReadSet: extractValue(text, ["Required read set", "必要读取集合"]),
+    resumeCommand: extractValue(text, ["Resume command", "恢复命令"]),
+  };
+}
+
 function renderAutoStatus(status, { lang = "en" } = {}) {
   if (lang === "zh") {
     return `# 自动模式状态
@@ -240,12 +291,96 @@ function renderAutoOutcome(outcome, { lang = "en" } = {}) {
 `;
 }
 
+function renderAutoLedger(ledger, { lang = "en" } = {}) {
+  if (lang === "zh") {
+    return `# 自动运行账本
+
+## Campaign
+
+- Campaign id: ${ledger.campaignId || ""}
+- Objective: ${ledger.objective || ""}
+- Active stage: ${ledger.activeStage || ""}
+- Active rung: ${ledger.activeRung || ""}
+
+## Owner
+
+- Owner type: ${ledger.ownerType || ""}
+- Owner id: ${ledger.ownerId || ""}
+- Command: ${ledger.command || ""}
+- Watch target: ${ledger.watchTarget || ""}
+- Started at: ${ledger.startedAt || ""}
+- Last observed at: ${ledger.lastObservedAt || ""}
+- Observed state: ${ledger.observedState || ""}
+
+## Checkpoints
+
+- Last checkpoint: ${ledger.lastCheckpoint || ""}
+- Checkpoint summary: ${ledger.checkpointSummary || ""}
+- Next transition: ${ledger.nextTransition || ""}
+
+## Boundaries
+
+- Continue boundary: ${ledger.continueBoundary || ""}
+- Stop boundary: ${ledger.stopBoundary || ""}
+- Escalation boundary: ${ledger.escalationBoundary || ""}
+
+## Resume
+
+- Required read set: ${ledger.requiredReadSet || ""}
+- Resume command: ${ledger.resumeCommand || ""}
+`;
+  }
+
+  return `# Auto Runtime Ledger
+
+## Campaign
+
+- Campaign id: ${ledger.campaignId || ""}
+- Objective: ${ledger.objective || ""}
+- Active stage: ${ledger.activeStage || ""}
+- Active rung: ${ledger.activeRung || ""}
+
+## Owner
+
+- Owner type: ${ledger.ownerType || ""}
+- Owner id: ${ledger.ownerId || ""}
+- Command: ${ledger.command || ""}
+- Watch target: ${ledger.watchTarget || ""}
+- Started at: ${ledger.startedAt || ""}
+- Last observed at: ${ledger.lastObservedAt || ""}
+- Observed state: ${ledger.observedState || ""}
+
+## Checkpoints
+
+- Last checkpoint: ${ledger.lastCheckpoint || ""}
+- Checkpoint summary: ${ledger.checkpointSummary || ""}
+- Next transition: ${ledger.nextTransition || ""}
+
+## Boundaries
+
+- Continue boundary: ${ledger.continueBoundary || ""}
+- Stop boundary: ${ledger.stopBoundary || ""}
+- Escalation boundary: ${ledger.escalationBoundary || ""}
+
+## Resume
+
+- Required read set: ${ledger.requiredReadSet || ""}
+- Resume command: ${ledger.resumeCommand || ""}
+`;
+}
+
 function writeAutoOutcome(targetDir, outcome, { lang = "en" } = {}) {
   const filePath = contextFile(targetDir, "auto-outcome.md");
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, renderAutoOutcome(outcome, { lang }).trimEnd() + "\n");
 }
 
+function writeAutoLedger(targetDir, ledger, { lang = "en" } = {}) {
+  const filePath = contextFile(targetDir, "auto-ledger.md");
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, renderAutoLedger(ledger, { lang }).trimEnd() + "\n");
+}
+
 function resolveRequiredArtifact(targetDir, configuredPath) {
   if (!isMeaningful(configuredPath)) {
     return { relativePath: "", absolutePath: "" };
@@ -258,12 +393,17 @@ function resolveRequiredArtifact(targetDir, configuredPath) {
 }
 
 module.exports = {
+  CURRENT_AUTO_MODE_SCHEMA_FIELDS,
+  listMissingCurrentAutoModeFields,
+  parseAutoLedger,
   parseAutoMode,
   parseAutoStatus,
   readWorkflowLanguage,
+  renderAutoLedger,
   renderAutoOutcome,
   renderAutoStatus,
   resolveRequiredArtifact,
+  writeAutoLedger,
   writeAutoOutcome,
   writeAutoStatus,
 };

package/lib/i18n.cjs

@@ -1563,6 +1563,7 @@ const ZH_SKILL_FILES = {
 `# 自动模式契约
 
 用这个文件定义 \`/lab:auto\` 的有边界自治执行范围。
+把 \`.lab/context/auto-ledger.md\` 当成运行时账本，记录 owner、checkpoint、resume 和 stop 边界。
 
 ## 目标
 
@@ -1602,6 +1603,7 @@ const ZH_SKILL_FILES = {
 - Rung 的 \`Command\` 应该绑定真实的长任务命令，由它产出最终实验结果。
 - 短 watcher 只用于查看进度；当真实实验还在运行时，不要把短 watcher 当成 stage 或 rung 的主命令。
 - 当真实实验进程还活着时，只记录进度更新并继续等待。
+- 当 loop 处于运行态时，把当前 owner、命令和 watch target 写进 \`.lab/context/auto-ledger.md\`。
 - Run command:
 - Iterate command:
 - Review command:
@@ -1634,6 +1636,43 @@ const ZH_SKILL_FILES = {
 - Stop conditions:
 - Escalation conditions:
 - Canonical promotion writeback: update \`.lab/context/data-decisions.md\`、\`.lab/context/decisions.md\` 和 \`.lab/context/workflow-state.md\`，然后刷新 \`state.md\` 等派生视图。
+`,
+  [path.join(".lab", "context", "auto-ledger.md")]:
+`# 自动运行账本
+
+## Campaign
+
+- Campaign id:
+- Objective:
+- Active stage:
+- Active rung:
+
+## Owner
+
+- Owner type:
+- Owner id:
+- Command:
+- Watch target:
+- Started at:
+- Last observed at:
+- Observed state:
+
+## Checkpoints
+
+- Last checkpoint:
+- Checkpoint summary:
+- Next transition:
+
+## Boundaries
+
+- Continue boundary:
+- Stop boundary:
+- Escalation boundary:
+
+## Resume
+
+- Required read set:
+- Resume command:
 `,
   [path.join(".lab", "context", "auto-outcome.md")]:
 `# 自动结果
@@ -2141,7 +2180,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`，不要只推荐别的 `/lab` 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\n\n本命令运行 `/lab:auto` 阶段。它必须读取 `.lab/context/eval-protocol.md`、`.lab/context/auto-mode.md`、`.lab/context/auto-status.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如果仓库的 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`，不要只推荐别的 `/lab` 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\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(
@@ -2162,7 +2201,7 @@ ZH_CONTENT[path.join(".claude", "commands", "lab-auto.md")] = claudeCommand(
   "lab-auto",
   "在已批准边界内编排自动实验循环",
   "auto mode objective",
-  "使用已安装的 `lab` 技能：`.claude/skills/lab/SKILL.md`。\n\n立刻针对用户当前给出的参数执行 `auto` 阶段，不要只推荐别的 lab 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\n\n本命令运行 lab workflow 的 `auto` 阶段。它必须读取 `.lab/context/eval-protocol.md`、`.lab/context/auto-mode.md`、`.lab/context/auto-status.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如果仓库的 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立刻针对用户当前给出的参数执行 `auto` 阶段，不要只推荐别的 lab 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\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 zhRecipeQuickPathLine =
@@ -2171,15 +2210,27 @@ const zhRecipeQuickPathLine =
 ZH_CONTENT[path.join(".codex", "prompts", "lab.md")] = ZH_CONTENT[
   path.join(".codex", "prompts", "lab.md")
 ].replace(
+  "\n\n## 子命令\n\n",
+  "\n\n## 可接受的阶段写法\n\n- `/lab:idea ...`、`/lab: idea ...`、`/lab idea ...`、`/lab-idea`、`/lab：idea ...`\n- `/lab:data ...`、`/lab: data ...`、`/lab data ...`、`/lab-data`、`/lab：data ...`\n- `/lab:auto ...`、`/lab: auto ...`、`/lab auto ...`、`/lab-auto`、`/lab：auto ...`\n- `/lab:framing ...`、`/lab: framing ...`、`/lab framing ...`、`/lab-framing`、`/lab：framing ...`\n- `/lab:spec ...`、`/lab: spec ...`、`/lab spec ...`、`/lab-spec`、`/lab：spec ...`\n- `/lab:run ...`、`/lab: run ...`、`/lab run ...`、`/lab-run`、`/lab：run ...`\n- `/lab:iterate ...`、`/lab: iterate ...`、`/lab iterate ...`、`/lab-iterate`、`/lab：iterate ...`\n- `/lab:review ...`、`/lab: review ...`、`/lab review ...`、`/lab-review`、`/lab：review ...`\n- `/lab:report ...`、`/lab: report ...`、`/lab report ...`、`/lab-report`、`/lab：report ...`\n- `/lab:write ...`、`/lab: write ...`、`/lab write ...`、`/lab-write`、`/lab：write ...`\n\n## 子命令\n\n"
+).replace(
   "- 始终使用 `skills/lab/SKILL.md` 作为工作流合同。\n",
   `- 始终使用 \`skills/lab/SKILL.md\` 作为工作流合同。\n${zhRecipeQuickPathLine}`
+).replace(
+  "- 用户显式调用 `/lab:<stage>` 时，要立刻执行该 stage，而不是只推荐别的 `/lab` stage。\n",
+  "- 用户只要显式调用某个 stage，无论写成 `/lab:<stage>`、`/lab: <stage>`、`/lab <stage>`、`/lab-<stage>` 还是 `/lab：<stage>`，都要立刻执行该 stage，而不是只推荐别的 `/lab` stage。\n"
 );
 
 ZH_CONTENT[path.join(".claude", "commands", "lab.md")] = ZH_CONTENT[
   path.join(".claude", "commands", "lab.md")
 ].replace(
+  "\n\n## 阶段别名\n\n",
+  "\n\n## 可接受的阶段写法\n\n- `/lab:idea ...`、`/lab: idea ...`、`/lab idea ...`、`/lab-idea`、`/lab：idea ...`\n- `/lab:data ...`、`/lab: data ...`、`/lab data ...`、`/lab-data`、`/lab：data ...`\n- `/lab:auto ...`、`/lab: auto ...`、`/lab auto ...`、`/lab-auto`、`/lab：auto ...`\n- `/lab:framing ...`、`/lab: framing ...`、`/lab framing ...`、`/lab-framing`、`/lab：framing ...`\n- `/lab:spec ...`、`/lab: spec ...`、`/lab spec ...`、`/lab-spec`、`/lab：spec ...`\n- `/lab:run ...`、`/lab: run ...`、`/lab run ...`、`/lab-run`、`/lab：run ...`\n- `/lab:iterate ...`、`/lab: iterate ...`、`/lab iterate ...`、`/lab-iterate`、`/lab：iterate ...`\n- `/lab:review ...`、`/lab: review ...`、`/lab review ...`、`/lab-review`、`/lab：review ...`\n- `/lab:report ...`、`/lab: report ...`、`/lab report ...`、`/lab-report`、`/lab：report ...`\n- `/lab:write ...`、`/lab: write ...`、`/lab write ...`、`/lab-write`、`/lab：write ...`\n\n## 阶段别名\n\n"
+).replace(
   "- 始终使用 `skills/lab/SKILL.md` 作为工作流合同。\n",
   `- 始终使用 \`skills/lab/SKILL.md\` 作为工作流合同。\n${zhRecipeQuickPathLine}`
+).replace(
+  "- 用户显式调用 `/lab <stage> ...` 或 `/lab-<stage>` 时，要立刻执行该 stage，而不是只推荐别的阶段。\n",
+  "- 用户只要显式调用某个 stage，无论写成 `/lab:<stage>`、`/lab: <stage>`、`/lab <stage>`、`/lab-<stage>` 还是 `/lab：<stage>`，都要立刻执行该 stage，而不是只推荐别的阶段。\n"
 );
 
 ZH_CONTENT[path.join(".codex", "skills", "lab", "SKILL.md")] = `---

package/lib/install.cjs

@@ -1,6 +1,7 @@
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
+const { CURRENT_AUTO_MODE_SCHEMA_FIELDS } = require("./auto_state.cjs");
 const { getLocalizedContent } = require("./i18n.cjs");
 
 const REPO_ROOT = path.resolve(__dirname, "..");
@@ -44,6 +45,7 @@ const PROJECT_OWNED_LOCALIZED_PATHS = [
   path.join(".lab", "context", "eval-protocol.md"),
   path.join(".lab", "context", "auto-mode.md"),
   path.join(".lab", "context", "auto-status.md"),
+  path.join(".lab", "context", "auto-ledger.md"),
   path.join(".lab", "context", "auto-outcome.md"),
   path.join(".lab", "context", "terminology-lock.md"),
   path.join(".lab", "context", "summary.md"),
@@ -131,6 +133,68 @@ function installLabAssets(targetDir, force) {
   );
 }
 
+function autoModeSchemaFieldLine(label, lang) {
+  if (lang === "zh") {
+    const zhDefaults = {
+      "Autonomy level": "- 自治级别: L2",
+      "Approval status": "- 批准状态: draft",
+      "Terminal goal type": "- 终止目标类型: ",
+      "Terminal goal target": "- 终止目标目标值: ",
+      "Required terminal artifact": "- 终止目标工件: ",
+      "Primary gate": "- 主 gate: ",
+      "Secondary guard": "- 次级 guard: ",
+      "Promotion condition": "- 升格条件: ",
+      "Stop reason": "- 停止原因: ",
+      "Escalation reason": "- 升级原因: ",
+    };
+    return zhDefaults[label] || "";
+  }
+
+  const defaults = {
+    "Autonomy level": "- Autonomy level: L2",
+    "Approval status": "- Approval status: draft",
+    "Terminal goal type": "- Terminal goal type: ",
+    "Terminal goal target": "- Terminal goal target: ",
+    "Required terminal artifact": "- Required terminal artifact: ",
+    "Primary gate": "- Primary gate: ",
+    "Secondary guard": "- Secondary guard: ",
+    "Promotion condition": "- Promotion condition: ",
+    "Stop reason": "- Stop reason: ",
+    "Escalation reason": "- Escalation reason: ",
+  };
+  return defaults[label] || "";
+}
+
+function migrateAutoModeContext(targetDir, lang) {
+  const filePath = path.join(targetDir, ".lab", "context", "auto-mode.md");
+  if (!fs.existsSync(filePath)) {
+    return;
+  }
+
+  const existing = fs.readFileSync(filePath, "utf8");
+  const missing = CURRENT_AUTO_MODE_SCHEMA_FIELDS
+    .map(([label]) => label)
+    .filter((label) => {
+      const localizedLabel = autoModeSchemaFieldLine(label, lang).replace(/^- /, "").split(":")[0];
+      return !existing.includes(`${label}:`) && !existing.includes(`${localizedLabel}:`);
+    });
+  if (missing.length === 0) {
+    return;
+  }
+
+  const trimmed = existing.trimEnd();
+  const header =
+    lang === "zh"
+      ? "## Managed schema migration\n\n- 这段由 `superlab update` 补齐，用于把旧版 auto 契约升级到当前 schema。保留现有内容，只补缺失字段。\n"
+      : "## Managed schema migration\n\n- This block was added by `superlab update` to bring a legacy auto contract up to the current schema without overwriting your existing content.\n";
+  const body = missing
+    .map((label) => autoModeSchemaFieldLine(label, lang))
+    .filter(Boolean)
+    .join("\n");
+
+  fs.writeFileSync(filePath, `${trimmed}\n\n${header}${body}\n`);
+}
+
 function ensureConfiguredProjectDirs(targetDir) {
   const workflowConfigPath = path.join(targetDir, ".lab", "config", "workflow.json");
   if (!fs.existsSync(workflowConfigPath)) {
@@ -604,6 +668,7 @@ function installSuperlab({
   writePlatformShims(targetDir, resolvedLang, force);
   writeManagedCoreFile(targetDir, resolvedLang, { force });
   localizeInstalledAssets(targetDir, resolvedLang, { newlyCreatedProjectOwnedPaths });
+  migrateAutoModeContext(targetDir, resolvedLang);
   ensureConfiguredProjectDirs(targetDir);
   chmodScripts(targetDir);
   const metadata = {

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

@@ -7,7 +7,7 @@ argument-hint: autonomous campaign target
 Use the installed `lab` skill at `.claude/skills/lab/SKILL.md`.
 
 Execute the requested `/lab-auto` command against the user's argument now. Do not only recommend another lab stage. If a blocking prerequisite is missing, say exactly what is missing and ask at most one clarifying question.
-This command runs the `auto` stage of the lab workflow. It must read `.lab/context/eval-protocol.md`, `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, and `.lab/context/auto-outcome.md`, enforce the declared terminal goal schema, make the primary gate, secondary guard, promotion condition, stop reason, and escalation reason explicit, orchestrate approved run, iterate, review, and report stages inside that contract, poll long-running work until completion or stop conditions, and write progress plus the final outcome back into `.lab/context/auto-status.md` and `.lab/context/auto-outcome.md`.
+This command runs the `auto` stage of the lab workflow. It must read `.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`, enforce the declared terminal goal schema, make the primary gate, secondary guard, promotion condition, stop reason, and escalation reason explicit, orchestrate approved run, iterate, review, and report stages inside that contract, poll long-running work until completion or stop conditions, and write live owner state plus progress and the final outcome back into `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, and `.lab/context/auto-outcome.md`.
 The first visible block must be `Auto preflight`. That first visible block must list the files read and echo `Autonomy level`, `Approval status`, `Allowed stages`, `Terminal goal`, `Primary gate`, and `Secondary guard` before any execution summary or action plan.
 If the preflight block cannot be completed because any required field is missing, stale, or inconsistent, stop before execution and say exactly which field blocked arming the loop.
 When the repository workflow language is Chinese, summaries, checklist items, task labels, and progress updates should be written in Chinese unless a literal identifier must stay unchanged.

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

@@ -13,6 +13,21 @@ argument-hint: [stage] [target]
 
 Use the same repository artifacts and stage boundaries every time.
 
+## Accepted Stage Spellings
+
+Treat all of these as equivalent stage requests:
+
+- `/lab:idea ...`, `/lab: idea ...`, `/lab idea ...`, `/lab-idea`, `/lab：idea ...`
+- `/lab:data ...`, `/lab: data ...`, `/lab data ...`, `/lab-data`, `/lab：data ...`
+- `/lab:auto ...`, `/lab: auto ...`, `/lab auto ...`, `/lab-auto`, `/lab：auto ...`
+- `/lab:framing ...`, `/lab: framing ...`, `/lab framing ...`, `/lab-framing`, `/lab：framing ...`
+- `/lab:spec ...`, `/lab: spec ...`, `/lab spec ...`, `/lab-spec`, `/lab：spec ...`
+- `/lab:run ...`, `/lab: run ...`, `/lab run ...`, `/lab-run`, `/lab：run ...`
+- `/lab:iterate ...`, `/lab: iterate ...`, `/lab iterate ...`, `/lab-iterate`, `/lab：iterate ...`
+- `/lab:review ...`, `/lab: review ...`, `/lab review ...`, `/lab-review`, `/lab：review ...`
+- `/lab:report ...`, `/lab: report ...`, `/lab report ...`, `/lab-report`, `/lab：report ...`
+- `/lab:write ...`, `/lab: write ...`, `/lab write ...`, `/lab-write`, `/lab：write ...`
+
 ## Stage Aliases
 
 - `/lab idea ...` or `/lab-idea`
@@ -50,7 +65,7 @@ Use the same repository artifacts and stage boundaries every time.
 
 - Always use `skills/lab/SKILL.md` as the workflow contract.
 - Use `skills/lab/references/recipes.md` as the quick path for common stage chains; do not invent new slash commands or aliases from it.
-- When the user explicitly invokes `/lab <stage> ...` or a direct `/lab-<stage>` alias, execute that stage now against the provided argument instead of only recommending another lab stage.
+- When the user explicitly invokes a stage through `/lab:<stage>`, `/lab: <stage>`, `/lab <stage>`, `/lab-<stage>`, or `/lab：<stage>`, execute that stage now against the provided argument instead of only recommending another lab stage.
 - Start by giving the user a concise stage summary. Materialize managed artifacts immediately when the stage contract requires them, then report the output path and next step.
 - When ambiguity matters, ask one clarifying question at a time; when multiple paths are viable, present 2-3 approaches before converging.
 - `spec` is not complete until the approved change is frozen under `.lab/changes/<change-id>/`.
@@ -72,7 +87,8 @@ Use the same repository artifacts and stage boundaries every time.
 - If the request omits the level or mixes it with a paper layer, phase, or table target, `/lab auto` should stop and ask for an explicit autonomy level before arming the loop.
 - The first visible output of a real `/lab auto` run must be `Auto preflight`.
 - 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`, and `.lab/context/auto-outcome.md`, `/lab auto` should stop instead of acting like the loop is armed.
+- 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.
 
 - 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-auto.md

@@ -6,7 +6,7 @@ argument-hint: autonomous campaign target
 Use the installed `lab` skill at `.codex/skills/lab/SKILL.md`.
 
 Execute the requested `/lab:auto` stage against the user's argument now. Do not only recommend another lab stage. If a blocking prerequisite is missing, say exactly what is missing and ask at most one clarifying question.
-This command runs the `/lab:auto` stage. It must read `.lab/context/eval-protocol.md`, `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, and `.lab/context/auto-outcome.md`, enforce the declared terminal goal schema, make the primary gate, secondary guard, promotion condition, stop reason, and escalation reason explicit, orchestrate approved run, iterate, review, and report stages inside that contract, poll long-running work until completion or stop conditions, and write progress plus the final outcome back into `.lab/context/auto-status.md` and `.lab/context/auto-outcome.md`.
+This command runs the `/lab:auto` stage. It must read `.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`, enforce the declared terminal goal schema, make the primary gate, secondary guard, promotion condition, stop reason, and escalation reason explicit, orchestrate approved run, iterate, review, and report stages inside that contract, poll long-running work until completion or stop conditions, and write live owner state plus progress and the final outcome back into `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, and `.lab/context/auto-outcome.md`.
 The first visible block must be `Auto preflight`. That first visible block must list the files read and echo `Autonomy level`, `Approval status`, `Allowed stages`, `Terminal goal`, `Primary gate`, and `Secondary guard` before any execution summary or action plan.
 If the preflight block cannot be completed because any required field is missing, stale, or inconsistent, stop before execution and say exactly which field blocked arming the loop.
 When the repository workflow language is Chinese, summaries, checklist items, task labels, and progress updates should be written in Chinese unless a literal identifier must stay unchanged.

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

@@ -7,7 +7,22 @@ argument-hint: workflow question or stage choice
 
 `/lab` is a strict research workflow command family. Use the same repository artifacts and stage boundaries every time.
 
-## Subcommands
+## Accepted Stage Spellings
+
+Treat all of these as equivalent stage requests:
+
+- `/lab:idea ...`, `/lab: idea ...`, `/lab idea ...`, `/lab-idea`, `/lab：idea ...`
+- `/lab:data ...`, `/lab: data ...`, `/lab data ...`, `/lab-data`, `/lab：data ...`
+- `/lab:auto ...`, `/lab: auto ...`, `/lab auto ...`, `/lab-auto`, `/lab：auto ...`
+- `/lab:framing ...`, `/lab: framing ...`, `/lab framing ...`, `/lab-framing`, `/lab：framing ...`
+- `/lab:spec ...`, `/lab: spec ...`, `/lab spec ...`, `/lab-spec`, `/lab：spec ...`
+- `/lab:run ...`, `/lab: run ...`, `/lab run ...`, `/lab-run`, `/lab：run ...`
+- `/lab:iterate ...`, `/lab: iterate ...`, `/lab iterate ...`, `/lab-iterate`, `/lab：iterate ...`
+- `/lab:review ...`, `/lab: review ...`, `/lab review ...`, `/lab-review`, `/lab：review ...`
+- `/lab:report ...`, `/lab: report ...`, `/lab report ...`, `/lab-report`, `/lab：report ...`
+- `/lab:write ...`, `/lab: write ...`, `/lab write ...`, `/lab-write`, `/lab：write ...`
+
+## Stage Aliases
 
 - `/lab:idea`
   Research the idea through two brainstorm passes and two literature sweeps, define the problem and failure case, compare against closest prior work, then end with a source-backed recommendation and an explicit approval gate before any implementation.
@@ -44,7 +59,7 @@ argument-hint: workflow question or stage choice
 
 - Always use `skills/lab/SKILL.md` as the workflow contract.
 - Use `skills/lab/references/recipes.md` as the quick path for common stage chains; do not invent new slash commands or aliases from it.
-- When the user explicitly invokes `/lab:<stage>`, execute that stage now against the provided argument instead of only recommending another `/lab` stage.
+- When the user explicitly invokes a stage through `/lab:<stage>`, `/lab: <stage>`, `/lab <stage>`, `/lab-<stage>`, or `/lab：<stage>`, execute that stage now against the provided argument instead of only recommending another `/lab` stage.
 - Start by giving the user a concise stage summary. Materialize managed artifacts immediately when the stage contract requires them, then report the output path and next step.
 - When ambiguity matters, ask one clarifying question at a time; when multiple paths are viable, present 2-3 approaches before converging.
 - `/lab:spec` is not complete until the approved change is frozen under `.lab/changes/<change-id>/`.
@@ -66,7 +81,8 @@ argument-hint: workflow question or stage choice
 - If the request omits the level or mixes it with a paper layer, phase, or table target, `/lab:auto` should stop and ask for an explicit autonomy level before arming the loop.
 - The first visible output of a real `/lab:auto` run must be `Auto preflight`.
 - 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`, and `.lab/context/auto-outcome.md`, `/lab:auto` should stop instead of acting like the loop is armed.
+- 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.
 
 - 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-ledger.md

@@ -0,0 +1,35 @@
+# Auto Runtime Ledger
+
+## Campaign
+
+- Campaign id:
+- Objective:
+- Active stage:
+- Active rung:
+
+## Owner
+
+- Owner type:
+- Owner id:
+- Command:
+- Watch target:
+- Started at:
+- Last observed at:
+- Observed state:
+
+## Checkpoints
+
+- Last checkpoint:
+- Checkpoint summary:
+- Next transition:
+
+## Boundaries
+
+- Continue boundary:
+- Stop boundary:
+- Escalation boundary:
+
+## Resume
+
+- Required read set:
+- Resume command:

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

@@ -3,6 +3,7 @@
 Use this file to define the bounded autonomous execution envelope for `/lab:auto`.
 Pair it with `.lab/context/eval-protocol.md`, which defines the paper-facing metrics, tables, gates, and benchmark ladder that auto mode should optimize against.
 If `eval-protocol.md` declares structured rung entries, auto mode follows those rung transitions first and uses the stage commands here as per-stage fallbacks.
+Use `.lab/context/auto-ledger.md` as the live runtime ledger for ownership, checkpoints, resume, and stop boundaries.
 
 ## Objective
 
@@ -42,6 +43,7 @@ If `eval-protocol.md` declares structured rung entries, auto mode follows those
 - Rung `Command` should be the real long-running command that owns the experiment result.
 - A short watcher is only a progress probe. Do not use a short watcher as the stage or rung command when the real experiment is still running.
 - While the real experiment process is still alive, only record a progress update and keep waiting.
+- Record the active owner, command, and watch target in `.lab/context/auto-ledger.md` while the loop is alive.
 - Run command:
 - Iterate command:
 - Review command:

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

@@ -108,12 +108,13 @@ Use this skill when the user invokes `/lab:*` or asks for the structured researc
 ### `/lab:auto`
 
 - Use this stage to orchestrate approved execution stages with bounded autonomy.
-- Read `.lab/config/workflow.json`, `.lab/context/mission.md`, `.lab/context/state.md`, `.lab/context/workflow-state.md`, `.lab/context/decisions.md`, `.lab/context/data-decisions.md`, `.lab/context/evidence-index.md`, `.lab/context/terminology-lock.md`, `.lab/context/auto-mode.md`, and `.lab/context/auto-status.md` before acting.
-- Treat `.lab/context/auto-mode.md` as the control contract and `.lab/context/auto-status.md` as the live state file.
+- Read `.lab/config/workflow.json`, `.lab/context/mission.md`, `.lab/context/state.md`, `.lab/context/workflow-state.md`, `.lab/context/decisions.md`, `.lab/context/data-decisions.md`, `.lab/context/evidence-index.md`, `.lab/context/terminology-lock.md`, `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, and `.lab/context/auto-ledger.md` before acting.
+- Treat `.lab/context/auto-mode.md` as the control contract, `.lab/context/auto-status.md` as the live summary, and `.lab/context/auto-ledger.md` as the runtime ledger.
 - Require `.lab/context/auto-mode.md` to expose `Primary gate`, `Secondary guard`, `Promotion condition`, `Stop reason`, and `Escalation reason` before execution.
 - Require `Autonomy level` and `Approval status` in `.lab/context/auto-mode.md` before execution.
 - Start every `/lab:auto` run with a visible `Auto preflight` summary that reports files read plus `Autonomy level`, `Approval status`, `Allowed stages`, `Terminal goal`, `Primary gate`, and `Secondary guard`.
 - If any required preflight field is missing or inconsistent, stop before any loop action. Do not present a fake auto summary as if the loop were armed.
+- Keep `.lab/context/auto-ledger.md` updated with the active owner, observed state, and resume boundary while the loop is live.
 - Treat `L1` as safe-run validation, `L2` as bounded iteration, and `L3` as aggressive campaign mode.
 - Surface the level guide every time `/lab:auto` starts, and make the detailed guide mandatory when the user omits the level or mixes it with a paper layer, phase, or table target.
 - Reuse `/lab:run`, `/lab:iterate`, `/lab:review`, `/lab:report`, and optional `/lab:write` instead of inventing a second workflow.

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

@@ -22,6 +22,7 @@
 - `.lab/context/terminology-lock.md`
 - `.lab/context/auto-mode.md`
 - `.lab/context/auto-status.md`
+- `.lab/context/auto-ledger.md`
 - `.lab/context/auto-outcome.md`
 
 ## Context Write Set
@@ -36,6 +37,7 @@
 - `.lab/context/summary.md`
 - `.lab/context/session-brief.md`
 - `.lab/context/auto-status.md`
+- `.lab/context/auto-ledger.md`
 - `.lab/context/auto-outcome.md`
 
 ## Boundary Rules
@@ -48,6 +50,7 @@
 - Treat `Sanity and Alternative-Explanation Checks` as the anomaly gate for automation. When a rung yields all-null outputs, suspiciously identical runs, no-op deltas, or impl/result mismatches, pause promotion logic until implementation reality checks, alternative explanations, and at least one cross-check are recorded.
 - Treat paper-template selection as an explicit write-time gate, not as a silent fallback, when the loop is about to create `.tex` deliverables for the first time.
 - Treat `.lab/context/auto-mode.md` as a visible control plane. The contract should make the primary gate, secondary guard, promotion condition, stop reason, and escalation reason explicit before execution starts.
+- Treat `.lab/context/auto-ledger.md` as the live runtime ledger for owner identity, observed state, checkpoint progress, continue boundary, stop boundary, escalation boundary, and resume read set.
 - The contract must declare `Autonomy level` and `Approval status`, and execution starts only when approval is explicitly set to `approved`.
 - The contract must also declare a concrete terminal goal:
   - `rounds`
@@ -72,6 +75,11 @@
 - Keep a poll-based waiting loop instead of sleeping blindly.
 - 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:
+  - `local-process`
+  - `local-runner`
+  - `remote-runner`
+- Every nonterminal `/lab:auto` state must remain resumable from `.lab/context/auto-ledger.md` plus `.lab/context/auto-status.md`.
 - Start every real `/lab:auto` run with a visible `Auto preflight` block before any execution summary or action plan. That first visible output should list:
   - files read
   - `Autonomy level`
@@ -82,6 +90,7 @@
   - `Secondary guard`
 - If any of those preflight fields are missing, stale, or inconsistent, stop before execution and report the blocking field directly.
 - Always write a canonical `.lab/context/auto-outcome.md` when the run completes, stops, or fails.
+- Always keep `.lab/context/auto-ledger.md` in sync with the current active owner while the loop is live.
 - Keep handoff wording stable across auto outcomes and downstream report or write handoffs: record completed work, frozen scope, allowed next action, required read set for the next owner, and the accept or revise or reject boundary.
 - When the evaluation protocol declares structured ladder rungs, execute them as a foreground rung state machine:
   - each rung must declare `Stage`, `Goal`, `Command`, `Watch`, `Gate`, `On pass`, `On fail`, and `On stop`

package/package.json

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