@zzclub/pipeline 0.10.1 → 0.10.2

package/src/commands/wechat-preview.ts

@@ -0,0 +1,160 @@
+import { spawn } from "child_process";
+import { flagArg, optionalArg, parseArgs } from "../args";
+import { printResult } from "../output";
+import {
+  clearPreviewEntries,
+  getPreviewServerStatus,
+  listPreviewEntries,
+  resolvePreviewHost,
+  resolvePreviewPort,
+  startPreviewServer,
+} from "../wechat-preview/server";
+
+async function openUrl(url: string): Promise<void> {
+  const opener =
+    process.platform === "darwin"
+      ? "open"
+      : process.platform === "win32"
+        ? "cmd"
+        : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    spawn(opener, args, { detached: true, stdio: "ignore" }).unref();
+  } catch {
+    // non-fatal
+  }
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: zzhub-pipeline wechat-preview <subcommand> [options]
+
+Subcommands:
+  serve     Start the singleton local preview server (or print existing URL)
+  status    Show whether the preview server is running
+  open      Open the dashboard in a browser
+  list      List registered preview entries
+  clear     Clear all preview entries
+
+serve options:
+  --host    Bind host (default: 127.0.0.1, env ZZHUB_WECHAT_PREVIEW_HOST)
+  --port    Bind port (default: 18765, env ZZHUB_WECHAT_PREVIEW_PORT)
+  --open    Open the dashboard after start
+  --force   Fail if a server is already running (default: reuse existing)
+
+Environment:
+  ZZHUB_WECHAT_PREVIEW_DIR   Data/lock directory override
+`.trim());
+}
+
+export async function wechatPreview(args: string[]): Promise<void> {
+  const sub = args[0];
+  const rest = args.slice(1);
+  const parsed = parseArgs(rest);
+
+  if (!sub || sub === "help" || sub === "--help" || parsed.help) {
+    printHelp();
+    return;
+  }
+
+  if (sub === "serve") {
+    const host = optionalArg(parsed, "host");
+    const portRaw = optionalArg(parsed, "port");
+    const port = portRaw ? Number(portRaw) : undefined;
+    const open = flagArg(parsed, "open");
+    const force = flagArg(parsed, "force");
+
+    const result = await startPreviewServer({
+      host,
+      port: port !== undefined && Number.isFinite(port) ? port : undefined,
+      open,
+      reuseExisting: !force,
+    });
+
+    if (open) {
+      await openUrl(result.url);
+    }
+
+    printResult({
+      action: "serve",
+      url: result.url,
+      host: result.host,
+      port: result.port,
+      reused: result.reused,
+      message: result.reused
+        ? `Already running at ${result.url}`
+        : `Listening on ${result.url}`,
+    });
+
+    // Keep process alive when we own the server
+    if (!result.reused) {
+      await new Promise<void>(() => {
+        // blocked until SIGINT/SIGTERM
+      });
+    }
+    return;
+  }
+
+  if (sub === "status") {
+    const host = optionalArg(parsed, "host");
+    const portRaw = optionalArg(parsed, "port");
+    const port = portRaw ? Number(portRaw) : undefined;
+    const status = await getPreviewServerStatus({
+      host: host ?? resolvePreviewHost(),
+      port: port !== undefined && Number.isFinite(port) ? port : resolvePreviewPort(),
+    });
+    printResult({ action: "status", ...status });
+    return;
+  }
+
+  if (sub === "open") {
+    const status = await getPreviewServerStatus();
+    if (!status.running || !status.url) {
+      throw new Error(
+        "WeChat preview server is not running. Start with: wechat-preview serve",
+      );
+    }
+    await openUrl(status.url);
+    printResult({ action: "open", url: status.url });
+    return;
+  }
+
+  if (sub === "list") {
+    const status = await getPreviewServerStatus();
+    if (status.running) {
+      // Prefer live server list
+      try {
+        const res = await fetch(`${status.url}/api/entries`);
+        if (res.ok) {
+          printResult({ action: "list", entries: await res.json() });
+          return;
+        }
+      } catch {
+        // fall through to disk
+      }
+    }
+    printResult({ action: "list", entries: listPreviewEntries(), source: "disk" });
+    return;
+  }
+
+  if (sub === "clear") {
+    const status = await getPreviewServerStatus();
+    if (status.running && status.url) {
+      try {
+        const res = await fetch(`${status.url}/api/entries`, { method: "DELETE" });
+        if (res.ok) {
+          const body = (await res.json()) as { cleared?: number };
+          printResult({ action: "clear", cleared: body.cleared ?? 0, via: "server" });
+          return;
+        }
+      } catch {
+        // fall through
+      }
+    }
+    const cleared = clearPreviewEntries();
+    printResult({ action: "clear", cleared, via: "disk" });
+    return;
+  }
+
+  throw new Error(`Unknown wechat-preview subcommand: ${sub}`);
+}

package/src/imgx/runtime.ts

@@ -304,10 +304,30 @@ export function screenshotHtml(options: {
   rmSync(tempShotDir, { recursive: true, force: true });
 }
 
+export class ChromeDumpError extends Error {
+  readonly stderr: string;
+  readonly tempHtmlPath?: string;
+  readonly exitCode: number | null;
+
+  constructor(message: string, options: {
+    stderr: string;
+    tempHtmlPath?: string;
+    exitCode: number | null;
+  }) {
+    super(message);
+    this.name = "ChromeDumpError";
+    this.stderr = options.stderr;
+    this.tempHtmlPath = options.tempHtmlPath;
+    this.exitCode = options.exitCode;
+  }
+}
+
 export function dumpHtmlDom(options: {
   chromePath: string;
   html: string;
   virtualTimeBudgetMs?: number;
+  /** When true, leave the temp shell HTML on disk if Chrome fails (caller must clean up). */
+  keepTempOnError?: boolean;
 }): string {
   const tempHtml = writeTempHtml(injectStaticRenderStyle(options.html));
   const fileUrl = pathToFileURL(tempHtml).href;
@@ -329,12 +349,20 @@ export function dumpHtmlDom(options: {
     stdout: "pipe",
     stderr: "pipe",
   });
-  cleanupTempFile(tempHtml);
   if (result.exitCode !== 0) {
     const stderr = new TextDecoder().decode(result.stderr);
-    throw new Error(`Chrome dump-dom failed:\n${stderr}`);
+    if (!options.keepTempOnError) {
+      cleanupTempFile(tempHtml);
+    }
+    throw new ChromeDumpError(`Chrome dump-dom failed (exit ${result.exitCode}):\n${stderr}`, {
+      stderr,
+      tempHtmlPath: options.keepTempOnError ? tempHtml : undefined,
+      exitCode: result.exitCode,
+    });
   }
-  return new TextDecoder().decode(result.stdout);
+  const dom = new TextDecoder().decode(result.stdout);
+  cleanupTempFile(tempHtml);
+  return dom;
 }
 
 export function cropTop(options: {

package/src/logger.test.ts

@@ -0,0 +1,56 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getDailyLogPath, getLogDir, runWithCommandLog } from "./logger";
+
+describe("pipeline daily logger", () => {
+  const previousLogDir = process.env.ZZHUB_PIPELINE_LOG_DIR;
+  let tempDir: string | null = null;
+
+  afterEach(() => {
+    if (previousLogDir === undefined) {
+      delete process.env.ZZHUB_PIPELINE_LOG_DIR;
+    } else {
+      process.env.ZZHUB_PIPELINE_LOG_DIR = previousLogDir;
+    }
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+      tempDir = null;
+    }
+  });
+
+  test("writes command start/ok markers and console output to the daily log", async () => {
+    tempDir = mkdtempSync(join(tmpdir(), "zzhub-pipeline-log-"));
+    process.env.ZZHUB_PIPELINE_LOG_DIR = tempDir;
+
+    await runWithCommandLog("status", ["--state", "/tmp/x.json"], async () => {
+      console.log("hello-from-status");
+    });
+
+    const logPath = getDailyLogPath();
+    expect(getLogDir()).toBe(tempDir);
+    expect(existsSync(logPath)).toBe(true);
+    const body = readFileSync(logPath, "utf-8");
+    expect(body).toContain("=== START command=status ===");
+    expect(body).toContain("=== OK command=status");
+    expect(body).toContain("[console.log] hello-from-status");
+    expect(body).toContain(`"--state"`);
+  });
+
+  test("records failure stack and rethrows", async () => {
+    tempDir = mkdtempSync(join(tmpdir(), "zzhub-pipeline-log-"));
+    process.env.ZZHUB_PIPELINE_LOG_DIR = tempDir;
+
+    await expect(
+      runWithCommandLog("publish", [], async () => {
+        throw new Error("boom-upload");
+      }),
+    ).rejects.toThrow("boom-upload");
+
+    const body = readFileSync(getDailyLogPath(), "utf-8");
+    expect(body).toContain("=== FAIL command=publish");
+    expect(body).toContain("Error: boom-upload");
+    expect(body).toContain("boom-upload");
+  });
+});

package/src/logger.ts

@@ -0,0 +1,178 @@
+/**
+ * Daily rolling file logger for zzhub-pipeline CLI commands.
+ *
+ * Layout (platform-aware, same base as wechat-preview config dir):
+ *   macOS:  ~/Library/Application Support/zzhub-pipeline/logs/pipeline-YYYY-MM-DD.log
+ *   Linux:  ~/.config/zzhub-pipeline/logs/pipeline-YYYY-MM-DD.log
+ *   Windows: %APPDATA%/zzhub-pipeline/logs/pipeline-YYYY-MM-DD.log
+ *
+ * Override with ZZHUB_PIPELINE_LOG_DIR.
+ */
+
+import { appendFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+
+const APP_DIR = "zzhub-pipeline";
+const LOG_DIR_NAME = "logs";
+const LOG_PREFIX = "pipeline-";
+const LOG_SUFFIX = ".log";
+/** Keep about two weeks of daily files. */
+const LOG_RETENTION_DAYS = 14;
+
+function getBaseConfigDir(): string {
+  const home = homedir();
+  const currentPlatform = platform();
+
+  if (currentPlatform === "win32") {
+    const appData = process.env.APPDATA;
+    if (appData) return join(appData, APP_DIR);
+    return join(home, "AppData", "Roaming", APP_DIR);
+  }
+
+  if (currentPlatform === "darwin") {
+    return join(home, "Library", "Application Support", APP_DIR);
+  }
+
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  if (xdgConfigHome && xdgConfigHome.trim().length > 0) {
+    return join(xdgConfigHome, APP_DIR);
+  }
+
+  return join(home, ".config", APP_DIR);
+}
+
+export function getLogDir(): string {
+  const override = process.env.ZZHUB_PIPELINE_LOG_DIR?.trim();
+  if (override) return override;
+  return join(getBaseConfigDir(), LOG_DIR_NAME);
+}
+
+function formatDateKey(date: Date = new Date()): string {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+export function getDailyLogPath(date: Date = new Date()): string {
+  return join(getLogDir(), `${LOG_PREFIX}${formatDateKey(date)}${LOG_SUFFIX}`);
+}
+
+function ensureLogDir(): string {
+  const dir = getLogDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+function pruneOldLogs(dir: string): void {
+  try {
+    const cutoff = Date.now() - LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+    for (const name of readdirSync(dir)) {
+      if (!name.startsWith(LOG_PREFIX) || !name.endsWith(LOG_SUFFIX)) continue;
+      const key = name.slice(LOG_PREFIX.length, -LOG_SUFFIX.length);
+      // YYYY-MM-DD
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(key)) continue;
+      const stamp = Date.parse(`${key}T00:00:00`);
+      if (!Number.isFinite(stamp) || stamp >= cutoff) continue;
+      unlinkSync(join(dir, name));
+    }
+  } catch {
+    // pruning is best-effort
+  }
+}
+
+export function appendLogLine(message: string, date: Date = new Date()): void {
+  try {
+    const dir = ensureLogDir();
+    pruneOldLogs(dir);
+    const path = getDailyLogPath(date);
+    const line = message.endsWith("\n") ? message : `${message}\n`;
+    appendFileSync(path, line, "utf-8");
+  } catch {
+    // never break CLI for logging failures
+  }
+}
+
+function formatError(err: unknown): string {
+  if (err instanceof Error) {
+    return `${err.name}: ${err.message}${err.stack ? `\n${err.stack}` : ""}`;
+  }
+  return String(err);
+}
+
+type ConsoleMethod = "log" | "info" | "warn" | "error" | "debug";
+
+function installConsoleTee(write: (chunk: string) => void): () => void {
+  const methods: ConsoleMethod[] = ["log", "info", "warn", "error", "debug"];
+  const originals = new Map<ConsoleMethod, (...args: unknown[]) => void>();
+
+  for (const method of methods) {
+    const original = console[method].bind(console);
+    originals.set(method, original);
+    console[method] = (...args: unknown[]) => {
+      original(...args);
+      try {
+        const text = args
+          .map((arg) => {
+            if (typeof arg === "string") return arg;
+            try {
+              return JSON.stringify(arg);
+            } catch {
+              return String(arg);
+            }
+          })
+          .join(" ");
+        write(`[console.${method}] ${text}`);
+      } catch {
+        // ignore
+      }
+    };
+  }
+
+  return () => {
+    for (const method of methods) {
+      const original = originals.get(method);
+      if (original) console[method] = original as typeof console.log;
+    }
+  };
+}
+
+/**
+ * Run a CLI command with daily-file logging.
+ * Captures console output, start/end markers, duration, and full error stacks.
+ */
+export async function runWithCommandLog(
+  command: string,
+  args: string[],
+  handler: () => Promise<void>,
+): Promise<void> {
+  const startedAt = new Date();
+  const startedMs = Date.now();
+  const logPath = getDailyLogPath(startedAt);
+  const write = (message: string) => {
+    appendLogLine(`[${new Date().toISOString()}] ${message}`, startedAt);
+  };
+
+  write(`=== START command=${command} ===`);
+  write(`log_file=${logPath}`);
+  write(`cwd=${process.cwd()}`);
+  write(`argv=${JSON.stringify(args)}`);
+  if (process.env.ZZHUB_PIPELINE_ROOT) {
+    write(`ZZHUB_PIPELINE_ROOT=${process.env.ZZHUB_PIPELINE_ROOT}`);
+  }
+
+  const restoreConsole = installConsoleTee(write);
+  try {
+    await handler();
+    write(`=== OK command=${command} duration_ms=${Date.now() - startedMs} ===`);
+  } catch (err) {
+    write(`=== FAIL command=${command} duration_ms=${Date.now() - startedMs} ===`);
+    write(formatError(err));
+    throw err;
+  } finally {
+    restoreConsole();
+  }
+}

package/src/plugins.ts

@@ -25,6 +25,7 @@ import { syncBlog } from "./commands/sync-blog";
 import { tasks } from "./commands/tasks";
 import { topic } from "./commands/topic";
 import { wechatExport } from "./commands/wechat-export";
+import { wechatPreview } from "./commands/wechat-preview";
 import { wxDrafts } from "./commands/wx-drafts";
 import { wxDraftDelete } from "./commands/wx-draft-delete";
 
@@ -71,6 +72,7 @@ export function getCommandPlugins(): CommandPlugin[] {
         { name: "republish", summary: "Publish completed task to additional accounts/platforms", plugin: "ops", handler: republish },
         { name: "imgx", summary: "Run bundled imgx renderer subcommands", plugin: "ops", handler: imgxCommand },
         { name: "wechat-export", summary: "Render markdown to WeChat HTML with bundled preview styles", plugin: "ops", handler: wechatExport },
+        { name: "wechat-preview", summary: "Local singleton server to preview exported WeChat HTML", plugin: "ops", handler: wechatPreview },
         { name: "cos-upload", summary: "Upload a local image to configured COS CDN", plugin: "ops", handler: cosUpload },
         { name: "config", summary: "Read or update pipeline config", plugin: "ops", handler: configCommand },
         { name: "doctor", summary: "Inspect resolved paths and provider health", plugin: "ops", handler: doctor },

package/src/providers/blog.ts

@@ -141,8 +141,7 @@ export async function publishBlogRoute({
       lines.push(`  - ${tag}`);
     }
   }
-  const author = state.route.content_profile || "default";
-  lines.push(`author: ${author}`);
+  lines.push("author: Kairos");
   lines.push("---");
 
   const bodyWithFrontmatter = `${lines.join("\n")}\n\n${stripFrontmatter(postContent)}`;

package/src/providers/index.ts

@@ -79,7 +79,7 @@ async function publishWechatArticleRoute({
   try {
     const markdownRenderer = await resolveMarkdownRenderer(config);
     const wxAccount = config.wx.accounts[account] ?? config.wx.accounts[config.wx.defaultAccount];
-    const { html } = await markdownRenderer.render({
+    const rendered = await markdownRenderer.render({
       markdownPath: exportPostPath,
       outPath: workspacePaths.zotepadExportHtml,
       account,
@@ -87,6 +87,34 @@ async function publishWechatArticleRoute({
       customCss: resolveConfigRelativePath(wxAccount?.customCss),
       themeOverrides: wxAccount?.theme,
     });
+    const { html } = rendered;
+
+    // Register with local preview server unless explicitly disabled.
+    if (process.env.ZZHUB_WECHAT_PREVIEW_ON_PUBLISH !== "0") {
+      try {
+        const { registerPreviewEntry } = await import("../wechat-preview/server");
+        await registerPreviewEntry(
+          {
+            title: `[publish] ${state.metadata.title || "untitled"}`,
+            account,
+            status: "success",
+            duration_ms: rendered.durationMs ?? 0,
+            markdown_path: exportPostPath,
+            html_path: workspacePaths.zotepadExportHtml,
+            preview_style: rendered.previewStyle,
+            html,
+            debug: {
+              bundle_rebuilt: rendered.bundleRebuilt,
+              bundle_stale: rendered.bundleStale,
+            },
+          },
+          { autoStart: process.env.ZZHUB_WECHAT_PREVIEW_AUTO_START !== "0" },
+        );
+      } catch {
+        // preview registration must never block publish
+      }
+    }
+
     const response = await createWechatDraft({
       account,
       title: state.metadata.title,

package/src/schema/config.ts

@@ -39,6 +39,8 @@ const WechatExportThemeOverridesSchema = z.object({
   fontFamily: z.string().optional(),
   bodyColor: z.string().optional(),
   mutedColor: z.string().optional(),
+  h2Color: z.string().optional(),
+  h3Color: z.string().optional(),
   primaryColor: z.string().optional(),
   dividerColor: z.string().optional(),
   blockquoteBorderColor: z.string().optional(),

package/src/state.ts

@@ -370,6 +370,30 @@ export function reenterPublish(state: WorkflowState): void {
   state.redo_hint = null;
 }
 
+/**
+ * Reset every derived artifact when the core inputs (body, title, route, intent,
+ * explicit constraints) have changed. The run identity (run_id/workspace_root/
+ * state_path) and the current title are preserved; everything produced by
+ * prepare/render/publish is wiped so the workflow re-runs from prepare.
+ *
+ * Used by ingest-handoff resume when it detects an upstream input change.
+ */
+export function resetDerivedState(state: WorkflowState): void {
+  state.mode = "active";
+  state.phase = defaultPhase();
+  state.asset_path = "";
+  state.formatted_body_path = null;
+  state.metadata = {
+    ...defaultMetadata(),
+    title: state.metadata.title,
+  };
+  state.artifacts = defaultArtifacts();
+  state.images = defaultImages();
+  state.publish = defaultPublish();
+  state.content_review = defaultContentReview();
+  state.redo_hint = null;
+}
+
 // ── Run ID ────────────────────────────────────────────────────────
 
 /**

package/src/task-manager.test.ts

@@ -0,0 +1,57 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdtemp, writeFile } from "fs/promises";
+import { join } from "path";
+import { tmpdir } from "os";
+
+import { defaultState, writeState } from "./state";
+import { loadTaskState } from "./task-manager";
+
+const TEST_CONFIG_PATH = join(
+  tmpdir(),
+  `zzhub-pipeline-test-config-loadtask-${process.pid}.json`,
+);
+process.env.ZZHUB_PIPELINE_CONFIG = TEST_CONFIG_PATH;
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return mkdtemp(join(tmpdir(), prefix));
+}
+
+afterAll(async () => {
+  await writeFile(TEST_CONFIG_PATH, "{}", "utf-8").catch(() => undefined);
+});
+
+describe("loadTaskState", () => {
+  test("returns a reconciled view when body_inputs drift from the body on disk", async () => {
+    const workspace = await makeTempDir("zzhub-loadtask-");
+    const statePath = join(workspace, "workflow-state.json");
+    const bodyPath = join(workspace, "post.md");
+
+    const state = defaultState();
+    state.run_id = "run-loadtask";
+    state.workspace_root = workspace;
+    state.state_path = statePath;
+    state.source_body_path = bodyPath;
+    state.route.primary = "wechat-article";
+    state.intent.content_form = "article";
+    state.metadata.title = "T";
+    state.metadata.slug = "t";
+    state.metadata.date = "2026-04-10";
+    state.phase.prepare.status = "done";
+    // State claims one illustration input is pending, but the rewritten body
+    // no longer contains any markers.
+    state.images.body_inputs = {
+      scope: "article",
+      expected: 1,
+      received: [],
+      status: "pending",
+      layout: "staggered",
+    };
+    await writeFile(bodyPath, "# T\n\nBody without any markers", "utf-8");
+    await writeState(statePath, state);
+
+    const resolved = await loadTaskState(statePath);
+
+    expect(resolved.state.images.body_inputs.status).toBe("none");
+    expect(resolved.state.images.body_inputs.expected).toBe(0);
+  });
+});

package/src/task-manager.ts

@@ -5,12 +5,26 @@ import { loadConfig, resolveWorkspacePaths, resolveWorkspaceRoot } from "./confi
 import {
   readResolvedState,
   type PhaseName,
+  type ResolvedState,
   type ValidationError,
   validateForPhase,
   type WorkflowState,
 } from "./state";
 import { reconcileStateArtifacts } from "./workflow-materials";
 
+/**
+ * Load workflow state and apply in-memory artifact reconciliation so every
+ * command sees the same reconciled view of body_inputs/render_assets that
+ * `status` produces. Use this instead of `readResolvedState` in commands that
+ * read state and then make a decision based on it. `writeState`'s own
+ * optimistic re-read deliberately stays un-reconciled.
+ */
+export async function loadTaskState(path: string): Promise<ResolvedState> {
+  const resolved = await readResolvedState(path);
+  await reconcileStateArtifacts(resolved.state);
+  return resolved;
+}
+
 export type TaskFileSource = "run" | "canonical";
 
 export interface TaskGap {
@@ -491,14 +505,18 @@ function buildTaskStatus(summary: TaskSummary, state: WorkflowState): TaskStatus
       },
     };
   } else {
+    // Reached only when prepare/render/publish all report done (or aren't
+    // required) yet mode/phase hasn't advanced to done — an inconsistent state.
+    // Re-running prepare here would reenterPrepare and wipe render_assets,
+    // forcing a wasteful re-render. Route to a read-only checkpoint instead.
     nextAction = {
-      action: "prepare",
-      reason: "Task is active and should continue from the current phase.",
-      executor: "cli",
-      command: `zzhub-pipeline prepare --state "${summary.state_path}"`,
+      action: "checkpoint",
+      reason: "Phases report done but the task is not marked complete; inspect state before mutating it.",
+      executor: "repair",
+      command: `zzhub-pipeline checkpoint --state "${summary.state_path}"`,
       params: {
         state_path: summary.state_path,
-        on_complete: "After the command succeeds, re-run status to determine the next step.",
+        on_complete: "Inspect the checkpoint output, then reset or repair the inconsistent phase before continuing.",
       },
     };
   }