@deployxai/dxc 0.2.5 → 0.3.0

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
 import {
   CONTENT_ARTIFACT_KINDS,
-  CONTENT_STAGE_INPUTS,
+  CONTENT_STAGE_DEFINITIONS,
   CONTENT_WORKFLOW_ID,
   LocalStateError,
   __commonJS,
@@ -15,15 +15,14 @@ import {
   articleBundleSchema,
   contentMemoryAddResultSchema,
   contentMemoryArchiveResultSchema,
+  contentMemoryCorrectResultSchema,
   contentMemoryInputSchema,
   contentMemoryListResultSchema,
   contentMemoryStoreSchema,
   contentProfileInputSchema,
-  contentProfileSaveResultSchema,
   contentProfileSchema,
+  contentProfileSessionResultSchema,
   contentProfileStatusResultSchema,
-  contentProfileUpdateInputSchema,
-  contentProfileUpdateResultSchema,
   contentProjectIndexSchema,
   contentProjectManifestSchema,
   createDeviceBindingSessionResponseSchema,
@@ -38,6 +37,7 @@ import {
   proveDeviceBindingSessionResponseSchema,
   publishingApprovalSchema,
   publishingArticleSchema,
+  publishingDraftAttentionDiagnosticsSchema,
   publishingDraftIntentResponseSchema,
   publishingPreviewLinkSchema,
   publishingPreviewSelectionStateSchema,
@@ -52,7 +52,7 @@ import {
   wechatRenderResultSchema,
   writePrivateBuffer,
   writePrivateJson
-} from "./chunks/chunk-JB5USZ4F.js";
+} from "./chunks/chunk-6JNQZHAQ.js";
 
 // node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err-helpers.js
 var require_err_helpers = __commonJS({
@@ -1306,7 +1306,7 @@ var require_sonic_boom = __commonJS({
       if (!(this instanceof SonicBoom)) {
         return new SonicBoom(opts);
       }
-      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append: append2 = true, mkdir: mkdir5, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append: append2 = true, mkdir: mkdir6, retryEAGAIN, fsync, contentMode, mode } = opts || {};
       fd = fd || dest;
       this._len = 0;
       this.fd = -1;
@@ -1331,7 +1331,7 @@ var require_sonic_boom = __commonJS({
       this.append = append2 || false;
       this.mode = mode;
       this.retryEAGAIN = retryEAGAIN || (() => true);
-      this.mkdir = mkdir5 || false;
+      this.mkdir = mkdir6 || false;
       let fsWriteSync;
       let fsWrite;
       if (contentMode === kContentModeBuffer) {
@@ -23266,7 +23266,7 @@ import os3 from "node:os";
 // apps/cli/package.json
 var package_default = {
   name: "@dxc/cli",
-  version: "0.2.5",
+  version: "0.3.0",
   private: true,
   type: "module",
   bin: {
@@ -26711,13 +26711,78 @@ async function runDoctor(runtime) {
 
 // apps/cli/src/profile.ts
 import { randomUUID } from "node:crypto";
-import { lstat, readFile, rename, stat } from "node:fs/promises";
+import { unlink } from "node:fs/promises";
 import path2 from "node:path";
 var PROFILE_DISPLAY_PATH = "~/.dxc/content-profile.json";
 var MEMORY_DISPLAY_PATH = "~/.dxc/content-memory.json";
 var USER_MEMORY_DISPLAY_PATH = "~/.dxc/USER.md";
 var PROFILE_MAXIMUM_BYTES = 64 * 1024;
 var MEMORY_MAXIMUM_BYTES = 128 * 1024;
+var PROFILE_SESSION_MAXIMUM_BYTES = 32 * 1024;
+var PROFILE_QUESTIONS = [
+  {
+    choices: [
+      { choiceId: "profile_creator.expert", label: "\u4E2A\u4EBA\u4E13\u5BB6\u6216\u987E\u95EE" },
+      { choiceId: "profile_creator.creator", label: "\u804C\u4E1A\u5185\u5BB9\u521B\u4F5C\u8005" },
+      { choiceId: "profile_creator.brand", label: "\u54C1\u724C\u6216\u4F01\u4E1A\u5185\u5BB9\u56E2\u961F" },
+      { choiceId: "profile_creator.educator", label: "\u6559\u80B2\u6216\u57F9\u8BAD\u8005" }
+    ],
+    inputType: "single-choice",
+    prompt: "\u8BF7\u9009\u62E9\u6700\u7B26\u5408\u4F60\u7684\u535A\u4E3B\u8EAB\u4EFD\u3002",
+    questionId: "creator-role"
+  },
+  {
+    choices: [],
+    inputType: "text",
+    prompt: "\u8BF7\u8F93\u5165\u5E0C\u671B\u8BFB\u8005\u770B\u5230\u7684\u540D\u79F0\u6216\u7B14\u540D\u3002",
+    questionId: "display-name"
+  },
+  {
+    choices: [
+      { choiceId: "profile_domain.business", label: "\u5546\u4E1A\u4E0E\u521B\u4E1A" },
+      { choiceId: "profile_domain.technology", label: "\u6280\u672F\u4E0E AI" },
+      { choiceId: "profile_domain.career", label: "\u804C\u573A\u4E0E\u4E2A\u4EBA\u6210\u957F" },
+      { choiceId: "profile_domain.lifestyle", label: "\u751F\u6D3B\u65B9\u5F0F" },
+      { choiceId: "profile_domain.education", label: "\u6559\u80B2\u4E0E\u77E5\u8BC6\u4F20\u64AD" }
+    ],
+    inputType: "multi-choice",
+    prompt: "\u8BF7\u9009\u62E9 1\u20135 \u4E2A\u4E3B\u8981\u5185\u5BB9\u9886\u57DF\u3002",
+    questionId: "primary-domains"
+  },
+  {
+    choices: [
+      { choiceId: "profile_audience.beginner", label: "\u521A\u5F00\u59CB\u4E86\u89E3" },
+      { choiceId: "profile_audience.problem-aware", label: "\u5DF2\u610F\u8BC6\u5230\u95EE\u9898" },
+      { choiceId: "profile_audience.evaluating", label: "\u6B63\u5728\u6BD4\u8F83\u65B9\u6848" },
+      { choiceId: "profile_audience.customer", label: "\u5DF2\u6709\u7ECF\u9A8C\u6216\u5BA2\u6237" }
+    ],
+    inputType: "single-choice",
+    prompt: "\u8BF7\u9009\u62E9\u6838\u5FC3\u8BFB\u8005\u5F53\u524D\u6240\u5904\u9636\u6BB5\u3002",
+    questionId: "target-audience"
+  },
+  {
+    choices: [
+      { choiceId: "profile_value.action", label: "\u7ED9\u4E00\u4E2A\u53EF\u6267\u884C\u7684\u65B9\u6CD5" },
+      { choiceId: "profile_value.explain", label: "\u89E3\u91CA\u590D\u6742\u95EE\u9898" },
+      { choiceId: "profile_value.case", label: "\u63D0\u4F9B\u771F\u5B9E\u6848\u4F8B" },
+      { choiceId: "profile_value.decision", label: "\u5E2E\u52A9\u505A\u51B3\u7B56" },
+      { choiceId: "profile_value.trust", label: "\u5EFA\u7ACB\u4E13\u4E1A\u4FE1\u4EFB" }
+    ],
+    inputType: "single-choice",
+    prompt: "\u8BF7\u9009\u62E9\u5185\u5BB9\u6700\u6838\u5FC3\u7684\u8BFB\u8005\u627F\u8BFA\u3002",
+    questionId: "content-value-promise"
+  },
+  {
+    choices: [
+      { choiceId: "profile_confirmation.guided", label: "\u5173\u952E\u9636\u6BB5\u786E\u8BA4" },
+      { choiceId: "profile_confirmation.review-every-stage", label: "\u6BCF\u4E2A\u5185\u5BB9\u9636\u6BB5\u90FD\u786E\u8BA4" },
+      { choiceId: "profile_confirmation.auto-until-delivery", label: "\u53EA\u5728\u6700\u7EC8\u9884\u89C8\u786E\u8BA4" }
+    ],
+    inputType: "single-choice",
+    prompt: "\u8BF7\u9009\u62E9\u5185\u5BB9\u5DE5\u4F5C\u6D41\u7684\u786E\u8BA4\u65B9\u5F0F\u3002",
+    questionId: "confirmation-policy"
+  }
+];
 var ProfileCliError = class extends Error {
   constructor(code, message, hint, fields) {
     super(message);
@@ -26747,6 +26812,23 @@ function userMemoryPath(homeDirectory) {
 function memoryPath(homeDirectory) {
   return path2.join(homeDirectory, ".dxc", "content-memory.json");
 }
+function profileSessionPath(homeDirectory, profileSessionId) {
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(
+    profileSessionId
+  )) {
+    throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "\u753B\u50CF\u4F1A\u8BDD ID \u65E0\u6548\u3002");
+  }
+  return path2.join(homeDirectory, ".dxc", "profile-sessions", `${profileSessionId}.json`);
+}
+function profileSession(value, expectedId) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || !("version" in value) || value.version !== 1 || !("profileSessionId" in value) || value.profileSessionId !== expectedId || !("index" in value) || !Number.isInteger(value.index) || Number(value.index) < 0 || Number(value.index) > PROFILE_QUESTIONS.length || !("createdAt" in value) || typeof value.createdAt !== "string" || !("answers" in value) || typeof value.answers !== "object" || value.answers === null || Array.isArray(value.answers)) {
+    return void 0;
+  }
+  return value;
+}
+function choiceLabel(questionIndex, choiceId) {
+  return PROFILE_QUESTIONS[questionIndex]?.choices.find((choice) => choice.choiceId === choiceId)?.label;
+}
 function singleLine(value) {
   return value.replace(/[\r\n]+/gu, " ").replace(/\s+/gu, " ").trim();
 }
@@ -26906,149 +26988,133 @@ async function refreshUserMemory(homeDirectory, user, now) {
     Buffer.from(renderUserMemory(user, memory.memories))
   );
 }
-async function readProfileInput(currentDirectory, homeDirectory, inputPath) {
-  try {
-    const target = resolveUserPath({ currentDirectory, homeDirectory, input: inputPath });
-    const metadata = await stat(target);
-    if (!metadata.isFile() || metadata.size > PROFILE_MAXIMUM_BYTES) {
-      throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "Profile input is invalid");
-    }
-    return parseJson(
-      await readFile(target, "utf8"),
-      "DXC_PROFILE_INPUT_INVALID",
-      "Profile input is invalid"
-    );
-  } catch (error) {
-    if (error instanceof ProfileCliError) {
-      throw error;
-    }
-    throw new ProfileCliError(
-      "DXC_PROFILE_INPUT_INVALID",
-      "\u753B\u50CF\u8F93\u5165\u6587\u4EF6\u65E0\u6CD5\u8BFB\u53D6\u6216\u4E0D\u662F\u6709\u6548 JSON\u3002",
-      "\u8BF7\u8BA9 DxC \u5DE5\u4F5C\u6D41\u91CD\u65B0\u751F\u6210\u753B\u50CF\u8F93\u5165\uFF1B\u65E0\u9700\u624B\u52A8\u4FEE\u6539\u8DEF\u5F84\u6216\u5E94\u7528\u6570\u636E\u6587\u4EF6\u3002"
-    );
-  }
-}
-function issueFields(issues) {
-  return [
-    ...new Set(
-      issues.map((issue) => issue.path.map(String).join(".")).filter((field) => field.length > 0)
-    )
-  ];
-}
-async function readProfileForSave(target, timestamp) {
-  try {
-    return await readProfile(target);
-  } catch (error) {
-    if (!(error instanceof ProfileCliError) || error.code !== "DXC_PROFILE_INVALID") {
-      throw error;
-    }
-    try {
-      const metadata = await lstat(target);
-      if (!metadata.isFile() || metadata.isSymbolicLink()) {
-        throw error;
-      }
-      const suffix = timestamp.replaceAll(":", "-");
-      await rename(target, `${target}.invalid-${suffix}.bak`);
-      return void 0;
-    } catch (recoveryError) {
-      if (recoveryError === error) {
-        throw error;
-      }
-      throw new ProfileCliError(
-        "DXC_PROFILE_INVALID",
-        "\u53D1\u73B0\u65E0\u6548\u7684\u65E7\u753B\u50CF\uFF0C\u4F46\u65E0\u6CD5\u5B89\u5168\u5907\u4EFD\u5E76\u6062\u590D\u3002",
-        "\u8BF7\u8BA9 DxC \u5DE5\u4F5C\u6D41\u91CD\u8BD5\uFF1B\u4E0D\u8981\u624B\u52A8\u5220\u9664 ~/.dxc \u4E2D\u7684\u6587\u4EF6\u3002"
-      );
-    }
-  }
-}
 var ProfileCli = class {
-  #currentDirectory;
   #homeDirectory;
   #now;
   #randomUUID;
   constructor(dependencies) {
-    this.#currentDirectory = dependencies.currentDirectory;
     this.#homeDirectory = dependencies.homeDirectory;
     this.#now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
     this.#randomUUID = dependencies.randomUUID ?? randomUUID;
   }
-  async save(inputPath) {
-    const input = contentProfileInputSchema.safeParse(
-      await readProfileInput(this.#currentDirectory, this.#homeDirectory, inputPath)
-    );
-    if (!input.success) {
-      const fields = issueFields(input.error.issues);
-      throw new ProfileCliError(
-        "DXC_PROFILE_INPUT_INVALID",
-        fields.length === 0 ? "\u753B\u50CF\u8F93\u5165\u4E0D\u7B26\u5408\u5F53\u524D\u7248\u672C\u8981\u6C42\u3002" : `\u753B\u50CF\u8F93\u5165\u7F3A\u5C11\u6216\u5305\u542B\u65E0\u6548\u5B57\u6BB5\uFF1A${fields.join("\u3001")}\u3002`,
-        "\u8BF7\u8BA9 DxC \u5DE5\u4F5C\u6D41\u8865\u9F50\u8FD9\u4E9B\u5B57\u6BB5\u540E\u81EA\u52A8\u91CD\u8BD5\uFF1B\u65E0\u9700\u624B\u5199 JSON\u3002",
-        fields
-      );
-    }
-    const target = profilePath(this.#homeDirectory);
-    const timestamp = this.#now().toISOString();
-    const existing = await readProfileForSave(target, timestamp);
-    const profile = contentProfileSchema.parse({
-      ...input.data,
-      createdAt: existing?.createdAt ?? timestamp,
-      profileId: existing?.profileId ?? this.#randomUUID(),
-      schemaVersion: "1",
-      updatedAt: timestamp
-    });
-    try {
-      await writePrivateJson(target, profile);
-      await refreshUserMemory(this.#homeDirectory, profile.user, this.#now());
-    } catch {
-      throw new ProfileCliError("DXC_PROFILE_IO_FAILED", "Unable to save local content profile");
-    }
-    return contentProfileSaveResultSchema.parse({
-      command: "profile.save",
-      data: {
-        profile,
-        profilePath: PROFILE_DISPLAY_PATH,
-        userMemoryPath: USER_MEMORY_DISPLAY_PATH
-      },
+  async begin() {
+    const profileSessionId = this.#randomUUID();
+    const session = {
+      answers: {},
+      createdAt: this.#now().toISOString(),
+      index: 0,
+      profileSessionId,
+      version: 1
+    };
+    await writePrivateJson(profileSessionPath(this.#homeDirectory, profileSessionId), session);
+    return contentProfileSessionResultSchema.parse({
+      command: "profile.begin",
+      data: { profileSessionId, question: PROFILE_QUESTIONS[0], status: "question" },
       ok: true
     });
   }
-  async update(inputPath) {
-    const input = contentProfileUpdateInputSchema.safeParse(
-      await readProfileInput(this.#currentDirectory, this.#homeDirectory, inputPath)
-    );
-    if (!input.success) {
-      throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "Profile update input is invalid");
+  async answer(profileSessionId, input) {
+    const target = profileSessionPath(this.#homeDirectory, profileSessionId);
+    let session;
+    try {
+      const parsed = profileSession(
+        JSON.parse(await readPrivateFile(target, PROFILE_SESSION_MAXIMUM_BYTES)),
+        profileSessionId
+      );
+      if (parsed === void 0) {
+        throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "\u753B\u50CF\u4F1A\u8BDD\u5DF2\u635F\u574F\u3002");
+      }
+      session = parsed;
+    } catch (error) {
+      if (error instanceof ProfileCliError) {
+        throw error;
+      }
+      throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "\u753B\u50CF\u4F1A\u8BDD\u4E0D\u5B58\u5728\u6216\u5DF2\u5B8C\u6210\u3002");
+    }
+    const question = PROFILE_QUESTIONS[session.index];
+    if (question === void 0) {
+      throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "\u753B\u50CF\u4F1A\u8BDD\u5DF2\u7ECF\u5B8C\u6210\u3002");
     }
-    const target = profilePath(this.#homeDirectory);
-    const existing = await readProfile(target);
-    if (existing === void 0) {
-      throw new ProfileCliError("DXC_PROFILE_INVALID", "Content profile is not initialized");
+    const choices = [...new Set(input.choices)];
+    if (question.inputType === "text") {
+      if (input.text === void 0 || input.text.trim().length === 0 || input.text.length > 120) {
+        throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "\u5F53\u524D\u753B\u50CF\u95EE\u9898\u9700\u8981\u6709\u6548\u6587\u672C\u7B54\u6848\u3002");
+      }
+    } else {
+      const maximum = question.inputType === "multi-choice" ? 5 : 1;
+      if (choices.length < 1 || choices.length > maximum || choices.some((choice) => choiceLabel(session.index, choice) === void 0)) {
+        throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "\u753B\u50CF\u9009\u62E9\u4E0D\u5C5E\u4E8E\u5F53\u524D\u95EE\u9898\u3002");
+      }
+    }
+    const answer = {
+      choices,
+      ...input.note === void 0 ? {} : { note: input.note.trim().slice(0, 500) },
+      ...input.text === void 0 ? {} : { text: input.text.trim() }
+    };
+    const answers = { ...session.answers, [question.questionId]: answer };
+    const nextIndex = session.index + 1;
+    if (nextIndex < PROFILE_QUESTIONS.length) {
+      await writePrivateJson(target, { ...session, answers, index: nextIndex });
+      return contentProfileSessionResultSchema.parse({
+        command: "profile.answer",
+        data: {
+          profileSessionId,
+          question: PROFILE_QUESTIONS[nextIndex],
+          status: "question"
+        },
+        ok: true
+      });
     }
-    const answerByQuestionId = new Map(
-      existing.answers.map((answer) => [answer.questionId, answer])
+    const creatorRole = choiceLabel(0, answers["creator-role"]?.choices[0] ?? "");
+    const displayName = answers["display-name"]?.text;
+    const primaryDomains = (answers["primary-domains"]?.choices ?? []).map((choice) => choiceLabel(2, choice)).filter((label) => label !== void 0);
+    const targetAudience = choiceLabel(3, answers["target-audience"]?.choices[0] ?? "");
+    const contentValuePromise = choiceLabel(4, answers["content-value-promise"]?.choices[0] ?? "");
+    const confirmationChoice = answers["confirmation-policy"]?.choices[0];
+    const confirmationPolicy = confirmationChoice?.replace("profile_confirmation.", "");
+    const existing = await readProfile(profilePath(this.#homeDirectory));
+    const existingUser = existing?.user;
+    const userWithoutRetiredPolicy = existingUser === void 0 ? {} : Object.fromEntries(
+      Object.entries(existingUser).filter(([key]) => key !== "visualGenerationAuthorization")
     );
-    for (const answer of input.data.answers ?? []) {
-      answerByQuestionId.set(answer.questionId, answer);
+    const parsedInput = contentProfileInputSchema.safeParse({
+      answers: existing?.answers ?? [],
+      questionnaireVersion: "dxc-onboarding@1",
+      user: {
+        ...userWithoutRetiredPolicy,
+        confirmationPolicy,
+        contentValuePromise,
+        creatorRole,
+        displayName,
+        primaryDomains,
+        primaryPlatform: "wechat-official-account",
+        targetAudience
+      }
+    });
+    if (!parsedInput.success) {
+      throw new ProfileCliError("DXC_PROFILE_INPUT_INVALID", "\u753B\u50CF\u7B54\u6848\u65E0\u6CD5\u5F62\u6210\u6709\u6548\u753B\u50CF\u3002");
     }
     const timestamp = this.#now().toISOString();
     const profile = contentProfileSchema.parse({
-      ...existing,
-      answers: [...answerByQuestionId.values()],
-      ...input.data.user === void 0 ? {} : { user: { ...existing.user, ...input.data.user } },
+      ...parsedInput.data,
+      createdAt: existing?.createdAt ?? timestamp,
+      profileId: existing?.profileId ?? this.#randomUUID(),
+      schemaVersion: "1",
       updatedAt: timestamp
     });
     try {
-      await writePrivateJson(target, profile);
+      await writePrivateJson(profilePath(this.#homeDirectory), profile);
       await refreshUserMemory(this.#homeDirectory, profile.user, this.#now());
+      await unlink(target);
     } catch {
-      throw new ProfileCliError("DXC_PROFILE_IO_FAILED", "Unable to update local content profile");
+      throw new ProfileCliError("DXC_PROFILE_IO_FAILED", "\u65E0\u6CD5\u539F\u5B50\u4FDD\u5B58\u753B\u50CF\u95EE\u7B54\u7ED3\u679C\u3002");
     }
-    return contentProfileUpdateResultSchema.parse({
-      command: "profile.update",
+    return contentProfileSessionResultSchema.parse({
+      command: "profile.answer",
       data: {
         profile,
         profilePath: PROFILE_DISPLAY_PATH,
+        status: "completed",
         userMemoryPath: USER_MEMORY_DISPLAY_PATH
       },
       ok: true
@@ -27073,20 +27139,16 @@ var ProfileCli = class {
   }
 };
 var ContentMemoryCli = class {
-  #currentDirectory;
   #homeDirectory;
   #now;
   #randomUUID;
   constructor(dependencies) {
-    this.#currentDirectory = dependencies.currentDirectory;
     this.#homeDirectory = dependencies.homeDirectory;
     this.#now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
     this.#randomUUID = dependencies.randomUUID ?? randomUUID;
   }
-  async add(inputPath) {
-    const input = contentMemoryInputSchema.safeParse(
-      await readProfileInput(this.#currentDirectory, this.#homeDirectory, inputPath)
-    );
+  async add(inputValue) {
+    const input = contentMemoryInputSchema.safeParse(inputValue);
     if (!input.success) {
       throw new ContentMemoryCliError(
         "DXC_MEMORY_INPUT_INVALID",
@@ -27181,11 +27243,73 @@ var ContentMemoryCli = class {
       ok: true
     });
   }
+  async correct(memoryId, inputValue) {
+    const input = contentMemoryInputSchema.safeParse(inputValue);
+    if (!input.success) {
+      throw new ContentMemoryCliError(
+        "DXC_MEMORY_INPUT_INVALID",
+        "Content memory correction is invalid"
+      );
+    }
+    const target = memoryPath(this.#homeDirectory);
+    const store = await readMemoryStore(target);
+    const index = store.memories.findIndex(
+      (memory2) => memory2.id === memoryId && memory2.status === "active"
+    );
+    if (index < 0) {
+      throw new ContentMemoryCliError(
+        "DXC_MEMORY_NOT_FOUND",
+        "Active content memory was not found"
+      );
+    }
+    if (store.memories.length >= 100) {
+      throw new ContentMemoryCliError("DXC_MEMORY_IO_FAILED", "Content memory capacity is reached");
+    }
+    const timestamp = this.#now().toISOString();
+    const archivedMemory = {
+      ...store.memories[index],
+      status: "archived",
+      updatedAt: timestamp
+    };
+    const memory = {
+      ...input.data,
+      createdAt: timestamp,
+      id: this.#randomUUID(),
+      source: "user-stated",
+      status: "active",
+      updatedAt: timestamp
+    };
+    const memories = [
+      ...store.memories.map((entry, entryIndex) => entryIndex === index ? archivedMemory : entry),
+      memory
+    ];
+    const next = contentMemoryStoreSchema.parse({ ...store, memories });
+    try {
+      await writePrivateJson(target, next);
+      const profile = await readProfile(profilePath(this.#homeDirectory));
+      await refreshUserMemory(this.#homeDirectory, profile?.user, this.#now());
+    } catch (error) {
+      if (error instanceof ContentMemoryCliError || error instanceof ProfileCliError) {
+        throw error;
+      }
+      throw new ContentMemoryCliError("DXC_MEMORY_IO_FAILED", "Unable to correct content memory");
+    }
+    return contentMemoryCorrectResultSchema.parse({
+      command: "memory.correct",
+      data: {
+        archivedMemory,
+        memories: next.memories.filter((entry) => entry.status === "active"),
+        memory,
+        memoryPath: MEMORY_DISPLAY_PATH
+      },
+      ok: true
+    });
+  }
 };
 
 // apps/cli/src/project.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { lstat as lstat2, mkdir } from "node:fs/promises";
+import { lstat, mkdir } from "node:fs/promises";
 import path3 from "node:path";
 var MANIFEST_NAME = "dxc.project.json";
 var MANIFEST_MAXIMUM_BYTES = 32 * 1024;
@@ -27291,7 +27415,7 @@ var ProjectCli = class {
     });
     const manifestTarget = path3.join(directory, MANIFEST_NAME);
     try {
-      await lstat2(manifestTarget);
+      await lstat(manifestTarget);
       throw new ProjectCliError("DXC_PROJECT_EXISTS", "\u8BE5\u76EE\u5F55\u5DF2\u7ECF\u662F DxC \u5185\u5BB9\u9879\u76EE\u3002");
     } catch (error) {
       if (error instanceof ProjectCliError) {
@@ -27427,7 +27551,17 @@ var ProjectCli = class {
 };
 
 // apps/cli/src/skills.ts
-import { cp, lstat as lstat3, mkdir as mkdir2, mkdtemp, readdir, rename as rename2, rm } from "node:fs/promises";
+import {
+  cp,
+  lstat as lstat2,
+  mkdir as mkdir2,
+  mkdtemp,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  writeFile
+} from "node:fs/promises";
 import os from "node:os";
 import path4 from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27457,7 +27591,7 @@ var SkillInstallerError = class extends Error {
 };
 async function isDirectory(directory) {
   try {
-    return (await lstat3(directory)).isDirectory();
+    return (await lstat2(directory)).isDirectory();
   } catch {
     return false;
   }
@@ -27481,7 +27615,7 @@ async function findBundledSkills() {
 async function assertRegularSkillTree(directory) {
   for (const entry of await readdir(directory, { withFileTypes: true })) {
     const entryPath = path4.join(directory, entry.name);
-    const entryStat = await lstat3(entryPath);
+    const entryStat = await lstat2(entryPath);
     if (entryStat.isSymbolicLink()) {
       throw new SkillInstallerError(
         "DXC_SKILL_SOURCE_UNSAFE",
@@ -27500,6 +27634,26 @@ async function assertRegularSkillTree(directory) {
     }
   }
 }
+async function renderCliInvocation(sourceRoot, stagedSkill) {
+  const skillFile = path4.join(stagedSkill, "SKILL.md");
+  const skill = await readFile(skillFile, "utf8");
+  if (!skill.includes("{{DXC_CLI_INVOCATION}}")) {
+    return;
+  }
+  const invocationTemplate = await readFile(
+    path4.join(sourceRoot, ".dxc-cli-invocation.template.md"),
+    "utf8"
+  );
+  const invocation = invocationTemplate.replaceAll("{{VERSION}}", package_default.version).trim();
+  const rendered = skill.replaceAll("{{DXC_CLI_INVOCATION}}", invocation);
+  if (rendered.includes("{{DXC_CLI_INVOCATION}}") || rendered.includes("{{VERSION}}")) {
+    throw new SkillInstallerError(
+      "DXC_SKILL_TEMPLATE_INVALID",
+      "Bundled Skill invocation template contains an unresolved placeholder"
+    );
+  }
+  await writeFile(skillFile, rendered, { mode: 384 });
+}
 function defaultTargetDirectory(homeDirectory, target) {
   return path4.join(homeDirectory, target === "codex" ? ".codex" : ".workbuddy", "skills");
 }
@@ -27542,10 +27696,11 @@ var SkillInstaller = class {
           errorOnExist: true,
           recursive: true
         });
+        await renderCliInvocation(sourceRoot, stagedSkill);
         if (destinationExists) {
-          await rename2(destination, backup);
+          await rename(destination, backup);
         }
-        await rename2(stagedSkill, destination);
+        await rename(stagedSkill, destination);
         installed.push(skill);
         if (destinationExists) {
           try {
@@ -27556,7 +27711,7 @@ var SkillInstaller = class {
         }
       } catch (error) {
         if (!await isDirectory(destination) && await isDirectory(backup)) {
-          await rename2(backup, destination);
+          await rename(backup, destination);
         }
         throw error;
       } finally {
@@ -27587,7 +27742,7 @@ import {
   randomUUID as randomUUID4
 } from "node:crypto";
 import { constants as fileConstants3 } from "node:fs";
-import { chmod, lstat as lstat6, mkdir as mkdir4, open as open3, rename as rename4, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { chmod, lstat as lstat5, mkdir as mkdir5, open as open3, rename as rename3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
 import os2 from "node:os";
 import path7 from "node:path";
 
@@ -27735,10 +27890,10 @@ var LOG_REDACTION_PATHS = Object.freeze([
 ]);
 
 // apps/cli/src/publishing-assets.ts
-import { createHash as createHash4 } from "node:crypto";
-import { constants as fileConstants } from "node:fs";
-import { lstat as lstat4, open, readdir as readdir2, realpath } from "node:fs/promises";
-import path5 from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { constants as fileConstants2 } from "node:fs";
+import { lstat as lstat4, mkdir as mkdir4, open as open2, readdir as readdir2, readFile as readFile3, realpath as realpath2 } from "node:fs/promises";
+import path6 from "node:path";
 
 // packages/renderer-wechat/src/article.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -29860,7 +30015,24 @@ function rewriteWechatAssetSources(html, replacements) {
 }
 
 // apps/cli/src/publishing-assets.ts
+var import_yaml3 = __toESM(require_dist(), 1);
+import sharp2 from "sharp";
+
+// apps/cli/src/publishing-image-optimization.ts
 var import_yaml2 = __toESM(require_dist(), 1);
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import { constants as fileConstants } from "node:fs";
+import {
+  lstat as lstat3,
+  mkdir as mkdir3,
+  open,
+  readFile as readFile2,
+  realpath,
+  rename as rename2,
+  unlink as unlink2,
+  writeFile as writeFile2
+} from "node:fs/promises";
+import path5 from "node:path";
 import sharp from "sharp";
 
 // apps/cli/src/wechat-error.ts
@@ -29879,46 +30051,402 @@ var WechatCliError = class extends Error {
   fields;
 };
 
+// apps/cli/src/publishing-image-optimization.ts
+var MAXIMUM_INPUT_BYTES = 32 * 1024 * 1024;
+var INLINE_IMAGE_LIMIT = 1024 * 1024 - 1;
+var INLINE_IMAGE_TARGET = 950 * 1024;
+var COVER_IMAGE_LIMIT = 5 * 1024 * 1024;
+var COVER_IMAGE_TARGET = 4500 * 1024;
+var VISUAL_PLAN_MAXIMUM_BYTES = 128 * 1024;
+var VISUAL_PLAN_FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/u;
+function sha256(value) {
+  return createHash4("sha256").update(value).digest("hex");
+}
+function safeDerivativeBase(value) {
+  return value.normalize("NFKC").replaceAll(/[^A-Za-z0-9._-]+/gu, "-").replaceAll(/^-+|-+$/gu, "").slice(0, 80) || "image";
+}
+function recordValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function portablePath(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0 || path5.isAbsolute(value) || value.includes("\\") || value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      `${label} \u5FC5\u987B\u662F\u9879\u76EE\u5185\u4F7F\u7528 / \u5206\u9694\u7684\u5B89\u5168\u76F8\u5BF9\u8DEF\u5F84\u3002`
+    );
+  }
+  return value;
+}
+function isWithin(target, directory) {
+  const relative = path5.relative(directory, target);
+  return relative === "" || !relative.startsWith(`..${path5.sep}`) && relative !== "..";
+}
+async function regularImage(target) {
+  let handle;
+  try {
+    handle = await open(target, fileConstants.O_RDONLY | fileConstants.O_NOFOLLOW);
+    const metadata = await handle.stat();
+    if (!metadata.isFile() || metadata.size <= 0 || metadata.size > MAXIMUM_INPUT_BYTES) {
+      throw new Error("invalid image");
+    }
+    return await handle.readFile();
+  } catch {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      `\u65E0\u6CD5\u5B89\u5168\u8BFB\u53D6\u56FE\u7247 ${path5.basename(target)}\uFF1B\u6587\u4EF6\u5FC5\u987B\u662F\u5C0F\u4E8E ${MAXIMUM_INPUT_BYTES} bytes \u7684\u666E\u901A\u6587\u4EF6\u3002`
+    );
+  } finally {
+    await handle?.close();
+  }
+}
+async function requirePreservedAlpha(bytes) {
+  const metadata = await sharp(bytes, {
+    failOn: "error",
+    limitInputPixels: 8e7
+  }).metadata();
+  if (metadata.format !== "png" || metadata.hasAlpha !== true) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_ALPHA_LOST",
+      "\u900F\u660E\u56FE\u7247\u4F18\u5316\u540E\u4E22\u5931\u900F\u660E\u901A\u9053\uFF1B\u5DF2\u963B\u65AD\u4E14\u4E0D\u4F1A\u8986\u76D6\u539F\u56FE\u3002"
+    );
+  }
+}
+async function decodedImageMetadata(source, sourcePath) {
+  let metadata;
+  try {
+    metadata = await sharp(source, { failOn: "error", limitInputPixels: 8e7 }).metadata();
+  } catch {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      "\u56FE\u7247\u65E0\u6CD5\u88AB\u5B89\u5168\u89E3\u7801\uFF1B\u4EC5\u652F\u6301\u6709\u6548 PNG/JPEG\u3002"
+    );
+  }
+  const extension = path5.extname(sourcePath).toLowerCase();
+  const expectedFormat = extension === ".png" ? "png" : extension === ".jpg" || extension === ".jpeg" ? "jpeg" : void 0;
+  if (expectedFormat === void 0 || metadata.format !== expectedFormat || metadata.width === void 0 || metadata.height === void 0) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      "\u56FE\u7247\u6269\u5C55\u540D\u3001\u771F\u5B9E\u683C\u5F0F\u6216\u5C3A\u5BF8\u65E0\u6548\uFF1B\u4EC5\u652F\u6301\u6269\u5C55\u540D\u4E0E\u5185\u5BB9\u4E00\u81F4\u7684 PNG/JPEG\u3002"
+    );
+  }
+  return {
+    format: expectedFormat,
+    hasAlpha: metadata.hasAlpha === true,
+    height: metadata.height,
+    width: metadata.width
+  };
+}
+async function writeExclusiveOrVerify(target, bytes) {
+  await mkdir3(path5.dirname(target), { recursive: true, mode: 448 });
+  try {
+    await writeFile2(target, bytes, { flag: "wx", mode: 384 });
+    return true;
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+    const existing = await regularImage(target);
+    if (sha256(existing) !== sha256(bytes)) {
+      throw new WechatCliError(
+        "DXC_PUBLISHING_IMAGE_OPTIMIZATION_CONFLICT",
+        `\u4F18\u5316\u76EE\u6807 ${path5.basename(target)} \u5DF2\u5B58\u5728\u4F46\u5185\u5BB9\u4E0D\u540C\uFF1B\u672A\u8986\u76D6\u4EFB\u4F55\u6587\u4EF6\u3002`
+      );
+    }
+    return false;
+  }
+}
+async function safeRealPathWithin(target, directory, label) {
+  const resolved = await realpath(target).catch(() => void 0);
+  if (resolved === void 0 || !isWithin(resolved, directory)) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      `${label} \u7684\u771F\u5B9E\u8DEF\u5F84\u4E0D\u5728\u5141\u8BB8\u7684\u9879\u76EE\u76EE\u5F55\u5185\u3002`
+    );
+  }
+  return resolved;
+}
+async function ensureSafeOptimizedDirectory(assetsDirectory, realAssetsDirectory) {
+  const optimizedDirectory = path5.join(assetsDirectory, "optimized");
+  await mkdir3(optimizedDirectory, { recursive: true, mode: 448 });
+  const metadata = await lstat3(optimizedDirectory).catch(() => void 0);
+  if (metadata === void 0 || !metadata.isDirectory() || metadata.isSymbolicLink()) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      "\u4F18\u5316\u76EE\u5F55\u5FC5\u987B\u662F\u7D20\u6750\u76EE\u5F55\u5185\u7684\u666E\u901A\u76EE\u5F55\uFF0C\u4E0D\u80FD\u662F\u7B26\u53F7\u94FE\u63A5\u3002"
+    );
+  }
+  await safeRealPathWithin(optimizedDirectory, realAssetsDirectory, "\u4F18\u5316\u76EE\u5F55");
+  return optimizedDirectory;
+}
+async function writePlanAtomically(target, expectedSource, source) {
+  const temporary = `${target}.${randomUUID3()}.tmp`;
+  try {
+    await writeFile2(temporary, source, { encoding: "utf8", flag: "wx", mode: 384 });
+    if (await readFile2(target, "utf8") !== expectedSource) {
+      throw new WechatCliError(
+        "DXC_PUBLISHING_IMAGE_OPTIMIZATION_CONFLICT",
+        "\u89C6\u89C9\u8BA1\u5212\u5728\u56FE\u7247\u4F18\u5316\u671F\u95F4\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u4FEE\u6539\uFF1B\u672A\u8986\u76D6\u65B0\u5185\u5BB9\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u518D\u8BD5\u3002"
+      );
+    }
+    await rename2(temporary, target);
+  } finally {
+    await unlink2(temporary).catch(() => void 0);
+  }
+}
+function candidateWidths(width) {
+  return [.../* @__PURE__ */ new Set([width, 2400, 2e3, 1600, 1280, 1080, 900, 720])].filter((candidate) => candidate > 0 && candidate <= width).sort((left, right) => right - left);
+}
+async function optimizedImage(source, targetBytes, metadata) {
+  const hasAlpha = metadata.hasAlpha;
+  for (const width of candidateWidths(metadata.width)) {
+    if (hasAlpha) {
+      const lossless = await sharp(source, { failOn: "error", limitInputPixels: 8e7 }).rotate().resize({ fit: "inside", width, withoutEnlargement: true }).png({ compressionLevel: 9, effort: 10 }).toBuffer();
+      if (lossless.byteLength <= targetBytes) {
+        await requirePreservedAlpha(lossless);
+        return { alphaPreserved: true, bytes: lossless, extension: ".png" };
+      }
+      for (const colours of [256, 192, 128, 96, 64]) {
+        const quantized = await sharp(source, {
+          failOn: "error",
+          limitInputPixels: 8e7
+        }).rotate().resize({ fit: "inside", width, withoutEnlargement: true }).png({ colours, compressionLevel: 9, effort: 10, palette: true }).toBuffer();
+        if (quantized.byteLength <= targetBytes) {
+          await requirePreservedAlpha(quantized);
+          return { alphaPreserved: true, bytes: quantized, extension: ".png" };
+        }
+      }
+      continue;
+    }
+    for (const quality of [88, 82, 76, 70, 64, 58]) {
+      const jpeg = await sharp(source, { failOn: "error", limitInputPixels: 8e7 }).rotate().resize({ fit: "inside", width, withoutEnlargement: true }).jpeg({ chromaSubsampling: "4:4:4", mozjpeg: true, progressive: true, quality }).toBuffer();
+      if (jpeg.byteLength <= targetBytes) {
+        return { alphaPreserved: true, bytes: jpeg, extension: ".jpg" };
+      }
+    }
+  }
+  throw new WechatCliError(
+    "DXC_PUBLISHING_IMAGE_OPTIMIZATION_LIMIT_UNREACHABLE",
+    `\u65E0\u6CD5\u5728\u4E0D\u4E22\u5931\u900F\u660E\u901A\u9053\u6216\u4F4E\u4E8E\u6700\u5C0F\u5C3A\u5BF8\u7B56\u7565\u7684\u524D\u63D0\u4E0B\u538B\u5230 ${targetBytes} bytes\uFF1B\u8BF7\u66F4\u6362\u6216\u88C1\u526A\u56FE\u7247\u3002`
+  );
+}
+async function optimizePublishingImages(input) {
+  const projectDirectory = path5.resolve(input.projectDirectory);
+  const visualPlanPath = path5.resolve(input.visualPlanFile);
+  if (!isWithin(visualPlanPath, projectDirectory)) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      "\u89C6\u89C9\u8BA1\u5212\u5FC5\u987B\u4F4D\u4E8E\u5F53\u524D\u5185\u5BB9\u9879\u76EE\u5185\u3002"
+    );
+  }
+  const projectMetadata = await lstat3(projectDirectory).catch(() => void 0);
+  const visualPlanMetadata = await lstat3(visualPlanPath).catch(() => void 0);
+  if (projectMetadata === void 0 || !projectMetadata.isDirectory() || projectMetadata.isSymbolicLink() || visualPlanMetadata === void 0 || !visualPlanMetadata.isFile() || visualPlanMetadata.isSymbolicLink() || visualPlanMetadata.size > VISUAL_PLAN_MAXIMUM_BYTES) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      "\u5185\u5BB9\u9879\u76EE\u548C\u89C6\u89C9\u8BA1\u5212\u5FC5\u987B\u662F\u975E\u7B26\u53F7\u94FE\u63A5\u7684\u666E\u901A\u76EE\u5F55\u4E0E\u6587\u4EF6\u3002"
+    );
+  }
+  const realProjectDirectory = await realpath(projectDirectory);
+  await safeRealPathWithin(visualPlanPath, realProjectDirectory, "\u89C6\u89C9\u8BA1\u5212");
+  const source = await readFile2(visualPlanPath, "utf8").catch(() => "");
+  if (Buffer.byteLength(source, "utf8") > VISUAL_PLAN_MAXIMUM_BYTES) {
+    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
+  }
+  const match = VISUAL_PLAN_FRONTMATTER.exec(source);
+  if (match?.[1] === void 0 || match[2] === void 0) {
+    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
+  }
+  let frontmatter2;
+  try {
+    frontmatter2 = recordValue((0, import_yaml2.parse)(match[1], { maxAliasCount: 10, uniqueKeys: true }));
+  } catch {
+    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
+  }
+  if (frontmatter2 === void 0) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+      "\u89C6\u89C9\u8BA1\u5212\u7684 YAML \u5934\u65E0\u6CD5\u8BFB\u53D6\u3002"
+    );
+  }
+  const assetsRelative = frontmatter2["assetsDirectory"] === void 0 ? "assets" : portablePath(frontmatter2["assetsDirectory"], "assetsDirectory");
+  frontmatter2["assetsDirectory"] = assetsRelative;
+  frontmatter2["inlineImagesSupported"] = true;
+  const assetsDirectory = path5.resolve(projectDirectory, assetsRelative);
+  if (!isWithin(assetsDirectory, projectDirectory)) {
+    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
+  }
+  const assetsMetadata = await lstat3(assetsDirectory).catch(() => void 0);
+  if (assetsMetadata === void 0 || !assetsMetadata.isDirectory() || assetsMetadata.isSymbolicLink()) {
+    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
+  }
+  const realAssetsDirectory = await safeRealPathWithin(
+    assetsDirectory,
+    realProjectDirectory,
+    "\u7D20\u6750\u76EE\u5F55"
+  );
+  const inlineAssets = Array.isArray(frontmatter2["inlineAssets"]) ? frontmatter2["inlineAssets"] : [];
+  const entries = [
+    {
+      assetId: "cover",
+      limit: COVER_IMAGE_LIMIT,
+      record: { path: frontmatter2["coverAsset"] },
+      role: "cover",
+      target: COVER_IMAGE_TARGET
+    },
+    ...inlineAssets.map((asset, index) => ({
+      assetId: `inline-${String(index + 1).padStart(2, "0")}`,
+      limit: INLINE_IMAGE_LIMIT,
+      record: recordValue(asset),
+      role: "inline",
+      target: INLINE_IMAGE_TARGET
+    }))
+  ];
+  const createdFiles = [];
+  const mutations = [];
+  let unchangedCount = 0;
+  let optimizedDirectory;
+  try {
+    for (const entry of entries) {
+      const assetPath = portablePath(entry.record?.["path"], `${entry.role} \u56FE\u7247\u8DEF\u5F84`);
+      const absolutePath = path5.resolve(projectDirectory, assetPath);
+      if (!isWithin(absolutePath, assetsDirectory)) {
+        throw new WechatCliError(
+          "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
+          `${assetPath} \u4E0D\u5728\u89C6\u89C9\u8BA1\u5212\u58F0\u660E\u7684\u7D20\u6750\u76EE\u5F55\u5185\u3002`
+        );
+      }
+      const assetMetadata = await lstat3(absolutePath).catch((error) => {
+        if (error.code === "ENOENT") {
+          return void 0;
+        }
+        throw error;
+      });
+      if (assetMetadata === void 0) {
+        throw new WechatCliError(
+          "DXC_PUBLISHING_VISUAL_ASSET_MISSING",
+          `\u89C6\u89C9\u7D20\u6750 ${entry.assetId} \u7F3A\u5931\uFF1B\u8BF7\u5C06\u771F\u5B9E\u56FE\u7247\u5199\u5165 CLI \u5206\u914D\u7684\u4F4D\u7F6E\u540E\u91CD\u8BD5\u3002`,
+          false,
+          { assetId: entry.assetId, role: entry.role }
+        );
+      }
+      await safeRealPathWithin(absolutePath, realAssetsDirectory, `${assetPath} \u56FE\u7247`);
+      const bytes = await regularImage(absolutePath);
+      const metadata = await decodedImageMetadata(bytes, assetPath);
+      const beforeSha256 = sha256(bytes);
+      let finalPath = assetPath;
+      let finalBytes = bytes;
+      let alphaPreserved = true;
+      if (bytes.byteLength > entry.limit) {
+        const optimized = await optimizedImage(bytes, entry.target, metadata);
+        optimizedDirectory ??= await ensureSafeOptimizedDirectory(
+          assetsDirectory,
+          realAssetsDirectory
+        );
+        const baseName = safeDerivativeBase(path5.basename(assetPath, path5.extname(assetPath)));
+        const optimizedSha256 = sha256(optimized.bytes);
+        const optimizedName = `${baseName}-${entry.role}-${beforeSha256.slice(0, 12)}-${optimizedSha256.slice(0, 12)}${optimized.extension}`;
+        const optimizedAbsolute = path5.join(optimizedDirectory, optimizedName);
+        const created = await writeExclusiveOrVerify(optimizedAbsolute, optimized.bytes);
+        if (created) {
+          createdFiles.push(optimizedAbsolute);
+        }
+        finalPath = path5.relative(projectDirectory, optimizedAbsolute).split(path5.sep).join("/");
+        finalBytes = optimized.bytes;
+        alphaPreserved = optimized.alphaPreserved;
+        mutations.push({
+          alphaPreserved,
+          afterBytes: finalBytes.byteLength,
+          afterSha256: sha256(finalBytes),
+          beforeBytes: bytes.byteLength,
+          beforeSha256,
+          from: assetPath,
+          role: entry.role,
+          to: finalPath
+        });
+      } else {
+        unchangedCount += 1;
+      }
+      if (entry.role === "cover") {
+        frontmatter2["coverAsset"] = finalPath;
+        frontmatter2["coverSha256"] = sha256(finalBytes);
+      } else if (entry.record !== void 0) {
+        if (finalPath !== assetPath && entry.record["sourcePath"] === void 0) {
+          entry.record["sourcePath"] = assetPath;
+        }
+        entry.record["path"] = finalPath;
+        entry.record["sha256"] = sha256(finalBytes);
+      }
+    }
+    frontmatter2["inlineAssets"] = inlineAssets;
+    const normalizedSource = `---
+${(0, import_yaml2.stringify)(frontmatter2, { lineWidth: 0 }).trimEnd()}
+---
+${match[2]}`;
+    await writePlanAtomically(visualPlanPath, source, normalizedSource);
+  } catch (error) {
+    await Promise.all(createdFiles.map((target) => unlink2(target).catch(() => void 0)));
+    if (error instanceof WechatCliError) {
+      throw error;
+    }
+    throw new WechatCliError(
+      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_FAILED",
+      "\u56FE\u7247\u4F18\u5316\u672A\u5B8C\u6210\uFF1B\u539F\u56FE\u548C\u89C6\u89C9\u8BA1\u5212\u5747\u672A\u88AB\u8986\u76D6\u3002"
+    );
+  }
+  return {
+    command: "wechat.draft.optimize-images",
+    data: { mutations, unchangedCount, visualPlanPath },
+    ok: true
+  };
+}
+
 // apps/cli/src/publishing-assets.ts
 var MAXIMUM_ARTICLE_BYTES = 512 * 1024;
-var MAXIMUM_IMAGE_BYTES = 5 * 1024 * 1024;
-var MAXIMUM_INLINE_IMAGE_BYTES = 1024 * 1024 - 1;
-var MAXIMUM_INLINE_IMAGES = 20;
+var PUBLISHING_COVER_MAXIMUM_BYTES = 5 * 1024 * 1024;
+var PUBLISHING_INLINE_IMAGE_MAXIMUM_BYTES = 1024 * 1024 - 1;
+var PUBLISHING_OPTIMIZABLE_IMAGE_MAXIMUM_BYTES = 32 * 1024 * 1024;
+var PUBLISHING_INLINE_IMAGE_MAXIMUM_COUNT = 20;
+var MAXIMUM_IMAGE_BYTES = PUBLISHING_COVER_MAXIMUM_BYTES;
+var MAXIMUM_INLINE_IMAGE_BYTES = PUBLISHING_INLINE_IMAGE_MAXIMUM_BYTES;
+var MAXIMUM_INLINE_IMAGES = PUBLISHING_INLINE_IMAGE_MAXIMUM_COUNT;
 var SUPPORTED_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".jpeg", ".jpg", ".png"]);
-var VISUAL_PLAN_MAXIMUM_BYTES = 128 * 1024;
+var VISUAL_PLAN_MAXIMUM_BYTES2 = 128 * 1024;
 var ARTICLE_FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/u;
-var VISUAL_PLAN_FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u;
+var VISUAL_PLAN_FRONTMATTER2 = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u;
 var LOCAL_WORKFLOW_FRONTMATTER_KEYS = ["dxc", "goldenLinesPath", "goldenLinesSha256"];
-function recordValue(value) {
+var WORKFLOW_VISUAL_SIDECAR_FILE = ".dxc/visual-assets.json";
+var WORKFLOW_PUBLISHING_VISUAL_PLAN_FILE = ".dxc/publishing-visual-plan.md";
+var WORKFLOW_LOCAL_PREVIEW_FILE = ".dxc/previews/current.html";
+function recordValue2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 async function validatePublishingImage(bytes, target) {
   let metadata;
   try {
-    metadata = await sharp(bytes, { failOn: "error", limitInputPixels: 8e7 }).metadata();
+    metadata = await sharp2(bytes, { failOn: "error", limitInputPixels: 8e7 }).metadata();
   } catch {
     throw new WechatCliError(
       "DXC_PUBLISHING_INPUT_INVALID",
-      `\u56FE\u7247 ${path5.basename(target)} \u65E0\u6CD5\u88AB\u5B89\u5168\u89E3\u7801\uFF1B\u4EC5\u652F\u6301\u6709\u6548 PNG/JPEG\u3002`
+      `\u56FE\u7247 ${path6.basename(target)} \u65E0\u6CD5\u88AB\u5B89\u5168\u89E3\u7801\uFF1B\u4EC5\u652F\u6301\u6709\u6548 PNG/JPEG\u3002`
     );
   }
-  const extension = path5.extname(target).toLowerCase();
+  const extension = path6.extname(target).toLowerCase();
   const expectedFormat = extension === ".png" ? "png" : extension === ".jpg" || extension === ".jpeg" ? "jpeg" : void 0;
   if (expectedFormat === void 0 || metadata.format !== expectedFormat || metadata.width === void 0 || metadata.height === void 0) {
     throw new WechatCliError(
       "DXC_PUBLISHING_INPUT_INVALID",
-      `\u56FE\u7247 ${path5.basename(target)} \u7684\u6269\u5C55\u540D\u4E0E\u771F\u5B9E PNG/JPEG \u683C\u5F0F\u4E0D\u4E00\u81F4\u3002`
+      `\u56FE\u7247 ${path6.basename(target)} \u7684\u6269\u5C55\u540D\u4E0E\u771F\u5B9E PNG/JPEG \u683C\u5F0F\u4E0D\u4E00\u81F4\u3002`
     );
   }
 }
 async function readPublishingInput(inputPath, maximumBytes, role = "article") {
-  const target = path5.resolve(inputPath);
+  const target = path6.resolve(inputPath);
   let handle;
   try {
-    handle = await open(target, fileConstants.O_RDONLY | fileConstants.O_NOFOLLOW);
+    handle = await open2(target, fileConstants2.O_RDONLY | fileConstants2.O_NOFOLLOW);
     const metadata = await handle.stat();
     if (metadata.isFile() && metadata.size > maximumBytes) {
-      const fileName = path5.basename(target);
+      const fileName = path6.basename(target);
       if (role === "inline-image") {
         throw new WechatCliError(
           "DXC_PUBLISHING_INLINE_IMAGE_TOO_LARGE",
@@ -29939,7 +30467,7 @@ async function readPublishingInput(inputPath, maximumBytes, role = "article") {
     if (!metadata.isFile() || metadata.size <= 0) {
       throw new WechatCliError(
         "DXC_PUBLISHING_INPUT_INVALID",
-        `\u6587\u4EF6 ${path5.basename(target)} \u4E0D\u662F\u53EF\u8BFB\u53D6\u7684\u975E\u7A7A\u666E\u901A\u6587\u4EF6\u3002`
+        `\u6587\u4EF6 ${path6.basename(target)} \u4E0D\u662F\u53EF\u8BFB\u53D6\u7684\u975E\u7A7A\u666E\u901A\u6587\u4EF6\u3002`
       );
     }
     const bytes = await handle.readFile();
@@ -29953,7 +30481,7 @@ async function readPublishingInput(inputPath, maximumBytes, role = "article") {
     }
     throw new WechatCliError(
       "DXC_PUBLISHING_INPUT_INVALID",
-      `\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 ${path5.basename(target)}\uFF1B\u8BF7\u786E\u8BA4\u8DEF\u5F84\u3001\u6743\u9650\u4E14\u6587\u4EF6\u4E0D\u662F\u7B26\u53F7\u94FE\u63A5\u3002`
+      `\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 ${path6.basename(target)}\uFF1B\u8BF7\u786E\u8BA4\u8DEF\u5F84\u3001\u6743\u9650\u4E14\u6587\u4EF6\u4E0D\u662F\u7B26\u53F7\u94FE\u63A5\u3002`
     );
   } finally {
     await handle?.close();
@@ -29962,16 +30490,16 @@ async function readPublishingInput(inputPath, maximumBytes, role = "article") {
 async function readContainedPublishingInput(inputPath, maximumBytes, allowedDirectories, role) {
   try {
     const [target, ...directories] = await Promise.all([
-      realpath(path5.resolve(inputPath)),
-      ...allowedDirectories.map((directory) => realpath(path5.resolve(directory)))
+      realpath2(path6.resolve(inputPath)),
+      ...allowedDirectories.map((directory) => realpath2(path6.resolve(directory)))
     ]);
     const contained = directories.some(
-      (directory) => target !== directory && target.startsWith(`${directory}${path5.sep}`)
+      (directory) => target !== directory && target.startsWith(`${directory}${path6.sep}`)
     );
     if (!contained) {
       throw new WechatCliError(
         "DXC_PUBLISHING_INPUT_INVALID",
-        `\u81EA\u52A8\u89E3\u6790\u7684\u7D20\u6750 ${path5.basename(inputPath)} \u4E0D\u5728\u6587\u7AE0\u76EE\u5F55\u6216\u663E\u5F0F\u7D20\u6750\u76EE\u5F55\u4E2D\u3002`
+        `\u81EA\u52A8\u89E3\u6790\u7684\u7D20\u6750 ${path6.basename(inputPath)} \u4E0D\u5728\u6587\u7AE0\u76EE\u5F55\u6216\u663E\u5F0F\u7D20\u6750\u76EE\u5F55\u4E2D\u3002`
       );
     }
   } catch (error) {
@@ -29980,13 +30508,13 @@ async function readContainedPublishingInput(inputPath, maximumBytes, allowedDire
     }
     throw new WechatCliError(
       "DXC_PUBLISHING_INPUT_INVALID",
-      `\u65E0\u6CD5\u5B89\u5168\u89E3\u6790\u7D20\u6750 ${path5.basename(inputPath)}\u3002`
+      `\u65E0\u6CD5\u5B89\u5168\u89E3\u6790\u7D20\u6750 ${path6.basename(inputPath)}\u3002`
     );
   }
   return readPublishingInput(inputPath, maximumBytes, role);
 }
 function publishingImageMediaType(inputPath) {
-  const extension = path5.extname(inputPath).toLowerCase();
+  const extension = path6.extname(inputPath).toLowerCase();
   if (extension === ".png") {
     return "image/png";
   }
@@ -29999,13 +30527,13 @@ function safeFileName(value) {
   return value.normalize("NFKC").replaceAll(/[^A-Za-z0-9._-]+/gu, "-").replaceAll(/^-+|-+$/gu, "").slice(0, 80);
 }
 function isWithinDirectory(target, directory) {
-  const relative = path5.relative(directory, target);
-  return relative === "" || !relative.startsWith(`..${path5.sep}`) && relative !== "..";
+  const relative = path6.relative(directory, target);
+  return relative === "" || !relative.startsWith(`..${path6.sep}`) && relative !== "..";
 }
 function commonDirectory(left, right) {
-  let directory = path5.resolve(left);
+  let directory = path6.resolve(left);
   while (!isWithinDirectory(right, directory)) {
-    const parent = path5.dirname(directory);
+    const parent = path6.dirname(directory);
     if (parent === directory) {
       return directory;
     }
@@ -30017,7 +30545,7 @@ async function collectedImages(directoryInput, articleDirectory) {
   if (directoryInput === void 0) {
     return [];
   }
-  const directory = path5.resolve(directoryInput);
+  const directory = path6.resolve(directoryInput);
   let entries;
   try {
     const metadata = await lstat4(directory);
@@ -30029,12 +30557,12 @@ async function collectedImages(directoryInput, articleDirectory) {
     }
     const sharedDirectory = commonDirectory(articleDirectory, directory);
     const [resolvedDirectory, resolvedSharedDirectory] = await Promise.all([
-      realpath(directory),
-      realpath(sharedDirectory)
+      realpath2(directory),
+      realpath2(sharedDirectory)
     ]);
-    const expectedDirectory = path5.resolve(
+    const expectedDirectory = path6.resolve(
       resolvedSharedDirectory,
-      path5.relative(sharedDirectory, directory)
+      path6.relative(sharedDirectory, directory)
     );
     if (resolvedDirectory !== expectedDirectory) {
       throw new WechatCliError(
@@ -30050,8 +30578,8 @@ async function collectedImages(directoryInput, articleDirectory) {
     throw new WechatCliError("DXC_PUBLISHING_ASSETS_DIRECTORY_INVALID");
   }
   return entries.filter(
-    (entry) => entry.isFile() && SUPPORTED_IMAGE_EXTENSIONS.has(path5.extname(entry.name).toLowerCase())
-  ).map((entry) => path5.join(directory, entry.name)).sort((left, right) => left.localeCompare(right, "zh-CN"));
+    (entry) => entry.isFile() && SUPPORTED_IMAGE_EXTENSIONS.has(path6.extname(entry.name).toLowerCase())
+  ).map((entry) => path6.join(directory, entry.name)).sort((left, right) => left.localeCompare(right, "zh-CN"));
 }
 function injectCollectedImages(source, images) {
   const diagnosticText = (value, maximum = 120) => {
@@ -30081,8 +30609,14 @@ function injectCollectedImages(source, images) {
   }
   const insertions = /* @__PURE__ */ new Map();
   for (const [index, image] of images.entries()) {
-    let headingLine = headingLines[index];
-    if (image.placementAnchor !== void 0) {
+    let headingLine = image.headingIndex === void 0 ? headingLines[index] : headingLines[image.headingIndex];
+    if (image.headingIndex !== void 0 && headingLine === void 0) {
+      throw new WechatCliError(
+        "DXC_PUBLISHING_VISUAL_ANCHOR_INVALID",
+        `\u89C6\u89C9\u8BA1\u5212\u7AE0\u8282\u5E8F\u53F7 ${image.headingIndex + 1} \u4E0D\u5B58\u5728\u3002`
+      );
+    }
+    if (image.headingIndex === void 0 && image.placementAnchor !== void 0) {
       const match = /^after-heading:(.+)$/u.exec(image.placementAnchor);
       const requestedHeading = match?.[1]?.trim().replace(/^##\s+/u, "").replace(/\s+#+\s*$/u, "").trim();
       const matches = requestedHeading === void 0 ? void 0 : headingLineByText.get(requestedHeading);
@@ -30112,12 +30646,12 @@ function injectCollectedImages(source, images) {
   return output.join("\n");
 }
 function parsedVisualPlan(source) {
-  const yamlSource = VISUAL_PLAN_FRONTMATTER.exec(source)?.[1];
+  const yamlSource = VISUAL_PLAN_FRONTMATTER2.exec(source)?.[1];
   if (yamlSource === void 0) {
     throw new WechatCliError("DXC_PUBLISHING_VISUAL_PLAN_INVALID");
   }
   try {
-    const plan = recordValue((0, import_yaml2.parse)(yamlSource, { maxAliasCount: 10, uniqueKeys: true }));
+    const plan = recordValue2((0, import_yaml3.parse)(yamlSource, { maxAliasCount: 10, uniqueKeys: true }));
     if (plan === void 0) {
       throw new WechatCliError("DXC_PUBLISHING_VISUAL_PLAN_INVALID");
     }
@@ -30129,29 +30663,299 @@ function parsedVisualPlan(source) {
     throw new WechatCliError("DXC_PUBLISHING_VISUAL_PLAN_INVALID");
   }
 }
-function validateVisualPlanPlacementAnchors(articleSource, visualPlanSource) {
-  const plan = parsedVisualPlan(visualPlanSource);
-  const inlineAssets = Array.isArray(plan["inlineAssets"]) ? plan["inlineAssets"] : [];
-  const images = inlineAssets.map((rawAsset) => {
-    const asset = recordValue(rawAsset);
-    if (typeof asset?.["path"] !== "string" || typeof asset["placementAnchor"] !== "string") {
+function parsedWorkflowVisualAssetsSidecar(value) {
+  const sidecar = recordValue2(value);
+  const assets = sidecar?.["assets"];
+  if (sidecar?.["version"] !== 1 || typeof sidecar["articleSha256"] !== "string" || !/^[a-f0-9]{64}$/u.test(sidecar["articleSha256"]) || typeof sidecar["visualPlanSha256"] !== "string" || !/^[a-f0-9]{64}$/u.test(sidecar["visualPlanSha256"]) || typeof sidecar["localPreviewPath"] !== "string" || typeof sidecar["publishingVisualPlanPath"] !== "string" || !Array.isArray(assets) || assets.length < 1 || assets.length > MAXIMUM_INLINE_IMAGES + 1) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+      "\u89C6\u89C9\u7D20\u6750 sidecar\uFF08\u65C1\u8F66\u5143\u6570\u636E\uFF09\u65E0\u6548\u3002"
+    );
+  }
+  const parsedAssets = assets.map((entry, index) => {
+    const asset = recordValue2(entry);
+    const expectedAssetId = index === 0 ? "cover" : `inline-${String(index).padStart(2, "0")}`;
+    const relativePath = asset?.["relativePath"];
+    const sectionId = asset?.["sectionId"];
+    if (asset?.["assetId"] !== expectedAssetId || asset["role"] !== (index === 0 ? "cover" : "inline") || typeof relativePath !== "string" || relativePath.includes("\\") || path6.posix.isAbsolute(relativePath) || relativePath.split("/").some((segment) => segment === "" || segment === "." || segment === "..") || typeof asset["sha256"] !== "string" || !/^[a-f0-9]{64}$/u.test(asset["sha256"]) || index > 0 && (typeof sectionId !== "string" || !/^sec_[0-9]{2}_[a-f0-9]{8}$/u.test(sectionId)) || index === 0 && sectionId !== void 0) {
       throw new WechatCliError(
         "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
-        "\u6B63\u6587\u914D\u56FE\u9700\u8981 path \u548C placementAnchor\u3002"
+        `\u89C6\u89C9\u7D20\u6750 ${expectedAssetId} \u7684 sidecar\uFF08\u65C1\u8F66\u5143\u6570\u636E\uFF09\u65E0\u6548\u3002`
       );
     }
+    const parsedSectionId = typeof sectionId === "string" ? sectionId : void 0;
     return {
-      alt: "\u89C6\u89C9\u8BA1\u5212\u951A\u70B9\u6821\u9A8C",
-      logicalPath: asset["path"],
-      placementAnchor: asset["placementAnchor"]
+      assetId: expectedAssetId,
+      relativePath,
+      role: index === 0 ? "cover" : "inline",
+      ...parsedSectionId === void 0 ? {} : { sectionId: parsedSectionId },
+      sha256: asset["sha256"]
     };
   });
-  injectCollectedImages(articleSource, images);
+  return {
+    articleSha256: sidecar["articleSha256"],
+    assets: parsedAssets,
+    localPreviewPath: sidecar["localPreviewPath"],
+    publishingVisualPlanPath: sidecar["publishingVisualPlanPath"],
+    version: 1,
+    visualPlanSha256: sidecar["visualPlanSha256"]
+  };
+}
+function workflowSha256(value) {
+  return createHash5("sha256").update(value).digest("hex");
 }
-async function plannedVisualAssets(visualPlanFile, assetsDirectoryInput) {
+function semanticVisualPlan(source, sections) {
+  const plan = parsedVisualPlan(source);
+  const cover = recordValue2(plan["cover"]);
+  const inline = Array.isArray(plan["inline"]) ? plan["inline"] : [];
+  if (typeof cover?.["purpose"] !== "string" || cover["purpose"].trim().length === 0) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+      "\u89C6\u89C9\u8BA1\u5212\u9700\u8981\u8BF4\u660E\u5C01\u9762\u7684\u5185\u5BB9\u76EE\u7684\u3002"
+    );
+  }
+  const sectionIds = new Set(sections.map((section) => section.sectionId));
+  if (inline.length > MAXIMUM_INLINE_IMAGES) {
+    throw new WechatCliError("DXC_PUBLISHING_TOO_MANY_INLINE_IMAGES");
+  }
+  const seenSections = /* @__PURE__ */ new Set();
+  const parsedInline = inline.map((entry) => {
+    const item = recordValue2(entry);
+    if (typeof item?.["sectionId"] !== "string" || !sectionIds.has(item["sectionId"]) || typeof item["purpose"] !== "string" || item["purpose"].trim().length === 0 || seenSections.has(item["sectionId"])) {
+      throw new WechatCliError(
+        "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+        "\u6B63\u6587\u89C6\u89C9\u8BA1\u5212\u5FC5\u987B\u4E3A\u6709\u6548\u4E14\u552F\u4E00\u7684 sectionId \u586B\u5199\u56FE\u7247\u76EE\u7684\u3002"
+      );
+    }
+    seenSections.add(item["sectionId"]);
+    return { purpose: item["purpose"].trim(), sectionId: item["sectionId"] };
+  });
+  return { cover: { purpose: cover["purpose"].trim() }, inline: parsedInline };
+}
+function parseWorkflowArticleSections(articleSource) {
+  const sourceHash = workflowSha256(articleSource);
+  const lines = articleSource.split(/\r?\n/u);
+  const sections = [];
+  let inFence = false;
+  for (const line of lines) {
+    if (/^\s*```/u.test(line)) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence || !/^##\s+\S/u.test(line)) {
+      continue;
+    }
+    const heading = line.replace(/^##\s+/u, "").replace(/\s+#+\s*$/u, "").trim();
+    const ordinal = sections.length + 1;
+    const identity = workflowSha256(`${sourceHash}:${ordinal}:${heading}`).slice(0, 8);
+    sections.push({
+      heading,
+      sectionId: `sec_${String(ordinal).padStart(2, "0")}_${identity}`
+    });
+  }
+  return sections;
+}
+function validateWorkflowSemanticVisualPlan(input) {
+  return semanticVisualPlan(input.source, input.sections);
+}
+function workflowVisualAssetAssignments(input) {
+  const plan = semanticVisualPlan(input.visualPlanSource, input.sections);
+  const directory = path6.join(
+    input.assetsDirectory ?? path6.join(input.projectDirectory, "assets"),
+    "visuals"
+  );
+  return [
+    { assetId: "cover", path: path6.join(directory, "cover.png"), role: "cover" },
+    ...plan.inline.map((item, index) => ({
+      assetId: `inline-${String(index + 1).padStart(2, "0")}`,
+      path: path6.join(directory, `inline-${String(index + 1).padStart(2, "0")}.png`),
+      role: "inline",
+      sectionId: item.sectionId
+    }))
+  ];
+}
+function localWorkflowPreviewHtml(prepared) {
+  const imageSources = new Map(
+    prepared.inlineAssets.map((asset) => [
+      asset.logicalPath,
+      `data:${asset.mediaType};base64,${asset.bytes.toString("base64")}`
+    ])
+  );
+  const article = rewriteWechatAssetSources(prepared.localRender.html, imageSources);
+  const coverMediaType = publishingImageMediaType(prepared.cover.path);
+  return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="referrer" content="no-referrer"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src data:; style-src 'unsafe-inline'"><title>\u672C\u5730\u5E26\u56FE\u9884\u89C8</title></head><body><main><p>\u672C\u5730\u5185\u5BB9\u4E0E\u914D\u56FE\u9884\u89C8\uFF1B\u6700\u7EC8\u4EA4\u4ED8\u4EE5\u4E91\u7AEF\u4E0D\u53EF\u53D8\u9884\u89C8\u4E3A\u51C6\u3002</p><img alt="\u5C01\u9762" style="max-width:100%" src="data:${coverMediaType};base64,${prepared.cover.bytes.toString("base64")}"><article>${article}</article></main></body></html>`;
+}
+async function finalizeWorkflowVisualAssets(input) {
+  const plan = semanticVisualPlan(input.visualPlanSource, input.sections);
+  const expected = workflowVisualAssetAssignments(input);
+  if (expected.length !== input.assignments.length || expected.some(
+    (asset, index) => asset.assetId !== input.assignments[index]?.assetId || path6.resolve(asset.path) !== path6.resolve(input.assignments[index]?.path)
+  )) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+      "\u89C6\u89C9\u7D20\u6750\u5206\u914D\u4E0E\u5F53\u524D\u5DE5\u4F5C\u9879\u4E0D\u4E00\u81F4\u3002"
+    );
+  }
+  await mkdir4(path6.join(input.assetsDirectory, "visuals"), { recursive: true });
+  const sectionIndex = new Map(input.sections.map((section, index) => [section.sectionId, index]));
+  const publishingPlanPath = path6.join(
+    input.projectDirectory,
+    WORKFLOW_PUBLISHING_VISUAL_PLAN_FILE
+  );
+  const relative = (target) => path6.relative(input.projectDirectory, target).split(path6.sep).join("/");
+  const publishingPlan = {
+    assetsDirectory: relative(input.assetsDirectory),
+    coverAsset: relative(expected[0].path),
+    inlineAssets: expected.slice(1).map((asset, index) => ({
+      assetId: asset.assetId,
+      path: relative(asset.path),
+      placementHeadingIndex: sectionIndex.get(asset.sectionId ?? ""),
+      purpose: plan.inline[index]?.purpose,
+      source: "agent-generated"
+    }))
+  };
+  await writePrivateBuffer(
+    publishingPlanPath,
+    Buffer.from(`---
+${(0, import_yaml3.stringify)(publishingPlan, { lineWidth: 0 }).trimEnd()}
+---
+`, "utf8")
+  );
+  await optimizePublishingImages({
+    projectDirectory: input.projectDirectory,
+    visualPlanFile: publishingPlanPath
+  });
+  const prepared = await preparePublishingDraft({
+    articleFile: input.articleFile,
+    assetsDirectory: input.assetsDirectory,
+    coverFile: "auto",
+    visualPlanFile: publishingPlanPath
+  });
+  const localPreviewPath = path6.join(input.projectDirectory, WORKFLOW_LOCAL_PREVIEW_FILE);
+  await writePrivateBuffer(
+    localPreviewPath,
+    Buffer.from(localWorkflowPreviewHtml(prepared), "utf8")
+  );
+  const materializedPlan = parsedVisualPlan(await readFile3(publishingPlanPath, "utf8"));
+  const materializedInline = Array.isArray(materializedPlan["inlineAssets"]) ? materializedPlan["inlineAssets"] : [];
+  const materializedCover = String(materializedPlan["coverAsset"]);
+  const materialized = [
+    { assetId: "cover", path: materializedCover, role: "cover" },
+    ...materializedInline.map((entry, index) => {
+      const item = recordValue2(entry);
+      const sectionId = expected[index + 1]?.sectionId;
+      return {
+        assetId: expected[index + 1]?.assetId ?? `inline-${index + 1}`,
+        path: String(item?.["path"]),
+        role: "inline",
+        ...sectionId === void 0 ? {} : { sectionId }
+      };
+    })
+  ];
+  const sidecar = {
+    articleSha256: workflowSha256(input.articleSource),
+    assets: await Promise.all(
+      materialized.map(async (asset) => {
+        const bytes = await readFile3(path6.join(input.projectDirectory, asset.path));
+        return {
+          assetId: asset.assetId,
+          relativePath: asset.path,
+          role: asset.role,
+          ...asset.sectionId === void 0 ? {} : { sectionId: asset.sectionId },
+          sha256: workflowSha256(bytes)
+        };
+      })
+    ),
+    localPreviewPath,
+    publishingVisualPlanPath: publishingPlanPath,
+    version: 1,
+    visualPlanSha256: workflowSha256(input.visualPlanSource)
+  };
+  await writePrivateJson(path6.join(input.projectDirectory, WORKFLOW_VISUAL_SIDECAR_FILE), sidecar);
+  return sidecar;
+}
+async function readWorkflowVisualAssetsSidecar(projectDirectory) {
+  const input = await readPublishingInput(
+    path6.join(projectDirectory, WORKFLOW_VISUAL_SIDECAR_FILE),
+    VISUAL_PLAN_MAXIMUM_BYTES2
+  );
+  try {
+    return parsedWorkflowVisualAssetsSidecar(JSON.parse(input.bytes.toString("utf8")));
+  } catch (error) {
+    if (error instanceof WechatCliError) {
+      throw error;
+    }
+    throw new WechatCliError(
+      "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+      "\u89C6\u89C9\u7D20\u6750 sidecar\uFF08\u65C1\u8F66\u5143\u6570\u636E\uFF09\u65E0\u6CD5\u89E3\u6790\u3002"
+    );
+  }
+}
+async function workflowVisualAssetsFingerprint(projectDirectory) {
+  try {
+    const sidecar = await readWorkflowVisualAssetsSidecar(projectDirectory);
+    const assets = await Promise.all(
+      sidecar.assets.map(async (asset) => {
+        const target = path6.resolve(projectDirectory, asset.relativePath);
+        if (!isWithinDirectory(target, projectDirectory)) {
+          return { assetId: asset.assetId, state: "invalid" };
+        }
+        try {
+          const input = await readPublishingInput(
+            target,
+            asset.role === "cover" ? MAXIMUM_IMAGE_BYTES : MAXIMUM_INLINE_IMAGE_BYTES,
+            asset.role === "cover" ? "cover" : "inline-image"
+          );
+          return { assetId: asset.assetId, sha256: workflowSha256(input.bytes) };
+        } catch {
+          return { assetId: asset.assetId, state: "invalid" };
+        }
+      })
+    );
+    return workflowSha256(JSON.stringify({ assets, sidecar }));
+  } catch {
+    return workflowSha256("visual-assets:missing-or-invalid");
+  }
+}
+async function validateWorkflowVisualAssets(input) {
+  const sidecar = await readWorkflowVisualAssetsSidecar(input.projectDirectory);
+  if (sidecar.articleSha256 !== workflowSha256(input.articleSource) || sidecar.visualPlanSha256 !== workflowSha256(input.visualPlanSource) || path6.resolve(sidecar.localPreviewPath) !== path6.resolve(input.projectDirectory, WORKFLOW_LOCAL_PREVIEW_FILE) || path6.resolve(sidecar.publishingVisualPlanPath) !== path6.resolve(input.projectDirectory, WORKFLOW_PUBLISHING_VISUAL_PLAN_FILE)) {
+    throw new WechatCliError(
+      "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+      "\u6587\u7AE0\u3001\u89C6\u89C9\u8BA1\u5212\u6216\u672C\u5730\u9884\u89C8\u4E0E\u89C6\u89C9\u7D20\u6750 sidecar\uFF08\u65C1\u8F66\u5143\u6570\u636E\uFF09\u4E0D\u4E00\u81F4\u3002"
+    );
+  }
+  for (const asset of sidecar.assets) {
+    const target = path6.resolve(input.projectDirectory, asset.relativePath);
+    if (!isWithinDirectory(target, path6.resolve(input.assetsDirectory))) {
+      throw new WechatCliError(
+        "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+        `\u89C6\u89C9\u7D20\u6750 ${asset.assetId} \u4E0D\u5728\u9879\u76EE\u7D20\u6750\u76EE\u5F55\u4E2D\u3002`
+      );
+    }
+    const materialized = await readPublishingInput(
+      target,
+      asset.role === "cover" ? MAXIMUM_IMAGE_BYTES : MAXIMUM_INLINE_IMAGE_BYTES,
+      asset.role === "cover" ? "cover" : "inline-image"
+    );
+    if (workflowSha256(materialized.bytes) !== asset.sha256) {
+      throw new WechatCliError(
+        "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+        `\u89C6\u89C9\u7D20\u6750 ${asset.assetId} \u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u5B8C\u6210 visual-plan \u9636\u6BB5\u3002`
+      );
+    }
+  }
+  await readPublishingInput(
+    sidecar.publishingVisualPlanPath,
+    VISUAL_PLAN_MAXIMUM_BYTES2,
+    "visual-plan"
+  );
+  return sidecar;
+}
+async function plannedVisualAssets(visualPlanFile, assetsDirectoryInput, maximumCoverBytes = MAXIMUM_IMAGE_BYTES, maximumInlineBytes = MAXIMUM_INLINE_IMAGE_BYTES) {
   let source;
   try {
-    source = (await readPublishingInput(visualPlanFile, VISUAL_PLAN_MAXIMUM_BYTES, "visual-plan")).bytes.toString("utf8");
+    source = (await readPublishingInput(visualPlanFile, VISUAL_PLAN_MAXIMUM_BYTES2, "visual-plan")).bytes.toString("utf8");
   } catch {
     throw new WechatCliError("DXC_PUBLISHING_VISUAL_PLAN_INVALID");
   }
@@ -30167,12 +30971,12 @@ async function plannedVisualAssets(visualPlanFile, assetsDirectoryInput) {
       "\u4F7F\u7528\u89C6\u89C9\u8BA1\u5212\u65F6\u5FC5\u987B\u663E\u5F0F\u63D0\u4F9B\u5176\u58F0\u660E\u7684\u7D20\u6750\u76EE\u5F55\u3002"
     );
   }
-  const assetsDirectory = path5.resolve(assetsDirectoryInput);
+  const assetsDirectory = path6.resolve(assetsDirectoryInput);
   const projectDirectory = commonDirectory(
-    path5.dirname(path5.resolve(visualPlanFile)),
+    path6.dirname(path6.resolve(visualPlanFile)),
     assetsDirectory
   );
-  const declaredAssetsDirectory = typeof plan["assetsDirectory"] === "string" ? path5.resolve(projectDirectory, plan["assetsDirectory"]) : assetsDirectory;
+  const declaredAssetsDirectory = typeof plan["assetsDirectory"] === "string" ? path6.resolve(projectDirectory, plan["assetsDirectory"]) : assetsDirectory;
   if (!isWithinDirectory(assetsDirectory, declaredAssetsDirectory)) {
     throw new WechatCliError(
       "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
@@ -30180,7 +30984,7 @@ async function plannedVisualAssets(visualPlanFile, assetsDirectoryInput) {
     );
   }
   const resolvePlannedAsset = (assetPath) => {
-    const target = path5.resolve(projectDirectory, assetPath);
+    const target = path6.resolve(projectDirectory, assetPath);
     if (!isWithinDirectory(target, declaredAssetsDirectory) || !isWithinDirectory(target, assetsDirectory)) {
       throw new WechatCliError("DXC_PUBLISHING_VISUAL_PLAN_INVALID");
     }
@@ -30189,7 +30993,7 @@ async function plannedVisualAssets(visualPlanFile, assetsDirectoryInput) {
   const coverAbsolutePath = resolvePlannedAsset(coverAsset);
   await readContainedPublishingInput(
     coverAbsolutePath,
-    MAXIMUM_IMAGE_BYTES,
+    maximumCoverBytes,
     [assetsDirectory],
     "cover"
   );
@@ -30197,23 +31001,24 @@ async function plannedVisualAssets(visualPlanFile, assetsDirectoryInput) {
     coverAbsolutePath,
     inline: await Promise.all(
       inlineAssets.map(async (rawAsset) => {
-        const asset = recordValue(rawAsset);
-        if (typeof asset?.["path"] !== "string" || typeof asset["placementAnchor"] !== "string") {
+        const asset = recordValue2(rawAsset);
+        const headingIndex = asset?.["placementHeadingIndex"];
+        if (typeof asset?.["path"] !== "string" || typeof asset["placementAnchor"] !== "string" && (!Number.isInteger(headingIndex) || Number(headingIndex) < 0)) {
           throw new WechatCliError(
             "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
-            "\u6B63\u6587\u914D\u56FE\u9700\u8981 path \u548C placementAnchor\u3002"
+            "\u6B63\u6587\u914D\u56FE\u9700\u8981\u5B89\u5168\u8DEF\u5F84\u548C\u6709\u6548\u7AE0\u8282\u5F15\u7528\u3002"
           );
         }
         const absolutePath = resolvePlannedAsset(asset["path"]);
         if (!isWithinDirectory(absolutePath, assetsDirectory)) {
           throw new WechatCliError(
             "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
-            `\u89C6\u89C9\u8BA1\u5212\u58F0\u660E\u7684\u7D20\u6750 ${path5.posix.basename(asset["path"])} \u4E0D\u5728\u6307\u5B9A\u7D20\u6750\u76EE\u5F55\u4E2D\u3002`
+            `\u89C6\u89C9\u8BA1\u5212\u58F0\u660E\u7684\u7D20\u6750 ${path6.posix.basename(asset["path"])} \u4E0D\u5728\u6307\u5B9A\u7D20\u6750\u76EE\u5F55\u4E2D\u3002`
           );
         }
         await readContainedPublishingInput(
           absolutePath,
-          MAXIMUM_INLINE_IMAGE_BYTES,
+          maximumInlineBytes,
           [assetsDirectory],
           "inline-image"
         );
@@ -30224,13 +31029,14 @@ async function plannedVisualAssets(visualPlanFile, assetsDirectoryInput) {
             "\u6B63\u6587\u914D\u56FE\u7684\u539F\u59CB\u8DEF\u5F84\u5FC5\u987B\u662F\u9879\u76EE\u5185\u5B89\u5168\u76F8\u5BF9\u8DEF\u5F84\u3002"
           );
         }
-        const digest = createHash4("sha256").update(absolutePath).digest("hex").slice(0, 12);
-        const fileName = safeFileName(path5.basename(absolutePath)) || `visual-${digest}.png`;
+        const digest = createHash5("sha256").update(absolutePath).digest("hex").slice(0, 12);
+        const fileName = safeFileName(path6.basename(absolutePath)) || `visual-${digest}.png`;
         return {
           absolutePath,
-          alt: typeof asset["purpose"] === "string" ? asset["purpose"] : path5.basename(absolutePath, path5.extname(absolutePath)),
+          alt: typeof asset["purpose"] === "string" ? asset["purpose"] : path6.basename(absolutePath, path6.extname(absolutePath)),
           logicalPath: `assets/dxc-visuals/${digest}-${fileName}`,
-          placementAnchor: asset["placementAnchor"],
+          ...typeof headingIndex === "number" ? { headingIndex } : {},
+          ...typeof asset["placementAnchor"] === "string" ? { placementAnchor: asset["placementAnchor"] } : {},
           plannedPath: asset["path"],
           ...sourceLogicalPath === void 0 ? {} : { sourceLogicalPath }
         };
@@ -30248,7 +31054,7 @@ function publishingArticleSource(source, digestOverride) {
   if (yamlSource === void 0 || body === void 0) {
     throw new WechatCliError("DXC_PUBLISHING_ARTICLE_INVALID");
   }
-  const document = (0, import_yaml2.parseDocument)(yamlSource, { uniqueKeys: true });
+  const document = (0, import_yaml3.parseDocument)(yamlSource, { uniqueKeys: true });
   if (document.errors.length > 0) {
     throw new WechatCliError("DXC_PUBLISHING_ARTICLE_INVALID");
   }
@@ -30273,21 +31079,21 @@ async function preparePublishingDraft(input) {
   } catch {
     throw new WechatCliError("DXC_PUBLISHING_ARTICLE_INVALID");
   }
-  const articleDirectory = path5.dirname(articleInput.path);
+  const articleDirectory = path6.dirname(articleInput.path);
   const availableImages = await collectedImages(input.assetsDirectory, articleDirectory);
   const availableByFileName = new Map(
-    availableImages.map((candidate) => [path5.basename(candidate), candidate])
+    availableImages.map((candidate) => [path6.basename(candidate), candidate])
   );
-  const projectDirectory = input.assetsDirectory === void 0 ? articleDirectory : commonDirectory(articleDirectory, path5.resolve(input.assetsDirectory));
-  const resolveDeclaredAsset = (logicalPath) => availableByFileName.get(path5.posix.basename(logicalPath)) ?? path5.resolve(projectDirectory, logicalPath);
+  const projectDirectory = input.assetsDirectory === void 0 ? articleDirectory : commonDirectory(articleDirectory, path6.resolve(input.assetsDirectory));
+  const resolveDeclaredAsset = (logicalPath) => availableByFileName.get(path6.posix.basename(logicalPath)) ?? path6.resolve(projectDirectory, logicalPath);
   const referenced = new Set(logicalInlinePaths(originalBundle));
   const automaticAssetDirectories = [
     articleDirectory,
-    ...input.assetsDirectory === void 0 ? [] : [path5.resolve(input.assetsDirectory)]
+    ...input.assetsDirectory === void 0 ? [] : [path6.resolve(input.assetsDirectory)]
   ];
   const articleCoverCandidate = originalBundle.coverImage !== void 0 && isSafeLogicalAssetPath(originalBundle.coverImage) ? resolveDeclaredAsset(originalBundle.coverImage) : void 0;
   const namedCoverCandidate = availableImages.find(
-    (candidate) => /^cover(?:[._-]|$)/iu.test(path5.basename(candidate))
+    (candidate) => /^cover(?:[._-]|$)/iu.test(path6.basename(candidate))
   );
   const explicitCover = input.coverFile !== void 0 && input.coverFile !== "auto" ? input.coverFile : void 0;
   const planned = input.visualPlanFile === void 0 ? void 0 : await plannedVisualAssets(input.visualPlanFile, input.assetsDirectory);
@@ -30313,16 +31119,16 @@ async function preparePublishingDraft(input) {
   const coverCandidate = explicitCover ?? planned?.coverAbsolutePath ?? articleCoverCandidate ?? namedCoverCandidate;
   const coverMode = explicitCover !== void 0 ? "explicit-file" : planned?.coverAbsolutePath !== void 0 ? "visual-plan" : articleCoverCandidate !== void 0 ? "article-frontmatter" : namedCoverCandidate !== void 0 ? "assets-directory" : void 0;
   const pickupCandidates = availableImages.filter(
-    (candidate) => candidate !== namedCoverCandidate && candidate !== articleCoverCandidate && !referencedFiles.has(path5.resolve(candidate)) && input.visualPlanFile === void 0
+    (candidate) => candidate !== namedCoverCandidate && candidate !== articleCoverCandidate && !referencedFiles.has(path6.resolve(candidate)) && input.visualPlanFile === void 0
   );
   const injected = [
     ...plannedInlineForInjection,
     ...pickupCandidates.slice(0, Math.max(0, MAXIMUM_INLINE_IMAGES - referenced.size)).map((candidate) => {
-      const digest = createHash4("sha256").update(candidate).digest("hex").slice(0, 12);
-      const fileName = safeFileName(path5.basename(candidate)) || `visual-${digest}.png`;
+      const digest = createHash5("sha256").update(candidate).digest("hex").slice(0, 12);
+      const fileName = safeFileName(path6.basename(candidate)) || `visual-${digest}.png`;
       return {
         absolutePath: candidate,
-        alt: path5.basename(candidate, path5.extname(candidate)),
+        alt: path6.basename(candidate, path6.extname(candidate)),
         logicalPath: `assets/dxc-visuals/${digest}-${fileName}`
       };
     }).filter((asset) => !referenced.has(asset.logicalPath))
@@ -30366,7 +31172,7 @@ async function preparePublishingDraft(input) {
   );
   const inlineAssets = await Promise.all(
     logicalInlinePaths(bundle).map(async (logicalPath) => {
-      const target = injectedByLogicalPath.get(logicalPath) ?? referencedFilesByLogicalPath.get(logicalPath) ?? path5.resolve(articleDirectory, logicalPath);
+      const target = injectedByLogicalPath.get(logicalPath) ?? referencedFilesByLogicalPath.get(logicalPath) ?? path6.resolve(articleDirectory, logicalPath);
       const asset = await readContainedPublishingInput(
         target,
         MAXIMUM_INLINE_IMAGE_BYTES,
@@ -30407,354 +31213,6 @@ async function preparePublishingDraft(input) {
   };
 }
 
-// apps/cli/src/publishing-image-optimization.ts
-var import_yaml3 = __toESM(require_dist(), 1);
-import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
-import { constants as fileConstants2 } from "node:fs";
-import {
-  lstat as lstat5,
-  mkdir as mkdir3,
-  open as open2,
-  readFile as readFile2,
-  realpath as realpath2,
-  rename as rename3,
-  unlink,
-  writeFile
-} from "node:fs/promises";
-import path6 from "node:path";
-import sharp2 from "sharp";
-var MAXIMUM_INPUT_BYTES = 32 * 1024 * 1024;
-var INLINE_IMAGE_LIMIT = 1024 * 1024 - 1;
-var INLINE_IMAGE_TARGET = 950 * 1024;
-var COVER_IMAGE_LIMIT = 5 * 1024 * 1024;
-var COVER_IMAGE_TARGET = 4500 * 1024;
-var VISUAL_PLAN_MAXIMUM_BYTES2 = 128 * 1024;
-var VISUAL_PLAN_FRONTMATTER2 = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/u;
-function sha256(value) {
-  return createHash5("sha256").update(value).digest("hex");
-}
-function safeDerivativeBase(value) {
-  return value.normalize("NFKC").replaceAll(/[^A-Za-z0-9._-]+/gu, "-").replaceAll(/^-+|-+$/gu, "").slice(0, 80) || "image";
-}
-function recordValue2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function portablePath(value, label) {
-  if (typeof value !== "string" || value.trim().length === 0 || path6.isAbsolute(value) || value.includes("\\") || value.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      `${label} \u5FC5\u987B\u662F\u9879\u76EE\u5185\u4F7F\u7528 / \u5206\u9694\u7684\u5B89\u5168\u76F8\u5BF9\u8DEF\u5F84\u3002`
-    );
-  }
-  return value;
-}
-function isWithin(target, directory) {
-  const relative = path6.relative(directory, target);
-  return relative === "" || !relative.startsWith(`..${path6.sep}`) && relative !== "..";
-}
-async function regularImage(target) {
-  let handle;
-  try {
-    handle = await open2(target, fileConstants2.O_RDONLY | fileConstants2.O_NOFOLLOW);
-    const metadata = await handle.stat();
-    if (!metadata.isFile() || metadata.size <= 0 || metadata.size > MAXIMUM_INPUT_BYTES) {
-      throw new Error("invalid image");
-    }
-    return await handle.readFile();
-  } catch {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      `\u65E0\u6CD5\u5B89\u5168\u8BFB\u53D6\u56FE\u7247 ${path6.basename(target)}\uFF1B\u6587\u4EF6\u5FC5\u987B\u662F\u5C0F\u4E8E ${MAXIMUM_INPUT_BYTES} bytes \u7684\u666E\u901A\u6587\u4EF6\u3002`
-    );
-  } finally {
-    await handle?.close();
-  }
-}
-async function requirePreservedAlpha(bytes) {
-  const metadata = await sharp2(bytes, {
-    failOn: "error",
-    limitInputPixels: 8e7
-  }).metadata();
-  if (metadata.format !== "png" || metadata.hasAlpha !== true) {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_ALPHA_LOST",
-      "\u900F\u660E\u56FE\u7247\u4F18\u5316\u540E\u4E22\u5931\u900F\u660E\u901A\u9053\uFF1B\u5DF2\u963B\u65AD\u4E14\u4E0D\u4F1A\u8986\u76D6\u539F\u56FE\u3002"
-    );
-  }
-}
-async function decodedImageMetadata(source, sourcePath) {
-  let metadata;
-  try {
-    metadata = await sharp2(source, { failOn: "error", limitInputPixels: 8e7 }).metadata();
-  } catch {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      "\u56FE\u7247\u65E0\u6CD5\u88AB\u5B89\u5168\u89E3\u7801\uFF1B\u4EC5\u652F\u6301\u6709\u6548 PNG/JPEG\u3002"
-    );
-  }
-  const extension = path6.extname(sourcePath).toLowerCase();
-  const expectedFormat = extension === ".png" ? "png" : extension === ".jpg" || extension === ".jpeg" ? "jpeg" : void 0;
-  if (expectedFormat === void 0 || metadata.format !== expectedFormat || metadata.width === void 0 || metadata.height === void 0) {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      "\u56FE\u7247\u6269\u5C55\u540D\u3001\u771F\u5B9E\u683C\u5F0F\u6216\u5C3A\u5BF8\u65E0\u6548\uFF1B\u4EC5\u652F\u6301\u6269\u5C55\u540D\u4E0E\u5185\u5BB9\u4E00\u81F4\u7684 PNG/JPEG\u3002"
-    );
-  }
-  return {
-    format: expectedFormat,
-    hasAlpha: metadata.hasAlpha === true,
-    height: metadata.height,
-    width: metadata.width
-  };
-}
-async function writeExclusiveOrVerify(target, bytes) {
-  await mkdir3(path6.dirname(target), { recursive: true, mode: 448 });
-  try {
-    await writeFile(target, bytes, { flag: "wx", mode: 384 });
-    return true;
-  } catch (error) {
-    if (error.code !== "EEXIST") {
-      throw error;
-    }
-    const existing = await regularImage(target);
-    if (sha256(existing) !== sha256(bytes)) {
-      throw new WechatCliError(
-        "DXC_PUBLISHING_IMAGE_OPTIMIZATION_CONFLICT",
-        `\u4F18\u5316\u76EE\u6807 ${path6.basename(target)} \u5DF2\u5B58\u5728\u4F46\u5185\u5BB9\u4E0D\u540C\uFF1B\u672A\u8986\u76D6\u4EFB\u4F55\u6587\u4EF6\u3002`
-      );
-    }
-    return false;
-  }
-}
-async function safeRealPathWithin(target, directory, label) {
-  const resolved = await realpath2(target).catch(() => void 0);
-  if (resolved === void 0 || !isWithin(resolved, directory)) {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      `${label} \u7684\u771F\u5B9E\u8DEF\u5F84\u4E0D\u5728\u5141\u8BB8\u7684\u9879\u76EE\u76EE\u5F55\u5185\u3002`
-    );
-  }
-  return resolved;
-}
-async function ensureSafeOptimizedDirectory(assetsDirectory, realAssetsDirectory) {
-  const optimizedDirectory = path6.join(assetsDirectory, "optimized");
-  await mkdir3(optimizedDirectory, { recursive: true, mode: 448 });
-  const metadata = await lstat5(optimizedDirectory).catch(() => void 0);
-  if (metadata === void 0 || !metadata.isDirectory() || metadata.isSymbolicLink()) {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      "\u4F18\u5316\u76EE\u5F55\u5FC5\u987B\u662F\u7D20\u6750\u76EE\u5F55\u5185\u7684\u666E\u901A\u76EE\u5F55\uFF0C\u4E0D\u80FD\u662F\u7B26\u53F7\u94FE\u63A5\u3002"
-    );
-  }
-  await safeRealPathWithin(optimizedDirectory, realAssetsDirectory, "\u4F18\u5316\u76EE\u5F55");
-  return optimizedDirectory;
-}
-async function writePlanAtomically(target, expectedSource, source) {
-  const temporary = `${target}.${randomUUID3()}.tmp`;
-  try {
-    await writeFile(temporary, source, { encoding: "utf8", flag: "wx", mode: 384 });
-    if (await readFile2(target, "utf8") !== expectedSource) {
-      throw new WechatCliError(
-        "DXC_PUBLISHING_IMAGE_OPTIMIZATION_CONFLICT",
-        "\u89C6\u89C9\u8BA1\u5212\u5728\u56FE\u7247\u4F18\u5316\u671F\u95F4\u5DF2\u88AB\u5176\u4ED6\u64CD\u4F5C\u4FEE\u6539\uFF1B\u672A\u8986\u76D6\u65B0\u5185\u5BB9\uFF0C\u8BF7\u91CD\u65B0\u8BFB\u53D6\u540E\u518D\u8BD5\u3002"
-      );
-    }
-    await rename3(temporary, target);
-  } finally {
-    await unlink(temporary).catch(() => void 0);
-  }
-}
-function candidateWidths(width) {
-  return [.../* @__PURE__ */ new Set([width, 2400, 2e3, 1600, 1280, 1080, 900, 720])].filter((candidate) => candidate > 0 && candidate <= width).sort((left, right) => right - left);
-}
-async function optimizedImage(source, targetBytes, metadata) {
-  const hasAlpha = metadata.hasAlpha;
-  for (const width of candidateWidths(metadata.width)) {
-    if (hasAlpha) {
-      const lossless = await sharp2(source, { failOn: "error", limitInputPixels: 8e7 }).rotate().resize({ fit: "inside", width, withoutEnlargement: true }).png({ compressionLevel: 9, effort: 10 }).toBuffer();
-      if (lossless.byteLength <= targetBytes) {
-        await requirePreservedAlpha(lossless);
-        return { alphaPreserved: true, bytes: lossless, extension: ".png" };
-      }
-      for (const colours of [256, 192, 128, 96, 64]) {
-        const quantized = await sharp2(source, {
-          failOn: "error",
-          limitInputPixels: 8e7
-        }).rotate().resize({ fit: "inside", width, withoutEnlargement: true }).png({ colours, compressionLevel: 9, effort: 10, palette: true }).toBuffer();
-        if (quantized.byteLength <= targetBytes) {
-          await requirePreservedAlpha(quantized);
-          return { alphaPreserved: true, bytes: quantized, extension: ".png" };
-        }
-      }
-      continue;
-    }
-    for (const quality of [88, 82, 76, 70, 64, 58]) {
-      const jpeg = await sharp2(source, { failOn: "error", limitInputPixels: 8e7 }).rotate().resize({ fit: "inside", width, withoutEnlargement: true }).jpeg({ chromaSubsampling: "4:4:4", mozjpeg: true, progressive: true, quality }).toBuffer();
-      if (jpeg.byteLength <= targetBytes) {
-        return { alphaPreserved: true, bytes: jpeg, extension: ".jpg" };
-      }
-    }
-  }
-  throw new WechatCliError(
-    "DXC_PUBLISHING_IMAGE_OPTIMIZATION_LIMIT_UNREACHABLE",
-    `\u65E0\u6CD5\u5728\u4E0D\u4E22\u5931\u900F\u660E\u901A\u9053\u6216\u4F4E\u4E8E\u6700\u5C0F\u5C3A\u5BF8\u7B56\u7565\u7684\u524D\u63D0\u4E0B\u538B\u5230 ${targetBytes} bytes\uFF1B\u8BF7\u66F4\u6362\u6216\u88C1\u526A\u56FE\u7247\u3002`
-  );
-}
-async function optimizePublishingImages(input) {
-  const projectDirectory = path6.resolve(input.projectDirectory);
-  const visualPlanPath = path6.resolve(input.visualPlanFile);
-  if (!isWithin(visualPlanPath, projectDirectory)) {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      "\u89C6\u89C9\u8BA1\u5212\u5FC5\u987B\u4F4D\u4E8E\u5F53\u524D\u5185\u5BB9\u9879\u76EE\u5185\u3002"
-    );
-  }
-  const projectMetadata = await lstat5(projectDirectory).catch(() => void 0);
-  const visualPlanMetadata = await lstat5(visualPlanPath).catch(() => void 0);
-  if (projectMetadata === void 0 || !projectMetadata.isDirectory() || projectMetadata.isSymbolicLink() || visualPlanMetadata === void 0 || !visualPlanMetadata.isFile() || visualPlanMetadata.isSymbolicLink() || visualPlanMetadata.size > VISUAL_PLAN_MAXIMUM_BYTES2) {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      "\u5185\u5BB9\u9879\u76EE\u548C\u89C6\u89C9\u8BA1\u5212\u5FC5\u987B\u662F\u975E\u7B26\u53F7\u94FE\u63A5\u7684\u666E\u901A\u76EE\u5F55\u4E0E\u6587\u4EF6\u3002"
-    );
-  }
-  const realProjectDirectory = await realpath2(projectDirectory);
-  await safeRealPathWithin(visualPlanPath, realProjectDirectory, "\u89C6\u89C9\u8BA1\u5212");
-  const source = await readFile2(visualPlanPath, "utf8").catch(() => "");
-  if (Buffer.byteLength(source, "utf8") > VISUAL_PLAN_MAXIMUM_BYTES2) {
-    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
-  }
-  const match = VISUAL_PLAN_FRONTMATTER2.exec(source);
-  if (match?.[1] === void 0 || match[2] === void 0) {
-    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
-  }
-  let frontmatter2;
-  try {
-    frontmatter2 = recordValue2((0, import_yaml3.parse)(match[1], { maxAliasCount: 10, uniqueKeys: true }));
-  } catch {
-    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
-  }
-  if (frontmatter2 === void 0) {
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-      "\u89C6\u89C9\u8BA1\u5212\u7684 YAML \u5934\u65E0\u6CD5\u8BFB\u53D6\u3002"
-    );
-  }
-  const assetsRelative = frontmatter2["assetsDirectory"] === void 0 ? "assets" : portablePath(frontmatter2["assetsDirectory"], "assetsDirectory");
-  frontmatter2["assetsDirectory"] = assetsRelative;
-  frontmatter2["inlineImagesSupported"] = true;
-  const assetsDirectory = path6.resolve(projectDirectory, assetsRelative);
-  if (!isWithin(assetsDirectory, projectDirectory)) {
-    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
-  }
-  const assetsMetadata = await lstat5(assetsDirectory).catch(() => void 0);
-  if (assetsMetadata === void 0 || !assetsMetadata.isDirectory() || assetsMetadata.isSymbolicLink()) {
-    throw new WechatCliError("DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID");
-  }
-  const realAssetsDirectory = await safeRealPathWithin(
-    assetsDirectory,
-    realProjectDirectory,
-    "\u7D20\u6750\u76EE\u5F55"
-  );
-  const inlineAssets = Array.isArray(frontmatter2["inlineAssets"]) ? frontmatter2["inlineAssets"] : [];
-  const entries = [
-    {
-      limit: COVER_IMAGE_LIMIT,
-      record: { path: frontmatter2["coverAsset"] },
-      role: "cover",
-      target: COVER_IMAGE_TARGET
-    },
-    ...inlineAssets.map((asset) => ({
-      limit: INLINE_IMAGE_LIMIT,
-      record: recordValue2(asset),
-      role: "inline",
-      target: INLINE_IMAGE_TARGET
-    }))
-  ];
-  const createdFiles = [];
-  const mutations = [];
-  let unchangedCount = 0;
-  let optimizedDirectory;
-  try {
-    for (const entry of entries) {
-      const assetPath = portablePath(entry.record?.["path"], `${entry.role} \u56FE\u7247\u8DEF\u5F84`);
-      const absolutePath = path6.resolve(projectDirectory, assetPath);
-      if (!isWithin(absolutePath, assetsDirectory)) {
-        throw new WechatCliError(
-          "DXC_PUBLISHING_IMAGE_OPTIMIZATION_INVALID",
-          `${assetPath} \u4E0D\u5728\u89C6\u89C9\u8BA1\u5212\u58F0\u660E\u7684\u7D20\u6750\u76EE\u5F55\u5185\u3002`
-        );
-      }
-      await safeRealPathWithin(absolutePath, realAssetsDirectory, `${assetPath} \u56FE\u7247`);
-      const bytes = await regularImage(absolutePath);
-      const metadata = await decodedImageMetadata(bytes, assetPath);
-      const beforeSha256 = sha256(bytes);
-      let finalPath = assetPath;
-      let finalBytes = bytes;
-      let alphaPreserved = true;
-      if (bytes.byteLength > entry.limit) {
-        const optimized = await optimizedImage(bytes, entry.target, metadata);
-        optimizedDirectory ??= await ensureSafeOptimizedDirectory(
-          assetsDirectory,
-          realAssetsDirectory
-        );
-        const baseName = safeDerivativeBase(path6.basename(assetPath, path6.extname(assetPath)));
-        const optimizedSha256 = sha256(optimized.bytes);
-        const optimizedName = `${baseName}-${entry.role}-${beforeSha256.slice(0, 12)}-${optimizedSha256.slice(0, 12)}${optimized.extension}`;
-        const optimizedAbsolute = path6.join(optimizedDirectory, optimizedName);
-        const created = await writeExclusiveOrVerify(optimizedAbsolute, optimized.bytes);
-        if (created) {
-          createdFiles.push(optimizedAbsolute);
-        }
-        finalPath = path6.relative(projectDirectory, optimizedAbsolute).split(path6.sep).join("/");
-        finalBytes = optimized.bytes;
-        alphaPreserved = optimized.alphaPreserved;
-        mutations.push({
-          alphaPreserved,
-          afterBytes: finalBytes.byteLength,
-          afterSha256: sha256(finalBytes),
-          beforeBytes: bytes.byteLength,
-          beforeSha256,
-          from: assetPath,
-          role: entry.role,
-          to: finalPath
-        });
-      } else {
-        unchangedCount += 1;
-      }
-      if (entry.role === "cover") {
-        frontmatter2["coverAsset"] = finalPath;
-        frontmatter2["coverSha256"] = sha256(finalBytes);
-      } else if (entry.record !== void 0) {
-        if (finalPath !== assetPath && entry.record["sourcePath"] === void 0) {
-          entry.record["sourcePath"] = assetPath;
-        }
-        entry.record["path"] = finalPath;
-        entry.record["sha256"] = sha256(finalBytes);
-      }
-    }
-    frontmatter2["inlineAssets"] = inlineAssets;
-    const normalizedSource = `---
-${(0, import_yaml3.stringify)(frontmatter2, { lineWidth: 0 }).trimEnd()}
----
-${match[2]}`;
-    await writePlanAtomically(visualPlanPath, source, normalizedSource);
-  } catch (error) {
-    await Promise.all(createdFiles.map((target) => unlink(target).catch(() => void 0)));
-    if (error instanceof WechatCliError) {
-      throw error;
-    }
-    throw new WechatCliError(
-      "DXC_PUBLISHING_IMAGE_OPTIMIZATION_FAILED",
-      "\u56FE\u7247\u4F18\u5316\u672A\u5B8C\u6210\uFF1B\u539F\u56FE\u548C\u89C6\u89C9\u8BA1\u5212\u5747\u672A\u88AB\u8986\u76D6\u3002"
-    );
-  }
-  return {
-    command: "wechat.draft.optimize-images",
-    data: { mutations, unchangedCount, visualPlanPath },
-    ok: true
-  };
-}
-
 // apps/cli/src/wechat.ts
 var DEFAULT_API_BASE_URL = "https://content.deployxai.com";
 var DEFAULT_POLL_INTERVAL_MS = 2e3;
@@ -30868,19 +31326,19 @@ function localPreviewOutputConflict() {
 async function ensureLocalPreviewDirectory(directory) {
   let metadata;
   try {
-    metadata = await lstat6(directory);
+    metadata = await lstat5(directory);
   } catch (error) {
     if (fileSystemErrorCode(error) !== "ENOENT") {
       throw error;
     }
     try {
-      await mkdir4(directory, { mode: 448 });
+      await mkdir5(directory, { mode: 448 });
     } catch (mkdirError) {
       if (fileSystemErrorCode(mkdirError) !== "EEXIST") {
         throw mkdirError;
       }
     }
-    metadata = await lstat6(directory);
+    metadata = await lstat5(directory);
   }
   if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
     throw localPreviewOutputConflict();
@@ -30895,7 +31353,7 @@ async function safeLocalPreviewOutput(options) {
     throw localPreviewOutputConflict();
   }
   try {
-    const projectMetadata = await lstat6(projectDirectory);
+    const projectMetadata = await lstat5(projectDirectory);
     if (!projectMetadata.isDirectory() || projectMetadata.isSymbolicLink()) {
       throw localPreviewOutputConflict();
     }
@@ -30906,7 +31364,7 @@ async function safeLocalPreviewOutput(options) {
       await ensureLocalPreviewDirectory(directory);
     }
     try {
-      const outputMetadata = await lstat6(outputFile);
+      const outputMetadata = await lstat5(outputFile);
       if (!outputMetadata.isFile() || outputMetadata.isSymbolicLink()) {
         throw localPreviewOutputConflict();
       }
@@ -31047,17 +31505,17 @@ async function readProtectedStateFile(target, invalidCode) {
   }
 }
 async function saveSession(stateDirectory, session) {
-  await mkdir4(stateDirectory, { mode: 448, recursive: true });
+  await mkdir5(stateDirectory, { mode: 448, recursive: true });
   await chmod(stateDirectory, 448);
   const target = sessionPath(stateDirectory);
   const temporary = `${target}.${process.pid}.tmp`;
-  await writeFile2(temporary, `${JSON.stringify(session)}
+  await writeFile3(temporary, `${JSON.stringify(session)}
 `, {
     encoding: "utf8",
     mode: 384
   });
   await chmod(temporary, 384);
-  await rename4(temporary, target);
+  await rename3(temporary, target);
   await chmod(target, 384);
 }
 async function readSessionValue(stateDirectory) {
@@ -31180,17 +31638,17 @@ async function loadOrCreateDeviceIdentity(stateDirectory) {
     publicKeyFingerprint: keyPair.publicKeyFingerprint,
     publicKeyPem: keyPair.publicKeyPem
   };
-  await mkdir4(stateDirectory, { mode: 448, recursive: true });
+  await mkdir5(stateDirectory, { mode: 448, recursive: true });
   await chmod(stateDirectory, 448);
   const target = deviceIdentityPath(stateDirectory);
   const temporary = `${target}.${process.pid}.tmp`;
-  await writeFile2(temporary, `${JSON.stringify(identity)}
+  await writeFile3(temporary, `${JSON.stringify(identity)}
 `, {
     encoding: "utf8",
     mode: 384
   });
   await chmod(temporary, 384);
-  await rename4(temporary, target);
+  await rename3(temporary, target);
   await chmod(target, 384);
   return { created: true, identity };
 }
@@ -31811,6 +32269,17 @@ var WechatCli = class {
     );
     return result;
   }
+  async publishingDraftDiagnostics(intentId, output) {
+    const session = await loadSession(this.#stateDirectory);
+    const { response } = await this.#authenticatedFetch(
+      session,
+      `${session.apiBaseUrl}/api/v1/draft-intents/${encodeURIComponent(intentId)}/diagnostics`
+    );
+    const result = publishingDraftAttentionDiagnosticsSchema.parse(await checkedJson(response));
+    output.writeStdout(`${JSON.stringify({ diagnostics: result })}
+`);
+    return result;
+  }
   async reverifyDraft(intentId, output) {
     const session = await loadSession(this.#stateDirectory);
     const { response } = await this.#authenticatedFetch(
@@ -32255,28 +32724,36 @@ ${session.authorizationUrl}
 };
 
 // apps/cli/src/workflow-delivery.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 import path9 from "node:path";
 
 // apps/cli/src/workflow.ts
-import { lstat as lstat7, readFile as readFile3 } from "node:fs/promises";
+import { createHash as createHash7 } from "node:crypto";
+import { lstat as lstat6, readFile as readFile4 } from "node:fs/promises";
 import path8 from "node:path";
 var import_yaml4 = __toESM(require_dist(), 1);
 var WORKFLOW_STATE_FILE = ".dxc/workflow.json";
 var WORKFLOW_STATE_MAXIMUM_BYTES = 16 * 1024;
 var ARTIFACT_MAXIMUM_BYTES = 5 * 1024 * 1024;
 var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u;
+var WORK_ITEM_PATTERN = /^wi1_([A-Za-z0-9_-]+)\.([a-f0-9]{32})$/u;
+var SCAFFOLD_MARKER = "dxcScaffold: true";
 var WorkflowCliError = class extends Error {
-  constructor(code, message) {
+  constructor(code, message, details) {
     super(message);
     this.code = code;
+    this.details = details;
     this.name = "WorkflowCliError";
   }
   code;
+  details;
 };
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function sha2562(value) {
+  return createHash7("sha256").update(value).digest("hex");
+}
 function workflowState(value, projectId) {
   if (!isRecord(value) || value["version"] !== 1 || value["projectId"] !== projectId) {
     return void 0;
@@ -32297,11 +32774,7 @@ function statePath(directory) {
   return path8.join(directory, WORKFLOW_STATE_FILE);
 }
 function projectSummary(location) {
-  return {
-    directory: location.directory,
-    projectId: location.manifest.projectId,
-    title: location.manifest.title
-  };
+  return { projectId: location.manifest.projectId, title: location.manifest.title };
 }
 function nextStep(lastCompletedStep) {
   const nextIndex = lastCompletedStep === null ? 0 : CONTENT_ARTIFACT_KINDS.indexOf(lastCompletedStep) + 1;
@@ -32312,23 +32785,16 @@ function previousStep(step) {
   return index <= 0 ? null : CONTENT_ARTIFACT_KINDS[index - 1] ?? null;
 }
 function requestedStep(value) {
-  const step = value;
-  if (!CONTENT_ARTIFACT_KINDS.includes(step)) {
+  if (!CONTENT_ARTIFACT_KINDS.includes(value)) {
     throw new WorkflowCliError(
       "DXC_WORKFLOW_STEP_INVALID",
-      `\u672A\u77E5\u9636\u6BB5 ${step}\u3002\u8BF7\u4F7F\u7528 ${CONTENT_ARTIFACT_KINDS.join("\u3001")}\u3002`
+      `\u672A\u77E5\u9636\u6BB5 ${value}\u3002\u8BF7\u4F7F\u7528 ${CONTENT_ARTIFACT_KINDS.join("\u3001")}\u3002`
     );
   }
-  return step;
-}
-function inputPaths(directory, manifest, step) {
-  const inputs = CONTENT_STAGE_INPUTS[step];
-  return [...inputs.required, ...inputs.optional].map(
-    (kind) => path8.join(directory, manifest.artifacts[kind])
-  );
+  return value;
 }
 function requiresStageConfirmation(policy, step) {
-  if (step === null || step === "delivery" || policy === "auto-until-delivery") {
+  if (step === "delivery" || policy === "auto-until-delivery") {
     return false;
   }
   if (policy === "review-every-stage") {
@@ -32348,71 +32814,264 @@ function stageLabel(step) {
     "visual-plan": "\u56FE\u7247\u548C\u89C6\u89C9\u7ED3\u679C"
   }[step];
 }
-function workItem(location, state, confirmationPolicy) {
-  const step = nextStep(state.lastCompletedStep);
-  return {
-    confirmationPolicy,
-    done: step === null,
-    inputs: step === null ? [] : inputPaths(location.directory, location.manifest, step),
-    output: step === null ? null : path8.join(location.directory, location.manifest.artifacts[step]),
-    project: projectSummary(location),
-    requiresConfirmation: requiresStageConfirmation(confirmationPolicy, step),
-    step
-  };
+function frontmatter(source) {
+  const yaml = FRONTMATTER.exec(source)?.[1];
+  if (yaml === void 0) {
+    return {};
+  }
+  try {
+    const value = (0, import_yaml4.parse)(yaml, { maxAliasCount: 10, uniqueKeys: true });
+    return isRecord(value) ? value : {};
+  } catch {
+    return {};
+  }
 }
-async function readArtifact(directory, relativePath) {
-  const target = path8.resolve(directory, relativePath);
-  const relative = path8.relative(directory, target);
+function selectedTitle(value) {
+  const title = value["selectedTitle"];
+  return typeof title === "string" && title.trim().length > 0 ? title.trim() : void 0;
+}
+function artifactPath(location, kind) {
+  return path8.join(location.directory, location.manifest.artifacts[kind]);
+}
+async function readArtifact(location, kind) {
+  const target = path8.resolve(location.directory, location.manifest.artifacts[kind]);
+  const relative = path8.relative(location.directory, target);
   if (relative.startsWith("..") || path8.isAbsolute(relative)) {
-    throw new WorkflowCliError("DXC_WORKFLOW_ARTIFACT_INVALID", "\u6B65\u9AA4\u4EA7\u7269\u8DEF\u5F84\u4E0D\u5728\u9879\u76EE\u76EE\u5F55\u4E2D\u3002");
+    throw new WorkflowCliError(
+      "DXC_WORKFLOW_ARTIFACT_INVALID",
+      `${kind} \u4EA7\u7269\u8DEF\u5F84\u4E0D\u5728\u9879\u76EE\u76EE\u5F55\u4E2D\u3002`,
+      { path: target, stage: kind }
+    );
   }
   try {
-    const metadata = await lstat7(target);
+    const metadata = await lstat6(target);
     if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size === 0 || metadata.size > ARTIFACT_MAXIMUM_BYTES) {
       throw new WorkflowCliError(
         "DXC_WORKFLOW_ARTIFACT_INVALID",
-        "\u5F53\u524D\u6B65\u9AA4\u7684\u4EA7\u7269\u4E3A\u7A7A\u3001\u8FC7\u5927\u6216\u4E0D\u662F\u666E\u901A\u6587\u4EF6\u3002"
+        `${kind} \u4EA7\u7269\u4E3A\u7A7A\u3001\u8FC7\u5927\u6216\u4E0D\u662F\u666E\u901A\u6587\u4EF6\u3002`,
+        { path: target, stage: kind }
       );
     }
-    return await readFile3(target, "utf8");
+    return await readFile4(target, "utf8");
   } catch (error) {
     if (error instanceof WorkflowCliError) {
       throw error;
     }
-    throw new WorkflowCliError(
-      "DXC_WORKFLOW_ARTIFACT_MISSING",
-      `\u5F53\u524D\u6B65\u9AA4\u5C1A\u672A\u5199\u5165 ${relativePath}\u3002`
-    );
+    throw new WorkflowCliError("DXC_WORKFLOW_ARTIFACT_MISSING", `\u7F3A\u5C11\u547D\u540D\u8F93\u5165\u6216\u4EA7\u7269 ${kind}\u3002`, {
+      path: target,
+      stage: kind
+    });
   }
 }
-function frontmatter(source) {
-  const yaml = FRONTMATTER.exec(source)?.[1];
-  if (yaml === void 0) {
-    return {};
+async function artifactAvailability(location, kind) {
+  const target = artifactPath(location, kind);
+  try {
+    const metadata = await lstat6(target);
+    if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size <= 0) {
+      return { availability: "missing" };
+    }
+    const source = await readFile4(target);
+    return { availability: "present", hash: sha2562(source), path: target };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return { availability: "missing" };
+    }
+    throw new WorkflowCliError("DXC_WORKFLOW_ARTIFACT_INVALID", `\u65E0\u6CD5\u5B89\u5168\u8BFB\u53D6\u547D\u540D\u8F93\u5165 ${kind}\u3002`, {
+      path: target,
+      stage: kind
+    });
+  }
+}
+function stageScaffold(stage, title) {
+  switch (stage) {
+    case "article":
+      return `---
+title: ""
+author: ""
+digest: ""
+tags: []
+${SCAFFOLD_MARKER}
+---
+
+# ${title}
+`;
+    case "titles":
+      return `---
+selectedTitle: ""
+${SCAFFOLD_MARKER}
+---
+
+# \u6807\u9898\u5019\u9009
+`;
+    case "visual-plan":
+      return `---
+cover:
+  purpose: ""
+inline: []
+${SCAFFOLD_MARKER}
+---
+
+# \u89C6\u89C9\u8BA1\u5212
+`;
+    case "quality-review":
+      return `---
+verdict: block
+${SCAFFOLD_MARKER}
+---
+
+# \u5BA1\u6821\u7ED3\u679C
+`;
+    case "delivery":
+      return "# \u5FAE\u4FE1\u8349\u7A3F\u4EA4\u4ED8\n";
+    default:
+      return `---
+${SCAFFOLD_MARKER}
+---
+
+# ${stageLabel(stage)}
+`;
   }
+}
+async function ensureStageScaffold(location, stage) {
+  if (stage === "delivery") {
+    return "not-applicable";
+  }
+  const target = artifactPath(location, stage);
   try {
-    const value = (0, import_yaml4.parse)(yaml, { maxAliasCount: 10, uniqueKeys: true });
-    return isRecord(value) ? value : {};
-  } catch {
-    return {};
+    const metadata = await lstat6(target);
+    if (!metadata.isFile() || metadata.isSymbolicLink()) {
+      throw new WorkflowCliError(
+        "DXC_WORKFLOW_ARTIFACT_INVALID",
+        `${stage} \u8F93\u51FA\u4F4D\u7F6E\u4E0D\u662F\u666E\u901A\u6587\u4EF6\u3002`,
+        { path: target, stage }
+      );
+    }
+    if (metadata.size > 0) {
+      return "existing";
+    }
+  } catch (error) {
+    if (error instanceof WorkflowCliError || !(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")) {
+      throw error;
+    }
   }
+  await writePrivateBuffer(target, Buffer.from(stageScaffold(stage, location.manifest.title)));
+  return "created";
 }
-function selectedTitle(value) {
-  const title = value["selectedTitle"];
-  return typeof title === "string" && title.trim().length > 0 ? title.trim() : void 0;
+async function workflowSections(location, stage) {
+  if (stage !== "visual-plan") {
+    return void 0;
+  }
+  const article = await artifactAvailability(location, "article");
+  if (article.availability === "missing") {
+    return [];
+  }
+  return parseWorkflowArticleSections(await readFile4(article.path, "utf8"));
+}
+function workflowConstraints(stage) {
+  if (stage === "article" || stage === "titles") {
+    return {
+      authorMaxCharacters: WECHAT_AUTHOR_CHARACTER_LIMIT,
+      digestMaxCharacters: WECHAT_DIGEST_CHARACTER_LIMIT,
+      titleMaxCharacters: WECHAT_TITLE_CHARACTER_LIMIT
+    };
+  }
+  if (stage === "visual-plan" || stage === "delivery") {
+    return {
+      coverMaxBytes: PUBLISHING_COVER_MAXIMUM_BYTES,
+      inlineImageMaxBytes: PUBLISHING_INLINE_IMAGE_MAXIMUM_BYTES,
+      inlineImageMaxCount: PUBLISHING_INLINE_IMAGE_MAXIMUM_COUNT,
+      supportedImageTypes: ["image/jpeg", "image/png"]
+    };
+  }
+  return {};
+}
+async function namedResources(location, stage, scaffold) {
+  const definition = CONTENT_STAGE_DEFINITIONS[stage];
+  const inputs = {};
+  for (const kind of [...definition.inputs.required, ...definition.inputs.optional]) {
+    const availability = await artifactAvailability(location, kind);
+    inputs[kind] = availability.availability === "missing" ? { availability: "missing" } : { availability: "present", path: availability.path };
+  }
+  return {
+    inputs,
+    output: { path: artifactPath(location, definition.output), scaffold }
+  };
+}
+async function inputFingerprint(location, stage) {
+  const definition = CONTENT_STAGE_DEFINITIONS[stage];
+  const inputs = {};
+  for (const kind of [...definition.inputs.required, ...definition.inputs.optional]) {
+    const availability = await artifactAvailability(location, kind);
+    inputs[kind] = availability.availability === "missing" ? { availability: "missing" } : { availability: "present", hash: availability.hash };
+  }
+  if (stage === "delivery") {
+    inputs["visual-assets"] = await workflowVisualAssetsFingerprint(location.directory);
+  }
+  return sha2562(JSON.stringify(inputs));
 }
-async function validateStageResult(step, source, location) {
-  if (source.trim().length === 0) {
-    throw new WorkflowCliError("DXC_WORKFLOW_ARTIFACT_INVALID", "\u5F53\u524D\u6B65\u9AA4\u6CA1\u6709\u53EF\u4FDD\u5B58\u7684\u5185\u5BB9\u3002");
+function cursorFingerprint(state) {
+  return sha2562(JSON.stringify(state));
+}
+function encodeWorkItem(payload) {
+  const encoded = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+  return `wi1_${encoded}.${sha2562(encoded).slice(0, 32)}`;
+}
+function decodeWorkItem(workItemId) {
+  const match = WORK_ITEM_PATTERN.exec(workItemId);
+  if (match === null || match[1] === void 0 || match[2] === void 0) {
+    throw new WorkflowCliError("DXC_WORK_ITEM_INVALID", "\u5DE5\u4F5C\u9879 ID \u683C\u5F0F\u65E0\u6548\u3002");
+  }
+  if (sha2562(match[1]).slice(0, 32) !== match[2]) {
+    throw new WorkflowCliError("DXC_WORK_ITEM_INVALID", "\u5DE5\u4F5C\u9879 ID \u5B8C\u6574\u6027\u6821\u9A8C\u5931\u8D25\u3002");
   }
-  if (step === "article") {
+  try {
+    const value = JSON.parse(Buffer.from(match[1], "base64url").toString("utf8"));
+    if (!isRecord(value) || value["version"] !== 1 || typeof value["projectId"] !== "string" || typeof value["stage"] !== "string" || !CONTENT_ARTIFACT_KINDS.includes(value["stage"]) || typeof value["action"] !== "string" || ![
+      "completed",
+      "delivery-confirm",
+      "delivery-preview",
+      "stage",
+      "stage-confirm",
+      "visual-assets"
+    ].includes(value["action"]) || typeof value["cursorFingerprint"] !== "string" || typeof value["inputFingerprint"] !== "string" || value["outputFingerprint"] !== void 0 && typeof value["outputFingerprint"] !== "string" || value["bindingFingerprint"] !== void 0 && typeof value["bindingFingerprint"] !== "string") {
+      throw new TypeError("invalid work item payload");
+    }
+    return value;
+  } catch (error) {
+    if (error instanceof WorkflowCliError) {
+      throw error;
+    }
+    throw new WorkflowCliError("DXC_WORK_ITEM_INVALID", "\u5DE5\u4F5C\u9879 ID \u8F7D\u8377\u65E0\u6548\u3002");
+  }
+}
+async function validateRequiredInputs(location, stage) {
+  for (const kind of CONTENT_STAGE_DEFINITIONS[stage].inputs.required) {
+    if ((await artifactAvailability(location, kind)).availability === "missing") {
+      throw new WorkflowCliError(
+        "DXC_WORKFLOW_INPUT_MISSING",
+        `\u5F53\u524D ${stage} \u9636\u6BB5\u7F3A\u5C11\u547D\u540D\u8F93\u5165 ${kind}\u3002`,
+        { input: kind, stage }
+      );
+    }
+  }
+}
+async function validateStageResult(stage, source, location) {
+  if (source.trim().length === 0 || source.includes(SCAFFOLD_MARKER)) {
+    throw new WorkflowCliError(
+      "DXC_WORKFLOW_ARTIFACT_INVALID",
+      `${stage} \u9636\u6BB5\u4ECD\u662F\u672A\u586B\u5199\u7684 scaffold\uFF08\u811A\u624B\u67B6\uFF09\u3002`,
+      { path: artifactPath(location, stage), stage }
+    );
+  }
+  if (stage === "article") {
     let article;
     try {
       article = parseArticleDocument(source);
     } catch {
       throw new WorkflowCliError(
         "DXC_WORKFLOW_ARTIFACT_INVALID",
-        "\u6B63\u6587\u9700\u8981\u5305\u542B\u53EF\u53D1\u5E03\u7684\u6807\u9898\u3001\u4F5C\u8005\u548C Markdown \u6B63\u6587\u3002"
+        "\u6B63\u6587\u9700\u8981\u5305\u542B\u53EF\u53D1\u5E03\u7684\u6807\u9898\u3001\u4F5C\u8005\u548C Markdown \u6B63\u6587\u3002",
+        { path: artifactPath(location, stage), stage }
       );
     }
     const lengths = {
@@ -32424,56 +33083,41 @@ async function validateStageResult(step, source, location) {
     if (invalid !== void 0) {
       throw new WorkflowCliError(
         "DXC_WORKFLOW_ARTICLE_FIELD_INVALID",
-        `${invalid} \u4E2A Unicode \u5B57\u7B26\uFF1B\u8BF7\u5728\u6B63\u6587\u9636\u6BB5\u4FEE\u6B63\u540E\u518D\u7EE7\u7EED\u3002`
+        `${invalid} \u4E2A Unicode \u5B57\u7B26\uFF1B\u8BF7\u5728\u6B63\u6587\u9636\u6BB5\u4FEE\u6B63\u540E\u518D\u7EE7\u7EED\u3002`,
+        { path: artifactPath(location, stage), stage }
       );
     }
   }
-  if (step === "titles") {
+  if (stage === "titles") {
     const title = selectedTitle(frontmatter(source));
-    if (title === void 0 || [...title].length > 32) {
+    if (title === void 0 || [...title].length > WECHAT_TITLE_CHARACTER_LIMIT) {
       throw new WorkflowCliError(
         "DXC_WORKFLOW_ARTIFACT_INVALID",
-        "\u6807\u9898\u6B65\u9AA4\u9700\u8981\u5728 selectedTitle \u4E2D\u4FDD\u5B58\u4E00\u4E2A\u4E0D\u8D85\u8FC7 32 \u5B57\u7684\u6700\u7EC8\u6807\u9898\u3002"
+        `\u6807\u9898\u6B65\u9AA4\u9700\u8981\u5728 selectedTitle \u4E2D\u4FDD\u5B58\u4E00\u4E2A\u4E0D\u8D85\u8FC7 ${WECHAT_TITLE_CHARACTER_LIMIT} \u5B57\u7684\u6700\u7EC8\u6807\u9898\u3002`,
+        { path: artifactPath(location, stage), stage }
       );
     }
   }
-  if (step === "visual-plan") {
-    const value = frontmatter(source);
-    if (typeof value["coverAsset"] !== "string") {
-      throw new WorkflowCliError(
-        "DXC_WORKFLOW_ARTIFACT_INVALID",
-        "\u89C6\u89C9\u6B65\u9AA4\u9700\u8981\u4FDD\u5B58\u771F\u5B9E\u5C01\u9762\u8DEF\u5F84 coverAsset\u3002"
-      );
-    }
-    const articleSource = await readArtifact(
-      location.directory,
-      location.manifest.artifacts.article
-    );
-    try {
-      validateVisualPlanPlacementAnchors(articleSource, source);
-    } catch (error) {
-      if (error instanceof WechatCliError) {
-        throw new WorkflowCliError(error.code, error.guidance ?? error.message);
-      }
-      throw error;
-    }
+  if (stage === "visual-plan") {
+    const articleSource = await readArtifact(location, "article");
+    validateWorkflowSemanticVisualPlan({
+      sections: parseWorkflowArticleSections(articleSource),
+      source
+    });
   }
-  if (step === "quality-review" && frontmatter(source)["verdict"] !== "pass") {
+  if (stage === "quality-review" && frontmatter(source)["verdict"] !== "pass") {
     throw new WorkflowCliError(
       "DXC_WORKFLOW_ARTIFACT_INVALID",
-      "\u5BA1\u6821\u6B65\u9AA4\u53EA\u6709 verdict: pass \u65F6\u624D\u80FD\u7EE7\u7EED\u4EA4\u4ED8\u3002"
+      "\u5BA1\u6821\u6B65\u9AA4\u53EA\u6709 verdict: pass \u65F6\u624D\u80FD\u7EE7\u7EED\u4EA4\u4ED8\u3002",
+      { path: artifactPath(location, stage), stage }
     );
   }
 }
 var WorkflowCli = class {
-  #currentDirectory;
-  #homeDirectory;
   #now;
   #profile;
   #projects;
   constructor(input) {
-    this.#currentDirectory = input.currentDirectory;
-    this.#homeDirectory = input.homeDirectory;
     this.#now = input.now ?? (() => /* @__PURE__ */ new Date());
     this.#profile = new ProfileCli({
       currentDirectory: input.currentDirectory,
@@ -32490,15 +33134,6 @@ var WorkflowCli = class {
     const status = await this.#profile.status();
     return status.data.configured ? status.data.profile.user.confirmationPolicy : "guided";
   }
-  async #locate(directory, projectId) {
-    if (directory !== void 0 && projectId !== void 0) {
-      throw new WorkflowCliError(
-        "DXC_WORKFLOW_PROJECT_REFERENCE_INVALID",
-        "\u9879\u76EE\u76EE\u5F55\u548C\u9879\u76EE ID \u53EA\u80FD\u6307\u5B9A\u4E00\u4E2A\u3002"
-      );
-    }
-    return projectId === void 0 ? this.#projects.locate(directory) : this.#projects.locateByProjectId(projectId);
-  }
   async #loadState(location, persistMigration = true, migrationUpdatedAt = this.#now().toISOString()) {
     try {
       const raw = await readPrivateFile(
@@ -32553,79 +33188,328 @@ var WorkflowCli = class {
     }
     return migrated;
   }
+  #nextTimestamp(previous) {
+    const current = this.#now().getTime();
+    const previousTime = previous === void 0 ? Number.NEGATIVE_INFINITY : Date.parse(previous);
+    return new Date(Math.max(current, previousTime + 1)).toISOString();
+  }
+  async #basePayload(location, state, stage, action) {
+    return {
+      action,
+      cursorFingerprint: cursorFingerprint(state),
+      inputFingerprint: await inputFingerprint(location, stage),
+      projectId: location.manifest.projectId,
+      stage,
+      version: 1
+    };
+  }
+  async #stagePayload(location, state) {
+    const stage = nextStep(state.lastCompletedStep);
+    if (stage === null) {
+      return this.#basePayload(location, state, "delivery", "completed");
+    }
+    return this.#basePayload(
+      location,
+      state,
+      stage,
+      stage === "delivery" ? "delivery-preview" : "stage"
+    );
+  }
+  async #confirmationPayload(location, state, stage) {
+    const source = await readArtifact(location, stage);
+    await validateStageResult(stage, source, location);
+    const base = await this.#basePayload(location, state, stage, "stage-confirm");
+    let bindingFingerprint;
+    if (stage === "visual-plan") {
+      bindingFingerprint = await workflowVisualAssetsFingerprint(location.directory);
+    }
+    return {
+      ...base,
+      ...bindingFingerprint === void 0 ? {} : { bindingFingerprint },
+      outputFingerprint: sha2562(source)
+    };
+  }
+  async #visualAssetsPayload(location, state) {
+    const source = await readArtifact(location, "visual-plan");
+    await validateStageResult("visual-plan", source, location);
+    return {
+      ...await this.#basePayload(location, state, "visual-plan", "visual-assets"),
+      outputFingerprint: sha2562(source)
+    };
+  }
+  async #currentWorkItemId(location, state) {
+    return encodeWorkItem(await this.#stagePayload(location, state));
+  }
+  async #stale(location, state) {
+    throw new WorkflowCliError(
+      "DXC_WORK_ITEM_STALE",
+      "\u5DE5\u4F5C\u9879\u5DF2\u8FC7\u671F\uFF1B\u8BF7\u4F7F\u7528\u5F53\u524D\u5DE5\u4F5C\u9879\u7EE7\u7EED\uFF0C\u4E0D\u4F1A\u66FF\u4F60\u9759\u9ED8\u5B8C\u6210\u65E7\u52A8\u4F5C\u3002",
+      { workItemId: await this.#currentWorkItemId(location, state) }
+    );
+  }
+  async #resolve(workItemId) {
+    const payload = decodeWorkItem(workItemId);
+    let location;
+    try {
+      location = await this.#projects.locateByProjectId(payload.projectId);
+    } catch {
+      throw new WorkflowCliError("DXC_WORK_ITEM_INVALID", "\u5DE5\u4F5C\u9879\u6307\u5411\u7684\u9879\u76EE\u4E0D\u5B58\u5728\u6216\u65E0\u6548\u3002");
+    }
+    const state = await this.#loadState(location);
+    const stage = nextStep(state.lastCompletedStep);
+    if (stage === null) {
+      const expected2 = encodeWorkItem(await this.#stagePayload(location, state));
+      if (payload.action !== "completed" || expected2 !== workItemId) {
+        return this.#stale(location, state);
+      }
+      return { location, payload, state };
+    }
+    if (payload.stage !== stage) {
+      return this.#stale(location, state);
+    }
+    const currentBase = await this.#basePayload(location, state, stage, payload.action);
+    if (payload.cursorFingerprint !== currentBase.cursorFingerprint || payload.inputFingerprint !== currentBase.inputFingerprint) {
+      return this.#stale(location, state);
+    }
+    let expected;
+    switch (payload.action) {
+      case "stage":
+      case "delivery-preview":
+        expected = await this.#stagePayload(location, state);
+        break;
+      case "stage-confirm":
+        expected = await this.#confirmationPayload(location, state, stage);
+        break;
+      case "visual-assets":
+        if (stage !== "visual-plan") {
+          return this.#stale(location, state);
+        }
+        expected = await this.#visualAssetsPayload(location, state);
+        break;
+      case "delivery-confirm": {
+        if (stage !== "delivery") {
+          return this.#stale(location, state);
+        }
+        expected = {
+          ...await this.#basePayload(location, state, stage, "delivery-confirm"),
+          ...payload.bindingFingerprint === void 0 ? {} : { bindingFingerprint: payload.bindingFingerprint }
+        };
+        break;
+      }
+      case "completed":
+        return this.#stale(location, state);
+    }
+    if (encodeWorkItem(expected) !== workItemId) {
+      return this.#stale(location, state);
+    }
+    return { location, payload, state };
+  }
+  async #workItem(resolved, rich, actionOverride) {
+    const { location, payload } = resolved;
+    const definition = CONTENT_STAGE_DEFINITIONS[payload.stage];
+    const workItemId = encodeWorkItem(payload);
+    let nextAction;
+    switch (payload.action) {
+      case "stage":
+        nextAction = { type: "run-stage" };
+        break;
+      case "visual-assets": {
+        const article = await readArtifact(location, "article");
+        const visualPlan = await readArtifact(location, "visual-plan");
+        const sections2 = parseWorkflowArticleSections(article);
+        const assetsDirectory = path8.join(location.directory, location.manifest.assetsDirectory);
+        await ensurePrivateDirectory(path8.join(assetsDirectory, "visuals"));
+        nextAction = {
+          assets: [
+            ...workflowVisualAssetAssignments({
+              assetsDirectory,
+              projectDirectory: location.directory,
+              sections: sections2,
+              visualPlanSource: visualPlan
+            })
+          ],
+          type: "generate-assets"
+        };
+        break;
+      }
+      case "stage-confirm":
+        nextAction = {
+          presentation: { path: artifactPath(location, payload.stage), type: "artifact" },
+          type: "confirm-stage"
+        };
+        break;
+      case "delivery-preview":
+        nextAction = { type: "preview" };
+        break;
+      case "delivery-confirm":
+        nextAction = actionOverride ?? {
+          expiresAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+          type: "confirm-delivery"
+        };
+        break;
+      case "completed":
+        nextAction = { type: "completed" };
+        break;
+    }
+    const base = {
+      nextAction: actionOverride ?? nextAction,
+      skill: definition.skill,
+      stage: payload.stage,
+      workItemId
+    };
+    if (!rich || payload.action === "completed") {
+      return base;
+    }
+    const scaffold = payload.action === "stage" ? await ensureStageScaffold(location, payload.stage) : payload.stage === "delivery" ? "not-applicable" : "existing";
+    const sections = await workflowSections(location, payload.stage);
+    return {
+      ...base,
+      constraints: workflowConstraints(payload.stage),
+      resources: await namedResources(location, payload.stage, scaffold),
+      ...sections === void 0 ? {} : { sections: [...sections] }
+    };
+  }
+  async #result(location, payload, rich = false, actionOverride) {
+    return {
+      command: "workflow.next",
+      data: {
+        project: projectSummary(location),
+        workItem: await this.#workItem(
+          { location, payload, state: await this.#loadState(location) },
+          rich,
+          actionOverride
+        )
+      },
+      ok: true
+    };
+  }
   async start(options) {
-    if (options.directory !== void 0 && options.projectId !== void 0) {
+    if (options.projectId !== void 0 && (options.directory !== void 0 || options.title !== void 0)) {
       throw new WorkflowCliError(
         "DXC_WORKFLOW_PROJECT_REFERENCE_INVALID",
-        "\u9879\u76EE\u76EE\u5F55\u548C\u9879\u76EE ID \u53EA\u80FD\u6307\u5B9A\u4E00\u4E2A\u3002"
+        "\u5DF2\u6709\u9879\u76EE\u53EA\u80FD\u4F7F\u7528 --project\uFF0C\u4E0D\u63A5\u53D7\u6807\u9898\u6216\u76EE\u5F55\u3002"
       );
     }
-    const directory = options.directory === void 0 ? void 0 : resolveUserPath({
-      currentDirectory: this.#currentDirectory,
-      homeDirectory: this.#homeDirectory,
-      input: options.directory
-    });
     const requested = options.from === void 0 ? void 0 : requestedStep(options.from);
     let location;
+    let existingState;
     if (options.projectId !== void 0) {
       location = await this.#projects.locateByProjectId(options.projectId);
-    } else if (directory !== void 0) {
-      try {
-        location = await this.#projects.locate(directory);
-      } catch (error) {
-        if (!(error instanceof ProjectCliError) || error.code !== "DXC_PROJECT_NOT_FOUND") {
-          throw error;
-        }
-        if (options.title === void 0 || options.title.trim().length === 0) {
-          throw new WorkflowCliError(
-            "DXC_WORKFLOW_TITLE_REQUIRED",
-            "\u521B\u5EFA\u65B0\u9879\u76EE\u65F6\u9700\u8981\u63D0\u4F9B\u6587\u7AE0\u4E3B\u9898\u3002"
-          );
-        }
-        const initialized = await this.#projects.initialize(directory, options.title);
-        location = { directory: initialized.data.directory, manifest: initialized.data.manifest };
+      existingState = await this.#loadState(location);
+      if (requested === void 0) {
+        return this.#result(location, await this.#stagePayload(location, existingState));
       }
     } else {
       if (options.title === void 0 || options.title.trim().length === 0) {
         throw new WorkflowCliError("DXC_WORKFLOW_TITLE_REQUIRED", "\u521B\u5EFA\u65B0\u9879\u76EE\u65F6\u9700\u8981\u63D0\u4F9B\u6587\u7AE0\u4E3B\u9898\u3002");
       }
-      const initialized = await this.#projects.initialize(void 0, options.title);
+      const initialized = await this.#projects.initialize(options.directory, options.title);
       location = { directory: initialized.data.directory, manifest: initialized.data.manifest };
     }
-    if (requested === void 0 && options.projectId !== void 0) {
-      const state2 = await this.#loadState(location);
-      const confirmationPolicy2 = await this.#confirmationPolicy();
-      return {
-        command: "workflow.next",
-        data: { match: "ready", work: workItem(location, state2, confirmationPolicy2) },
-        ok: true
-      };
-    }
-    if (requested === void 0 && directory !== void 0) {
-      const state2 = await this.#loadState(location);
-      if (state2.lastCompletedStep !== null) {
-        const confirmationPolicy2 = await this.#confirmationPolicy();
-        return {
-          command: "workflow.next",
-          data: { match: "ready", work: workItem(location, state2, confirmationPolicy2) },
-          ok: true
-        };
-      }
-    }
-    const step = requested ?? "research";
+    const stage = requested ?? "research";
     const state = {
-      lastCompletedStep: previousStep(step),
+      lastCompletedStep: previousStep(stage),
       projectId: location.manifest.projectId,
-      updatedAt: this.#now().toISOString(),
+      updatedAt: this.#nextTimestamp(existingState?.updatedAt),
       version: 1
     };
     await writePrivateJson(statePath(location.directory), state);
-    const confirmationPolicy = await this.#confirmationPolicy();
-    return {
-      command: "workflow.next",
-      data: { match: "ready", work: workItem(location, state, confirmationPolicy) },
-      ok: true
+    return this.#result(location, await this.#stagePayload(location, state));
+  }
+  async next(options) {
+    if (options.projectId === void 0 === (options.workItemId === void 0)) {
+      throw new WorkflowCliError(
+        "DXC_WORKFLOW_PROJECT_REFERENCE_INVALID",
+        "workflow next \u5FC5\u987B\u4E14\u53EA\u80FD\u6307\u5B9A --project \u6216 --work-item\u3002"
+      );
+    }
+    if (options.workItemId !== void 0) {
+      const resolved = await this.#resolve(options.workItemId);
+      return this.#result(resolved.location, resolved.payload, true);
+    }
+    const location = await this.#projects.locateByProjectId(options.projectId);
+    const state = await this.#loadState(location);
+    return this.#result(location, await this.#stagePayload(location, state));
+  }
+  async complete(workItemId, confirmed = false) {
+    const resolved = await this.#resolve(workItemId);
+    const { location, payload, state } = resolved;
+    if (payload.action === "completed") {
+      return this.#result(location, payload);
+    }
+    if (payload.stage === "delivery" || payload.action.startsWith("delivery-")) {
+      throw new WorkflowCliError(
+        "DXC_WORKFLOW_DELIVERY_REQUIRED",
+        "\u5185\u5BB9\u5DF2\u7ECF\u51C6\u5907\u5B8C\u6210\uFF1B\u8BF7\u751F\u6210\u5FAE\u4FE1\u9884\u89C8\u5E76\u786E\u8BA4\u4EA4\u4ED8\u3002"
+      );
+    }
+    if (payload.action === "stage-confirm") {
+      if (!confirmed) {
+        throw new WorkflowCliError(
+          "DXC_WORKFLOW_CONFIRMATION_REQUIRED",
+          `\u8BF7\u660E\u786E\u786E\u8BA4\u91C7\u7528\u5F53\u524D${stageLabel(payload.stage)}\u3002`
+        );
+      }
+      return this.#advance(location, state, payload.stage);
+    }
+    if (confirmed) {
+      throw new WorkflowCliError(
+        "DXC_WORKFLOW_CONFIRMATION_REQUIRED",
+        "\u751F\u4EA7\u5DE5\u4F5C\u9879\u4E0D\u80FD\u76F4\u63A5\u786E\u8BA4\uFF1B\u8BF7\u5148\u5B8C\u6210\u6821\u9A8C\u5E76\u5C55\u793A CLI \u8FD4\u56DE\u7684\u786E\u8BA4\u5DE5\u4F5C\u9879\u3002"
+      );
+    }
+    await validateRequiredInputs(location, payload.stage);
+    const source = await readArtifact(location, payload.stage);
+    await validateStageResult(payload.stage, source, location);
+    if (payload.action === "stage" && payload.stage === "visual-plan") {
+      const visualPayload = await this.#visualAssetsPayload(location, state);
+      return this.#result(location, visualPayload, true);
+    }
+    if (payload.action === "visual-assets") {
+      const articleSource = await readArtifact(location, "article");
+      const sections = parseWorkflowArticleSections(articleSource);
+      const assetsDirectory = path8.join(location.directory, location.manifest.assetsDirectory);
+      const assignments = workflowVisualAssetAssignments({
+        assetsDirectory,
+        projectDirectory: location.directory,
+        sections,
+        visualPlanSource: source
+      });
+      try {
+        await finalizeWorkflowVisualAssets({
+          articleFile: artifactPath(location, "article"),
+          articleSource,
+          assetsDirectory,
+          assignments,
+          projectDirectory: location.directory,
+          sections,
+          visualPlanSource: source
+        });
+      } catch (error) {
+        if (error instanceof WechatCliError) {
+          throw new WorkflowCliError(error.code, error.guidance ?? error.message, {
+            ...error.fields,
+            stage: payload.stage
+          });
+        }
+        throw error;
+      }
+    }
+    const policy = await this.#confirmationPolicy();
+    if (requiresStageConfirmation(policy, payload.stage)) {
+      const confirmationPayload = await this.#confirmationPayload(location, state, payload.stage);
+      return this.#result(location, confirmationPayload, true);
+    }
+    return this.#advance(location, state, payload.stage);
+  }
+  async #advance(location, state, stage) {
+    const nextState = {
+      ...state,
+      lastCompletedStep: stage,
+      updatedAt: this.#nextTimestamp(state.updatedAt)
     };
+    await writePrivateJson(statePath(location.directory), nextState);
+    return this.#result(location, await this.#stagePayload(location, nextState));
   }
   async listProjects() {
     const projects = [];
@@ -32647,6 +33531,7 @@ var WorkflowCli = class {
       projects.push({
         ...projectSummary(indexed.location),
         available: true,
+        directory: indexed.location.directory,
         done: step === null,
         step,
         updatedAt: state.updatedAt
@@ -32655,96 +33540,82 @@ var WorkflowCli = class {
     projects.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
     return { command: "project.list", data: { projects }, ok: true };
   }
-  async next(query, directory) {
-    const projects = await this.#projects.find(query, directory);
-    if (projects.length === 0) {
-      return { command: "workflow.next", data: { match: "none", projects: [] }, ok: true };
+  async deliveryInputs(workItemId) {
+    const resolved = await this.#resolve(workItemId);
+    if (resolved.payload.stage !== "delivery" || resolved.payload.action !== "delivery-preview" && resolved.payload.action !== "delivery-confirm") {
+      throw new WorkflowCliError("DXC_WORK_ITEM_STALE", "\u5F53\u524D\u5DE5\u4F5C\u9879\u4E0D\u662F\u53EF\u4EA4\u4ED8\u5DE5\u4F5C\u9879\u3002");
     }
-    if (projects.length > 1) {
-      return {
-        command: "workflow.next",
-        data: { match: "multiple", projects: projects.map(projectSummary) },
-        ok: true
-      };
+    await validateRequiredInputs(resolved.location, "delivery");
+    const titleSource = await readArtifact(resolved.location, "titles");
+    const title = selectedTitle(frontmatter(titleSource));
+    if (title === void 0) {
+      throw new WorkflowCliError("DXC_WORKFLOW_ARTIFACT_INVALID", "\u6807\u9898\u4EA7\u7269\u7F3A\u5C11\u6700\u7EC8\u6807\u9898\u3002");
     }
-    const location = projects[0];
-    if (location === void 0) {
-      throw new ProjectCliError("DXC_PROJECT_NOT_FOUND", "Content project was not found");
+    let sidecar;
+    try {
+      sidecar = await readWorkflowVisualAssetsSidecar(resolved.location.directory);
+      await validateWorkflowVisualAssets({
+        articleSource: await readArtifact(resolved.location, "article"),
+        assetsDirectory: path8.join(
+          resolved.location.directory,
+          resolved.location.manifest.assetsDirectory
+        ),
+        projectDirectory: resolved.location.directory,
+        visualPlanSource: await readArtifact(resolved.location, "visual-plan")
+      });
+    } catch {
+      throw new WorkflowCliError(
+        "DXC_WORKFLOW_ARTIFACT_INVALID",
+        "\u89C6\u89C9\u7D20\u6750 sidecar\uFF08\u65C1\u8F66\u5143\u6570\u636E\uFF09\u7F3A\u5931\uFF0C\u8BF7\u91CD\u65B0\u5B8C\u6210 visual-plan \u9636\u6BB5\u3002"
+      );
     }
-    const state = await this.#loadState(location);
-    const confirmationPolicy = await this.#confirmationPolicy();
     return {
-      command: "workflow.next",
-      data: { match: "ready", work: workItem(location, state, confirmationPolicy) },
-      ok: true
+      articleFile: artifactPath(resolved.location, "article"),
+      assetsDirectory: path8.join(
+        resolved.location.directory,
+        resolved.location.manifest.assetsDirectory
+      ),
+      project: projectSummary(resolved.location),
+      projectDirectory: resolved.location.directory,
+      title,
+      visualPlanFile: sidecar.publishingVisualPlanPath
     };
   }
-  async complete(directory, projectId, confirmed = false) {
-    const location = await this.#locate(directory, projectId);
-    const state = await this.#loadState(location);
-    const confirmationPolicy = await this.#confirmationPolicy();
-    const step = nextStep(state.lastCompletedStep);
-    if (step === null) {
-      return {
-        command: "workflow.next",
-        data: { match: "ready", work: workItem(location, state, confirmationPolicy) },
-        ok: true
-      };
-    }
-    if (step === "delivery") {
-      throw new WorkflowCliError(
-        "DXC_WORKFLOW_DELIVERY_REQUIRED",
-        "\u5185\u5BB9\u5DF2\u7ECF\u51C6\u5907\u5B8C\u6210\uFF1B\u8BF7\u751F\u6210\u5FAE\u4FE1\u9884\u89C8\u5E76\u786E\u8BA4\u4EA4\u4ED8\u3002"
-      );
-    }
-    const source = await readArtifact(location.directory, location.manifest.artifacts[step]);
-    await validateStageResult(step, source, location);
-    if (requiresStageConfirmation(confirmationPolicy, step) && !confirmed) {
-      throw new WorkflowCliError(
-        "DXC_WORKFLOW_CONFIRMATION_REQUIRED",
-        `\u5F53\u524D\u786E\u8BA4\u7B56\u7565\u8981\u6C42\u7528\u6237\u786E\u8BA4${stageLabel(step)}\uFF1B\u786E\u8BA4\u91C7\u7528\u5F53\u524D\u4EA7\u7269\u540E\uFF0C\u8BF7\u4F7F\u7528 --confirm \u5B8C\u6210\u672C\u9636\u6BB5\u3002`
-      );
+  async issueDeliveryConfirmation(previewWorkItemId, bindingFingerprint, expiresAt) {
+    const resolved = await this.#resolve(previewWorkItemId);
+    if (resolved.payload.action !== "delivery-preview") {
+      throw new WorkflowCliError("DXC_WORK_ITEM_STALE", "\u8BF7\u4ECE\u5F53\u524D delivery \u9884\u89C8\u5DE5\u4F5C\u9879\u5F00\u59CB\u3002");
     }
-    const nextState = {
-      ...state,
-      lastCompletedStep: step,
-      updatedAt: this.#now().toISOString()
-    };
-    await writePrivateJson(statePath(location.directory), nextState);
-    return {
-      command: "workflow.next",
-      data: { match: "ready", work: workItem(location, nextState, confirmationPolicy) },
-      ok: true
+    const payload = {
+      ...await this.#basePayload(
+        resolved.location,
+        resolved.state,
+        "delivery",
+        "delivery-confirm"
+      ),
+      bindingFingerprint
     };
+    return this.#result(resolved.location, payload, true, {
+      expiresAt,
+      type: "confirm-delivery"
+    });
   }
-  async deliveryInputs(directory, projectId) {
-    const location = await this.#locate(directory, projectId);
-    const state = await this.#loadState(location);
-    if (nextStep(state.lastCompletedStep) !== "delivery") {
+  async resolveDeliveryConfirmation(workItemId, bindingFingerprint) {
+    const resolved = await this.#resolve(workItemId);
+    if (resolved.payload.action !== "delivery-confirm" || resolved.payload.bindingFingerprint !== bindingFingerprint) {
       throw new WorkflowCliError(
-        "DXC_WORKFLOW_NOT_READY",
-        "\u8BF7\u5148\u5B8C\u6210\u6B63\u6587\u3001\u6807\u9898\u3001\u89C6\u89C9\u548C\u5BA1\u6821\u6B65\u9AA4\uFF0C\u518D\u751F\u6210\u5FAE\u4FE1\u9884\u89C8\u3002"
+        "DXC_WORK_ITEM_STALE",
+        "\u6700\u7EC8\u9884\u89C8\u7ED1\u5B9A\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u5E76\u786E\u8BA4\u5F53\u524D\u9884\u89C8\u3002"
       );
     }
-    const titleSource = await readArtifact(location.directory, location.manifest.artifacts.titles);
-    const title = selectedTitle(frontmatter(titleSource));
-    return {
-      articleFile: path8.join(location.directory, location.manifest.artifacts.article),
-      assetsDirectory: path8.join(location.directory, location.manifest.assetsDirectory),
-      project: projectSummary(location),
-      projectDirectory: location.directory,
-      title,
-      visualPlanFile: path8.join(location.directory, location.manifest.artifacts["visual-plan"])
-    };
+    return this.deliveryInputs(workItemId);
   }
-  async completeDelivery(directory, receipt) {
-    const location = await this.#projects.locate(directory);
-    const state = await this.#loadState(location);
-    const confirmationPolicy = await this.#confirmationPolicy();
-    if (nextStep(state.lastCompletedStep) !== "delivery") {
-      throw new WorkflowCliError("DXC_WORKFLOW_NOT_READY", "\u5F53\u524D\u6587\u7AE0\u4E0D\u5728\u5FAE\u4FE1\u4EA4\u4ED8\u6B65\u9AA4\u3002");
+  async completeDelivery(workItemId, bindingFingerprint, receipt) {
+    const resolved = await this.#resolve(workItemId);
+    if (resolved.payload.action !== "delivery-confirm" || resolved.payload.bindingFingerprint !== bindingFingerprint) {
+      throw new WorkflowCliError("DXC_WORK_ITEM_STALE", "\u4EA4\u4ED8\u786E\u8BA4\u4E0D\u5C5E\u4E8E\u5F53\u524D\u4E0D\u53EF\u53D8\u9884\u89C8\u3002");
     }
-    const deliveryFile = path8.join(location.directory, location.manifest.artifacts.delivery);
+    const deliveryFile = artifactPath(resolved.location, "delivery");
     await writePrivateBuffer(
       deliveryFile,
       Buffer.from(
@@ -32752,22 +33623,12 @@ var WorkflowCli = class {
 
 - intentId: ${receipt.intentId}
 - mediaId: ${receipt.mediaId}
-- completedAt: ${this.#now().toISOString()}
+- completedAt: ${this.#nextTimestamp(resolved.state.updatedAt)}
 `,
         "utf8"
       )
     );
-    const nextState = {
-      ...state,
-      lastCompletedStep: "delivery",
-      updatedAt: this.#now().toISOString()
-    };
-    await writePrivateJson(statePath(location.directory), nextState);
-    return {
-      command: "workflow.next",
-      data: { match: "ready", work: workItem(location, nextState, confirmationPolicy) },
-      ok: true
-    };
+    return this.#advance(resolved.location, resolved.state, "delivery");
   }
 };
 
@@ -32775,15 +33636,21 @@ var WorkflowCli = class {
 var DELIVERY_STATE_FILE = ".dxc/delivery.json";
 var DELIVERY_STATE_MAXIMUM_BYTES = 32 * 1024;
 var MAXIMUM_POLL_ATTEMPTS = 150;
+var CHOICE_PATTERN = /^choice1_([A-Za-z0-9_-]+)\.([a-f0-9]{32})$/u;
+function sha2563(value) {
+  return createHash8("sha256").update(value, "utf8").digest("hex");
+}
 function selectedDraftIdempotencyKey(projectId, rootSnapshotHash, selectedSnapshotHash, selectionRevision) {
-  const selectionDigest = createHash7("sha256").update(`${rootSnapshotHash}:${selectedSnapshotHash}:${selectionRevision}`, "utf8").digest("hex");
+  const selectionDigest = sha2563(
+    `${rootSnapshotHash}:${selectedSnapshotHash}:${selectionRevision}`
+  );
   return `dxc:${projectId}:${selectionDigest}`;
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function deliveryState(value) {
-  if (!isRecord2(value) || value["version"] !== 1) {
+  if (!isRecord2(value) || value["version"] !== 1 && value["version"] !== 2) {
     return void 0;
   }
   const required = [
@@ -32803,31 +33670,86 @@ function deliveryState(value) {
   if (value["intentId"] !== void 0 && typeof value["intentId"] !== "string") {
     return void 0;
   }
+  if (value["version"] === 2 && (typeof value["selectedSnapshotHash"] !== "string" || typeof value["selectedSnapshotId"] !== "string" || !Number.isInteger(value["selectionRevision"]) || typeof value["templateId"] !== "string")) {
+    return void 0;
+  }
   return value;
 }
-function accountChoice(account) {
-  return { id: account.id, name: account.displayName };
-}
 function availableAccounts(accounts) {
   return accounts.filter(
     (account) => account.status === "ACTIVE" && account.draftCapability === "available" && account.permissions.includes(11)
   );
 }
+function encodeChoice(workItemId, account) {
+  const payload = Buffer.from(
+    JSON.stringify({ accountId: account.id, workItemFingerprint: sha2563(workItemId) }),
+    "utf8"
+  ).toString("base64url");
+  return `choice1_${payload}.${sha2563(payload).slice(0, 32)}`;
+}
+function decodeChoice(choiceId, workItemId) {
+  const match = CHOICE_PATTERN.exec(choiceId);
+  if (match === null || match[1] === void 0 || match[2] === void 0 || sha2563(match[1]).slice(0, 32) !== match[2]) {
+    throw new WorkflowCliError("DXC_WORK_ITEM_INVALID", "\u516C\u4F17\u53F7 choiceId \u65E0\u6548\u3002");
+  }
+  try {
+    const payload = JSON.parse(Buffer.from(match[1], "base64url").toString("utf8"));
+    if (!isRecord2(payload) || typeof payload["accountId"] !== "string" || payload["workItemFingerprint"] !== sha2563(workItemId)) {
+      throw new TypeError("choice binding mismatch");
+    }
+    return payload["accountId"];
+  } catch {
+    throw new WorkflowCliError(
+      "DXC_WORK_ITEM_STALE",
+      "\u516C\u4F17\u53F7 choiceId \u4E0D\u5C5E\u4E8E\u5F53\u524D delivery \u5DE5\u4F5C\u9879\uFF0C\u8BF7\u91CD\u65B0\u9009\u62E9\u3002"
+    );
+  }
+}
+function selectedState(state, preview) {
+  return {
+    ...state,
+    idempotencyKey: selectedDraftIdempotencyKey(
+      state.projectId,
+      state.rootSnapshotHash,
+      preview.selectedSnapshotHash,
+      preview.selectionRevision
+    ),
+    selectedSnapshotHash: preview.selectedSnapshotHash,
+    selectedSnapshotId: preview.selectedSnapshotId,
+    selectionRevision: preview.selectionRevision,
+    templateId: preview.templateId,
+    version: 2
+  };
+}
+function deliveryBindingFingerprint(state) {
+  return sha2563(
+    JSON.stringify({
+      accountId: state.accountId,
+      projectId: state.projectId,
+      rootSnapshotHash: state.rootSnapshotHash,
+      rootSnapshotId: state.rootSnapshotId,
+      selectedSnapshotHash: state.selectedSnapshotHash,
+      selectedSnapshotId: state.selectedSnapshotId,
+      selectionRevision: state.selectionRevision,
+      templateId: state.templateId
+    })
+  );
+}
+function completedVerification(verification) {
+  return verification !== void 0 && verification.authorMatched === true && verification.contentMatched === true && verification.coverMatched === true && verification.digestMatched === true && verification.titleMatched === true && verification.imageMismatches.length === 0;
+}
 var WorkflowDeliveryCli = class {
   #output;
   #sleep;
   #wechat;
   #workflow;
   constructor(input) {
-    this.#output = {
-      writeStderr: input.output.writeStderr,
-      writeStdout: () => void 0
-    };
+    this.#output = { writeStderr: input.output.writeStderr, writeStdout: () => void 0 };
     this.#sleep = input.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
     this.#wechat = input.wechat;
     this.#workflow = input.workflow;
   }
-  async #readState(projectDirectory) {
+  async #readStateIfPresent(projectDirectory) {
     try {
       const source = await readPrivateFile(
         path9.join(projectDirectory, DELIVERY_STATE_FILE),
@@ -32839,10 +33761,7 @@ var WorkflowDeliveryCli = class {
       }
     } catch (error) {
       if (error instanceof LocalStateError && error.failure === "missing") {
-        throw new WorkflowCliError(
-          "DXC_WORKFLOW_PREVIEW_REQUIRED",
-          "\u8BF7\u5148\u751F\u6210\u5E76\u67E5\u770B\u5F53\u524D\u6587\u7AE0\u7684\u5FAE\u4FE1\u9884\u89C8\u3002"
-        );
+        return void 0;
       }
     }
     throw new WorkflowCliError(
@@ -32850,11 +33769,64 @@ var WorkflowDeliveryCli = class {
       "\u672C\u5730\u4EA4\u4ED8\u72B6\u6001\u65E0\u6CD5\u8BFB\u53D6\uFF1B\u672A\u521B\u5EFA\u65B0\u7684\u5FAE\u4FE1\u8349\u7A3F\u3002"
     );
   }
+  async #readState(projectDirectory) {
+    const state = await this.#readStateIfPresent(projectDirectory);
+    if (state !== void 0) {
+      return state;
+    }
+    throw new WorkflowCliError(
+      "DXC_WORKFLOW_PREVIEW_REQUIRED",
+      "\u8BF7\u5148\u751F\u6210\u5E76\u67E5\u770B\u5F53\u524D\u6587\u7AE0\u7684\u5FAE\u4FE1\u9884\u89C8\u3002"
+    );
+  }
   async #writeState(projectDirectory, state) {
     await writePrivateJson(path9.join(projectDirectory, DELIVERY_STATE_FILE), state);
   }
+  async #selectState(projectDirectory, state) {
+    const preview = await this.#wechat.draftPreviewStatus(
+      { snapshotHash: state.rootSnapshotHash, snapshotId: state.rootSnapshotId },
+      this.#output
+    );
+    const selected = selectedState(state, preview);
+    await this.#writeState(projectDirectory, selected);
+    return selected;
+  }
+  #selectionWorkItem(workItemId, accounts) {
+    const nextAction = {
+      choices: accounts.map((account) => ({
+        choiceId: encodeChoice(workItemId, account),
+        label: account.displayName
+      })),
+      purpose: "wechat-account",
+      type: "select-choice"
+    };
+    return {
+      nextAction,
+      skill: "dxc-wechat-publisher",
+      stage: "delivery",
+      workItemId
+    };
+  }
   async preview(options) {
-    const inputs = await this.#workflow.deliveryInputs(options.directory, options.projectId);
+    const inputs = await this.#workflow.deliveryInputs(options.workItemId);
+    const existingState = await this.#readStateIfPresent(inputs.projectDirectory);
+    if (existingState?.projectId === inputs.project.projectId && existingState.intentId !== void 0) {
+      await this.#wechat.publishingDraftStatus(existingState.intentId, this.#output);
+      const selected = await this.#selectState(inputs.projectDirectory, existingState);
+      const confirmation2 = await this.#workflow.issueDeliveryConfirmation(
+        options.workItemId,
+        deliveryBindingFingerprint(selected),
+        selected.previewExpiresAt
+      );
+      return {
+        command: "workflow.preview",
+        data: {
+          ...confirmation2.data,
+          status: "needs-attention"
+        },
+        ok: true
+      };
+    }
     const accounts = availableAccounts(await this.#wechat.accounts(this.#output));
     if (accounts.length === 0) {
       throw new WechatCliError(
@@ -32862,9 +33834,10 @@ var WorkflowDeliveryCli = class {
         "\u5F53\u524D\u6CA1\u6709\u53EF\u521B\u5EFA\u8349\u7A3F\u7684\u516C\u4F17\u53F7\uFF0C\u8BF7\u5148\u5B8C\u6210\u516C\u4F17\u53F7\u7ED1\u5B9A\u3002"
       );
     }
-    const account = options.accountId === void 0 ? accounts.length === 1 ? accounts[0] : void 0 : accounts.find((candidate) => candidate.id === options.accountId);
+    const accountId = options.choiceId === void 0 ? void 0 : decodeChoice(options.choiceId, options.workItemId);
+    const account = accountId === void 0 ? accounts.length === 1 ? accounts[0] : void 0 : accounts.find((candidate) => candidate.id === accountId);
     if (account === void 0) {
-      if (options.accountId !== void 0) {
+      if (accountId !== void 0) {
         throw new WechatCliError(
           "DXC_PUBLISHING_ACCOUNT_UNAVAILABLE",
           "\u9009\u62E9\u7684\u516C\u4F17\u53F7\u5F53\u524D\u4E0D\u53EF\u7528\u4E8E\u521B\u5EFA\u8349\u7A3F\u3002"
@@ -32873,17 +33846,15 @@ var WorkflowDeliveryCli = class {
       return {
         command: "workflow.preview",
         data: {
-          accounts: accounts.map(accountChoice),
-          status: "account-selection-required"
+          project: inputs.project,
+          status: "account-selection-required",
+          workItem: this.#selectionWorkItem(options.workItemId, accounts)
         },
         ok: true
       };
     }
     await this.#wechat.optimizeDraftImages(
-      {
-        projectDirectory: inputs.projectDirectory,
-        visualPlanFile: inputs.visualPlanFile
-      },
+      { projectDirectory: inputs.projectDirectory, visualPlanFile: inputs.visualPlanFile },
       this.#output
     );
     const preview = await this.#wechat.previewDraft(
@@ -32891,14 +33862,14 @@ var WorkflowDeliveryCli = class {
         accountId: account.id,
         articleFile: inputs.articleFile,
         assetsDirectory: inputs.assetsDirectory,
-        browserMode: options.browserMode ?? "system",
+        browserMode: "agent",
         coverFile: "auto",
         title: inputs.title,
         visualPlanFile: inputs.visualPlanFile
       },
       this.#output
     );
-    await this.#writeState(inputs.projectDirectory, {
+    const state = await this.#selectState(inputs.projectDirectory, {
       accountId: account.id,
       idempotencyKey: `dxc:${inputs.project.projectId}:${preview.snapshot.snapshotHash}`,
       previewExpiresAt: preview.preview.expiresAt,
@@ -32908,14 +33879,14 @@ var WorkflowDeliveryCli = class {
       rootSnapshotId: preview.snapshot.id,
       version: 1
     });
+    const confirmation = await this.#workflow.issueDeliveryConfirmation(
+      options.workItemId,
+      deliveryBindingFingerprint(state),
+      state.previewExpiresAt
+    );
     return {
       command: "workflow.preview",
-      data: {
-        account: accountChoice(account),
-        expiresAt: preview.preview.expiresAt,
-        opened: true,
-        status: "ready"
-      },
+      data: { ...confirmation.data, status: "ready" },
       ok: true
     };
   }
@@ -32930,6 +33901,30 @@ var WorkflowDeliveryCli = class {
     }
     return current;
   }
+  async #diagnostics(result) {
+    try {
+      return await this.#wechat.publishingDraftDiagnostics(result.intent.id, this.#output);
+    } catch {
+      return {
+        ...result.intent.errorCode === void 0 ? {} : { errorCode: result.intent.errorCode },
+        intentId: result.intent.id,
+        reason: {
+          message: result.intent.progress.message,
+          nextAction: result.intent.progress.nextAction,
+          phase: "unknown",
+          retryAllowed: false
+        },
+        status: result.intent.status,
+        ...result.intent.verification === void 0 ? {} : {
+          verification: {
+            ...result.intent.verification,
+            coverMatched: null,
+            imageMismatches: []
+          }
+        }
+      };
+    }
+  }
   async deliver(options) {
     if (!options.confirmed) {
       throw new WechatCliError(
@@ -32937,29 +33932,33 @@ var WorkflowDeliveryCli = class {
         "\u8BF7\u5148\u67E5\u770B\u5FAE\u4FE1\u9884\u89C8\u5E76\u660E\u786E\u786E\u8BA4\u521B\u5EFA\u8349\u7A3F\u3002"
       );
     }
-    const inputs = await this.#workflow.deliveryInputs(options.directory, options.projectId);
-    let state = await this.#readState(inputs.projectDirectory);
+    const unresolvedInputs = await this.#workflow.deliveryInputs(options.workItemId);
+    let state = await this.#selectState(
+      unresolvedInputs.projectDirectory,
+      await this.#readState(unresolvedInputs.projectDirectory)
+    );
+    const bindingFingerprint = deliveryBindingFingerprint(state);
+    const inputs = await this.#workflow.resolveDeliveryConfirmation(
+      options.workItemId,
+      bindingFingerprint
+    );
     if (state.projectId !== inputs.project.projectId) {
-      throw new WorkflowCliError(
-        "DXC_WORKFLOW_DELIVERY_STATE_INVALID",
-        "\u9884\u89C8\u4E0D\u5C5E\u4E8E\u5F53\u524D\u6587\u7AE0\uFF1B\u8BF7\u91CD\u65B0\u751F\u6210\u5FAE\u4FE1\u9884\u89C8\u3002"
-      );
+      throw new WorkflowCliError("DXC_WORK_ITEM_STALE", "\u9884\u89C8\u4E0D\u5C5E\u4E8E\u5F53\u524D\u6587\u7AE0\uFF1B\u8BF7\u91CD\u65B0\u751F\u6210\u5FAE\u4FE1\u9884\u89C8\u3002");
     }
     const preview = await this.#wechat.draftPreviewStatus(
       { snapshotHash: state.rootSnapshotHash, snapshotId: state.rootSnapshotId },
       this.#output
     );
-    const template = { id: preview.templateId, selectionRevision: preview.selectionRevision };
-    const selectedIdempotencyKey = selectedDraftIdempotencyKey(
-      state.projectId,
-      state.rootSnapshotHash,
-      preview.selectedSnapshotHash,
-      preview.selectionRevision
-    );
-    if (state.intentId === void 0 && state.idempotencyKey !== selectedIdempotencyKey) {
-      state = { ...state, idempotencyKey: selectedIdempotencyKey };
-      await this.#writeState(inputs.projectDirectory, state);
+    const current = selectedState(state, preview);
+    if (deliveryBindingFingerprint(current) !== bindingFingerprint) {
+      await this.#writeState(inputs.projectDirectory, current);
+      throw new WorkflowCliError(
+        "DXC_WORK_ITEM_STALE",
+        "\u6A21\u677F\u3001\u8D26\u53F7\u6216\u4E0D\u53EF\u53D8\u5FEB\u7167\u9009\u62E9\u5DF2\u7ECF\u53D8\u5316\uFF0C\u8BF7\u91CD\u65B0\u67E5\u770B\u6700\u7EC8\u9884\u89C8\u3002"
+      );
     }
+    state = current;
+    const template = { id: state.templateId, selectionRevision: state.selectionRevision };
     if (!preview.viewed) {
       const refreshed = await this.#wechat.refreshDraftPreview(
         {
@@ -32971,9 +33970,19 @@ var WorkflowDeliveryCli = class {
       );
       state = { ...state, previewExpiresAt: refreshed.expiresAt };
       await this.#writeState(inputs.projectDirectory, state);
+      const confirmation = await this.#workflow.issueDeliveryConfirmation(
+        (await this.#workflow.next({ projectId: state.projectId })).data.workItem.workItemId,
+        bindingFingerprint,
+        refreshed.expiresAt
+      );
       return {
         command: "workflow.deliver",
-        data: { expiresAt: refreshed.expiresAt, status: "preview-required", template },
+        data: {
+          expiresAt: refreshed.expiresAt,
+          status: "preview-required",
+          template,
+          workItem: confirmation.data.workItem
+        },
         ok: true
       };
     }
@@ -32991,7 +34000,8 @@ var WorkflowDeliveryCli = class {
     );
     state = { ...state, intentId: result.intent.id };
     await this.#writeState(inputs.projectDirectory, state);
-    if (result.intent.status === "FAILED" && state.retryAttempt === 0) {
+    let diagnostics = result.intent.status === "FAILED" ? await this.#diagnostics(result) : void 0;
+    if (result.intent.status === "FAILED" && state.retryAttempt === 0 && diagnostics?.reason.retryAllowed === true) {
       result = await this.#terminal(
         await this.#wechat.retryFailedDraft(
           {
@@ -33003,32 +34013,57 @@ var WorkflowDeliveryCli = class {
       );
       state = { ...state, intentId: result.intent.id, retryAttempt: 1 };
       await this.#writeState(inputs.projectDirectory, state);
+      diagnostics = void 0;
     }
-    if (result.intent.status === "CREATED_UNVERIFIED") {
-      result = await this.#terminal(
-        await this.#wechat.reverifyDraft(result.intent.id, this.#output)
-      );
+    if (result.intent.status === "CREATED_UNVERIFIED" && result.intent.mediaId !== void 0) {
+      try {
+        result = await this.#terminal(
+          await this.#wechat.reverifyDraft(result.intent.id, this.#output)
+        );
+        diagnostics = void 0;
+      } catch {
+      }
     }
     if (result.intent.status === "SUCCEEDED" && result.intent.mediaId !== void 0) {
-      await this.#workflow.completeDelivery(inputs.projectDirectory, {
-        intentId: result.intent.id,
-        mediaId: result.intent.mediaId
-      });
-      return {
-        command: "workflow.deliver",
-        data: { mediaId: result.intent.mediaId, status: "completed", template },
-        ok: true
+      const completedDiagnostics = await this.#diagnostics(result);
+      if (completedVerification(completedDiagnostics.verification)) {
+        await this.#workflow.completeDelivery(options.workItemId, bindingFingerprint, {
+          intentId: result.intent.id,
+          mediaId: result.intent.mediaId
+        });
+        return {
+          command: "workflow.deliver",
+          data: {
+            mediaId: result.intent.mediaId,
+            status: "completed",
+            template,
+            verification: completedDiagnostics.verification
+          },
+          ok: true
+        };
+      }
+      diagnostics = {
+        ...completedDiagnostics,
+        reason: {
+          message: "\u8349\u7A3F\u5DF2\u521B\u5EFA\uFF0C\u4F46\u4E94\u5B57\u6BB5\u6216\u56FE\u7247\u8EAB\u4EFD\u56DE\u8BFB\u5C1A\u672A\u5168\u90E8\u901A\u8FC7\u3002",
+          nextAction: "\u4FDD\u7559\u539F intent\uFF0C\u53EA\u8BFB\u6838\u9A8C\u540E\u7EE7\u7EED\u3002",
+          phase: "draft-readback",
+          retryAllowed: false
+        }
       };
     }
+    diagnostics ??= await this.#diagnostics(result);
     return {
       command: "workflow.deliver",
       data: {
         ...result.intent.errorCode === void 0 ? {} : { errorCode: result.intent.errorCode },
         intentId: result.intent.id,
-        message: result.intent.progress.message,
+        message: diagnostics.reason.message,
+        reason: diagnostics.reason,
         status: "needs-attention",
         template,
-        ...result.intent.verification === void 0 ? {} : { verification: result.intent.verification }
+        ...result.intent.verification === void 0 ? {} : { verification: result.intent.verification },
+        ...diagnostics.verification === void 0 ? {} : { verificationDetails: diagnostics.verification }
       },
       ok: true
     };
@@ -33063,12 +34098,6 @@ function positiveInteger(value, name = "value") {
   }
   return parsed;
 }
-function previewBrowserMode(value) {
-  if (value !== "agent" && value !== "system") {
-    throw new CommanderError(1, "DXC_OPTION_INVALID", "browser must be agent or system");
-  }
-  return value;
-}
 function skillInstallTarget(value) {
   if (value !== "codex" && value !== "workbuddy") {
     throw new CommanderError(1, "DXC_OPTION_INVALID", "target must be codex or workbuddy");
@@ -33088,10 +34117,20 @@ function actionError(error) {
     };
   }
   if (error instanceof WorkflowCliError || error instanceof ProjectCliError || error instanceof ProfileCliError || error instanceof ContentMemoryCliError || error instanceof SkillInstallerError) {
-    return { code: error.code, message: error.message, retryable: false };
+    return {
+      code: error.code,
+      ...error instanceof WorkflowCliError && error.details !== void 0 ? { details: error.details } : {},
+      message: error.message,
+      retryable: false
+    };
   }
   if (error instanceof Error && error.name === "KnowledgeCliError" && "code" in error) {
-    return { code: String(error.code), message: error.message, retryable: false };
+    return {
+      code: String(error.code),
+      ..."details" in error && error.details !== void 0 ? { details: error.details } : {},
+      message: error.message,
+      retryable: false
+    };
   }
   return {
     code: "DXC_COMMAND_FAILED",
@@ -33126,7 +34165,7 @@ async function loadKnowledgeModule() {
     }
   };
   try {
-    return await import("./chunks/knowledge-YPR7JKUT.js");
+    return await import("./chunks/knowledge-JCYMCMSP.js");
   } finally {
     process.emitWarning = emitWarning;
   }
@@ -33217,24 +34256,27 @@ function createProgram(context) {
       })
     )
   );
-  workflow.command("next").description("\u8FD4\u56DE\u552F\u4E00\u9700\u8981\u6267\u884C\u7684\u4E0B\u4E00\u6B65").argument("[query]", "\u6587\u7AE0\u6807\u9898\u6216\u9879\u76EE ID").option("--directory <path>", "\u6307\u5B9A\u9879\u76EE\u76EE\u5F55").option("--json", "\u8F93\u51FA JSON").action(
-    async (query, options) => runAction(
+  workflow.command("next").description("\u8FD4\u56DE\u552F\u4E00\u9700\u8981\u6267\u884C\u7684\u4E0B\u4E00\u6B65").option("--project <uuid>", "\u9879\u76EE ID").option("--work-item <id>", "\u5F53\u524D\u5DE5\u4F5C\u9879 ID").option("--json", "\u8F93\u51FA JSON").action(
+    async (options) => runAction(
       context,
       options.json === true,
       () => new WorkflowCli({
         currentDirectory: context.currentDirectory,
         homeDirectory: context.homeDirectory
-      }).next(query, options.directory)
+      }).next({
+        ...options.project === void 0 ? {} : { projectId: options.project },
+        ...options.workItem === void 0 ? {} : { workItemId: options.workItem }
+      })
     )
   );
-  workflow.command("complete").description("\u4FDD\u5B58\u5F53\u524D\u6B65\u9AA4\u5E76\u8FD4\u56DE\u4E0B\u4E00\u6B65").option("--confirm", "\u786E\u8BA4\u91C7\u7528\u5F53\u524D\u9636\u6BB5\u4EA7\u7269").option("--directory <path>", "\u9879\u76EE\u76EE\u5F55").option("--project <uuid>", "\u9879\u76EE ID").option("--json", "\u8F93\u51FA JSON").action(
+  workflow.command("complete").description("\u4FDD\u5B58\u5F53\u524D\u6B65\u9AA4\u5E76\u8FD4\u56DE\u4E0B\u4E00\u6B65").requiredOption("--work-item <id>", "\u5F53\u524D\u5DE5\u4F5C\u9879 ID").option("--confirm", "\u786E\u8BA4\u91C7\u7528\u5F53\u524D\u9636\u6BB5\u4EA7\u7269").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => runAction(
       context,
       options.json === true,
       () => new WorkflowCli({
         currentDirectory: context.currentDirectory,
         homeDirectory: context.homeDirectory
-      }).complete(options.directory, options.project, options.confirm === true)
+      }).complete(options.workItem, options.confirm === true)
     )
   );
   const deliveryAction = async (json, action) => runAction(context, json, () => {
@@ -33250,24 +34292,21 @@ function createProgram(context) {
       })
     );
   });
-  workflow.command("preview").description("\u51C6\u5907\u5E76\u6253\u5F00\u5F53\u524D\u6587\u7AE0\u7684\u5FAE\u4FE1\u9884\u89C8").option("--account <uuid>", "\u591A\u4E2A\u516C\u4F17\u53F7\u65F6\u9009\u62E9\u76EE\u6807\u8D26\u53F7").option("--directory <path>", "\u9879\u76EE\u76EE\u5F55").option("--project <uuid>", "\u9879\u76EE ID").option("--browser <agent|system>", "\u9884\u89C8\u6253\u5F00\u4F4D\u7F6E", "system").option("--json", "\u8F93\u51FA JSON").action(
+  workflow.command("preview").description("\u51C6\u5907\u5E76\u6253\u5F00\u5F53\u524D\u6587\u7AE0\u7684\u5FAE\u4FE1\u9884\u89C8").requiredOption("--work-item <id>", "\u5F53\u524D delivery \u5DE5\u4F5C\u9879 ID").option("--choice <id>", "\u516C\u4F17\u53F7\u5019\u9009 choiceId").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => deliveryAction(
       options.json === true,
       (delivery) => delivery.preview({
-        ...options.account === void 0 ? {} : { accountId: options.account },
-        browserMode: previewBrowserMode(options.browser),
-        ...options.directory === void 0 ? {} : { directory: options.directory },
-        ...options.project === void 0 ? {} : { projectId: options.project }
+        ...options.choice === void 0 ? {} : { choiceId: options.choice },
+        workItemId: options.workItem
       })
     )
   );
-  workflow.command("deliver").description("\u786E\u8BA4\u5F53\u524D\u9884\u89C8\u5E76\u521B\u5EFA\u5FAE\u4FE1\u516C\u4F17\u53F7\u8349\u7A3F").option("--directory <path>", "\u9879\u76EE\u76EE\u5F55").option("--project <uuid>", "\u9879\u76EE ID").option("--confirm", "\u786E\u8BA4\u5DF2\u7ECF\u67E5\u770B\u9884\u89C8\u5E76\u521B\u5EFA\u8349\u7A3F").option("--json", "\u8F93\u51FA JSON").action(
+  workflow.command("deliver").description("\u786E\u8BA4\u5F53\u524D\u9884\u89C8\u5E76\u521B\u5EFA\u5FAE\u4FE1\u516C\u4F17\u53F7\u8349\u7A3F").requiredOption("--work-item <id>", "\u6700\u7EC8\u9884\u89C8\u7ED1\u5B9A\u5DE5\u4F5C\u9879 ID").option("--confirm", "\u786E\u8BA4\u5DF2\u7ECF\u67E5\u770B\u9884\u89C8\u5E76\u521B\u5EFA\u8349\u7A3F").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => deliveryAction(
       options.json === true,
       (delivery) => delivery.deliver({
         confirmed: options.confirm === true,
-        ...options.directory === void 0 ? {} : { directory: options.directory },
-        ...options.project === void 0 ? {} : { projectId: options.project }
+        workItemId: options.workItem
       })
     )
   );
@@ -33301,45 +34340,54 @@ function createProgram(context) {
     })
   );
   const profile = program2.command("profile").description("\u7BA1\u7406\u672C\u5730\u521B\u4F5C\u753B\u50CF");
-  profile.command("status").description("\u67E5\u770B\u521B\u4F5C\u753B\u50CF").option("--json", "\u8F93\u51FA JSON").action(
+  profile.command("begin").description("\u5F00\u59CB\u753B\u50CF\u95EE\u7B54").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => runAction(
       context,
       options.json === true,
       () => new ProfileCli({
         currentDirectory: context.currentDirectory,
         homeDirectory: context.homeDirectory
-      }).status()
+      }).begin()
     )
   );
-  profile.command("save").description("\u4FDD\u5B58\u521B\u4F5C\u753B\u50CF").requiredOption("--input <path>", "\u753B\u50CF JSON \u6587\u4EF6").option("--json", "\u8F93\u51FA JSON").action(
+  profile.command("answer").description("\u56DE\u7B54\u5F53\u524D\u753B\u50CF\u95EE\u9898").requiredOption("--session <uuid>", "\u753B\u50CF\u4F1A\u8BDD ID").option("--choice <id>", "\u9009\u62E9\u9879 choiceId\uFF0C\u53EF\u91CD\u590D", collectValues, []).option("--text <value>", "\u6587\u672C\u7B54\u6848").option("--note <value>", "\u8865\u5145\u8BF4\u660E").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => runAction(
       context,
       options.json === true,
       () => new ProfileCli({
         currentDirectory: context.currentDirectory,
         homeDirectory: context.homeDirectory
-      }).save(options.input)
+      }).answer(options.session, {
+        choices: options.choice,
+        ...options.note === void 0 ? {} : { note: options.note },
+        ...options.text === void 0 ? {} : { text: options.text }
+      })
     )
   );
-  profile.command("update").description("\u66F4\u65B0\u521B\u4F5C\u753B\u50CF").requiredOption("--input <path>", "\u753B\u50CF\u66F4\u65B0 JSON \u6587\u4EF6").option("--json", "\u8F93\u51FA JSON").action(
+  profile.command("status").description("\u67E5\u770B\u521B\u4F5C\u753B\u50CF").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => runAction(
       context,
       options.json === true,
       () => new ProfileCli({
         currentDirectory: context.currentDirectory,
         homeDirectory: context.homeDirectory
-      }).update(options.input)
+      }).status()
     )
   );
   const memory = program2.command("memory").description("\u7BA1\u7406\u672C\u5730\u5185\u5BB9\u8BB0\u5FC6");
-  memory.command("add").description("\u4FDD\u5B58\u4E00\u6761\u7528\u6237\u786E\u8BA4\u7684\u5185\u5BB9\u8BB0\u5FC6").requiredOption("--input <path>", "\u8BB0\u5FC6 JSON \u6587\u4EF6").option("--json", "\u8F93\u51FA JSON").action(
+  memory.command("add").description("\u4FDD\u5B58\u4E00\u6761\u7528\u6237\u786E\u8BA4\u7684\u5185\u5BB9\u8BB0\u5FC6").requiredOption("--content <text>", "\u8BB0\u5FC6\u6B63\u6587").requiredOption("--kind <kind>", "\u8BB0\u5FC6\u9886\u57DF\u7C7B\u578B").requiredOption("--scope <scope>", "global \u6216 project").option("--expires-at <datetime>", "\u8FC7\u671F\u65F6\u95F4").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => runAction(
       context,
       options.json === true,
       () => new ContentMemoryCli({
         currentDirectory: context.currentDirectory,
         homeDirectory: context.homeDirectory
-      }).add(options.input)
+      }).add({
+        content: options.content,
+        ...options.expiresAt === void 0 ? {} : { expiresAt: options.expiresAt },
+        kind: options.kind,
+        scope: options.scope
+      })
     )
   );
   memory.command("list").description("\u67E5\u770B\u5185\u5BB9\u8BB0\u5FC6").option("--json", "\u8F93\u51FA JSON").action(
@@ -33352,42 +34400,49 @@ function createProgram(context) {
       }).list()
     )
   );
-  memory.command("archive").description("\u5F52\u6863\u4E00\u6761\u5185\u5BB9\u8BB0\u5FC6").argument("<memory-id>", "\u8BB0\u5FC6 ID").option("--json", "\u8F93\u51FA JSON").action(
-    async (memoryId, options) => runAction(
+  memory.command("correct").description("\u539F\u5B50\u66F4\u6B63\u4E00\u6761\u5185\u5BB9\u8BB0\u5FC6").requiredOption("--memory <uuid>", "\u88AB\u66F4\u6B63\u7684\u8BB0\u5FC6 ID").requiredOption("--content <text>", "\u66F4\u6B63\u540E\u7684\u6B63\u6587").requiredOption("--kind <kind>", "\u8BB0\u5FC6\u9886\u57DF\u7C7B\u578B").requiredOption("--scope <scope>", "global \u6216 project").option("--expires-at <datetime>", "\u8FC7\u671F\u65F6\u95F4").option("--json", "\u8F93\u51FA JSON").action(
+    async (options) => runAction(
       context,
       options.json === true,
       () => new ContentMemoryCli({
         currentDirectory: context.currentDirectory,
         homeDirectory: context.homeDirectory
-      }).archive(memoryId)
+      }).correct(options.memory, {
+        content: options.content,
+        ...options.expiresAt === void 0 ? {} : { expiresAt: options.expiresAt },
+        kind: options.kind,
+        scope: options.scope
+      })
     )
   );
-  const knowledge = program2.command("knowledge").description("\u7BA1\u7406\u672C\u5730\u5386\u53F2\u6587\u7AE0\u548C\u91D1\u53E5");
-  knowledge.command("status").description("\u67E5\u770B\u77E5\u8BC6\u5E93\u72B6\u6001").option("--json", "\u8F93\u51FA JSON").action(
-    async (options) => withKnowledge(context, "knowledge.status", options.json === true, (cli) => cli.status())
-  );
-  knowledge.command("import").description("\u5BFC\u5165\u7528\u6237\u660E\u786E\u9009\u62E9\u7684\u6587\u7AE0").argument("<files...>", "Markdown \u6216\u6587\u672C\u6587\u4EF6").option("--lexical-only", "\u53EA\u5EFA\u7ACB\u5173\u952E\u8BCD\u7D22\u5F15").option("--json", "\u8F93\u51FA JSON").action(
-    async (files, options) => withKnowledge(
+  memory.command("archive").description("\u5F52\u6863\u4E00\u6761\u5185\u5BB9\u8BB0\u5FC6").requiredOption("--memory <uuid>", "\u8BB0\u5FC6 ID").option("--json", "\u8F93\u51FA JSON").action(
+    async (options) => runAction(
       context,
-      "knowledge.import",
       options.json === true,
-      (cli) => cli.importArticles({ files, lexicalOnly: options.lexicalOnly === true })
+      () => new ContentMemoryCli({
+        currentDirectory: context.currentDirectory,
+        homeDirectory: context.homeDirectory
+      }).archive(options.memory)
     )
   );
-  knowledge.command("import-directory").description("\u5BFC\u5165\u7528\u6237\u660E\u786E\u9009\u62E9\u7684\u76EE\u5F55").requiredOption("--directory <path>", "\u6587\u7AE0\u76EE\u5F55").option("--lexical-only", "\u53EA\u5EFA\u7ACB\u5173\u952E\u8BCD\u7D22\u5F15").option("--json", "\u8F93\u51FA JSON").action(
+  const knowledge = program2.command("knowledge").description("\u7BA1\u7406\u672C\u5730\u5386\u53F2\u6587\u7AE0\u548C\u91D1\u53E5");
+  knowledge.command("status").description("\u67E5\u770B\u77E5\u8BC6\u5E93\u72B6\u6001").option("--json", "\u8F93\u51FA JSON").action(
+    async (options) => withKnowledge(context, "knowledge.status", options.json === true, (cli) => cli.status())
+  );
+  knowledge.command("import").description("\u5BFC\u5165\u7528\u6237\u660E\u786E\u9009\u62E9\u7684\u6587\u7AE0").requiredOption("--source <path>", "\u7528\u6237\u660E\u786E\u9009\u62E9\u7684\u5355\u6587\u4EF6\u6216\u76EE\u5F55").option("--lexical-only", "\u53EA\u5EFA\u7ACB\u5173\u952E\u8BCD\u7D22\u5F15").option("--choice <id>", "\u6A21\u578B\u4E0D\u53EF\u7528\u65F6 CLI \u8FD4\u56DE\u7684 choiceId").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => withKnowledge(
       context,
       "knowledge.import",
       options.json === true,
-      (cli) => cli.importDirectory(options.directory, options.lexicalOnly === true)
+      (cli) => cli.importSource(options.source, options.lexicalOnly === true, options.choice)
     )
   );
-  knowledge.command("search").description("\u68C0\u7D22\u5386\u53F2\u6587\u7AE0\u548C\u91D1\u53E5").argument("<query>", "\u68C0\u7D22\u76EE\u6807").option("--mode <mode>", "hybrid / lexical / semantic", "hybrid").option("--limit <count>", "\u6700\u591A\u8FD4\u56DE\u6761\u6570", "8").option("--json", "\u8F93\u51FA JSON").action(
+  knowledge.command("search").description("\u68C0\u7D22\u5386\u53F2\u6587\u7AE0\u548C\u91D1\u53E5").argument("<query>", "\u68C0\u7D22\u76EE\u6807").option("--mode <mode>", "hybrid / lexical / semantic", "hybrid").option("--limit <count>", "\u6700\u591A\u8FD4\u56DE\u6761\u6570", "8").option("--choice <id>", "\u6A21\u578B\u4E0D\u53EF\u7528\u65F6 CLI \u8FD4\u56DE\u7684 choiceId").option("--json", "\u8F93\u51FA JSON").action(
     async (query, options) => withKnowledge(
       context,
       "knowledge.search",
       options.json === true,
-      (cli) => cli.search(query, options.mode, positiveInteger(options.limit, "limit"))
+      (cli) => cli.search(query, options.mode, positiveInteger(options.limit, "limit"), options.choice)
     )
   );
   knowledge.command("remove").description("\u5220\u9664\u4E00\u7BC7\u672C\u5730\u5386\u53F2\u6587\u7AE0").argument("<article-id>", "\u6587\u7AE0 ID").option("--json", "\u8F93\u51FA JSON").action(
@@ -33399,14 +34454,6 @@ function createProgram(context) {
     )
   );
   const quotes = knowledge.command("quotes").description("\u7BA1\u7406\u672C\u5730\u91D1\u53E5");
-  quotes.command("init").description("\u521D\u59CB\u5316\u91D1\u53E5\u5E93").option("--json", "\u8F93\u51FA JSON").action(
-    async (options) => withKnowledge(
-      context,
-      "knowledge.quotes.init",
-      options.json === true,
-      (cli) => cli.initQuotes()
-    )
-  );
   quotes.command("status").description("\u67E5\u770B\u91D1\u53E5\u5E93\u72B6\u6001").option("--json", "\u8F93\u51FA JSON").action(
     async (options) => withKnowledge(
       context,
@@ -33461,14 +34508,6 @@ function createProgram(context) {
       (cli) => cli.archiveQuote(quoteId)
     )
   );
-  quotes.command("sync").description("\u540C\u6B65\u91D1\u53E5\u5E93\u7D22\u5F15").option("--lexical-only", "\u53EA\u5EFA\u7ACB\u5173\u952E\u8BCD\u7D22\u5F15").option("--json", "\u8F93\u51FA JSON").action(
-    async (options) => withKnowledge(
-      context,
-      "knowledge.quotes.sync",
-      options.json === true,
-      (cli) => cli.syncQuotes(options.lexicalOnly === true)
-    )
-  );
   const auth = program2.command("auth").description("\u7BA1\u7406\u5F53\u524D\u8BBE\u5907\u767B\u5F55");
   const authAction = (options, action) => runAction(
     context,