superlab 0.1.44 → 0.1.46

package/bin/superlab.cjs

@@ -39,7 +39,7 @@ Usage:
   superlab init [--target <dir>] [--platform codex|claude|both|all] [--lang en|zh] [--force]
   superlab install [--target <dir>] [--platform codex|claude|both|all] [--lang en|zh] [--force]
   superlab paper attach-template --path <dir> [--target <dir>]
-  superlab auto start [--target <dir>]
+  superlab auto start [--target <dir>] [--objective <text>] [--campaign-kind <kind>] [--allowed-stages <csv>]
   superlab auto status [--target <dir>]
   superlab auto stop [--target <dir>]
   superlab update [--target <dir>]
@@ -222,10 +222,34 @@ function parseAutoArgs(argv) {
   if (!["start", "status", "stop"].includes(action || "")) {
     throw new Error(`Unknown auto action: ${action || "(missing)"}`);
   }
-  return {
+  const options = {
     action,
-    ...parseTargetOnlyArgs(rest),
+    targetDir: process.cwd(),
+    requestedObjective: "",
+    requestedCampaignKind: "",
+    requestedAllowedStages: "",
   };
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const value = rest[index];
+    if (value === "--target") {
+      options.targetDir = path.resolve(rest[index + 1]);
+      index += 1;
+    } else if (action === "start" && value === "--objective") {
+      options.requestedObjective = rest[index + 1] || "";
+      index += 1;
+    } else if (action === "start" && value === "--campaign-kind") {
+      options.requestedCampaignKind = rest[index + 1] || "";
+      index += 1;
+    } else if (action === "start" && value === "--allowed-stages") {
+      options.requestedAllowedStages = rest[index + 1] || "";
+      index += 1;
+    } else {
+      throw new Error(`Unknown option: ${value}`);
+    }
+  }
+
+  return options;
 }
 
 function printVersion(options) {
@@ -963,7 +987,14 @@ async function main() {
       return;
     }
     if (options.action === "start") {
-      const result = await startAutoMode({ targetDir: options.targetDir });
+      const result = await startAutoMode({
+        targetDir: options.targetDir,
+        requestedContract: {
+          objective: options.requestedObjective,
+          campaignKind: options.requestedCampaignKind,
+          allowedStages: options.requestedAllowedStages,
+        },
+      });
       const verb = result.status.status === "stopped" ? "stopped" : "completed";
       console.log(`auto mode ${verb} in ${options.targetDir}`);
       console.log(`objective: ${result.mode.objective}`);

package/lib/auto_contracts.cjs

@@ -43,6 +43,146 @@ const PROMOTION_CANONICAL_FILES = [
   path.join(".lab", "context", "workflow-state.md"),
 ];
 
+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 inferCampaignKind({ campaignKind = "", allowedStages = [] }) {
+  if (isMeaningful(campaignKind)) {
+    return campaignKind.trim().toLowerCase();
+  }
+  const stageSet = new Set((allowedStages || []).map((stage) => stage.trim().toLowerCase()).filter(Boolean));
+  const hasPlanning = ["idea", "data", "framing", "spec"].some((stage) => stageSet.has(stage));
+  const hasExecution = ["run", "iterate"].some((stage) => stageSet.has(stage));
+  const hasWriteOnly = stageSet.has("write") && !hasExecution;
+
+  if (hasPlanning && !hasExecution) {
+    return "spec";
+  }
+  if (hasExecution) {
+    return "experiment-loop";
+  }
+  if (hasWriteOnly || stageSet.has("report")) {
+    return "report-polish";
+  }
+  return "generic";
+}
+
+function normalizeRequestedAutoContract(requested = {}) {
+  const allowedStages = Array.isArray(requested.allowedStages)
+    ? requested.allowedStages.map((stage) => String(stage).trim().toLowerCase()).filter(Boolean)
+    : normalizeList(requested.allowedStages || "").map((stage) => stage.toLowerCase());
+  return {
+    objective: (requested.objective || "").trim(),
+    campaignKind:
+      isMeaningful(requested.campaignKind || "") || allowedStages.length > 0
+        ? inferCampaignKind({
+            campaignKind: requested.campaignKind || "",
+            allowedStages,
+          })
+        : "",
+    allowedStages,
+  };
+}
+
+function sameStageSet(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  const leftSet = new Set(left);
+  return right.every((value) => leftSet.has(value));
+}
+
+function hasLiveOwner(status, ledger) {
+  const normalizedStatus = (status.status || "").trim().toLowerCase();
+  const observedState = (ledger.observedState || "").trim().toLowerCase();
+  if ((ledger.ownerType || "").trim().toLowerCase() === "local-process" && isLocalProcessAlive(ledger.ownerId)) {
+    return true;
+  }
+  if (["local-runner", "remote-runner"].includes((ledger.ownerType || "").trim().toLowerCase())) {
+    return ["running", "retrying", "resuming", "checkpointed"].includes(observedState);
+  }
+  return normalizedStatus === "running" || ["running", "retrying", "resuming"].includes(observedState);
+}
+
+function classifyAutoContractFit({ mode, status, ledger, requested }) {
+  const normalizedRequest = normalizeRequestedAutoContract(requested);
+  const requestIsEmpty =
+    !isMeaningful(normalizedRequest.objective) &&
+    !isMeaningful(normalizedRequest.campaignKind) &&
+    normalizedRequest.allowedStages.length === 0;
+  const currentCampaignKind = inferCampaignKind(mode);
+  if (requestIsEmpty) {
+    return {
+      classification: "fit",
+      reason: "no requested contract override",
+      currentCampaignKind,
+      requestedCampaignKind: "",
+    };
+  }
+
+  const requestedCampaignKind = normalizedRequest.campaignKind || currentCampaignKind;
+  const requestedStages = normalizedRequest.allowedStages.length > 0
+    ? normalizedRequest.allowedStages
+    : mode.allowedStages;
+  const stageOutsideCurrentEnvelope = requestedStages.some((stage) => !mode.allowedStages.includes(stage));
+  const objectiveDiffers =
+    isMeaningful(normalizedRequest.objective) &&
+    isMeaningful(mode.objective) &&
+    normalizedRequest.objective.trim() !== mode.objective.trim();
+  const kindDiffers = requestedCampaignKind !== currentCampaignKind;
+
+  if (hasLiveOwner(status, ledger) && (kindDiffers || stageOutsideCurrentEnvelope || objectiveDiffers)) {
+    return {
+      classification: "live-conflict",
+      reason: "requested campaign conflicts with a live auto campaign",
+      currentCampaignKind,
+      requestedCampaignKind,
+    };
+  }
+
+  if (kindDiffers || stageOutsideCurrentEnvelope) {
+    return {
+      classification: "hard-mismatch",
+      reason: stageOutsideCurrentEnvelope
+        ? "requested stages fall outside the current auto-stage envelope"
+        : "requested campaign kind differs from the current auto campaign",
+      currentCampaignKind,
+      requestedCampaignKind,
+    };
+  }
+
+  if (!sameStageSet(requestedStages, mode.allowedStages) || objectiveDiffers) {
+    return {
+      classification: "soft-mismatch",
+      reason: !sameStageSet(requestedStages, mode.allowedStages)
+        ? "requested stages differ but stay inside the current envelope"
+        : "requested objective differs inside the same campaign family",
+      currentCampaignKind,
+      requestedCampaignKind,
+    };
+  }
+
+  return {
+    classification: "fit",
+    reason: "requested campaign matches current auto contract",
+    currentCampaignKind,
+    requestedCampaignKind,
+  };
+}
+
 function resolveFrozenCoreEntries(rawValue) {
   const normalized = normalizeList(rawValue);
   const paths = new Set();
@@ -380,9 +520,14 @@ module.exports = {
   REVIEW_CONTEXT_FILES,
   VALID_APPROVAL_STATUSES,
   VALID_TERMINAL_GOAL_TYPES,
+  classifyAutoContractFit,
   changedSnapshotPaths,
   detectFrozenCoreChanges,
+  hasLiveOwner,
   hashPathState,
+  inferCampaignKind,
+  isLocalProcessAlive,
+  normalizeRequestedAutoContract,
   resolveFrozenCoreEntries,
   resolveStageCommand,
   snapshotFrozenCore,

package/lib/auto_runner.cjs

@@ -1,4 +1,5 @@
 const fs = require("node:fs");
+const path = require("node:path");
 const { spawn } = require("node:child_process");
 const { refreshContext } = require("./context.cjs");
 const { parseEvalProtocol, validateEvalProtocol } = require("./eval_protocol.cjs");
@@ -9,7 +10,11 @@ const {
   sleep,
 } = require("./auto_common.cjs");
 const {
+  classifyAutoContractFit,
   detectFrozenCoreChanges,
+  inferCampaignKind,
+  isLocalProcessAlive,
+  normalizeRequestedAutoContract,
   resolveStageCommand,
   snapshotFrozenCore,
   snapshotPaths,
@@ -28,6 +33,7 @@ const {
   readWorkflowLanguage,
   resolveRequiredArtifact,
   writeAutoLedger,
+  writeAutoMode,
   writeAutoOutcome,
   writeAutoStatus,
 } = require("./auto_state.cjs");
@@ -48,22 +54,6 @@ 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,
@@ -143,6 +133,146 @@ function resolveResumePlan({ mode, evalProtocol, status, ledger, now }) {
   return { blockingIssue: "", resumePlan: null };
 }
 
+function makeCampaignId({ requested, now }) {
+  const raw = isMeaningful(requested.campaignKind)
+    ? `${requested.campaignKind}-${now.toISOString()}`
+    : `auto-${now.toISOString()}`;
+  return raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+function archiveAutoArtifact(targetDir, relativePath, campaignId, now) {
+  const absolutePath = path.join(targetDir, relativePath);
+  if (!fs.existsSync(absolutePath)) {
+    return "";
+  }
+  const archiveDir = path.join(targetDir, ".lab", "context", "archive");
+  fs.mkdirSync(archiveDir, { recursive: true });
+  const baseName = path.basename(relativePath);
+  const archivePath = path.join(
+    archiveDir,
+    `${now.toISOString().slice(0, 10)}-${campaignId}-${baseName}`
+  );
+  fs.copyFileSync(absolutePath, archivePath);
+  return archivePath;
+}
+
+function buildRolledOverAutoMode(mode, requested, now) {
+  const allowedStages = requested.allowedStages.length > 0 ? requested.allowedStages : mode.allowedStages;
+  const campaignKind = requested.campaignKind || inferCampaignKind({ allowedStages });
+  return {
+    campaignId: makeCampaignId({ requested: { ...requested, campaignKind }, now }),
+    campaignKind,
+    campaignStartedAt: now.toISOString(),
+    objective: requested.objective || mode.objective,
+    autonomyLevel: mode.autonomyLevel || "l2",
+    approvalStatus: "draft",
+    allowedStages,
+    successCriteria: "",
+    terminalGoalType: "",
+    terminalGoalTarget: "",
+    requiredTerminalArtifact: "",
+    primaryGate: "",
+    secondaryGuard: "",
+    promotionCondition: "",
+    stopReason: "",
+    escalationReason: "",
+    maxIterations: mode.maxIterations,
+    maxWallClockTime: mode.maxWallClockTime,
+    maxFailures: mode.maxFailures,
+    pollInterval: mode.pollInterval,
+    stageCommands: {
+      run: "",
+      iterate: "",
+      review: "",
+      report: "",
+      write: "",
+    },
+    successCheckCommand: "",
+    stopCheckCommand: mode.stopCheckCommand,
+    promotionCheckCommand: "",
+    promotionCommand: "",
+    promotionPolicy: "",
+    frozenCore: mode.frozenCore,
+    explorationEnvelope: "",
+    stopConditions: "",
+    escalationConditions: "",
+  };
+}
+
+function rolloverAutoCampaign({ targetDir, mode, status, ledger, requested, lang, now }) {
+  const newMode = buildRolledOverAutoMode(mode, requested, now);
+  const archivedPaths = [
+    archiveAutoArtifact(targetDir, path.join(".lab", "context", "auto-mode.md"), mode.campaignId || "auto-campaign", now),
+    archiveAutoArtifact(targetDir, path.join(".lab", "context", "auto-status.md"), mode.campaignId || "auto-campaign", now),
+  ].filter(Boolean);
+
+  const hasMeaningfulLedger = [
+    ledger.campaignId,
+    ledger.ownerType,
+    ledger.ownerId,
+    ledger.observedState,
+    ledger.activeRung,
+  ].some((value) => isMeaningful(value));
+  if (hasMeaningfulLedger) {
+    const archivedLedger = archiveAutoArtifact(
+      targetDir,
+      path.join(".lab", "context", "auto-ledger.md"),
+      mode.campaignId || "auto-campaign",
+      now
+    );
+    if (archivedLedger) {
+      archivedPaths.push(archivedLedger);
+    }
+  }
+
+  writeAutoMode(targetDir, newMode, { lang });
+  writeAutoStatus(
+    targetDir,
+    {
+      status: "idle",
+      currentStage: "",
+      currentCommand: "",
+      activeRunId: "",
+      iterationCount: "0",
+      currentRung: "",
+      watchTarget: "",
+      nextRung: "",
+      startedAt: "",
+      lastHeartbeat: now.toISOString(),
+      lastCheckpoint: "",
+      lastSummary: `rolled over from previous auto campaign${archivedPaths.length > 0 ? `; archived: ${archivedPaths.join(", ")}` : ""}`,
+      decision: "fill the new auto-mode contract and approve it before starting the next campaign",
+    },
+    { lang }
+  );
+  writeAutoLedger(
+    targetDir,
+    {
+      campaignId: newMode.campaignId,
+      objective: newMode.objective,
+      activeStage: "",
+      activeRung: "",
+      ownerType: "",
+      ownerId: "",
+      command: "",
+      watchTarget: "",
+      startedAt: "",
+      lastObservedAt: now.toISOString(),
+      observedState: "draft",
+      lastCheckpoint: "",
+      checkpointSummary: "new campaign draft created by controlled rollover",
+      nextTransition: "",
+      continueBoundary: "Fill and approve the new contract before starting the campaign.",
+      stopBoundary: "",
+      escalationBoundary: "",
+      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 }
+  );
+  return { newMode, archivedPaths };
+}
+
 async function runCommandWithPolling({
   targetDir,
   stage,
@@ -333,17 +463,51 @@ async function evaluateTerminalGoal({ mode, iteration, targetDir, deadlineMs })
   };
 }
 
-async function startAutoMode({ targetDir, now = new Date() }) {
+async function startAutoMode({ targetDir, now = new Date(), requestedContract = null }) {
   const mode = parseAutoMode(targetDir);
   const existingStatus = parseAutoStatus(targetDir);
   const existingLedger = parseAutoLedger(targetDir);
   const evalProtocol = parseEvalProtocol(targetDir);
+  const lang = readWorkflowLanguage(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`
     );
   }
+  if (requestedContract) {
+    const fit = classifyAutoContractFit({
+      mode,
+      status: existingStatus,
+      ledger: existingLedger,
+      requested: requestedContract,
+    });
+    if (fit.classification === "live-conflict") {
+      throw new Error(
+        `requested auto campaign conflicts with the current live campaign; stop the live campaign before rolling over (current: ${fit.currentCampaignKind}, requested: ${fit.requestedCampaignKind})`
+      );
+    }
+    if (fit.classification === "hard-mismatch") {
+      const normalizedRequest = normalizeRequestedAutoContract(requestedContract);
+      const { newMode, archivedPaths } = rolloverAutoCampaign({
+        targetDir,
+        mode,
+        status: existingStatus,
+        ledger: existingLedger,
+        requested: normalizedRequest,
+        lang,
+        now,
+      });
+      throw new Error(
+        `current auto contract does not fit the requested campaign and was rolled over to a new draft (${newMode.campaignId}); archived old campaign files: ${archivedPaths.join(", ")}; fill the new contract fields and approve it before starting auto mode`
+      );
+    }
+    if (fit.classification === "soft-mismatch") {
+      throw new Error(
+        `current auto contract only partially fits the requested campaign: ${fit.reason}; update auto-mode.md or narrow the request before starting auto mode`
+      );
+    }
+  }
   const issues = validateAutoMode(mode, null, evalProtocol);
   if (issues.length > 0) {
     throw new Error(issues.join(" | "));
@@ -366,7 +530,6 @@ async function startAutoMode({ targetDir, now = new Date() }) {
     throw new Error(blockingIssue);
   }
 
-  const lang = readWorkflowLanguage(targetDir);
   const timestamp = now.toISOString();
   const status = {
     status: "running",

package/lib/auto_state.cjs

@@ -16,6 +16,9 @@ function parseAutoMode(targetDir) {
   return {
     path: contextFile(targetDir, "auto-mode.md"),
     text,
+    campaignId: extractValue(text, ["Campaign id", "Campaign ID", "活动 id"]),
+    campaignKind: normalizeScalar(extractValue(text, ["Campaign kind", "活动类型"])),
+    campaignStartedAt: extractValue(text, ["Campaign started at", "活动开始时间"]),
     objective: extractValue(text, ["Objective", "目标"]),
     autonomyLevel: normalizeScalar(extractValue(text, ["Autonomy level", "自治级别"])),
     approvalStatus: normalizeScalar(extractValue(text, ["Approval status", "批准状态"])),
@@ -52,7 +55,10 @@ function parseAutoMode(targetDir) {
   };
 }
 
-const CURRENT_AUTO_MODE_SCHEMA_FIELDS = [
+const CURRENT_AUTO_MODE_MIGRATION_FIELDS = [
+  ["Campaign id", "campaignId"],
+  ["Campaign kind", "campaignKind"],
+  ["Campaign started at", "campaignStartedAt"],
   ["Autonomy level", "autonomyLevel"],
   ["Approval status", "approvalStatus"],
   ["Terminal goal type", "terminalGoalType"],
@@ -65,12 +71,22 @@ const CURRENT_AUTO_MODE_SCHEMA_FIELDS = [
   ["Escalation reason", "escalationReason"],
 ];
 
+const CURRENT_AUTO_MODE_SCHEMA_FIELDS = CURRENT_AUTO_MODE_MIGRATION_FIELDS.filter(
+  ([label]) => !["Campaign id", "Campaign kind", "Campaign started at"].includes(label)
+);
+
 function listMissingCurrentAutoModeFields(mode) {
   return CURRENT_AUTO_MODE_SCHEMA_FIELDS
     .filter(([, key]) => !isMeaningful(mode[key]))
     .map(([label]) => label);
 }
 
+function listMissingMigratedAutoModeFields(mode) {
+  return CURRENT_AUTO_MODE_MIGRATION_FIELDS
+    .filter(([, key]) => !isMeaningful(mode[key]))
+    .map(([label]) => label);
+}
+
 function parseAutoStatus(targetDir) {
   const text = readFileIfExists(contextFile(targetDir, "auto-status.md"));
   return {
@@ -392,18 +408,147 @@ function resolveRequiredArtifact(targetDir, configuredPath) {
   };
 }
 
+function renderAutoModeContract(mode, { lang = "en" } = {}) {
+  const allowedStages = Array.isArray(mode.allowedStages) ? mode.allowedStages.join(", ") : (mode.allowedStages || "");
+  if (lang === "zh") {
+    return `# 自动模式契约
+
+用这个文件定义 \`/lab:auto\` 的有边界自治执行范围。
+
+## 目标
+
+- Campaign id: ${mode.campaignId || ""}
+- 活动类型: ${mode.campaignKind || ""}
+- 活动开始时间: ${mode.campaignStartedAt || ""}
+- Objective: ${mode.objective || ""}
+- 自治级别: ${mode.autonomyLevel || "L2"}
+- 批准状态: ${mode.approvalStatus || "draft"}
+- 允许阶段: ${allowedStages}
+- 成功标准: ${mode.successCriteria || ""}
+- 终止目标类型: ${mode.terminalGoalType || ""}
+- 终止目标目标值: ${mode.terminalGoalTarget || ""}
+- 终止目标工件: ${mode.requiredTerminalArtifact || ""}
+- 主 gate: ${mode.primaryGate || ""}
+- 次级 guard: ${mode.secondaryGuard || ""}
+- 升格条件: ${mode.promotionCondition || ""}
+- 停止原因: ${mode.stopReason || ""}
+- 升级原因: ${mode.escalationReason || ""}
+
+## 循环预算
+
+- Max iterations: ${mode.maxIterations || ""}
+- Max wall-clock time: ${mode.maxWallClockTime || ""}
+- Max failures: ${mode.maxFailures || ""}
+- Poll interval: ${mode.pollInterval || ""}
+
+## 阶段命令
+
+- Run command: ${mode.stageCommands?.run || ""}
+- Iterate command: ${mode.stageCommands?.iterate || ""}
+- Review command: ${mode.stageCommands?.review || ""}
+- Report command: ${mode.stageCommands?.report || ""}
+- Write command: ${mode.stageCommands?.write || ""}
+- Success check command: ${mode.successCheckCommand || ""}
+- Stop check command: ${mode.stopCheckCommand || ""}
+- Promotion check command: ${mode.promotionCheckCommand || ""}
+- Promotion command: ${mode.promotionCommand || ""}
+
+## 升格策略
+
+- Promotion policy: ${mode.promotionPolicy || ""}
+
+## 边界
+
+- Frozen core: ${mode.frozenCore || ""}
+- Exploration envelope: ${mode.explorationEnvelope || ""}
+
+## 停止条件
+
+- Stop conditions: ${mode.stopConditions || ""}
+- Escalation conditions: ${mode.escalationConditions || ""}
+`;
+  }
+
+  return `# Auto Mode Contract
+
+Use this file to define the bounded autonomous execution envelope for \`/lab:auto\`.
+
+## Objective
+
+- Campaign id: ${mode.campaignId || ""}
+- Campaign kind: ${mode.campaignKind || ""}
+- Campaign started at: ${mode.campaignStartedAt || ""}
+- Objective: ${mode.objective || ""}
+- Autonomy level: ${mode.autonomyLevel || "L2"}
+- Approval status: ${mode.approvalStatus || "draft"}
+- Allowed stages: ${allowedStages}
+- Success criteria: ${mode.successCriteria || ""}
+- 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 || ""}
+
+## Loop Budget
+
+- Max iterations: ${mode.maxIterations || ""}
+- Max wall-clock time: ${mode.maxWallClockTime || ""}
+- Max failures: ${mode.maxFailures || ""}
+- Poll interval: ${mode.pollInterval || ""}
+
+## Stage Commands
+
+- Run command: ${mode.stageCommands?.run || ""}
+- Iterate command: ${mode.stageCommands?.iterate || ""}
+- Review command: ${mode.stageCommands?.review || ""}
+- Report command: ${mode.stageCommands?.report || ""}
+- Write command: ${mode.stageCommands?.write || ""}
+- Success check command: ${mode.successCheckCommand || ""}
+- Stop check command: ${mode.stopCheckCommand || ""}
+- Promotion check command: ${mode.promotionCheckCommand || ""}
+- Promotion command: ${mode.promotionCommand || ""}
+
+## Promotion Policy
+
+- Promotion policy: ${mode.promotionPolicy || ""}
+
+## Boundaries
+
+- Frozen core: ${mode.frozenCore || ""}
+- Exploration envelope: ${mode.explorationEnvelope || ""}
+
+## Stop Conditions
+
+- Stop conditions: ${mode.stopConditions || ""}
+- Escalation conditions: ${mode.escalationConditions || ""}
+`;
+}
+
+function writeAutoMode(targetDir, mode, { lang = "en" } = {}) {
+  const filePath = contextFile(targetDir, "auto-mode.md");
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, renderAutoModeContract(mode, { lang }).trimEnd() + "\n");
+}
+
 module.exports = {
+  CURRENT_AUTO_MODE_MIGRATION_FIELDS,
   CURRENT_AUTO_MODE_SCHEMA_FIELDS,
   listMissingCurrentAutoModeFields,
+  listMissingMigratedAutoModeFields,
   parseAutoLedger,
   parseAutoMode,
   parseAutoStatus,
   readWorkflowLanguage,
   renderAutoLedger,
+  renderAutoModeContract,
   renderAutoOutcome,
   renderAutoStatus,
   resolveRequiredArtifact,
   writeAutoLedger,
+  writeAutoMode,
   writeAutoOutcome,
   writeAutoStatus,
 };

package/lib/i18n.cjs

@@ -2217,7 +2217,7 @@ ZH_CONTENT[path.join(".codex", "prompts", "lab.md")] = ZH_CONTENT[
   `- 始终使用 \`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"
+  "- 用户只要显式调用某个 stage，无论写成 `/lab:<stage>`、`/lab: <stage>`、`/lab <stage>`、`/lab-<stage>` 还是 `/lab：<stage>`，都要立刻执行该 stage，而不是只推荐别的 `/lab` stage。\n- 如果输入看起来像 stage 请求，但又不属于上述受支持写法，就必须停下并要求用户用精确的 stage 名重述，而不是自己猜。\n"
 );
 
 ZH_CONTENT[path.join(".claude", "commands", "lab.md")] = ZH_CONTENT[
@@ -2230,7 +2230,7 @@ ZH_CONTENT[path.join(".claude", "commands", "lab.md")] = ZH_CONTENT[
   `- 始终使用 \`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"
+  "- 用户只要显式调用某个 stage，无论写成 `/lab:<stage>`、`/lab: <stage>`、`/lab <stage>`、`/lab-<stage>` 还是 `/lab：<stage>`，都要立刻执行该 stage，而不是只推荐别的阶段。\n- 如果输入看起来像 stage 请求，但又不属于上述受支持写法，就必须停下并要求用户用精确的 stage 名重述，而不是自己猜。\n"
 );
 
 ZH_CONTENT[path.join(".codex", "skills", "lab", "SKILL.md")] = `---