@deployxai/dxc 0.3.1 → 0.3.3

package/dist/chunks/chunk-P5VZG7OG.js

@@ -0,0 +1,2345 @@
+import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/contracts/src/content-workflow.ts
+import { z } from "zod";
+var CONTENT_WORKFLOW_ID = "dxc-article@1";
+var CONTENT_PROFILE_QUESTIONNAIRE_VERSION = "dxc-onboarding@1";
+var CONTENT_ARTIFACT_KINDS = [
+  "research",
+  "brief",
+  "outline",
+  "article",
+  "titles",
+  "visual-plan",
+  "quality-review",
+  "delivery"
+];
+var contentArtifactKindSchema = z.enum(CONTENT_ARTIFACT_KINDS);
+var DXC_STAGE_SKILL_NAMES = [
+  "dxc-research",
+  "dxc-content-brief",
+  "dxc-article-outline",
+  "dxc-article-write",
+  "dxc-title-write",
+  "dxc-visual-plan",
+  "dxc-content-review",
+  "dxc-wechat-publisher"
+];
+var dxcStageSkillNameSchema = z.enum(DXC_STAGE_SKILL_NAMES);
+var CONTENT_STAGE_DEFINITIONS = {
+  article: {
+    inputs: { optional: [], required: ["research", "brief", "outline"] },
+    output: "article",
+    skill: "dxc-article-write",
+    stage: "article"
+  },
+  brief: {
+    inputs: { optional: [], required: ["research"] },
+    output: "brief",
+    skill: "dxc-content-brief",
+    stage: "brief"
+  },
+  delivery: {
+    inputs: { optional: [], required: ["article", "titles", "visual-plan", "quality-review"] },
+    output: "delivery",
+    skill: "dxc-wechat-publisher",
+    stage: "delivery"
+  },
+  outline: {
+    inputs: { optional: [], required: ["research", "brief"] },
+    output: "outline",
+    skill: "dxc-article-outline",
+    stage: "outline"
+  },
+  "quality-review": {
+    inputs: { optional: ["visual-plan"], required: ["research", "article", "titles"] },
+    output: "quality-review",
+    skill: "dxc-content-review",
+    stage: "quality-review"
+  },
+  research: {
+    inputs: { optional: [], required: [] },
+    output: "research",
+    skill: "dxc-research",
+    stage: "research"
+  },
+  titles: {
+    inputs: { optional: ["brief"], required: ["article"] },
+    output: "titles",
+    skill: "dxc-title-write",
+    stage: "titles"
+  },
+  "visual-plan": {
+    inputs: { optional: ["outline"], required: ["article", "titles"] },
+    output: "visual-plan",
+    skill: "dxc-visual-plan",
+    stage: "visual-plan"
+  }
+};
+var contentWorkflowWorkItemIdSchema = z.string().regex(/^wi1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u);
+var contentWorkflowChoiceIdSchema = z.string().regex(/^choice1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u);
+var contentWorkflowSectionIdSchema = z.string().regex(/^sec_[0-9]{2}_[a-f0-9]{8}$/u);
+var contentWorkflowAssetIdSchema = z.enum([
+  "cover",
+  ...Array.from({ length: 20 }, (_, index) => `inline-${String(index + 1).padStart(2, "0")}`)
+]);
+var contentWorkflowChoiceSchema = z.object({
+  choiceId: contentWorkflowChoiceIdSchema,
+  label: z.string().trim().min(1).max(120)
+}).strict();
+var contentWorkflowAssetAssignmentSchema = z.object({
+  assetId: contentWorkflowAssetIdSchema,
+  path: z.string().trim().min(1).max(4096),
+  role: z.enum(["cover", "inline"]),
+  sectionId: contentWorkflowSectionIdSchema.optional()
+}).strict();
+var contentWorkflowNextActionSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("run-stage") }).strict(),
+  z.object({
+    assets: z.array(contentWorkflowAssetAssignmentSchema).min(1).max(21),
+    type: z.literal("generate-assets")
+  }).strict(),
+  z.object({
+    presentation: z.object({ path: z.string().trim().min(1).max(4096), type: z.literal("artifact") }).strict(),
+    preview: z.object({ path: z.string().trim().min(1).max(4096), type: z.literal("local-preview") }).strict().optional(),
+    type: z.literal("confirm-stage")
+  }).strict(),
+  z.object({
+    choices: z.array(contentWorkflowChoiceSchema).min(2).max(100),
+    purpose: z.literal("wechat-account"),
+    type: z.literal("select-choice")
+  }).strict(),
+  z.object({ type: z.literal("preview") }).strict(),
+  z.object({
+    expiresAt: z.iso.datetime(),
+    type: z.literal("confirm-delivery")
+  }).strict(),
+  z.object({
+    items: z.array(z.object({ label: z.string().trim().min(1).max(300) }).strict()).min(1).max(20),
+    type: z.literal("confirm-knowledge-repair")
+  }).strict(),
+  z.object({ type: z.literal("completed") }).strict()
+]);
+var contentWorkflowInputResourceSchema = z.discriminatedUnion("availability", [
+  z.object({ availability: z.literal("missing") }).strict(),
+  z.object({
+    availability: z.literal("present"),
+    path: z.string().trim().min(1).max(4096)
+  }).strict()
+]);
+var contentWorkflowResourcesSchema = z.object({
+  inputs: z.record(z.string(), contentWorkflowInputResourceSchema),
+  output: z.object({
+    path: z.string().trim().min(1).max(4096),
+    scaffold: z.enum(["created", "existing", "not-applicable"])
+  }).strict()
+}).strict();
+var contentWorkflowConstraintsSchema = z.object({
+  authorMaxCharacters: z.number().int().positive().optional(),
+  coverMaxBytes: z.number().int().positive().optional(),
+  digestMaxCharacters: z.number().int().positive().optional(),
+  inlineImageMaxBytes: z.number().int().positive().optional(),
+  inlineImageMaxCount: z.number().int().positive().optional(),
+  supportedImageTypes: z.array(z.enum(["image/jpeg", "image/png"])).optional(),
+  titleMaxCharacters: z.number().int().positive().optional()
+}).strict();
+var contentWorkflowSectionSchema = z.object({
+  heading: z.string().trim().min(1).max(300),
+  sectionId: contentWorkflowSectionIdSchema
+}).strict();
+var contentWorkflowProjectSummarySchema = z.object({
+  projectId: z.uuid(),
+  title: z.string().trim().min(1).max(160)
+}).strict();
+var contentWorkflowProfileContextSchema = z.object({
+  contentValuePromise: z.string().trim().min(1).max(500),
+  coreValues: z.string().trim().min(1).max(500).optional(),
+  creatorRole: z.string().trim().min(1).max(120),
+  displayName: z.string().trim().min(1).max(120),
+  penName: z.string().trim().min(1).max(120).optional(),
+  pointOfView: z.string().trim().min(1).max(120).optional(),
+  primaryDomains: z.array(z.string().trim().min(1).max(120)).min(1).max(5),
+  redLines: z.string().trim().min(1).max(500).optional(),
+  targetAudience: z.string().trim().min(1).max(500),
+  titlePreferences: z.string().trim().min(1).max(500).optional(),
+  visualPreferences: z.string().trim().min(1).max(500).optional(),
+  writingVoice: z.string().trim().min(1).max(500).optional()
+}).strict();
+var contentWorkflowMemoryContextSchema = z.object({
+  content: z.string().trim().min(1).max(500),
+  expiresAt: z.iso.datetime().optional(),
+  id: z.uuid(),
+  kind: z.enum([
+    "audience-change",
+    "brand-context",
+    "business-context",
+    "temporary-campaign",
+    "writing-preference"
+  ])
+}).strict();
+var contentWorkflowAdoptedKnowledgeSchema = z.discriminatedUnion("sourceType", [
+  z.object({
+    heading: z.string().trim().min(1).max(300).nullable(),
+    knowledgeRef: z.string().regex(/^kr1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u),
+    label: z.string().trim().min(1).max(300),
+    snippet: z.string().trim().min(1).max(420),
+    sourceType: z.literal("history-article")
+  }).strict(),
+  z.object({
+    attribution: z.string().trim().min(1).max(300).nullable(),
+    knowledgeRef: z.string().regex(/^kr1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u),
+    label: z.string().trim().min(1).max(300),
+    snippet: z.string().trim().min(1).max(420),
+    sourceType: z.literal("quote"),
+    verbatimUse: z.enum(["original", "needs-verification", "permitted"])
+  }).strict()
+]);
+var contentWorkflowContextSchema = z.object({
+  adoptedKnowledge: z.array(contentWorkflowAdoptedKnowledgeSchema).max(20),
+  memories: z.array(contentWorkflowMemoryContextSchema).max(20),
+  profile: contentWorkflowProfileContextSchema.nullable()
+}).strict();
+var contentWorkflowWorkItemSchema = z.object({
+  constraints: contentWorkflowConstraintsSchema.optional(),
+  context: contentWorkflowContextSchema.optional(),
+  nextAction: contentWorkflowNextActionSchema,
+  resources: contentWorkflowResourcesSchema.optional(),
+  sections: z.array(contentWorkflowSectionSchema).max(100).optional(),
+  skill: dxcStageSkillNameSchema,
+  stage: contentArtifactKindSchema,
+  workItemId: contentWorkflowWorkItemIdSchema
+}).strict().superRefine((workItem, context) => {
+  if (workItem.stage === "visual-plan" && workItem.nextAction.type === "confirm-stage" && workItem.nextAction.preview === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "visual-plan confirmation requires a local preview",
+      path: ["nextAction", "preview"]
+    });
+  }
+});
+var contentWorkflowNextResultSchema = z.object({
+  command: z.literal("workflow.next"),
+  data: z.object({
+    project: contentWorkflowProjectSummarySchema,
+    workItem: contentWorkflowWorkItemSchema
+  }).strict(),
+  ok: z.literal(true)
+}).strict();
+function isPortableRelativePath(value) {
+  if (value.startsWith("/") || value.includes("\\") || /[:*?"<>|\0]/u.test(value)) {
+    return false;
+  }
+  return value.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+var portableRelativePathSchema = z.string().trim().min(1).max(240).refine(isPortableRelativePath, "path must stay inside the project directory");
+var contentProjectArtifactPathsSchema = z.object({
+  article: portableRelativePathSchema,
+  brief: portableRelativePathSchema,
+  delivery: portableRelativePathSchema,
+  outline: portableRelativePathSchema,
+  "quality-review": portableRelativePathSchema,
+  research: portableRelativePathSchema,
+  titles: portableRelativePathSchema,
+  "visual-plan": portableRelativePathSchema
+}).strict();
+var contentProjectManifestSchema = z.object({
+  artifacts: contentProjectArtifactPathsSchema,
+  assetsDirectory: portableRelativePathSchema,
+  // Persisted 0.1.x projects may contain this field. New projects do not create checkpoints.
+  checkpointsDirectory: portableRelativePathSchema.optional(),
+  createdAt: z.iso.datetime(),
+  projectId: z.uuid(),
+  schemaVersion: z.literal("1"),
+  title: z.string().trim().min(1).max(160),
+  workflowId: z.literal(CONTENT_WORKFLOW_ID)
+}).strict();
+var contentProjectIndexEntrySchema = z.object({
+  directory: z.string().trim().min(1).max(4096),
+  projectId: z.uuid(),
+  title: z.string().trim().min(1).max(160),
+  updatedAt: z.iso.datetime()
+}).strict();
+var contentProjectIndexSchema = z.object({
+  projects: z.array(contentProjectIndexEntrySchema).max(1e3),
+  schemaVersion: z.literal("1")
+}).strict();
+var contentProfileAnswerSchema = z.object({
+  note: z.string().trim().max(500).optional(),
+  questionId: z.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u),
+  selectedOptionIds: z.array(z.string().regex(/^[a-z][a-z0-9._-]{1,95}$/u)).max(8).default([]),
+  text: z.string().trim().min(1).max(500).optional()
+}).strict().refine((answer) => answer.selectedOptionIds.length > 0 || answer.text !== void 0, {
+  message: "profile answer requires choices or text"
+});
+var contentConfirmationPolicySchema = z.enum([
+  "guided",
+  "review-every-stage",
+  "auto-until-delivery"
+]);
+var currentProfileUserSchema = z.object({
+  confirmationPolicy: contentConfirmationPolicySchema.default("guided"),
+  contentValuePromise: z.string().trim().min(1).max(500),
+  coreValues: z.string().trim().min(1).max(500).optional(),
+  creatorRole: z.string().trim().min(1).max(120),
+  displayName: z.string().trim().min(1).max(120),
+  historyDirectory: z.string().trim().min(1).max(4096).optional(),
+  penName: z.string().trim().min(1).max(120).optional(),
+  pointOfView: z.string().trim().min(1).max(120).optional(),
+  primaryDomains: z.array(z.string().trim().min(1).max(120)).min(1).max(5),
+  primaryPlatform: z.literal("wechat-official-account"),
+  publishingCadence: z.string().trim().min(1).max(120).optional(),
+  redLines: z.string().trim().min(1).max(500).optional(),
+  targetAudience: z.string().trim().min(1).max(500),
+  titlePreferences: z.string().trim().min(1).max(500).optional(),
+  visualPreferences: z.string().trim().min(1).max(500).optional(),
+  writingVoice: z.string().trim().min(1).max(500).optional()
+}).strict();
+var storedProfileUserSchema = currentProfileUserSchema.extend({
+  visualGenerationAuthorization: z.object({
+    maxImagesPerRun: z.number().int().min(1).max(20),
+    mode: z.literal("auto-within-limit")
+  }).strict().optional()
+});
+var contentProfileInputSchema = z.object({
+  answers: z.array(contentProfileAnswerSchema).max(32).default([]),
+  questionnaireVersion: z.literal(CONTENT_PROFILE_QUESTIONNAIRE_VERSION),
+  user: currentProfileUserSchema
+}).strict();
+var contentProfileSchema = z.object({
+  answers: z.array(contentProfileAnswerSchema).max(32),
+  createdAt: z.iso.datetime(),
+  profileId: z.uuid(),
+  questionnaireVersion: z.literal(CONTENT_PROFILE_QUESTIONNAIRE_VERSION),
+  schemaVersion: z.literal("1"),
+  updatedAt: z.iso.datetime(),
+  user: storedProfileUserSchema
+}).strict();
+var contentProfileViewSchema = currentProfileUserSchema.omit({ confirmationPolicy: true, historyDirectory: true, primaryPlatform: true }).extend({
+  confirmation: z.object({
+    label: z.enum(["\u5173\u952E\u5185\u5BB9\u8282\u70B9\u786E\u8BA4", "\u6BCF\u4E2A\u5185\u5BB9\u9636\u6BB5\u90FD\u5C55\u793A\u5E76\u7B49\u5F85\u786E\u8BA4", "\u81EA\u52A8\u63A8\u8FDB\u5230\u4EA4\u4ED8\u524D\u786E\u8BA4"]),
+    reviewEveryStage: z.boolean()
+  }).strict()
+}).strict();
+var contentProfileResultDataSchema = z.object({ profile: contentProfileViewSchema }).strict();
+var contentProfileStatusResultSchema = z.object({
+  command: z.literal("profile.status"),
+  data: z.discriminatedUnion("configured", [
+    z.object({
+      configured: z.literal(false)
+    }).strict(),
+    contentProfileResultDataSchema.extend({ configured: z.literal(true) }).strict()
+  ]),
+  ok: z.literal(true)
+}).strict();
+var contentProfileSessionIdSchema = z.uuid();
+var CONTENT_PROFILE_FIELDS = [
+  "all",
+  "confirmation-policy",
+  "content-value-promise",
+  "core-values",
+  "creator-role",
+  "display-name",
+  "pen-name",
+  "point-of-view",
+  "primary-domains",
+  "publishing-cadence",
+  "red-lines",
+  "target-audience",
+  "title-preferences",
+  "visual-preferences",
+  "writing-voice"
+];
+var contentProfileFieldSchema = z.enum(CONTENT_PROFILE_FIELDS);
+var contentProfileQuestionSchema = z.object({
+  choices: z.array(
+    z.object({
+      choiceId: z.string().regex(/^profile_[a-z0-9.-]+$/u),
+      label: z.string().trim().min(1).max(120)
+    }).strict()
+  ).max(12),
+  inputType: z.enum(["multi-choice", "single-choice", "text"]),
+  field: contentProfileFieldSchema.exclude(["all"]),
+  prompt: z.string().trim().min(1).max(500),
+  questionId: z.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u)
+}).strict();
+var contentProfileSessionResultSchema = z.object({
+  command: z.enum(["profile.answer", "profile.begin"]),
+  data: z.discriminatedUnion("status", [
+    z.object({
+      profileSessionId: contentProfileSessionIdSchema,
+      question: contentProfileQuestionSchema,
+      status: z.literal("question")
+    }).strict(),
+    z.object({
+      profile: contentProfileViewSchema,
+      status: z.literal("completed")
+    }).strict()
+  ]),
+  ok: z.literal(true)
+}).strict();
+var contentProfileCommandSchema = z.enum([
+  "profile.answer",
+  "profile.begin",
+  "profile.status"
+]);
+var contentProfileErrorResultSchema = z.object({
+  command: contentProfileCommandSchema,
+  error: z.object({
+    actual: z.string().trim().min(1).optional(),
+    candidates: z.array(z.string().trim().min(1)).max(32).optional(),
+    code: z.enum([
+      "DXC_COMMAND_FAILED",
+      "DXC_PROFILE_BUSY",
+      "DXC_PROFILE_INPUT_INVALID",
+      "DXC_PROFILE_INVALID",
+      "DXC_PROFILE_IO_FAILED",
+      "DXC_PROFILE_SESSION_EXPIRED"
+    ]),
+    expected: z.string().trim().min(1).optional(),
+    field: z.string().trim().min(1).optional(),
+    message: z.string().trim().min(1),
+    recovery: z.string().trim().min(1),
+    retryable: z.boolean()
+  }).strict(),
+  ok: z.literal(false)
+}).strict();
+var CONTENT_MEMORY_KINDS = [
+  "audience-change",
+  "brand-context",
+  "business-context",
+  "temporary-campaign",
+  "writing-preference"
+];
+var contentMemoryKindSchema = z.enum(CONTENT_MEMORY_KINDS);
+var contentMemoryScopeSchema = z.enum(["global", "project"]);
+var contentMemoryFieldsSchema = z.object({
+  content: z.string().trim().min(1).max(500),
+  expiresAt: z.iso.datetime().optional(),
+  kind: contentMemoryKindSchema
+}).strict();
+var contentMemoryInputSchema = contentMemoryFieldsSchema.extend({ scope: z.literal("global").default("global") }).strict().refine((input) => input.kind !== "temporary-campaign" || input.expiresAt !== void 0, {
+  message: "temporary campaign memory requires an expiry time"
+});
+var storedContentMemoryInputSchema = contentMemoryFieldsSchema.extend({
+  scope: contentMemoryScopeSchema
+});
+var contentMemoryRecordSchema = storedContentMemoryInputSchema.and(
+  z.object({
+    createdAt: z.iso.datetime(),
+    id: z.uuid(),
+    source: z.literal("user-stated"),
+    status: z.enum(["active", "archived", "expired"]),
+    updatedAt: z.iso.datetime()
+  }).strict()
+);
+var contentMemoryStoreSchema = z.object({ memories: z.array(contentMemoryRecordSchema).max(100), schemaVersion: z.literal("1") }).strict();
+var contentMemoryViewSchema = contentMemoryFieldsSchema.extend({ id: z.uuid() }).strict();
+var contentMemoryResultDataSchema = z.object({
+  memories: z.array(contentMemoryViewSchema)
+}).strict();
+var contentMemoryAddResultSchema = z.object({
+  command: z.literal("memory.add"),
+  data: contentMemoryResultDataSchema.extend({ memory: contentMemoryViewSchema }),
+  ok: z.literal(true)
+}).strict();
+var contentMemoryArchiveResultSchema = z.object({
+  command: z.literal("memory.archive"),
+  data: contentMemoryResultDataSchema.extend({ memory: contentMemoryViewSchema }),
+  ok: z.literal(true)
+}).strict();
+var contentMemoryCorrectResultSchema = z.object({
+  command: z.literal("memory.correct"),
+  data: contentMemoryResultDataSchema.extend({
+    archivedMemory: contentMemoryViewSchema,
+    memory: contentMemoryViewSchema
+  }),
+  ok: z.literal(true)
+}).strict();
+var contentMemoryListResultSchema = z.object({
+  command: z.literal("memory.list"),
+  data: contentMemoryResultDataSchema,
+  ok: z.literal(true)
+}).strict();
+var contentMemoryCommandSchema = z.enum([
+  "memory.add",
+  "memory.archive",
+  "memory.correct",
+  "memory.list"
+]);
+var contentMemoryErrorResultSchema = z.object({
+  command: contentMemoryCommandSchema,
+  error: z.object({
+    code: z.enum([
+      "DXC_COMMAND_FAILED",
+      "DXC_MEMORY_BUSY",
+      "DXC_MEMORY_INPUT_INVALID",
+      "DXC_MEMORY_INVALID",
+      "DXC_MEMORY_IO_FAILED",
+      "DXC_MEMORY_NOT_FOUND"
+    ]),
+    actual: z.string().trim().min(1).optional(),
+    candidates: z.array(z.string().trim().min(1)).max(32).optional(),
+    expected: z.string().trim().min(1).optional(),
+    field: z.string().trim().min(1).optional(),
+    message: z.string().trim().min(1),
+    recovery: z.string().trim().min(1),
+    retryable: z.boolean()
+  }).strict(),
+  ok: z.literal(false)
+}).strict();
+var contentProjectListItemSchema = z.object({
+  availability: z.discriminatedUnion("available", [
+    z.object({ available: z.literal(true) }).strict(),
+    z.object({
+      available: z.literal(false),
+      reason: z.enum(["project-directory-missing", "project-invalid", "project-unreadable"]),
+      recovery: z.literal("\u8BF7\u7528\u6237\u786E\u8BA4\u9879\u76EE\u7684\u65B0\u4F4D\u7F6E\u540E\u91CD\u65B0\u8FDB\u5165\u8BE5\u9879\u76EE\u3002")
+    }).strict()
+  ]),
+  done: z.boolean(),
+  projectId: z.uuid(),
+  step: contentArtifactKindSchema.nullable(),
+  title: z.string().trim().min(1).max(160),
+  updatedAt: z.iso.datetime()
+}).strict();
+var contentProjectListResultSchema = z.object({
+  command: z.literal("project.list"),
+  data: z.object({ projects: z.array(contentProjectListItemSchema).max(1e3) }).strict(),
+  ok: z.literal(true)
+}).strict();
+var contentProjectRelinkResultSchema = z.object({
+  command: z.literal("project.relink"),
+  data: z.object({
+    projectId: z.uuid(),
+    title: z.string().trim().min(1).max(160),
+    updatedAt: z.iso.datetime()
+  }).strict(),
+  ok: z.literal(true)
+}).strict();
+var contentProjectCommandSchema = z.enum(["project.list", "project.relink"]);
+var contentProjectErrorResultSchema = z.object({
+  command: contentProjectCommandSchema,
+  error: z.object({
+    actual: z.string().trim().min(1).optional(),
+    candidates: z.array(z.string().trim().min(1)).max(32).optional(),
+    code: z.enum([
+      "DXC_COMMAND_FAILED",
+      "DXC_PROJECT_BUSY",
+      "DXC_PROJECT_EXISTS",
+      "DXC_PROJECT_INVALID",
+      "DXC_PROJECT_IO_FAILED",
+      "DXC_PROJECT_NOT_FOUND"
+    ]),
+    expected: z.string().trim().min(1).optional(),
+    field: z.string().trim().min(1).optional(),
+    message: z.string().trim().min(1),
+    recovery: z.string().trim().min(1),
+    retryable: z.boolean()
+  }).strict(),
+  ok: z.literal(false)
+}).strict();
+var contentWorkflowCommandSchema = z.enum([
+  "workflow.complete",
+  "workflow.deliver",
+  "workflow.next",
+  "workflow.preview",
+  "workflow.repair-knowledge",
+  "workflow.start"
+]);
+var CONTENT_WORKFLOW_LOCAL_ERROR_CODES = [
+  "DXC_API_BASE_URL_INVALID",
+  "DXC_API_REQUEST_FAILED",
+  "DXC_API_RESPONSE_INVALID",
+  "DXC_COMMAND_FAILED",
+  "DXC_DEVICE_IDENTITY_INVALID",
+  "DXC_DEVICE_IDENTITY_MISSING",
+  "DXC_DEVICE_IDENTITY_READ_FAILED",
+  "DXC_DEVICE_REFRESH_CONTEXT_MISSING",
+  "DXC_DEVICE_SESSION_TOKEN_MISSING",
+  "DXC_DRAFT_CONFIRMATION_REQUIRED",
+  "DXC_DRAFT_RETRY_NOT_SAFE",
+  "DXC_PUBLISHING_ACCOUNT_UNAVAILABLE",
+  "DXC_PUBLISHING_ARTICLE_INVALID",
+  "DXC_PUBLISHING_ASSETS_DIRECTORY_INVALID",
+  "DXC_PUBLISHING_AUTHOR_TOO_LONG",
+  "DXC_PUBLISHING_CLOUD_PREFLIGHT_FAILED",
+  "DXC_PUBLISHING_COVER_REQUIRED",
+  "DXC_PUBLISHING_COVER_TOO_LARGE",
+  "DXC_PUBLISHING_DIGEST_TOO_LONG",
+  "DXC_PUBLISHING_INLINE_ASSETS_MISMATCH",
+  "DXC_PUBLISHING_INLINE_IMAGE_TOO_LARGE",
+  "DXC_PUBLISHING_INPUT_INVALID",
+  "DXC_PUBLISHING_INPUT_TYPE_UNSUPPORTED",
+  "DXC_PUBLISHING_LOCAL_PREVIEW_ASSET_MISMATCH",
+  "DXC_PUBLISHING_LOCAL_PREVIEW_OUTPUT_CONFLICT",
+  "DXC_PUBLISHING_LOCAL_PREVIEW_TOO_LARGE",
+  "DXC_PUBLISHING_LOCAL_PREVIEW_WRITE_FAILED",
+  "DXC_PUBLISHING_PREFLIGHT_FAILED",
+  "DXC_PUBLISHING_TEMPLATE_HINT_MISMATCH",
+  "DXC_PUBLISHING_TITLE_TOO_LONG",
+  "DXC_PUBLISHING_TOO_MANY_INLINE_IMAGES",
+  "DXC_PUBLISHING_UPLOAD_URL_INVALID",
+  "DXC_PUBLISHING_VISUAL_ANCHOR_INVALID",
+  "DXC_PUBLISHING_VISUAL_PLAN_INVALID",
+  "DXC_PUBLISHING_VISUAL_PLAN_YAML_INVALID",
+  "DXC_WECHAT_NOT_CONNECTED",
+  "DXC_WECHAT_SESSION_INVALID",
+  "DXC_WECHAT_SESSION_SERVER_MISMATCH",
+  "DXC_WORKFLOW_ARTICLE_FIELD_INVALID",
+  "DXC_WORKFLOW_ARTICLE_FRONTMATTER_INVALID",
+  "DXC_WORKFLOW_ARTIFACT_INVALID",
+  "DXC_WORKFLOW_ARTIFACT_MISSING",
+  "DXC_WORKFLOW_BUSY",
+  "DXC_WORKFLOW_CONFIRMATION_REQUIRED",
+  "DXC_WORKFLOW_DELIVERY_REQUIRED",
+  "DXC_WORKFLOW_DELIVERY_STATE_INVALID",
+  "DXC_WORKFLOW_INPUT_MISSING",
+  "DXC_WORKFLOW_PREVIEW_REQUIRED",
+  "DXC_WORKFLOW_PROJECT_REFERENCE_INVALID",
+  "DXC_WORKFLOW_QUOTE_USAGE_INVALID",
+  "DXC_WORKFLOW_STATE_INVALID",
+  "DXC_WORKFLOW_STEP_INVALID",
+  "DXC_WORKFLOW_TITLE_FIELD_INVALID",
+  "DXC_WORKFLOW_TITLE_REQUIRED",
+  "DXC_WORK_ITEM_INVALID"
+];
+var contentWorkflowFailureBaseSchema = z.object({
+  actual: z.string().trim().min(1).optional(),
+  candidates: z.array(z.string().trim().min(1)).max(100).optional(),
+  details: z.record(z.string(), z.union([z.boolean(), z.number(), z.string()])).optional(),
+  expected: z.string().trim().min(1).optional(),
+  field: z.string().trim().min(1).optional(),
+  fields: z.record(z.string(), z.union([z.boolean(), z.number(), z.string()])).optional(),
+  message: z.string().trim().min(1),
+  recovery: z.string().trim().min(1),
+  retryable: z.boolean()
+});
+var contentWorkflowServerErrorCodeSchema = z.string().regex(
+  /^(?:ASSET|COVER|DEVICE|IDEMPOTENCY|INLINE|PUBLISHING|SNAPSHOT|WECHAT|WORKER)_[A-Z0-9_]+$/u
+);
+var contentWorkflowFailureSchema = z.union([
+  contentWorkflowFailureBaseSchema.extend({
+    code: z.literal("DXC_WORK_ITEM_STALE"),
+    expected: contentWorkflowWorkItemIdSchema,
+    field: z.literal("workItemId"),
+    retryable: z.literal(false)
+  }).strict(),
+  contentWorkflowFailureBaseSchema.extend({
+    code: z.union([
+      z.enum(CONTENT_WORKFLOW_LOCAL_ERROR_CODES),
+      contentWorkflowServerErrorCodeSchema
+    ])
+  }).strict()
+]);
+var contentWorkflowErrorResultSchema = z.object({
+  command: contentWorkflowCommandSchema,
+  error: contentWorkflowFailureSchema,
+  ok: z.literal(false)
+}).strict();
+
+// packages/contracts/src/content-knowledge.ts
+import { z as z2 } from "zod";
+var CONTENT_KNOWLEDGE_SCHEMA_VERSION = "2";
+var CONTENT_KNOWLEDGE_EMBEDDING_MODEL = "Xenova/bge-small-zh-v1.5";
+var CONTENT_KNOWLEDGE_EMBEDDING_REVISION = "75c43b069aac4d136ba6bc1122f995fedcfd2781";
+var CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS = 512;
+var CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION = "q8";
+var CONTENT_KNOWLEDGE_CHUNKER_VERSION = "dxc-markdown-chunker@3";
+var contentKnowledgeSearchModeSchema = z2.enum(["hybrid", "lexical", "semantic"]);
+var contentKnowledgeSourceFilterSchema = z2.enum(["all", "history", "quotes"]);
+var contentKnowledgeRefSchema = z2.string().regex(/^kr1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u);
+var contentKnowledgeQuoteStatusSchema = z2.enum(["active", "archived"]);
+var contentKnowledgeQuoteOriginSchema = z2.enum(["original", "third-party"]);
+var contentKnowledgeQuoteVerbatimUseSchema = z2.enum([
+  "original",
+  "needs-verification",
+  "permitted",
+  "do-not-use-verbatim"
+]);
+var contentKnowledgeModelSchema = z2.object({
+  dimensions: z2.literal(CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS),
+  id: z2.literal(CONTENT_KNOWLEDGE_EMBEDDING_MODEL),
+  quantization: z2.literal(CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION),
+  revision: z2.literal(CONTENT_KNOWLEDGE_EMBEDDING_REVISION)
+}).strict();
+var contentKnowledgeArticleSummarySchema = z2.object({
+  articleId: z2.uuid(),
+  chunkCount: z2.number().int().positive(),
+  importedAt: z2.iso.datetime(),
+  sourceLabel: z2.string().trim().min(1).max(255),
+  title: z2.string().trim().min(1).max(300),
+  updatedAt: z2.iso.datetime()
+}).strict();
+var contentKnowledgeImportItemSchema = z2.object({
+  article: contentKnowledgeArticleSummarySchema,
+  semanticIndexed: z2.boolean(),
+  status: z2.enum(["created", "updated", "unchanged"])
+}).strict();
+var contentKnowledgeImportSkippedItemSchema = z2.object({
+  code: z2.enum(["DXC_KNOWLEDGE_ARTICLE_INVALID", "DXC_KNOWLEDGE_FILE_TOO_LARGE"]),
+  message: z2.string().trim().min(1),
+  sourceLabel: z2.string().trim().min(1).max(255)
+}).strict();
+var contentKnowledgeImportResultSchema = z2.object({
+  command: z2.literal("knowledge.import"),
+  data: z2.object({
+    imported: z2.array(contentKnowledgeImportItemSchema),
+    skipped: z2.array(contentKnowledgeImportSkippedItemSchema)
+  }).strict(),
+  ok: z2.literal(true)
+}).strict();
+var contentKnowledgeMatchLaneSchema = z2.enum(["lexical", "semantic"]);
+var contentKnowledgeSearchItemBaseSchema = z2.object({
+  lanes: z2.array(contentKnowledgeMatchLaneSchema).min(1).max(2),
+  rank: z2.number().int().positive().max(20),
+  snippet: z2.string().trim().min(1).max(420)
+}).strict();
+var contentKnowledgeHistorySearchItemSchema = contentKnowledgeSearchItemBaseSchema.extend({
+  heading: z2.string().trim().min(1).max(300).nullable(),
+  knowledgeRef: contentKnowledgeRefSchema,
+  sourceType: z2.literal("history-article"),
+  sourceLabel: z2.string().trim().min(1).max(255),
+  title: z2.string().trim().min(1).max(300)
+});
+var contentKnowledgeQuoteSearchItemSchema = contentKnowledgeSearchItemBaseSchema.extend({
+  attribution: z2.string().trim().min(1).max(300).nullable(),
+  knowledgeRef: contentKnowledgeRefSchema,
+  origin: contentKnowledgeQuoteOriginSchema,
+  sourceLabel: z2.string().trim().min(1).max(300).nullable(),
+  sourceType: z2.literal("quote"),
+  tags: z2.array(z2.string().trim().min(1).max(80)).max(20),
+  verbatimUse: contentKnowledgeQuoteVerbatimUseSchema
+});
+var contentKnowledgeSearchItemSchema = z2.discriminatedUnion("sourceType", [
+  contentKnowledgeHistorySearchItemSchema,
+  contentKnowledgeQuoteSearchItemSchema
+]);
+var contentKnowledgeQuoteSummarySchema = z2.object({
+  activeCount: z2.number().int().nonnegative(),
+  archivedCount: z2.number().int().nonnegative(),
+  sourceInitialized: z2.boolean()
+}).strict();
+var contentKnowledgeQuoteRecordSchema = z2.object({
+  attribution: z2.string().trim().min(1).max(300).nullable(),
+  origin: contentKnowledgeQuoteOriginSchema,
+  quoteId: z2.uuid(),
+  source: z2.string().trim().min(1).max(300).nullable(),
+  status: contentKnowledgeQuoteStatusSchema,
+  tags: z2.array(z2.string().trim().min(1).max(80)).max(20),
+  text: z2.string().trim().min(1).max(2e3),
+  verbatimUse: contentKnowledgeQuoteVerbatimUseSchema
+}).strict();
+var contentKnowledgeQuoteListResultSchema = z2.object({
+  command: z2.literal("knowledge.quotes.list"),
+  data: z2.object({ quotes: z2.array(contentKnowledgeQuoteRecordSchema).max(5e3) }).strict(),
+  ok: z2.literal(true)
+}).strict();
+var contentKnowledgeQuoteMutationResultSchema = z2.object({
+  command: z2.enum([
+    "knowledge.quotes.add",
+    "knowledge.quotes.update",
+    "knowledge.quotes.archive"
+  ]),
+  data: z2.object({ quote: contentKnowledgeQuoteRecordSchema, synced: z2.literal(true) }).strict(),
+  ok: z2.literal(true)
+}).strict();
+var contentKnowledgeQuoteStatusResultSchema = z2.object({
+  command: z2.literal("knowledge.quotes.status"),
+  data: contentKnowledgeQuoteSummarySchema,
+  ok: z2.literal(true)
+}).strict();
+var contentKnowledgeSearchItemLegacySchema = z2.object({
+  articleId: z2.uuid(),
+  chunkId: z2.uuid(),
+  chunkSha256: z2.string().regex(/^[a-f0-9]{64}$/u),
+  heading: z2.string().trim().min(1).max(300).nullable(),
+  lanes: z2.array(contentKnowledgeMatchLaneSchema).min(1).max(2),
+  ordinal: z2.number().int().nonnegative(),
+  rank: z2.number().int().positive().max(20),
+  snippet: z2.string().trim().min(1).max(420),
+  sourceLabel: z2.string().trim().min(1).max(255),
+  title: z2.string().trim().min(1).max(300)
+}).strict();
+var contentKnowledgeSearchResultSchema = z2.object({
+  command: z2.literal("knowledge.search"),
+  data: z2.object({
+    mode: contentKnowledgeSearchModeSchema,
+    query: z2.string().trim().min(1).max(500),
+    results: z2.array(contentKnowledgeSearchItemSchema).max(20),
+    sourceFilter: contentKnowledgeSourceFilterSchema
+  }).strict(),
+  ok: z2.literal(true)
+}).strict();
+var contentKnowledgeStatusResultSchema = z2.object({
+  command: z2.literal("knowledge.status"),
+  data: z2.object({
+    articleCount: z2.number().int().nonnegative(),
+    chunkCount: z2.number().int().nonnegative(),
+    modelCached: z2.boolean(),
+    semanticIndexedChunkCount: z2.number().int().nonnegative(),
+    quotes: contentKnowledgeQuoteSummarySchema
+  }).strict(),
+  ok: z2.literal(true)
+}).strict();
+var contentKnowledgeRemoveResultSchema = z2.object({
+  command: z2.literal("knowledge.remove"),
+  data: z2.object({
+    knowledgeRef: contentKnowledgeRefSchema,
+    removed: z2.boolean()
+  }).strict(),
+  ok: z2.literal(true)
+}).strict();
+var contentKnowledgeAdoptResultSchema = z2.object({
+  command: z2.literal("knowledge.adopt"),
+  data: z2.object({
+    adopted: z2.discriminatedUnion("sourceType", [
+      z2.object({
+        heading: z2.string().trim().min(1).max(300).nullable(),
+        knowledgeRef: contentKnowledgeRefSchema,
+        label: z2.string().trim().min(1).max(300),
+        snippet: z2.string().trim().min(1).max(420),
+        sourceType: z2.literal("history-article")
+      }).strict(),
+      z2.object({
+        attribution: z2.string().trim().min(1).max(300).nullable(),
+        knowledgeRef: contentKnowledgeRefSchema,
+        label: z2.string().trim().min(1).max(300),
+        snippet: z2.string().trim().min(1).max(420),
+        sourceType: z2.literal("quote"),
+        verbatimUse: contentKnowledgeQuoteVerbatimUseSchema
+      }).strict()
+    ]),
+    projectId: z2.uuid()
+  }).strict(),
+  ok: z2.literal(true)
+}).strict();
+var contentKnowledgeCommandSchema = z2.enum([
+  "knowledge.adopt",
+  "knowledge.import",
+  "knowledge.remove",
+  "knowledge.search",
+  "knowledge.status",
+  "knowledge.quotes.add",
+  "knowledge.quotes.archive",
+  "knowledge.quotes.list",
+  "knowledge.quotes.status",
+  "knowledge.quotes.update"
+]);
+var contentKnowledgeErrorResultSchema = z2.object({
+  command: contentKnowledgeCommandSchema,
+  error: z2.object({
+    code: z2.enum([
+      "DXC_COMMAND_FAILED",
+      "DXC_KNOWLEDGE_ARTICLE_INVALID",
+      "DXC_KNOWLEDGE_BUSY",
+      "DXC_KNOWLEDGE_DIRECTORY_INVALID",
+      "DXC_KNOWLEDGE_DIRECTORY_TOO_LARGE",
+      "DXC_KNOWLEDGE_FILE_TOO_LARGE",
+      "DXC_KNOWLEDGE_INPUT_NOT_FOUND",
+      "DXC_KNOWLEDGE_IO_FAILED",
+      "DXC_KNOWLEDGE_MODEL_FAILED",
+      "DXC_KNOWLEDGE_QUERY_INVALID",
+      "DXC_KNOWLEDGE_REFERENCE_INVALID",
+      "DXC_KNOWLEDGE_REFERENCE_STALE",
+      "DXC_KNOWLEDGE_QUOTE_INVALID",
+      "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
+      "DXC_KNOWLEDGE_SCHEMA_UNSUPPORTED",
+      "DXC_KNOWLEDGE_SEMANTIC_NOT_READY",
+      "DXC_KNOWLEDGE_STATE_INVALID"
+    ]),
+    actual: z2.string().trim().min(1).optional(),
+    candidates: z2.array(z2.string().trim().min(1)).max(32).optional(),
+    details: z2.object({
+      nextAction: z2.object({
+        choices: z2.array(
+          z2.object({
+            choiceId: z2.string().regex(/^knowledge-choice1_[A-Za-z0-9_-]+\.[a-f0-9]{32}$/u),
+            label: z2.string().trim().min(1).max(120)
+          }).strict()
+        ).length(2),
+        purpose: z2.literal("knowledge-model-unavailable"),
+        type: z2.literal("select-choice")
+      }).strict()
+    }).strict().optional(),
+    expected: z2.string().trim().min(1).optional(),
+    field: z2.string().trim().min(1).optional(),
+    message: z2.string().trim().min(1),
+    recovery: z2.string().trim().min(1),
+    retryable: z2.boolean()
+  }).strict(),
+  ok: z2.literal(false)
+}).strict();
+
+// packages/contracts/src/index.ts
+import { z as z6 } from "zod";
+
+// packages/contracts/src/publishing.ts
+import { z as z3 } from "zod";
+var sha256Schema = z3.string().regex(/^[a-f0-9]{64}$/u);
+var wechatTemplateIdSchema = z3.enum([
+  "wechat-minimal@1",
+  "wechat-academic-paper@1",
+  "wechat-aurora-glass@1",
+  "wechat-bauhaus@1",
+  "wechat-cyberpunk-neon@1",
+  "wechat-knowledge-base@1",
+  "wechat-luxury-gold@1",
+  "wechat-morandi-forest@1",
+  "wechat-neo-brutalism@1",
+  "wechat-receipt@1",
+  "wechat-sunset-film@1"
+]);
+var publishingUploadKindSchema = z3.enum(["article-source", "cover-image", "inline-image"]);
+var publishingUploadMediaTypeSchema = z3.enum([
+  "text/markdown",
+  "text/plain",
+  "image/jpeg",
+  "image/png"
+]);
+var createPublishingUploadRequestSchema = z3.object({
+  fileName: z3.string().trim().min(1).max(160),
+  kind: publishingUploadKindSchema,
+  mediaType: publishingUploadMediaTypeSchema,
+  sha256: sha256Schema,
+  size: z3.number().int().positive().max(5 * 1024 * 1024)
+}).strict().superRefine((value, context) => {
+  if (value.kind === "article-source" && value.mediaType !== "text/markdown" && value.mediaType !== "text/plain") {
+    context.addIssue({
+      code: "custom",
+      message: "article source requires a text media type",
+      path: ["mediaType"]
+    });
+  }
+  if ((value.kind === "cover-image" || value.kind === "inline-image") && value.mediaType !== "image/jpeg" && value.mediaType !== "image/png") {
+    context.addIssue({
+      code: "custom",
+      message: "image upload requires a supported image media type",
+      path: ["mediaType"]
+    });
+  }
+  if (value.kind === "article-source" && value.size > 512 * 1024) {
+    context.addIssue({
+      code: "custom",
+      message: "article source exceeds the maximum size",
+      path: ["size"]
+    });
+  }
+  if (value.kind === "inline-image" && value.size >= 1024 * 1024) {
+    context.addIssue({
+      code: "custom",
+      message: "inline image must be smaller than 1 MiB",
+      path: ["size"]
+    });
+  }
+});
+var publishingUploadSessionSchema = z3.object({
+  expiresAt: z3.iso.datetime(),
+  id: z3.uuid(),
+  kind: publishingUploadKindSchema,
+  uploadUrl: z3.url()
+}).strict();
+var publishingUploadReceiptSchema = z3.object({
+  id: z3.uuid(),
+  sha256: sha256Schema,
+  size: z3.number().int().positive().max(5 * 1024 * 1024),
+  status: z3.literal("UPLOADED")
+}).strict();
+var createPublishingArticleRequestSchema = z3.object({
+  coverUploadId: z3.uuid(),
+  inlineAssets: z3.array(
+    z3.object({
+      logicalPath: z3.string().trim().min(1).max(240),
+      uploadId: z3.uuid()
+    }).strict()
+  ).max(20).optional(),
+  sourceUploadId: z3.uuid()
+}).strict().superRefine((value, context) => {
+  const inlineAssets = value.inlineAssets ?? [];
+  const logicalPaths = inlineAssets.map((asset) => asset.logicalPath);
+  const uploadIds = inlineAssets.map((asset) => asset.uploadId);
+  if (new Set(logicalPaths).size !== logicalPaths.length) {
+    context.addIssue({
+      code: "custom",
+      message: "inline asset logical paths must be unique",
+      path: ["inlineAssets"]
+    });
+  }
+  if (new Set(uploadIds).size !== uploadIds.length) {
+    context.addIssue({
+      code: "custom",
+      message: "inline asset uploads must be unique",
+      path: ["inlineAssets"]
+    });
+  }
+});
+var publishingInlineAssetSchema = z3.object({
+  logicalPath: z3.string().trim().min(1).max(240),
+  mediaType: z3.enum(["image/jpeg", "image/png"]),
+  sha256: sha256Schema
+}).strict();
+var publishingArticleSchema = z3.object({
+  cover: z3.object({
+    height: z3.number().int().positive().max(12e3),
+    mediaType: z3.enum(["image/jpeg", "image/png"]),
+    width: z3.number().int().positive().max(12e3)
+  }).strict(),
+  coverHash: sha256Schema,
+  createdAt: z3.iso.datetime(),
+  id: z3.uuid(),
+  inlineAssets: z3.array(publishingInlineAssetSchema).max(20).default([]),
+  sourceHash: sha256Schema
+}).strict();
+var createPublishingRenderSnapshotRequestSchema = z3.object({
+  title: z3.string().trim().min(1).max(64).optional()
+}).strict();
+var publishingPreflightIssueSchema = z3.object({
+  code: z3.string().trim().min(1),
+  message: z3.string().trim().min(1),
+  path: z3.string().trim().min(1).optional()
+}).strict();
+var publishingPreflightSchema = z3.object({
+  errors: z3.array(publishingPreflightIssueSchema),
+  metrics: z3.object({
+    digestCharacters: z3.number().int().nonnegative(),
+    externalLinkCount: z3.number().int().nonnegative(),
+    htmlCharacters: z3.number().int().nonnegative(),
+    imageCount: z3.number().int().nonnegative(),
+    tableCount: z3.number().int().nonnegative()
+  }).strict(),
+  ok: z3.boolean(),
+  warnings: z3.array(publishingPreflightIssueSchema)
+}).strict();
+var publishingRenderSnapshotSchema = z3.object({
+  articleId: z3.uuid(),
+  assetManifestHash: sha256Schema,
+  author: z3.string().trim().min(1).max(16),
+  commentsEnabled: z3.boolean(),
+  coverHash: sha256Schema,
+  createdAt: z3.iso.datetime(),
+  digest: z3.string().trim().min(1).max(120),
+  htmlHash: sha256Schema,
+  id: z3.uuid(),
+  inlineAssets: z3.array(publishingInlineAssetSchema).max(20).default([]),
+  preflight: publishingPreflightSchema,
+  rendererVersion: z3.string().trim().min(1),
+  snapshotHash: sha256Schema,
+  sourceHash: sha256Schema,
+  templateId: wechatTemplateIdSchema,
+  title: z3.string().trim().min(1).max(32)
+}).strict();
+var createPublishingPreviewLinkRequestSchema = z3.object({
+  snapshotHash: sha256Schema
+}).strict();
+var publishingPreviewLinkSchema = z3.object({
+  createdAt: z3.iso.datetime().optional(),
+  expiresAt: z3.iso.datetime(),
+  expiresInSeconds: z3.number().int().positive().max(24 * 60 * 60).optional(),
+  snapshotHash: sha256Schema,
+  url: z3.url()
+}).strict();
+var publishingPreviewSelectionStateSchema = z3.object({
+  rootSnapshotHash: sha256Schema,
+  rootSnapshotId: z3.uuid(),
+  selectedSnapshotHash: sha256Schema,
+  selectedSnapshotId: z3.uuid(),
+  selectionRevision: z3.number().int().nonnegative(),
+  templateId: wechatTemplateIdSchema,
+  updatedAt: z3.iso.datetime(),
+  viewed: z3.boolean(),
+  viewedAt: z3.iso.datetime().nullable()
+}).strict();
+var createPublishingApprovalRequestSchema = z3.object({
+  accountId: z3.uuid(),
+  confirmed: z3.literal(true),
+  snapshotHash: sha256Schema
+}).strict();
+var publishingApprovalSchema = z3.object({
+  accountId: z3.uuid(),
+  confirmedAt: z3.iso.datetime(),
+  id: z3.uuid(),
+  rootSnapshotHash: sha256Schema,
+  rootSnapshotId: z3.uuid(),
+  selectedSnapshotHash: sha256Schema,
+  selectedSnapshotId: z3.uuid(),
+  templateId: wechatTemplateIdSchema
+}).strict();
+var createPublishingDraftIntentRequestSchema = z3.object({
+  approvalId: z3.uuid(),
+  previousIntentId: z3.uuid().optional()
+}).strict();
+var publishingDraftStatusSchema = z3.enum([
+  "QUEUED",
+  "PREPARING",
+  "UPLOADING_ASSETS",
+  "ASSET_UPLOAD_UNVERIFIED",
+  "CREATING_DRAFT",
+  "VERIFYING",
+  "SUCCEEDED",
+  "CREATED_UNVERIFIED",
+  "FAILED"
+]);
+var publishingDraftIntentSchema = z3.object({
+  accountId: z3.uuid(),
+  approvalId: z3.uuid(),
+  createdAt: z3.iso.datetime(),
+  errorCode: z3.string().trim().min(1).optional(),
+  id: z3.uuid(),
+  mediaId: z3.string().trim().min(1).max(128).optional(),
+  progress: z3.object({
+    label: z3.string().trim().min(1).max(40),
+    message: z3.string().trim().min(1).max(300),
+    nextAction: z3.string().trim().min(1).max(300),
+    pollAfterSeconds: z3.number().int().positive().max(60).nullable(),
+    terminal: z3.boolean()
+  }).strict(),
+  snapshotHash: sha256Schema,
+  status: publishingDraftStatusSchema,
+  updatedAt: z3.iso.datetime(),
+  verification: z3.object({
+    authorMatched: z3.boolean(),
+    contentMatched: z3.boolean(),
+    digestMatched: z3.boolean(),
+    titleMatched: z3.boolean()
+  }).strict().optional()
+}).strict();
+var publishingDraftIntentResponseSchema = z3.object({
+  intent: publishingDraftIntentSchema
+}).strict();
+var publishingDraftAttentionDiagnosticsSchema = z3.object({
+  errorCode: z3.string().trim().min(1).optional(),
+  intentId: z3.uuid(),
+  reason: z3.object({
+    message: z3.string().trim().min(1).max(500),
+    nextAction: z3.string().trim().min(1).max(500),
+    phase: z3.enum([
+      "preparation",
+      "asset-upload",
+      "draft-create",
+      "draft-readback",
+      "verification",
+      "unknown"
+    ]),
+    retryAllowed: z3.boolean()
+  }).strict(),
+  status: publishingDraftStatusSchema,
+  verification: z3.object({
+    authorMatched: z3.boolean(),
+    coverMatched: z3.boolean().nullable(),
+    contentMatched: z3.boolean(),
+    digestMatched: z3.boolean(),
+    firstDifference: z3.enum(["image-count", "image-identity", "image-order", "text"]).nullable().optional(),
+    imageMismatches: z3.array(
+      z3.object({
+        actualIndex: z3.number().int().nonnegative().optional(),
+        expectedIndex: z3.number().int().nonnegative().optional(),
+        kind: z3.enum(["identity", "missing", "order", "unexpected"]),
+        logicalPath: z3.string().trim().min(1).max(240).optional(),
+        role: z3.enum(["cover", "inline-image"])
+      }).strict()
+    ).max(41),
+    titleMatched: z3.boolean()
+  }).strict().optional()
+}).strict();
+
+// packages/contracts/src/content-monitor.ts
+import { z as z5 } from "zod";
+
+// packages/contracts/src/content-source.ts
+import { z as z4 } from "zod";
+var sourceFetchKindSchema = z4.enum(["rss", "api", "html"]);
+var sourceExecutionLocationSchema = z4.literal("local-device");
+var sourceDataTransitSchema = z4.literal("local-only");
+var sourceCaptureMetadataSchema = z4.object({
+  capturedAt: z4.iso.datetime(),
+  contentHash: z4.string().regex(/^[a-f0-9]{64}$/u),
+  dataTransit: sourceDataTransitSchema,
+  executionLocation: sourceExecutionLocationSchema,
+  extractor: z4.string().trim().min(1).max(120),
+  finalUrl: z4.url(),
+  mediaType: z4.string().trim().min(1).max(160),
+  sourceUrl: z4.url()
+}).strict();
+var sourceFeedItemSchema = z4.object({
+  id: z4.string().trim().min(1).max(256),
+  publishedAt: z4.iso.datetime().optional(),
+  summary: z4.string().trim().min(1).max(2e3).optional(),
+  title: z4.string().trim().min(1).max(500),
+  url: z4.url().optional()
+}).strict();
+var sourceHtmlDocumentSchema = z4.object({
+  canonicalUrl: z4.url().optional(),
+  excerpt: z4.string().trim().min(1).max(12e3),
+  title: z4.string().trim().min(1).max(500)
+}).strict();
+var sourceFetchDataSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    capture: sourceCaptureMetadataSchema,
+    items: z4.array(sourceFeedItemSchema).max(100),
+    kind: z4.literal("rss")
+  }).strict(),
+  z4.object({
+    capture: sourceCaptureMetadataSchema,
+    kind: z4.literal("api"),
+    payload: z4.unknown()
+  }).strict(),
+  z4.object({
+    capture: sourceCaptureMetadataSchema,
+    document: sourceHtmlDocumentSchema,
+    kind: z4.literal("html")
+  }).strict()
+]);
+var sourceFetchResultSchema = z4.object({
+  command: z4.literal("source.fetch"),
+  data: sourceFetchDataSchema,
+  ok: z4.literal(true)
+}).strict();
+var sourceFetchErrorResultSchema = z4.object({
+  command: z4.literal("source.fetch"),
+  error: z4.object({
+    code: z4.enum([
+      "DXC_SOURCE_AUTH_MISSING",
+      "DXC_SOURCE_CONTENT_INVALID",
+      "DXC_SOURCE_FETCH_FAILED",
+      "DXC_SOURCE_REDIRECT_LIMIT",
+      "DXC_SOURCE_RESPONSE_TOO_LARGE",
+      "DXC_SOURCE_URL_BLOCKED",
+      "DXC_SOURCE_URL_INVALID"
+    ]).or(z4.literal("DXC_SOURCE_FAILED")),
+    message: z4.string().trim().min(1).max(500),
+    recovery: z4.string().trim().min(1).max(800).optional()
+  }).strict(),
+  ok: z4.literal(false)
+}).strict();
+
+// packages/contracts/src/content-monitor.ts
+var contentMonitorSourceSchema = z5.object({
+  bearerEnvironment: z5.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u).nullable(),
+  createdAt: z5.iso.datetime(),
+  enabled: z5.boolean(),
+  headerEnvironments: z5.array(
+    z5.object({
+      environment: z5.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u),
+      header: z5.string().regex(/^[A-Za-z0-9-]+$/u)
+    }).strict()
+  ).max(12),
+  id: z5.uuid(),
+  kind: sourceFetchKindSchema,
+  name: z5.string().trim().min(1).max(120),
+  rssLimit: z5.number().int().min(1).max(100).nullable(),
+  url: z5.url()
+}).strict();
+var contentMonitorSourceSummarySchema = contentMonitorSourceSchema.extend({
+  lastRunAt: z5.iso.datetime().nullable(),
+  lastRunSummary: z5.string().trim().min(1).max(200).nullable(),
+  latestItemAt: z5.iso.datetime().nullable(),
+  observedItemCount: z5.number().int().nonnegative()
+});
+var contentMonitorRunSourceResultSchema = z5.object({
+  failureMessage: z5.string().trim().min(1).max(500).nullable(),
+  monitoredItemCount: z5.number().int().nonnegative(),
+  newItemCount: z5.number().int().nonnegative(),
+  sourceId: z5.uuid(),
+  sourceName: z5.string().trim().min(1).max(120),
+  summary: z5.string().trim().min(1).max(200),
+  unchangedItemCount: z5.number().int().nonnegative(),
+  updatedItemCount: z5.number().int().nonnegative()
+}).strict();
+var contentMonitorAddResultSchema = z5.object({
+  command: z5.literal("monitor.add"),
+  data: z5.object({
+    source: contentMonitorSourceSchema,
+    summary: z5.string().trim().min(1).max(200)
+  }).strict(),
+  ok: z5.literal(true)
+}).strict();
+var contentMonitorListResultSchema = z5.object({
+  command: z5.literal("monitor.list"),
+  data: z5.object({
+    sources: z5.array(contentMonitorSourceSummarySchema),
+    summary: z5.string().trim().min(1).max(200)
+  }).strict(),
+  ok: z5.literal(true)
+}).strict();
+var contentMonitorRunResultSchema = z5.object({
+  command: z5.literal("monitor.run"),
+  data: z5.object({
+    failedSourceCount: z5.number().int().nonnegative(),
+    finishedAt: z5.iso.datetime(),
+    results: z5.array(contentMonitorRunSourceResultSchema),
+    startedAt: z5.iso.datetime(),
+    summary: z5.string().trim().min(1).max(200)
+  }).strict(),
+  ok: z5.literal(true)
+}).strict();
+var contentMonitorStatusResultSchema = z5.object({
+  command: z5.literal("monitor.status"),
+  data: z5.object({
+    databasePath: z5.literal("~/.dxc/source-monitor.sqlite"),
+    enabledSourceCount: z5.number().int().nonnegative(),
+    latestRunAt: z5.iso.datetime().nullable(),
+    latestRunSummary: z5.string().trim().min(1).max(200).nullable(),
+    sourceCount: z5.number().int().nonnegative(),
+    summary: z5.string().trim().min(1).max(200)
+  }).strict(),
+  ok: z5.literal(true)
+}).strict();
+var contentMonitorRemoveResultSchema = z5.object({
+  command: z5.literal("monitor.remove"),
+  data: z5.object({
+    removed: z5.boolean(),
+    sourceId: z5.uuid(),
+    summary: z5.string().trim().min(1).max(200)
+  }).strict(),
+  ok: z5.literal(true)
+}).strict();
+var contentMonitorCommandSchema = z5.enum([
+  "monitor.add",
+  "monitor.list",
+  "monitor.remove",
+  "monitor.run",
+  "monitor.status"
+]);
+var contentMonitorErrorResultSchema = z5.object({
+  command: contentMonitorCommandSchema,
+  error: z5.object({
+    code: z5.enum([
+      "DXC_MONITOR_IO_FAILED",
+      "DXC_MONITOR_SCHEMA_UNSUPPORTED",
+      "DXC_MONITOR_SOURCE_INVALID",
+      "DXC_MONITOR_SOURCE_NOT_FOUND",
+      "DXC_MONITOR_STATE_INVALID"
+    ]),
+    message: z5.string().trim().min(1).max(500)
+  }).strict(),
+  ok: z5.literal(false)
+}).strict();
+
+// packages/contracts/src/index.ts
+var liveHealthResponseSchema = z6.object({
+  status: z6.literal("ok")
+}).strict();
+var readyHealthResponseSchema = z6.object({
+  status: z6.literal("ready"),
+  checks: z6.object({
+    configuration: z6.literal("ok")
+  }).strict()
+}).strict();
+var versionResultSchema = z6.object({
+  ok: z6.literal(true),
+  command: z6.literal("version"),
+  data: z6.object({
+    cliVersion: z6.string().min(1),
+    nodeVersion: z6.string().min(1)
+  }).strict()
+}).strict();
+var doctorCheckSchema = z6.object({
+  name: z6.enum(["node-runtime", "working-directory"]),
+  status: z6.enum(["ok", "error"]),
+  message: z6.string().min(1)
+}).strict();
+var doctorResultSchema = z6.object({
+  ok: z6.boolean(),
+  command: z6.literal("doctor"),
+  data: z6.object({
+    status: z6.enum(["ok", "error"]),
+    checks: z6.array(doctorCheckSchema)
+  }).strict()
+}).strict();
+var articleAssetSchema = z6.object({
+  logicalPath: z6.string().trim().min(1),
+  role: z6.enum(["cover", "inline"])
+}).strict();
+var articleBundleSchema = z6.object({
+  schemaVersion: z6.literal("1"),
+  title: z6.string().trim().min(1),
+  author: z6.string().trim().min(1),
+  digest: z6.string().trim().min(1),
+  templateHint: wechatTemplateIdSchema.optional(),
+  coverImage: z6.string().trim().min(1).optional(),
+  commentsEnabled: z6.boolean(),
+  tags: z6.array(z6.string().trim().min(1)),
+  markdown: z6.string().trim().min(1),
+  assets: z6.array(articleAssetSchema)
+}).strict();
+var preflightIssueSchema = z6.object({
+  code: z6.string().trim().min(1),
+  path: z6.string().trim().min(1).optional(),
+  message: z6.string().trim().min(1)
+}).strict();
+var preflightResultSchema = z6.object({
+  ok: z6.boolean(),
+  errors: z6.array(preflightIssueSchema),
+  warnings: z6.array(preflightIssueSchema),
+  metrics: z6.object({
+    digestCharacters: z6.number().int().nonnegative(),
+    htmlCharacters: z6.number().int().nonnegative(),
+    imageCount: z6.number().int().nonnegative(),
+    externalLinkCount: z6.number().int().nonnegative(),
+    tableCount: z6.number().int().nonnegative()
+  }).strict()
+}).strict();
+var wechatRenderResultSchema = z6.object({
+  templateId: wechatTemplateIdSchema,
+  rendererVersion: z6.string().trim().min(1),
+  sourceHash: z6.string().regex(/^[a-f0-9]{64}$/u),
+  htmlHash: z6.string().regex(/^[a-f0-9]{64}$/u),
+  html: z6.string().min(1),
+  preflight: preflightResultSchema
+}).strict();
+var wechatPermissionIdSchema = z6.union([z6.literal(3), z6.literal(11)]);
+var deviceBindingSessionStatusSchema = z6.enum([
+  "CREATED",
+  "PROVED",
+  "AUTHORIZATION_PENDING",
+  "BOUND",
+  "EXPIRED",
+  "FAILED"
+]);
+var createDeviceBindingSessionRequestSchema = z6.object({
+  deviceName: z6.string().trim().min(1).max(80),
+  installationId: z6.uuid(),
+  publicKeyPem: z6.string().min(80).max(2048)
+}).strict();
+var createDeviceBindingSessionResponseSchema = z6.object({
+  challenge: z6.string().regex(/^[A-Za-z0-9_-]{43,128}$/u),
+  expiresAt: z6.iso.datetime(),
+  id: z6.uuid()
+}).strict();
+var proveDeviceBindingSessionRequestSchema = z6.object({
+  challenge: z6.string().regex(/^[A-Za-z0-9_-]{43,128}$/u),
+  deviceRefreshTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u).optional(),
+  deviceSessionTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u),
+  signature: z6.string().regex(/^[A-Za-z0-9_-]{64,256}$/u)
+}).strict();
+var proveDeviceBindingSessionResponseSchema = z6.object({
+  bindingToken: z6.string().min(32).max(256),
+  expiresAt: z6.iso.datetime(),
+  id: z6.uuid(),
+  status: z6.literal("PROVED")
+}).strict();
+var deviceSessionIdentitySchema = z6.object({
+  deviceId: z6.uuid(),
+  deviceName: z6.string().trim().min(1).max(80),
+  expiresAt: z6.iso.datetime(),
+  tenantId: z6.uuid(),
+  userId: z6.uuid()
+}).strict();
+var deviceSessionStatusResponseSchema = z6.object({
+  identity: deviceSessionIdentitySchema
+}).strict();
+var deviceSessionCredentialEnrollmentRequestSchema = z6.object({
+  refreshTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u),
+  signature: z6.string().regex(/^[A-Za-z0-9_-]{64,256}$/u)
+}).strict();
+var deviceSessionRefreshRequestSchema = z6.object({
+  nextDeviceSessionTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u),
+  nextRefreshTokenHash: z6.string().regex(/^[a-f0-9]{64}$/u),
+  refreshToken: z6.string().regex(/^[A-Za-z0-9_-]{43,256}$/u),
+  rotationId: z6.uuid(),
+  signature: z6.string().regex(/^[A-Za-z0-9_-]{64,256}$/u)
+}).strict();
+var wechatLoginSessionPurposeSchema = z6.enum(["link", "login", "start"]);
+var wechatLoginSessionStatusSchema = z6.enum([
+  "URL_READY",
+  "EXCHANGING",
+  "IDENTIFIED",
+  "SUCCEEDED",
+  "EXPIRED",
+  "FAILED"
+]);
+var wechatLoginFailureCodeSchema = z6.enum([
+  "WECHAT_LOGIN_DEVICE_UNAUTHORIZED",
+  "WECHAT_LOGIN_IDENTITY_CONFLICT",
+  "WECHAT_LOGIN_IDENTITY_NOT_LINKED",
+  "WECHAT_LOGIN_PROVIDER_FAILED",
+  "WECHAT_LOGIN_SESSION_INVALID"
+]);
+var createWechatLoginSessionRequestSchema = z6.object({
+  purpose: wechatLoginSessionPurposeSchema
+}).strict();
+var createWechatLoginSessionResponseSchema = z6.object({
+  authorizationUrl: z6.url(),
+  expiresAt: z6.iso.datetime(),
+  id: z6.uuid(),
+  pollToken: z6.string().min(32).max(256),
+  purpose: wechatLoginSessionPurposeSchema
+}).strict();
+var wechatLoginSessionResponseSchema = z6.object({
+  expiresAt: z6.iso.datetime(),
+  failureCode: wechatLoginFailureCodeSchema.optional(),
+  id: z6.uuid(),
+  identity: deviceSessionIdentitySchema.optional(),
+  purpose: wechatLoginSessionPurposeSchema,
+  status: wechatLoginSessionStatusSchema
+}).strict().superRefine((session, context) => {
+  if (session.status === "SUCCEEDED" && session.identity === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "successful login session requires an identity"
+    });
+  }
+  if (session.status === "FAILED" && session.failureCode === void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "failed login session requires a failure code"
+    });
+  }
+  if (session.status !== "FAILED" && session.failureCode !== void 0) {
+    context.addIssue({
+      code: "custom",
+      message: "only failed login session may expose a failure code"
+    });
+  }
+});
+var wechatAccountSchema = z6.object({
+  id: z6.uuid(),
+  displayName: z6.string().trim().min(1),
+  accountType: z6.string().trim().min(1),
+  status: z6.enum(["ACTIVE", "PERMISSION_CHANGED", "REVOKED"]),
+  permissions: z6.array(wechatPermissionIdSchema),
+  draftCapability: z6.enum(["available", "missing", "revoked"])
+}).strict();
+var createWechatAuthorizationSessionResponseSchema = z6.object({
+  id: z6.uuid(),
+  authorizationUrl: z6.url(),
+  pollToken: z6.string().min(32).max(256),
+  expiresAt: z6.iso.datetime()
+}).strict();
+var wechatAuthorizationSessionResponseSchema = z6.object({
+  id: z6.uuid(),
+  status: z6.enum(["URL_READY", "EXCHANGING", "AUTHORIZED", "BOUND", "EXPIRED", "FAILED"]),
+  expiresAt: z6.iso.datetime(),
+  account: wechatAccountSchema.optional()
+}).strict();
+var wechatAccountsResponseSchema = z6.object({
+  accounts: z6.array(wechatAccountSchema)
+}).strict();
+var apiErrorResponseSchema = z6.object({
+  error: z6.object({
+    code: z6.string().trim().min(1),
+    message: z6.string().trim().min(1),
+    retryable: z6.boolean()
+  }).strict()
+}).strict();
+
+// apps/cli/src/local-state.ts
+import { randomUUID } from "node:crypto";
+import { constants as fileConstants } from "node:fs";
+import { chmod, lstat, mkdir, open, rename, unlink } from "node:fs/promises";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+var LocalStateError = class extends Error {
+  constructor(failure) {
+    super(failure);
+    this.failure = failure;
+    this.name = "LocalStateError";
+  }
+  failure;
+};
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function ownedByCurrentUser(userId, ownerId) {
+  return userId === void 0 || userId === ownerId;
+}
+async function ensurePrivateDirectory(directory) {
+  try {
+    await mkdir(directory, { mode: 448, recursive: true });
+    const metadata = await lstat(directory);
+    const userId = typeof process.getuid === "function" ? process.getuid() : void 0;
+    if (!metadata.isDirectory() || metadata.isSymbolicLink() || !ownedByCurrentUser(userId, metadata.uid)) {
+      throw new LocalStateError("invalid");
+    }
+    await chmod(directory, 448);
+  } catch (error) {
+    if (error instanceof LocalStateError) {
+      throw error;
+    }
+    if (errorCode(error) === "ELOOP") {
+      throw new LocalStateError("invalid");
+    }
+    throw new LocalStateError("io");
+  }
+}
+async function ensurePrivateRegularFile(target) {
+  await ensurePrivateDirectory(path.dirname(target));
+  let handle;
+  try {
+    handle = await open(
+      target,
+      fileConstants.O_CREAT | fileConstants.O_RDWR | fileConstants.O_NOFOLLOW,
+      384
+    );
+    const metadata = await handle.stat();
+    const userId = typeof process.getuid === "function" ? process.getuid() : void 0;
+    if (!metadata.isFile() || !ownedByCurrentUser(userId, metadata.uid)) {
+      throw new LocalStateError("invalid");
+    }
+    await handle.chmod(384);
+  } catch (error) {
+    if (error instanceof LocalStateError) {
+      throw error;
+    }
+    if (errorCode(error) === "ELOOP") {
+      throw new LocalStateError("invalid");
+    }
+    throw new LocalStateError("io");
+  } finally {
+    await handle?.close();
+  }
+}
+async function readPrivateFile(target, maximumBytes) {
+  const contents = await readPrivateBuffer(target, maximumBytes);
+  return contents.toString("utf8");
+}
+async function readPrivateBuffer(target, maximumBytes) {
+  let handle;
+  try {
+    handle = await open(target, fileConstants.O_RDONLY | fileConstants.O_NOFOLLOW);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") {
+      throw new LocalStateError("missing");
+    }
+    if (errorCode(error) === "ELOOP") {
+      throw new LocalStateError("invalid");
+    }
+    throw new LocalStateError("io");
+  }
+  try {
+    const metadata = await handle.stat();
+    const userId = typeof process.getuid === "function" ? process.getuid() : void 0;
+    if (!metadata.isFile() || !ownedByCurrentUser(userId, metadata.uid) || metadata.size > maximumBytes || process.platform !== "win32" && (metadata.mode & 63) !== 0) {
+      throw new LocalStateError("invalid");
+    }
+    return await handle.readFile();
+  } catch (error) {
+    if (error instanceof LocalStateError) {
+      throw error;
+    }
+    throw new LocalStateError("io");
+  } finally {
+    await handle.close();
+  }
+}
+async function writePrivateJson(target, value) {
+  await writePrivateBuffer(target, Buffer.from(`${JSON.stringify(value, void 0, 2)}
+`, "utf8"));
+}
+async function writePrivateBuffer(target, value) {
+  const directory = path.dirname(target);
+  await ensurePrivateDirectory(directory);
+  const temporary = path.join(directory, `.${path.basename(target)}.${randomUUID()}.tmp`);
+  let handle;
+  try {
+    handle = await open(
+      temporary,
+      fileConstants.O_CREAT | fileConstants.O_EXCL | fileConstants.O_WRONLY | fileConstants.O_NOFOLLOW,
+      384
+    );
+    await handle.writeFile(value);
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await rename(temporary, target);
+    await chmod(target, 384);
+  } catch (error) {
+    throw error instanceof LocalStateError ? error : new LocalStateError("io");
+  } finally {
+    await handle?.close();
+    await unlink(temporary).catch(() => void 0);
+  }
+}
+var LOCK_WAIT_MILLISECONDS = 3e3;
+var LOCK_RETRY_MILLISECONDS = 10;
+var LOCK_STALE_MILLISECONDS = 5 * 6e4;
+async function readLockOwner(lockPath) {
+  let handle;
+  try {
+    handle = await open(lockPath, fileConstants.O_RDONLY | fileConstants.O_NOFOLLOW);
+    const metadata = await handle.stat();
+    if (!metadata.isFile() || metadata.size < 1 || metadata.size > 256) {
+      throw new LocalStateError("invalid");
+    }
+    const value = JSON.parse(await handle.readFile("utf8"));
+    if (typeof value !== "object" || value === null || !("pid" in value) || !Number.isSafeInteger(value.pid) || Number(value.pid) <= 0 || !("token" in value) || typeof value.token !== "string" || value.token.length < 1) {
+      throw new LocalStateError("invalid");
+    }
+    return { pid: Number(value.pid), token: value.token };
+  } catch (error) {
+    if (error instanceof LocalStateError) {
+      throw error;
+    }
+    if (errorCode(error) === "ELOOP") {
+      throw new LocalStateError("invalid");
+    }
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return errorCode(error) !== "ESRCH";
+  }
+}
+async function acquireReclaimGuard(lockPath, identity) {
+  const owner = { pid: process.pid, token: randomUUID() };
+  const basePath = `${lockPath}.reclaim-${String(identity.dev)}-${String(identity.ino)}`;
+  let guardPath = basePath;
+  for (let generation = 0; generation < 32; generation += 1) {
+    let handle;
+    try {
+      handle = await open(
+        guardPath,
+        fileConstants.O_CREAT | fileConstants.O_EXCL | fileConstants.O_WRONLY | fileConstants.O_NOFOLLOW,
+        384
+      );
+      await handle.writeFile(`${JSON.stringify(owner)}
+`);
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      return async () => {
+        try {
+          const current = await readLockOwner(guardPath);
+          if (current.token === owner.token) {
+            await unlink(guardPath);
+          }
+        } catch (error) {
+          if (errorCode(error) !== "ENOENT") {
+            throw error instanceof LocalStateError ? error : new LocalStateError("io");
+          }
+        }
+      };
+    } catch (error) {
+      await handle?.close();
+      if (errorCode(error) === "ELOOP") {
+        throw new LocalStateError("invalid");
+      }
+      if (errorCode(error) !== "EEXIST") {
+        throw error instanceof LocalStateError ? error : new LocalStateError("io");
+      }
+      const metadata = await lstat(guardPath);
+      let previous;
+      try {
+        previous = await readLockOwner(guardPath);
+      } catch (ownerError) {
+        if (!(ownerError instanceof LocalStateError && ownerError.failure === "invalid")) {
+          throw ownerError;
+        }
+      }
+      if (previous !== void 0 && processIsAlive(previous.pid)) {
+        return void 0;
+      }
+      if (previous === void 0 && Date.now() - metadata.mtimeMs <= LOCK_STALE_MILLISECONDS) {
+        return void 0;
+      }
+      const predecessor = previous?.token ?? `${metadata.ino}-${Math.trunc(metadata.mtimeMs)}`;
+      guardPath = `${basePath}.next-${predecessor}`;
+    }
+  }
+  throw new LocalStateError("invalid");
+}
+async function acquirePrivateFileLock(target, hooks) {
+  const directory = path.dirname(target);
+  await ensurePrivateDirectory(directory);
+  const lockPath = path.join(directory, `.${path.basename(target)}.lock`);
+  const startedAt = Date.now();
+  const owner = { pid: process.pid, token: randomUUID() };
+  while (Date.now() - startedAt <= LOCK_WAIT_MILLISECONDS) {
+    let handle;
+    try {
+      handle = await open(
+        lockPath,
+        fileConstants.O_CREAT | fileConstants.O_EXCL | fileConstants.O_WRONLY | fileConstants.O_NOFOLLOW,
+        384
+      );
+      await handle.writeFile(`${JSON.stringify(owner)}
+`);
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      return async () => {
+        let current;
+        try {
+          current = await readLockOwner(lockPath);
+        } catch (error) {
+          if (errorCode(error) === "ENOENT") {
+            return;
+          }
+          throw error instanceof LocalStateError ? error : new LocalStateError("io");
+        }
+        if (current.token !== owner.token) {
+          return;
+        }
+        await unlink(lockPath).catch((error) => {
+          if (errorCode(error) !== "ENOENT") {
+            throw new LocalStateError("io");
+          }
+        });
+      };
+    } catch (error) {
+      await handle?.close();
+      if (errorCode(error) !== "EEXIST") {
+        if (errorCode(error) === "ELOOP") {
+          throw new LocalStateError("invalid");
+        }
+        throw error instanceof LocalStateError ? error : new LocalStateError("io");
+      }
+      try {
+        const metadata = await lstat(lockPath);
+        if (!metadata.isFile() || metadata.isSymbolicLink()) {
+          throw new LocalStateError("invalid");
+        }
+        if (Date.now() - metadata.mtimeMs > LOCK_STALE_MILLISECONDS) {
+          await hooks?.afterStaleMetadataRead?.(lockPath);
+          const releaseGuard = await acquireReclaimGuard(lockPath, metadata);
+          if (releaseGuard === void 0) {
+            await hooks?.afterReclaimGuardDenied?.(lockPath);
+            await delay(LOCK_RETRY_MILLISECONDS);
+            continue;
+          }
+          try {
+            const currentMetadata = await lstat(lockPath);
+            if (currentMetadata.dev !== metadata.dev || currentMetadata.ino !== metadata.ino || Date.now() - currentMetadata.mtimeMs <= LOCK_STALE_MILLISECONDS) {
+              continue;
+            }
+            let staleOwner;
+            try {
+              staleOwner = await readLockOwner(lockPath);
+            } catch (ownerError) {
+              if (!(ownerError instanceof LocalStateError && ownerError.failure === "invalid")) {
+                throw ownerError;
+              }
+            }
+            if (staleOwner !== void 0 && processIsAlive(staleOwner.pid)) {
+              await delay(LOCK_RETRY_MILLISECONDS);
+              continue;
+            }
+            const stalePath = `${lockPath}.stale-${randomUUID()}`;
+            await rename(lockPath, stalePath);
+            await hooks?.afterStaleRename?.(lockPath);
+            const movedMetadata = await lstat(stalePath);
+            if (movedMetadata.dev !== metadata.dev || movedMetadata.ino !== metadata.ino) {
+              throw new LocalStateError("invalid");
+            }
+            await unlink(stalePath);
+          } finally {
+            await releaseGuard();
+          }
+          continue;
+        }
+      } catch (metadataError) {
+        if (metadataError instanceof LocalStateError) {
+          throw metadataError;
+        }
+        if (errorCode(metadataError) !== "ENOENT") {
+          throw new LocalStateError("io");
+        }
+      }
+      await delay(LOCK_RETRY_MILLISECONDS);
+    }
+  }
+  throw new LocalStateError("busy");
+}
+async function withPrivateFileLocks(targets, action, hooks) {
+  const releases = [];
+  try {
+    for (const target of [...new Set(targets)].sort()) {
+      releases.push(await acquirePrivateFileLock(target, hooks));
+    }
+    return await action();
+  } finally {
+    for (const release of releases.reverse()) {
+      await release();
+    }
+  }
+}
+
+// apps/cli/src/user-path.ts
+import path2 from "node:path";
+function expandHome(input, homeDirectory, pathApi) {
+  if (input === "~") {
+    return homeDirectory;
+  }
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return pathApi.join(homeDirectory, input.slice(2));
+  }
+  return input;
+}
+function windowsShellPath(input) {
+  const msys = /^\/([a-z])(?:\/(.*))?$/iu.exec(input);
+  if (msys !== null) {
+    return `${msys[1]?.toUpperCase()}:\\${(msys[2] ?? "").replaceAll("/", "\\")}`;
+  }
+  const mounted = /^\/(?:cygdrive|mnt)\/([a-z])(?:\/(.*))?$/iu.exec(input);
+  if (mounted !== null) {
+    return `${mounted[1]?.toUpperCase()}:\\${(mounted[2] ?? "").replaceAll("/", "\\")}`;
+  }
+  return input;
+}
+function resolveUserPath(options) {
+  const platform = options.platform ?? process.platform;
+  const pathApi = platform === "win32" ? path2.win32 : path2.posix;
+  const expanded = expandHome(options.input, options.homeDirectory, pathApi);
+  if (platform === "win32") {
+    return pathApi.resolve(options.currentDirectory, windowsShellPath(expanded));
+  }
+  return pathApi.resolve(options.currentDirectory, expanded);
+}
+
+// apps/cli/src/project.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { lstat as lstat2, mkdir as mkdir2, unlink as unlink2 } from "node:fs/promises";
+import path3 from "node:path";
+var MANIFEST_NAME = "dxc.project.json";
+var MANIFEST_MAXIMUM_BYTES = 32 * 1024;
+var PROJECT_INDEX_MAXIMUM_BYTES = 512 * 1024;
+var PROJECT_INDEX_RELATIVE_PATH = ".dxc/content-projects.json";
+var DEFAULT_PROJECTS_RELATIVE_PATH = ".dxc/projects";
+var DEFAULT_ARTIFACT_PATHS = {
+  article: "artifacts/04-article.md",
+  brief: "artifacts/02-brief.md",
+  delivery: "artifacts/08-delivery.md",
+  outline: "artifacts/03-outline.md",
+  "quality-review": "artifacts/07-quality-review.md",
+  research: "artifacts/01-research.md",
+  titles: "artifacts/05-titles.md",
+  "visual-plan": "artifacts/06-visual-plan.md"
+};
+var ProjectCliError = class extends Error {
+  constructor(code, message, fields = { recovery: "\u8BF7\u6309\u5F53\u524D\u9879\u76EE Skill \u7684\u6062\u590D\u52A8\u4F5C\u91CD\u8BD5\u3002" }) {
+    super(message);
+    this.code = code;
+    this.fields = fields;
+    this.name = "ProjectCliError";
+  }
+  code;
+  fields;
+};
+function errorCode2(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function indexPath(homeDirectory) {
+  return path3.join(homeDirectory, PROJECT_INDEX_RELATIVE_PATH);
+}
+async function readManifest(directory) {
+  try {
+    const source = await readPrivateFile(
+      path3.join(directory, MANIFEST_NAME),
+      MANIFEST_MAXIMUM_BYTES
+    );
+    const parsed = contentProjectManifestSchema.safeParse(JSON.parse(source));
+    if (!parsed.success) {
+      throw new ProjectCliError("DXC_PROJECT_INVALID", "\u9879\u76EE\u6587\u4EF6 dxc.project.json \u5DF2\u635F\u574F\u3002");
+    }
+    return parsed.data;
+  } catch (error) {
+    if (error instanceof ProjectCliError) {
+      throw error;
+    }
+    if (error instanceof LocalStateError && error.failure === "missing") {
+      throw new ProjectCliError("DXC_PROJECT_NOT_FOUND", "\u6CA1\u6709\u627E\u5230\u5185\u5BB9\u9879\u76EE\u3002");
+    }
+    throw new ProjectCliError("DXC_PROJECT_IO_FAILED", "\u65E0\u6CD5\u8BFB\u53D6\u5185\u5BB9\u9879\u76EE\u3002");
+  }
+}
+async function readIndex(homeDirectory) {
+  try {
+    const source = await readPrivateFile(indexPath(homeDirectory), PROJECT_INDEX_MAXIMUM_BYTES);
+    const parsed = contentProjectIndexSchema.safeParse(JSON.parse(source));
+    if (!parsed.success) {
+      throw new ProjectCliError("DXC_PROJECT_INVALID", "\u672C\u5730\u9879\u76EE\u5217\u8868\u5DF2\u635F\u574F\u3002");
+    }
+    return parsed.data;
+  } catch (error) {
+    if (error instanceof LocalStateError && error.failure === "missing") {
+      return { projects: [], schemaVersion: "1" };
+    }
+    if (error instanceof ProjectCliError) {
+      throw error;
+    }
+    throw new ProjectCliError("DXC_PROJECT_IO_FAILED", "\u65E0\u6CD5\u8BFB\u53D6\u672C\u5730\u9879\u76EE\u5217\u8868\u3002");
+  }
+}
+var ProjectCli = 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 ?? randomUUID2;
+  }
+  async #rememberLocked(directory, manifest) {
+    const target = indexPath(this.#homeDirectory);
+    const index = await readIndex(this.#homeDirectory);
+    const entry = {
+      directory,
+      projectId: manifest.projectId,
+      title: manifest.title,
+      updatedAt: this.#now().toISOString()
+    };
+    const projects = [
+      entry,
+      ...index.projects.filter(
+        (project) => project.projectId !== entry.projectId && project.directory !== entry.directory
+      )
+    ].slice(0, 1e3);
+    await writePrivateJson(target, { projects, schemaVersion: "1" });
+  }
+  async initialize(directoryInput, title) {
+    const projectId = this.#randomUUID();
+    const directory = directoryInput === void 0 ? path3.join(this.#homeDirectory, DEFAULT_PROJECTS_RELATIVE_PATH, projectId) : resolveUserPath({
+      currentDirectory: this.#currentDirectory,
+      homeDirectory: this.#homeDirectory,
+      input: directoryInput
+    });
+    const manifestTarget = path3.join(directory, MANIFEST_NAME);
+    const parsed = contentProjectManifestSchema.safeParse({
+      artifacts: DEFAULT_ARTIFACT_PATHS,
+      assetsDirectory: "assets",
+      createdAt: this.#now().toISOString(),
+      projectId,
+      schemaVersion: "1",
+      title,
+      workflowId: CONTENT_WORKFLOW_ID
+    });
+    if (!parsed.success) {
+      throw new ProjectCliError("DXC_PROJECT_INVALID", "\u9879\u76EE\u6807\u9898\u6216\u76EE\u5F55\u4E0D\u5408\u6CD5\u3002");
+    }
+    const target = indexPath(this.#homeDirectory);
+    await withPrivateFileLocks([target], async () => {
+      try {
+        await lstat2(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) {
+          throw error;
+        }
+        if (errorCode2(error) !== "ENOENT") {
+          throw new ProjectCliError("DXC_PROJECT_IO_FAILED", "\u65E0\u6CD5\u68C0\u67E5\u9879\u76EE\u76EE\u5F55\u3002");
+        }
+      }
+      let manifestWritten = false;
+      try {
+        if (directoryInput === void 0) {
+          await ensurePrivateDirectory(directory);
+          await ensurePrivateDirectory(path3.join(directory, "artifacts"));
+          await ensurePrivateDirectory(path3.join(directory, parsed.data.assetsDirectory));
+        } else {
+          await mkdir2(path3.join(directory, "artifacts"), { recursive: true });
+          await mkdir2(path3.join(directory, parsed.data.assetsDirectory), { recursive: true });
+        }
+        await writePrivateJson(manifestTarget, parsed.data);
+        manifestWritten = true;
+        await this.#rememberLocked(directory, parsed.data);
+      } catch (error) {
+        if (manifestWritten) {
+          await unlink2(manifestTarget).catch(() => void 0);
+        }
+        if (error instanceof ProjectCliError) {
+          throw error;
+        }
+        throw new ProjectCliError("DXC_PROJECT_IO_FAILED", "\u65E0\u6CD5\u521B\u5EFA\u5185\u5BB9\u9879\u76EE\u3002", {
+          recovery: "\u9879\u76EE\u6E05\u5355\u5DF2\u5B89\u5168\u56DE\u6EDA\uFF1B\u8BF7\u4FDD\u7559\u4E3B\u9898\u548C\u76EE\u5F55\u540E\u91CD\u8BD5\u540C\u4E00\u521B\u5EFA\u52A8\u4F5C\u3002",
+          retryable: true
+        });
+      }
+    }).catch((error) => {
+      if (error instanceof LocalStateError && error.failure === "busy") {
+        throw new ProjectCliError("DXC_PROJECT_BUSY", "\u672C\u5730\u9879\u76EE\u7D22\u5F15\u6B63\u5728\u66F4\u65B0\u3002", {
+          recovery: "\u9879\u76EE\u5C1A\u672A\u521B\u5EFA\uFF1B\u8BF7\u7B49\u5F85\u5F53\u524D\u9879\u76EE\u52A8\u4F5C\u5B8C\u6210\u540E\u91CD\u8BD5\u540C\u4E00\u64CD\u4F5C\u3002",
+          retryable: true
+        });
+      }
+      throw error;
+    });
+    return { data: { directory, manifest: parsed.data } };
+  }
+  async locateByProjectId(projectIdInput) {
+    const projectId = projectIdInput.trim().toLocaleLowerCase("en-US");
+    const index = await readIndex(this.#homeDirectory);
+    const entry = index.projects.find(
+      (candidate) => candidate.projectId.toLocaleLowerCase("en-US") === projectId
+    );
+    if (entry === void 0) {
+      throw new ProjectCliError("DXC_PROJECT_NOT_FOUND", "\u6CA1\u6709\u627E\u5230\u6307\u5B9A\u7684\u5185\u5BB9\u9879\u76EE\u3002");
+    }
+    const manifest = await readManifest(entry.directory);
+    if (manifest.projectId !== entry.projectId) {
+      throw new ProjectCliError("DXC_PROJECT_INVALID", "\u672C\u5730\u9879\u76EE\u767B\u8BB0\u4E0E\u9879\u76EE\u6587\u4EF6\u4E0D\u4E00\u81F4\u3002");
+    }
+    return { directory: entry.directory, manifest };
+  }
+  async locate(directoryInput) {
+    if (directoryInput !== void 0) {
+      const directory2 = resolveUserPath({
+        currentDirectory: this.#currentDirectory,
+        homeDirectory: this.#homeDirectory,
+        input: directoryInput
+      });
+      return { directory: directory2, manifest: await readManifest(directory2) };
+    }
+    let directory = path3.resolve(this.#currentDirectory);
+    while (true) {
+      try {
+        return { directory, manifest: await readManifest(directory) };
+      } catch (error) {
+        if (!(error instanceof ProjectCliError) || error.code !== "DXC_PROJECT_NOT_FOUND") {
+          throw error;
+        }
+      }
+      const parent = path3.dirname(directory);
+      if (parent === directory) {
+        throw new ProjectCliError("DXC_PROJECT_NOT_FOUND", "\u5F53\u524D\u76EE\u5F55\u4E2D\u6CA1\u6709 DxC \u5185\u5BB9\u9879\u76EE\u3002");
+      }
+      directory = parent;
+    }
+  }
+  async relink(projectIdInput, directoryInput) {
+    const projectId = projectIdInput.trim().toLocaleLowerCase("en-US");
+    const directory = resolveUserPath({
+      currentDirectory: this.#currentDirectory,
+      homeDirectory: this.#homeDirectory,
+      input: directoryInput
+    });
+    const manifest = await readManifest(directory);
+    if (manifest.projectId.toLocaleLowerCase("en-US") !== projectId) {
+      throw new ProjectCliError("DXC_PROJECT_INVALID", "\u6240\u9009\u4F4D\u7F6E\u4E0D\u5C5E\u4E8E\u8BE5\u9879\u76EE ID\u3002", {
+        actual: manifest.projectId,
+        expected: projectId,
+        field: "project",
+        recovery: "\u8BF7\u8BA9\u7528\u6237\u91CD\u65B0\u9009\u62E9\u4E0E\u8BE5\u9879\u76EE ID \u5BF9\u5E94\u7684\u9879\u76EE\u4F4D\u7F6E\u3002"
+      });
+    }
+    const target = indexPath(this.#homeDirectory);
+    return withPrivateFileLocks([target], async () => {
+      const index = await readIndex(this.#homeDirectory);
+      const existing = index.projects.find(
+        (entry) => entry.projectId.toLocaleLowerCase("en-US") === projectId
+      );
+      if (existing === void 0) {
+        throw new ProjectCliError("DXC_PROJECT_NOT_FOUND", "\u672C\u5730\u9879\u76EE\u5217\u8868\u4E2D\u6CA1\u6709\u8BE5\u9879\u76EE ID\u3002", {
+          actual: projectId,
+          field: "project",
+          recovery: "\u8BF7\u91CD\u65B0\u5217\u51FA\u9879\u76EE\u5E76\u4F7F\u7528\u5F53\u524D\u8FD4\u56DE\u7684\u9879\u76EE ID\u3002"
+        });
+      }
+      const updatedAt = this.#now().toISOString();
+      await writePrivateJson(target, {
+        projects: index.projects.map(
+          (entry) => entry.projectId === existing.projectId ? { directory, projectId: manifest.projectId, title: manifest.title, updatedAt } : entry
+        ),
+        schemaVersion: "1"
+      });
+      return contentProjectRelinkResultSchema.parse({
+        command: "project.relink",
+        data: { projectId: manifest.projectId, title: manifest.title, updatedAt },
+        ok: true
+      });
+    }).catch((error) => {
+      if (error instanceof LocalStateError && error.failure === "busy") {
+        throw new ProjectCliError("DXC_PROJECT_BUSY", "\u672C\u5730\u9879\u76EE\u7D22\u5F15\u6B63\u5728\u66F4\u65B0\u3002", {
+          recovery: "\u8BF7\u7B49\u5F85\u5F53\u524D\u9879\u76EE\u52A8\u4F5C\u5B8C\u6210\u540E\u91CD\u8BD5\u540C\u4E00\u64CD\u4F5C\u3002",
+          retryable: true
+        });
+      }
+      throw error;
+    });
+  }
+  async find(query, directoryInput) {
+    if (directoryInput !== void 0) {
+      return [await this.locate(directoryInput)];
+    }
+    if (query === void 0 || query.trim().length === 0) {
+      try {
+        return [await this.locate()];
+      } catch (error) {
+        if (!(error instanceof ProjectCliError) || error.code !== "DXC_PROJECT_NOT_FOUND") {
+          throw error;
+        }
+      }
+    }
+    const normalized = query?.trim().toLocaleLowerCase("zh-CN");
+    const index = await readIndex(this.#homeDirectory);
+    const candidates = index.projects.filter(
+      (project) => normalized === void 0 || project.projectId.toLocaleLowerCase("zh-CN").includes(normalized) || project.title.toLocaleLowerCase("zh-CN").includes(normalized)
+    );
+    const locations = [];
+    for (const candidate of candidates) {
+      try {
+        const manifest = await readManifest(candidate.directory);
+        if (manifest.projectId === candidate.projectId) {
+          locations.push({ directory: candidate.directory, manifest });
+        }
+      } catch (error) {
+        if (!(error instanceof ProjectCliError)) {
+          throw error;
+        }
+      }
+    }
+    return locations;
+  }
+  async list() {
+    const index = await readIndex(this.#homeDirectory);
+    const projects = [];
+    for (const entry of index.projects) {
+      try {
+        const manifest = await readManifest(entry.directory);
+        projects.push({
+          entry,
+          ...manifest.projectId === entry.projectId ? { location: { directory: entry.directory, manifest } } : {}
+        });
+      } catch (error) {
+        if (!(error instanceof ProjectCliError)) {
+          throw error;
+        }
+        projects.push({
+          entry,
+          unavailableReason: error.code === "DXC_PROJECT_NOT_FOUND" ? "project-directory-missing" : error.code === "DXC_PROJECT_INVALID" ? "project-invalid" : "project-unreadable"
+        });
+      }
+    }
+    return projects;
+  }
+};
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS,
+  publishingUploadSessionSchema,
+  publishingUploadReceiptSchema,
+  publishingArticleSchema,
+  publishingRenderSnapshotSchema,
+  publishingPreviewLinkSchema,
+  publishingPreviewSelectionStateSchema,
+  createPublishingApprovalRequestSchema,
+  publishingApprovalSchema,
+  publishingDraftIntentResponseSchema,
+  publishingDraftAttentionDiagnosticsSchema,
+  CONTENT_ARTIFACT_KINDS,
+  CONTENT_STAGE_DEFINITIONS,
+  contentWorkflowAdoptedKnowledgeSchema,
+  contentWorkflowContextSchema,
+  portableRelativePathSchema,
+  contentProfileInputSchema,
+  contentProfileSchema,
+  contentProfileViewSchema,
+  contentProfileStatusResultSchema,
+  contentProfileFieldSchema,
+  contentProfileSessionResultSchema,
+  contentProfileErrorResultSchema,
+  CONTENT_MEMORY_KINDS,
+  contentMemoryInputSchema,
+  contentMemoryStoreSchema,
+  contentMemoryViewSchema,
+  contentMemoryAddResultSchema,
+  contentMemoryArchiveResultSchema,
+  contentMemoryCorrectResultSchema,
+  contentMemoryListResultSchema,
+  contentMemoryErrorResultSchema,
+  contentProjectListResultSchema,
+  contentProjectErrorResultSchema,
+  contentWorkflowErrorResultSchema,
+  CONTENT_KNOWLEDGE_SCHEMA_VERSION,
+  CONTENT_KNOWLEDGE_EMBEDDING_MODEL,
+  CONTENT_KNOWLEDGE_EMBEDDING_REVISION,
+  CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS,
+  CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION,
+  CONTENT_KNOWLEDGE_CHUNKER_VERSION,
+  contentKnowledgeSearchModeSchema,
+  contentKnowledgeSourceFilterSchema,
+  contentKnowledgeRefSchema,
+  contentKnowledgeModelSchema,
+  contentKnowledgeImportResultSchema,
+  contentKnowledgeQuoteListResultSchema,
+  contentKnowledgeQuoteMutationResultSchema,
+  contentKnowledgeQuoteStatusResultSchema,
+  contentKnowledgeSearchResultSchema,
+  contentKnowledgeStatusResultSchema,
+  contentKnowledgeRemoveResultSchema,
+  contentKnowledgeAdoptResultSchema,
+  contentKnowledgeErrorResultSchema,
+  doctorResultSchema,
+  articleBundleSchema,
+  preflightResultSchema,
+  wechatRenderResultSchema,
+  createDeviceBindingSessionResponseSchema,
+  proveDeviceBindingSessionResponseSchema,
+  deviceSessionStatusResponseSchema,
+  createWechatLoginSessionResponseSchema,
+  wechatLoginSessionResponseSchema,
+  createWechatAuthorizationSessionResponseSchema,
+  wechatAuthorizationSessionResponseSchema,
+  wechatAccountsResponseSchema,
+  apiErrorResponseSchema,
+  LocalStateError,
+  ensurePrivateDirectory,
+  ensurePrivateRegularFile,
+  readPrivateFile,
+  readPrivateBuffer,
+  writePrivateJson,
+  writePrivateBuffer,
+  withPrivateFileLocks,
+  resolveUserPath,
+  ProjectCliError,
+  ProjectCli
+};