superlab 0.1.45 → 0.1.47

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>] [--autonomy-level <L1|L2|L3>]
   superlab auto status [--target <dir>]
   superlab auto stop [--target <dir>]
   superlab update [--target <dir>]
@@ -222,10 +222,38 @@ 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: "",
+    requestedAutonomyLevel: "",
   };
+
+  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 if (action === "start" && value === "--autonomy-level") {
+      options.requestedAutonomyLevel = (rest[index + 1] || "").trim();
+      index += 1;
+    } else {
+      throw new Error(`Unknown option: ${value}`);
+    }
+  }
+
+  return options;
 }
 
 function printVersion(options) {
@@ -963,7 +991,15 @@ 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,
+          autonomyLevel: options.requestedAutonomyLevel,
+        },
+      });
       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

@@ -6,6 +6,7 @@ const {
   extractValue,
   isMeaningful,
   normalizeList,
+  normalizeScalar,
   parseInteger,
   readFileIfExists,
   readWorkflowConfig,
@@ -43,6 +44,147 @@ 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(),
+    autonomyLevel: normalizeScalar(requested.autonomyLevel || ""),
+    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 +522,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: requested.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

@@ -2180,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-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`，不要只推荐别的 `/lab` 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\n\n先把用户请求规范化成可交给 CLI 的 auto contract 字段：objective、autonomy level、campaign kind、allowed stages，以及任何不改变范围就能明确的 terminal-goal 提示。\n你的第一步执行动作必须是对当前项目运行 `superlab auto start`，而不是自己直接改写 `.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 或 `.lab/context/auto-outcome.md`。\n把规范化后的字段通过 CLI 参数传下去，包括 `--objective`、`--campaign-kind`、`--allowed-stages`，以及在用户已明确或已隐含时传 `--autonomy-level`。\nCLI 返回后的 runtime 结果才是事实来源。如果 CLI 报 rollover、conflict、缺字段，或已经成功启动 campaign，就如实回报，不要绕过 CLI 自己做 prompt 侧写回。\n\n本命令运行 `/lab:auto` 阶段。它必须读取 `.lab/context/eval-protocol.md`、`.lab/context/auto-mode.md`、`.lab/context/auto-status.md`、`.lab/context/auto-ledger.md` 与 `.lab/context/auto-outcome.md`，先确认 autonomy level、approval status、terminal goal schema，以及 primary gate、secondary guard、promotion condition、stop reason、escalation reason，再把 eval-protocol 里的指标释义、主表计划、来源约束与结构化实验阶梯当作执行依据，在不修改 mission、framing 和核心 claims 的前提下编排已批准的 `run`、`iterate`、`review`、`report`，轮询长任务完成情况；如果声明了 rung，就保持会话活着并按 rung 转移继续推进。\n首个可见输出块必须是 `Auto preflight`。这个块必须列出已读取文件，并回显 `Autonomy level`、`Approval status`、`Allowed stages`、`Terminal goal`、`Primary gate` 和 `Secondary guard`，然后才能进入执行摘要或动作计划。\n如果 preflight 所需字段缺失、过期或彼此冲突，就必须在执行前停下，并明确指出到底是哪一个字段阻止了 loop 启动。\n当 loop 活着时，必须把当前 owner、观察状态、checkpoint 摘要、继续边界、停止边界和恢复读取集合写进 `.lab/context/auto-ledger.md`。\n如果仓库的 workflow language 是中文，摘要、清单条目、任务标签和进度更新都必须使用中文，除非某个文件路径、代码标识符或字面指标名必须保持原样。\n把 `Layer 3`、`Phase 1`、`Table 2` 这类表达视为论文范围目标；只有显式写成 `Autonomy level L3` 或 `自治级别 L3` 时，才把它当成执行权限级别。\n不要用 `sleep 30`、单次 `pgrep` 或一次性的 `metrics.json` 探针来代替真实长任务命令；当真实实验进程还活着时，只允许发进度更新并继续等待。"
 );
 
 ZH_CONTENT[path.join(".claude", "commands", "lab.md")] = claudeCommand(
@@ -2201,7 +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-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立刻针对用户当前给出的参数执行 `auto` 阶段，不要只推荐别的 lab 阶段。只有在缺少阻塞性前提时，才明确指出缺什么，并且一次最多追问一个问题。\n\n先把用户请求规范化成可交给 CLI 的 auto contract 字段：objective、autonomy level、campaign kind、allowed stages，以及任何不改变范围就能明确的 terminal-goal 提示。\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 zhRecipeQuickPathLine =

package/lib/install.cjs

@@ -1,7 +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 { CURRENT_AUTO_MODE_MIGRATION_FIELDS } = require("./auto_state.cjs");
 const { getLocalizedContent } = require("./i18n.cjs");
 
 const REPO_ROOT = path.resolve(__dirname, "..");
@@ -156,6 +156,9 @@ function installLabAssets(targetDir, force) {
 function autoModeSchemaFieldLine(label, lang) {
   if (lang === "zh") {
     const zhDefaults = {
+      "Campaign id": "- Campaign id: ",
+      "Campaign kind": "- 活动类型: ",
+      "Campaign started at": "- 活动开始时间: ",
       "Autonomy level": "- 自治级别: L2",
       "Approval status": "- 批准状态: draft",
       "Terminal goal type": "- 终止目标类型: ",
@@ -171,6 +174,9 @@ function autoModeSchemaFieldLine(label, lang) {
   }
 
   const defaults = {
+    "Campaign id": "- Campaign id: ",
+    "Campaign kind": "- Campaign kind: ",
+    "Campaign started at": "- Campaign started at: ",
     "Autonomy level": "- Autonomy level: L2",
     "Approval status": "- Approval status: draft",
     "Terminal goal type": "- Terminal goal type: ",
@@ -192,7 +198,7 @@ function migrateAutoModeContext(targetDir, lang) {
   }
 
   const existing = fs.readFileSync(filePath, "utf8");
-  const missing = CURRENT_AUTO_MODE_SCHEMA_FIELDS
+  const missing = CURRENT_AUTO_MODE_MIGRATION_FIELDS
     .map(([label]) => label)
     .filter((label) => {
       const localizedLabel = autoModeSchemaFieldLine(label, lang).replace(/^- /, "").split(":")[0];

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

@@ -7,6 +7,10 @@ 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.
+First normalize the user's request into CLI-ready auto contract fields: objective, autonomy level, campaign kind, allowed stages, and any explicit terminal-goal hints that can be inferred without changing scope.
+Your first execution action must be to run `superlab auto start` against the current project instead of directly rewriting `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, or `.lab/context/auto-outcome.md` yourself.
+Pass the normalized fields through CLI flags, including `--objective`, `--campaign-kind`, `--allowed-stages`, and `--autonomy-level` when the user specified or implied them.
+After that CLI handoff, treat the CLI/runtime result as the source of truth. If it reports rollover, conflict, missing contract fields, or a started campaign, reflect that result back to the user instead of bypassing it with prompt-side edits.
 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.

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

@@ -7,6 +7,10 @@ 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.
+First normalize the user's request into CLI-ready auto contract fields: objective, autonomy level, campaign kind, allowed stages, and any explicit terminal-goal hints that can be inferred without changing scope.
+Your first execution action must be to run `superlab auto start` against the current project instead of directly rewriting `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, or `.lab/context/auto-outcome.md` yourself.
+Pass the normalized fields through CLI flags, including `--objective`, `--campaign-kind`, `--allowed-stages`, and `--autonomy-level` when the user specified or implied them.
+After that CLI handoff, treat the CLI/runtime result as the source of truth. If it reports rollover, conflict, missing contract fields, or a started campaign, reflect that result back to the user instead of bypassing it with prompt-side edits.
 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.

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

@@ -7,6 +7,10 @@ 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.
+First normalize the user's request into CLI-ready auto contract fields: objective, autonomy level, campaign kind, allowed stages, and any explicit terminal-goal hints that can be inferred without changing scope.
+Your first execution action must be to run `superlab auto start` against the current project instead of directly rewriting `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, or `.lab/context/auto-outcome.md` yourself.
+Pass the normalized fields through CLI flags, including `--objective`, `--campaign-kind`, `--allowed-stages`, and `--autonomy-level` when the user specified or implied them.
+After that CLI handoff, treat the CLI/runtime result as the source of truth. If it reports rollover, conflict, missing contract fields, or a started campaign, reflect that result back to the user instead of bypassing it with prompt-side edits.
 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.

package/package-assets/claude/commands/lab/357/274/232auto.md

@@ -7,6 +7,10 @@ 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.
+First normalize the user's request into CLI-ready auto contract fields: objective, autonomy level, campaign kind, allowed stages, and any explicit terminal-goal hints that can be inferred without changing scope.
+Your first execution action must be to run `superlab auto start` against the current project instead of directly rewriting `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, or `.lab/context/auto-outcome.md` yourself.
+Pass the normalized fields through CLI flags, including `--objective`, `--campaign-kind`, `--allowed-stages`, and `--autonomy-level` when the user specified or implied them.
+After that CLI handoff, treat the CLI/runtime result as the source of truth. If it reports rollover, conflict, missing contract fields, or a started campaign, reflect that result back to the user instead of bypassing it with prompt-side edits.
 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.

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

@@ -6,6 +6,10 @@ 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.
+First normalize the user's request into CLI-ready auto contract fields: objective, autonomy level, campaign kind, allowed stages, and any explicit terminal-goal hints that can be inferred without changing scope.
+Your first execution action must be to run `superlab auto start` against the current project instead of directly rewriting `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, or `.lab/context/auto-outcome.md` yourself.
+Pass the normalized fields through CLI flags, including `--objective`, `--campaign-kind`, `--allowed-stages`, and `--autonomy-level` when the user specified or implied them.
+After that CLI handoff, treat the CLI/runtime result as the source of truth. If it reports rollover, conflict, missing contract fields, or a started campaign, reflect that result back to the user instead of bypassing it with prompt-side edits.
 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.

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

@@ -6,6 +6,10 @@ 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.
+First normalize the user's request into CLI-ready auto contract fields: objective, autonomy level, campaign kind, allowed stages, and any explicit terminal-goal hints that can be inferred without changing scope.
+Your first execution action must be to run `superlab auto start` against the current project instead of directly rewriting `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, or `.lab/context/auto-outcome.md` yourself.
+Pass the normalized fields through CLI flags, including `--objective`, `--campaign-kind`, `--allowed-stages`, and `--autonomy-level` when the user specified or implied them.
+After that CLI handoff, treat the CLI/runtime result as the source of truth. If it reports rollover, conflict, missing contract fields, or a started campaign, reflect that result back to the user instead of bypassing it with prompt-side edits.
 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.

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

@@ -6,6 +6,10 @@ 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.
+First normalize the user's request into CLI-ready auto contract fields: objective, autonomy level, campaign kind, allowed stages, and any explicit terminal-goal hints that can be inferred without changing scope.
+Your first execution action must be to run `superlab auto start` against the current project instead of directly rewriting `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, or `.lab/context/auto-outcome.md` yourself.
+Pass the normalized fields through CLI flags, including `--objective`, `--campaign-kind`, `--allowed-stages`, and `--autonomy-level` when the user specified or implied them.
+After that CLI handoff, treat the CLI/runtime result as the source of truth. If it reports rollover, conflict, missing contract fields, or a started campaign, reflect that result back to the user instead of bypassing it with prompt-side edits.
 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.

package/package-assets/codex/prompts/lab/357/274/232auto.md

@@ -6,6 +6,10 @@ 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.
+First normalize the user's request into CLI-ready auto contract fields: objective, autonomy level, campaign kind, allowed stages, and any explicit terminal-goal hints that can be inferred without changing scope.
+Your first execution action must be to run `superlab auto start` against the current project instead of directly rewriting `.lab/context/auto-mode.md`, `.lab/context/auto-status.md`, `.lab/context/auto-ledger.md`, or `.lab/context/auto-outcome.md` yourself.
+Pass the normalized fields through CLI flags, including `--objective`, `--campaign-kind`, `--allowed-stages`, and `--autonomy-level` when the user specified or implied them.
+After that CLI handoff, treat the CLI/runtime result as the source of truth. If it reports rollover, conflict, missing contract fields, or a started campaign, reflect that result back to the user instead of bypassing it with prompt-side edits.
 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.

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

@@ -7,6 +7,9 @@ Use `.lab/context/auto-ledger.md` as the live runtime ledger for ownership, chec
 
 ## Objective
 
+- Campaign id:
+- Campaign kind:
+- Campaign started at:
 - Objective: 
 - Autonomy level: L2
 - Autonomy level controls execution privilege, not paper layer or table number.

package/package.json

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