@deployxai/dxc 0.1.13 → 0.2.1

package/dist/chunks/chunk-RONRJJBC.js

@@ -1,2379 +0,0 @@
-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-knowledge.ts
-import { z } 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 = z.enum(["hybrid", "lexical", "semantic"]);
-var contentKnowledgeQuoteStatusSchema = z.enum(["active", "archived"]);
-var contentKnowledgeQuoteOriginSchema = z.enum(["original", "third-party"]);
-var contentKnowledgeQuoteVerbatimUseSchema = z.enum([
-  "original",
-  "needs-verification",
-  "permitted",
-  "do-not-use-verbatim"
-]);
-var contentKnowledgeModelSchema = z.object({
-  dimensions: z.literal(CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS),
-  id: z.literal(CONTENT_KNOWLEDGE_EMBEDDING_MODEL),
-  quantization: z.literal(CONTENT_KNOWLEDGE_EMBEDDING_QUANTIZATION),
-  revision: z.literal(CONTENT_KNOWLEDGE_EMBEDDING_REVISION)
-}).strict();
-var contentKnowledgeArticleSummarySchema = z.object({
-  articleId: z.uuid(),
-  chunkCount: z.number().int().positive(),
-  contentSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  importedAt: z.iso.datetime(),
-  sourceLabel: z.string().trim().min(1).max(255),
-  title: z.string().trim().min(1).max(300),
-  updatedAt: z.iso.datetime()
-}).strict();
-var contentKnowledgeImportItemSchema = z.object({
-  article: contentKnowledgeArticleSummarySchema,
-  semanticIndexed: z.boolean(),
-  status: z.enum(["created", "updated", "unchanged"])
-}).strict();
-var contentKnowledgeImportSkippedItemSchema = z.object({
-  code: z.enum(["DXC_KNOWLEDGE_ARTICLE_INVALID", "DXC_KNOWLEDGE_FILE_TOO_LARGE"]),
-  message: z.string().trim().min(1),
-  sourceLabel: z.string().trim().min(1).max(255)
-}).strict();
-var contentKnowledgeImportResultSchema = z.object({
-  command: z.literal("knowledge.import"),
-  data: z.object({
-    imported: z.array(contentKnowledgeImportItemSchema),
-    model: contentKnowledgeModelSchema.nullable(),
-    skipped: z.array(contentKnowledgeImportSkippedItemSchema)
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeMatchLaneSchema = z.enum(["lexical", "semantic"]);
-var contentKnowledgeSearchItemBaseSchema = z.object({
-  lanes: z.array(contentKnowledgeMatchLaneSchema).min(1).max(2),
-  rank: z.number().int().positive().max(20),
-  snippet: z.string().trim().min(1).max(420)
-}).strict();
-var contentKnowledgeHistorySearchItemSchema = contentKnowledgeSearchItemBaseSchema.extend({
-  articleId: z.uuid(),
-  chunkId: z.uuid(),
-  chunkSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  heading: z.string().trim().min(1).max(300).nullable(),
-  ordinal: z.number().int().nonnegative(),
-  sourceType: z.literal("history-article"),
-  sourceLabel: z.string().trim().min(1).max(255),
-  title: z.string().trim().min(1).max(300)
-});
-var contentKnowledgeQuoteSearchItemSchema = contentKnowledgeSearchItemBaseSchema.extend({
-  attribution: z.string().trim().min(1).max(300).nullable(),
-  contentSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  origin: contentKnowledgeQuoteOriginSchema,
-  quoteId: z.uuid(),
-  sourceLabel: z.string().trim().min(1).max(300).nullable(),
-  sourceType: z.literal("quote"),
-  status: contentKnowledgeQuoteStatusSchema,
-  tags: z.array(z.string().trim().min(1).max(80)).max(20),
-  verbatimUse: contentKnowledgeQuoteVerbatimUseSchema
-});
-var contentKnowledgeSearchItemSchema = z.discriminatedUnion("sourceType", [
-  contentKnowledgeHistorySearchItemSchema,
-  contentKnowledgeQuoteSearchItemSchema
-]);
-var contentKnowledgeQuoteSummarySchema = z.object({
-  activeCount: z.number().int().nonnegative(),
-  archivedCount: z.number().int().nonnegative(),
-  sourceInitialized: z.boolean(),
-  sourcePath: z.literal("~/Documents/DxC/\u91D1\u53E5\u5E93.md"),
-  sourceSha256: z.string().regex(/^[a-f0-9]{64}$/u).nullable()
-}).strict();
-var contentKnowledgeQuoteRecordSchema = z.object({
-  attribution: z.string().trim().min(1).max(300).nullable(),
-  origin: contentKnowledgeQuoteOriginSchema,
-  quoteId: z.uuid(),
-  source: z.string().trim().min(1).max(300).nullable(),
-  status: contentKnowledgeQuoteStatusSchema,
-  tags: z.array(z.string().trim().min(1).max(80)).max(20),
-  text: z.string().trim().min(1).max(2e3),
-  verbatimUse: contentKnowledgeQuoteVerbatimUseSchema
-}).strict();
-var contentKnowledgeQuoteListResultSchema = z.object({
-  command: z.literal("knowledge.quotes.list"),
-  data: z.object({ quotes: z.array(contentKnowledgeQuoteRecordSchema).max(5e3) }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeQuoteMutationResultSchema = z.object({
-  command: z.enum([
-    "knowledge.quotes.add",
-    "knowledge.quotes.update",
-    "knowledge.quotes.archive"
-  ]),
-  data: z.object({ pendingSync: z.literal(true), quote: contentKnowledgeQuoteRecordSchema }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeQuoteInitResultSchema = z.object({
-  command: z.literal("knowledge.quotes.init"),
-  data: contentKnowledgeQuoteSummarySchema.extend({ created: z.boolean() }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeQuoteStatusResultSchema = z.object({
-  command: z.literal("knowledge.quotes.status"),
-  data: contentKnowledgeQuoteSummarySchema,
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeQuoteSyncResultSchema = z.object({
-  command: z.literal("knowledge.quotes.sync"),
-  data: contentKnowledgeQuoteSummarySchema.extend({
-    model: contentKnowledgeModelSchema.nullable(),
-    status: z.enum(["created", "updated", "unchanged"])
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeSearchItemLegacySchema = z.object({
-  articleId: z.uuid(),
-  chunkId: z.uuid(),
-  chunkSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-  heading: z.string().trim().min(1).max(300).nullable(),
-  lanes: z.array(contentKnowledgeMatchLaneSchema).min(1).max(2),
-  ordinal: z.number().int().nonnegative(),
-  rank: z.number().int().positive().max(20),
-  snippet: z.string().trim().min(1).max(420),
-  sourceLabel: z.string().trim().min(1).max(255),
-  title: z.string().trim().min(1).max(300)
-}).strict();
-var contentKnowledgeSearchResultSchema = z.object({
-  command: z.literal("knowledge.search"),
-  data: z.object({
-    mode: contentKnowledgeSearchModeSchema,
-    model: contentKnowledgeModelSchema.nullable(),
-    query: z.string().trim().min(1).max(500),
-    results: z.array(contentKnowledgeSearchItemSchema).max(20)
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeStatusResultSchema = z.object({
-  command: z.literal("knowledge.status"),
-  data: z.object({
-    articleCount: z.number().int().nonnegative(),
-    chunkCount: z.number().int().nonnegative(),
-    databasePath: z.literal("~/.dxc/content-memory.sqlite"),
-    model: contentKnowledgeModelSchema,
-    modelCached: z.boolean(),
-    semanticIndexedChunkCount: z.number().int().nonnegative(),
-    quotes: contentKnowledgeQuoteSummarySchema
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeRemoveResultSchema = z.object({
-  command: z.literal("knowledge.remove"),
-  data: z.object({
-    articleId: z.uuid(),
-    removed: z.boolean()
-  }).strict(),
-  ok: z.literal(true)
-}).strict();
-var contentKnowledgeCommandSchema = z.enum([
-  "knowledge.import",
-  "knowledge.remove",
-  "knowledge.search",
-  "knowledge.status",
-  "knowledge.quotes.init",
-  "knowledge.quotes.add",
-  "knowledge.quotes.archive",
-  "knowledge.quotes.list",
-  "knowledge.quotes.status",
-  "knowledge.quotes.sync",
-  "knowledge.quotes.update"
-]);
-var contentKnowledgeErrorResultSchema = z.object({
-  command: contentKnowledgeCommandSchema,
-  error: z.object({
-    code: z.enum([
-      "DXC_KNOWLEDGE_ARTICLE_INVALID",
-      "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_QUOTE_INVALID",
-      "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
-      "DXC_KNOWLEDGE_SCHEMA_UNSUPPORTED",
-      "DXC_KNOWLEDGE_SEMANTIC_NOT_READY",
-      "DXC_KNOWLEDGE_STATE_INVALID"
-    ]),
-    message: z.string().trim().min(1)
-  }).strict(),
-  ok: z.literal(false)
-}).strict();
-
-// packages/contracts/src/content-source.ts
-import { z as z2 } from "zod";
-var sourceFetchKindSchema = z2.enum(["rss", "api", "html"]);
-var sourceExecutionLocationSchema = z2.literal("local-device");
-var sourceDataTransitSchema = z2.literal("local-only");
-var sourceCaptureMetadataSchema = z2.object({
-  capturedAt: z2.iso.datetime(),
-  contentHash: z2.string().regex(/^[a-f0-9]{64}$/u),
-  dataTransit: sourceDataTransitSchema,
-  executionLocation: sourceExecutionLocationSchema,
-  extractor: z2.string().trim().min(1).max(120),
-  finalUrl: z2.url(),
-  mediaType: z2.string().trim().min(1).max(160),
-  sourceUrl: z2.url()
-}).strict();
-var sourceFeedItemSchema = z2.object({
-  id: z2.string().trim().min(1).max(256),
-  publishedAt: z2.iso.datetime().optional(),
-  summary: z2.string().trim().min(1).max(2e3).optional(),
-  title: z2.string().trim().min(1).max(500),
-  url: z2.url().optional()
-}).strict();
-var sourceHtmlDocumentSchema = z2.object({
-  canonicalUrl: z2.url().optional(),
-  excerpt: z2.string().trim().min(1).max(12e3),
-  title: z2.string().trim().min(1).max(500)
-}).strict();
-var sourceFetchDataSchema = z2.discriminatedUnion("kind", [
-  z2.object({
-    capture: sourceCaptureMetadataSchema,
-    items: z2.array(sourceFeedItemSchema).max(100),
-    kind: z2.literal("rss")
-  }).strict(),
-  z2.object({
-    capture: sourceCaptureMetadataSchema,
-    kind: z2.literal("api"),
-    payload: z2.unknown()
-  }).strict(),
-  z2.object({
-    capture: sourceCaptureMetadataSchema,
-    document: sourceHtmlDocumentSchema,
-    kind: z2.literal("html")
-  }).strict()
-]);
-var sourceFetchResultSchema = z2.object({
-  command: z2.literal("source.fetch"),
-  data: sourceFetchDataSchema,
-  ok: z2.literal(true)
-}).strict();
-var sourceFetchErrorResultSchema = z2.object({
-  command: z2.literal("source.fetch"),
-  error: z2.object({
-    code: z2.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(z2.literal("DXC_SOURCE_FAILED")),
-    message: z2.string().trim().min(1).max(500),
-    recovery: z2.string().trim().min(1).max(800).optional()
-  }).strict(),
-  ok: z2.literal(false)
-}).strict();
-
-// packages/contracts/src/content-monitor.ts
-import { z as z3 } from "zod";
-var CONTENT_MONITOR_SCHEMA_VERSION = "1";
-var contentMonitorSourceSchema = z3.object({
-  bearerEnvironment: z3.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u).nullable(),
-  createdAt: z3.iso.datetime(),
-  enabled: z3.boolean(),
-  headerEnvironments: z3.array(
-    z3.object({
-      environment: z3.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u),
-      header: z3.string().regex(/^[A-Za-z0-9-]+$/u)
-    }).strict()
-  ).max(12),
-  id: z3.uuid(),
-  kind: sourceFetchKindSchema,
-  name: z3.string().trim().min(1).max(120),
-  rssLimit: z3.number().int().min(1).max(100).nullable(),
-  url: z3.url()
-}).strict();
-var contentMonitorSourceSummarySchema = contentMonitorSourceSchema.extend({
-  lastRunAt: z3.iso.datetime().nullable(),
-  lastRunSummary: z3.string().trim().min(1).max(200).nullable(),
-  latestItemAt: z3.iso.datetime().nullable(),
-  observedItemCount: z3.number().int().nonnegative()
-});
-var contentMonitorRunSourceResultSchema = z3.object({
-  failureMessage: z3.string().trim().min(1).max(500).nullable(),
-  monitoredItemCount: z3.number().int().nonnegative(),
-  newItemCount: z3.number().int().nonnegative(),
-  sourceId: z3.uuid(),
-  sourceName: z3.string().trim().min(1).max(120),
-  summary: z3.string().trim().min(1).max(200),
-  unchangedItemCount: z3.number().int().nonnegative(),
-  updatedItemCount: z3.number().int().nonnegative()
-}).strict();
-var contentMonitorAddResultSchema = z3.object({
-  command: z3.literal("monitor.add"),
-  data: z3.object({
-    source: contentMonitorSourceSchema,
-    summary: z3.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z3.literal(true)
-}).strict();
-var contentMonitorListResultSchema = z3.object({
-  command: z3.literal("monitor.list"),
-  data: z3.object({
-    sources: z3.array(contentMonitorSourceSummarySchema),
-    summary: z3.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z3.literal(true)
-}).strict();
-var contentMonitorRunResultSchema = z3.object({
-  command: z3.literal("monitor.run"),
-  data: z3.object({
-    failedSourceCount: z3.number().int().nonnegative(),
-    finishedAt: z3.iso.datetime(),
-    results: z3.array(contentMonitorRunSourceResultSchema),
-    startedAt: z3.iso.datetime(),
-    summary: z3.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z3.literal(true)
-}).strict();
-var contentMonitorStatusResultSchema = z3.object({
-  command: z3.literal("monitor.status"),
-  data: z3.object({
-    databasePath: z3.literal("~/.dxc/source-monitor.sqlite"),
-    enabledSourceCount: z3.number().int().nonnegative(),
-    latestRunAt: z3.iso.datetime().nullable(),
-    latestRunSummary: z3.string().trim().min(1).max(200).nullable(),
-    sourceCount: z3.number().int().nonnegative(),
-    summary: z3.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z3.literal(true)
-}).strict();
-var contentMonitorRemoveResultSchema = z3.object({
-  command: z3.literal("monitor.remove"),
-  data: z3.object({
-    removed: z3.boolean(),
-    sourceId: z3.uuid(),
-    summary: z3.string().trim().min(1).max(200)
-  }).strict(),
-  ok: z3.literal(true)
-}).strict();
-var contentMonitorCommandSchema = z3.enum([
-  "monitor.add",
-  "monitor.list",
-  "monitor.remove",
-  "monitor.run",
-  "monitor.status"
-]);
-var contentMonitorErrorResultSchema = z3.object({
-  command: contentMonitorCommandSchema,
-  error: z3.object({
-    code: z3.enum([
-      "DXC_MONITOR_IO_FAILED",
-      "DXC_MONITOR_SCHEMA_UNSUPPORTED",
-      "DXC_MONITOR_SOURCE_INVALID",
-      "DXC_MONITOR_SOURCE_NOT_FOUND",
-      "DXC_MONITOR_STATE_INVALID"
-    ]),
-    message: z3.string().trim().min(1).max(500)
-  }).strict(),
-  ok: z3.literal(false)
-}).strict();
-
-// packages/contracts/src/index.ts
-import { z as z6 } from "zod";
-
-// packages/contracts/src/publishing.ts
-import { z as z4 } from "zod";
-var sha256Schema = z4.string().regex(/^[a-f0-9]{64}$/u);
-var wechatTemplateIdSchema = z4.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 = z4.enum(["article-source", "cover-image", "inline-image"]);
-var publishingUploadMediaTypeSchema = z4.enum([
-  "text/markdown",
-  "text/plain",
-  "image/jpeg",
-  "image/png"
-]);
-var createPublishingUploadRequestSchema = z4.object({
-  fileName: z4.string().trim().min(1).max(160),
-  kind: publishingUploadKindSchema,
-  mediaType: publishingUploadMediaTypeSchema,
-  sha256: sha256Schema,
-  size: z4.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 = z4.object({
-  expiresAt: z4.iso.datetime(),
-  id: z4.uuid(),
-  kind: publishingUploadKindSchema,
-  uploadUrl: z4.url()
-}).strict();
-var publishingUploadReceiptSchema = z4.object({
-  id: z4.uuid(),
-  sha256: sha256Schema,
-  size: z4.number().int().positive().max(5 * 1024 * 1024),
-  status: z4.literal("UPLOADED")
-}).strict();
-var createPublishingArticleRequestSchema = z4.object({
-  coverUploadId: z4.uuid(),
-  inlineAssets: z4.array(
-    z4.object({
-      logicalPath: z4.string().trim().min(1).max(240),
-      uploadId: z4.uuid()
-    }).strict()
-  ).max(20).optional(),
-  sourceUploadId: z4.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 = z4.object({
-  logicalPath: z4.string().trim().min(1).max(240),
-  mediaType: z4.enum(["image/jpeg", "image/png"]),
-  sha256: sha256Schema
-}).strict();
-var publishingArticleSchema = z4.object({
-  cover: z4.object({
-    height: z4.number().int().positive().max(12e3),
-    mediaType: z4.enum(["image/jpeg", "image/png"]),
-    width: z4.number().int().positive().max(12e3)
-  }).strict(),
-  coverHash: sha256Schema,
-  createdAt: z4.iso.datetime(),
-  id: z4.uuid(),
-  inlineAssets: z4.array(publishingInlineAssetSchema).max(20).default([]),
-  sourceHash: sha256Schema
-}).strict();
-var createPublishingRenderSnapshotRequestSchema = z4.object({
-  title: z4.string().trim().min(1).max(64).optional()
-}).strict();
-var publishingPreflightIssueSchema = z4.object({
-  code: z4.string().trim().min(1),
-  message: z4.string().trim().min(1),
-  path: z4.string().trim().min(1).optional()
-}).strict();
-var publishingPreflightSchema = z4.object({
-  errors: z4.array(publishingPreflightIssueSchema),
-  metrics: z4.object({
-    digestCharacters: z4.number().int().nonnegative(),
-    externalLinkCount: z4.number().int().nonnegative(),
-    htmlCharacters: z4.number().int().nonnegative(),
-    imageCount: z4.number().int().nonnegative(),
-    tableCount: z4.number().int().nonnegative()
-  }).strict(),
-  ok: z4.boolean(),
-  warnings: z4.array(publishingPreflightIssueSchema)
-}).strict();
-var publishingRenderSnapshotSchema = z4.object({
-  articleId: z4.uuid(),
-  assetManifestHash: sha256Schema,
-  author: z4.string().trim().min(1).max(16),
-  commentsEnabled: z4.boolean(),
-  coverHash: sha256Schema,
-  createdAt: z4.iso.datetime(),
-  digest: z4.string().trim().min(1).max(120),
-  htmlHash: sha256Schema,
-  id: z4.uuid(),
-  inlineAssets: z4.array(publishingInlineAssetSchema).max(20).default([]),
-  preflight: publishingPreflightSchema,
-  rendererVersion: z4.string().trim().min(1),
-  snapshotHash: sha256Schema,
-  sourceHash: sha256Schema,
-  templateId: wechatTemplateIdSchema,
-  title: z4.string().trim().min(1).max(32)
-}).strict();
-var createPublishingPreviewLinkRequestSchema = z4.object({
-  snapshotHash: sha256Schema
-}).strict();
-var publishingPreviewLinkSchema = z4.object({
-  createdAt: z4.iso.datetime().optional(),
-  expiresAt: z4.iso.datetime(),
-  expiresInSeconds: z4.number().int().positive().max(24 * 60 * 60).optional(),
-  snapshotHash: sha256Schema,
-  url: z4.url()
-}).strict();
-var publishingPreviewSelectionStateSchema = z4.object({
-  rootSnapshotHash: sha256Schema,
-  rootSnapshotId: z4.uuid(),
-  selectedSnapshotHash: sha256Schema,
-  selectedSnapshotId: z4.uuid(),
-  selectionRevision: z4.number().int().nonnegative(),
-  templateId: wechatTemplateIdSchema,
-  updatedAt: z4.iso.datetime(),
-  viewed: z4.boolean(),
-  viewedAt: z4.iso.datetime().nullable()
-}).strict();
-var createPublishingApprovalRequestSchema = z4.object({
-  accountId: z4.uuid(),
-  confirmed: z4.literal(true),
-  snapshotHash: sha256Schema
-}).strict();
-var publishingApprovalSchema = z4.object({
-  accountId: z4.uuid(),
-  confirmedAt: z4.iso.datetime(),
-  id: z4.uuid(),
-  rootSnapshotHash: sha256Schema,
-  rootSnapshotId: z4.uuid(),
-  selectedSnapshotHash: sha256Schema,
-  selectedSnapshotId: z4.uuid(),
-  snapshotHash: sha256Schema,
-  snapshotId: z4.uuid(),
-  templateId: wechatTemplateIdSchema
-}).strict().superRefine((approval, context) => {
-  if (approval.snapshotId !== approval.selectedSnapshotId || approval.snapshotHash !== approval.selectedSnapshotHash) {
-    context.addIssue({
-      code: "custom",
-      message: "legacy snapshot aliases must identify the selected snapshot"
-    });
-  }
-});
-var createPublishingDraftIntentRequestSchema = z4.object({
-  approvalId: z4.uuid(),
-  previousIntentId: z4.uuid().optional()
-}).strict();
-var publishingDraftStatusSchema = z4.enum([
-  "QUEUED",
-  "PREPARING",
-  "UPLOADING_ASSETS",
-  "ASSET_UPLOAD_UNVERIFIED",
-  "CREATING_DRAFT",
-  "VERIFYING",
-  "SUCCEEDED",
-  "CREATED_UNVERIFIED",
-  "FAILED"
-]);
-var publishingDraftIntentSchema = z4.object({
-  accountId: z4.uuid(),
-  approvalId: z4.uuid(),
-  createdAt: z4.iso.datetime(),
-  errorCode: z4.string().trim().min(1).optional(),
-  id: z4.uuid(),
-  mediaId: z4.string().trim().min(1).max(128).optional(),
-  progress: z4.object({
-    label: z4.string().trim().min(1).max(40),
-    message: z4.string().trim().min(1).max(300),
-    nextAction: z4.string().trim().min(1).max(300),
-    pollAfterSeconds: z4.number().int().positive().max(60).nullable(),
-    terminal: z4.boolean()
-  }).strict(),
-  snapshotHash: sha256Schema,
-  status: publishingDraftStatusSchema,
-  updatedAt: z4.iso.datetime(),
-  verification: z4.object({
-    authorMatched: z4.boolean(),
-    contentMatched: z4.boolean(),
-    digestMatched: z4.boolean(),
-    titleMatched: z4.boolean()
-  }).strict().optional()
-}).strict();
-var publishingDraftIntentResponseSchema = z4.object({
-  intent: publishingDraftIntentSchema
-}).strict();
-
-// packages/contracts/src/content-workflow.ts
-import { z as z5 } 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 = z5.enum(CONTENT_ARTIFACT_KINDS);
-var CONTENT_STAGE_SKILLS = {
-  article: { name: "dxc-article-write", version: "0.1.0" },
-  brief: { name: "dxc-content-brief", version: "0.1.0" },
-  delivery: { name: "dxc-wechat-publisher", version: "0.6.0" },
-  outline: { name: "dxc-article-outline", version: "0.1.0" },
-  "quality-review": { name: "dxc-content-review", version: "0.3.0" },
-  research: { name: "dxc-research", version: "0.2.0" },
-  titles: { name: "dxc-title-write", version: "0.3.0" },
-  "visual-plan": { name: "dxc-visual-plan", version: "0.3.0" }
-};
-var CONTENT_STAGE_INPUTS = {
-  article: {
-    optional: [],
-    required: ["research", "brief", "outline"]
-  },
-  brief: {
-    optional: [],
-    required: ["research"]
-  },
-  delivery: {
-    optional: [],
-    required: ["article", "titles", "visual-plan", "quality-review"]
-  },
-  outline: {
-    optional: [],
-    required: ["research", "brief"]
-  },
-  "quality-review": {
-    optional: ["visual-plan"],
-    required: ["research", "article", "titles"]
-  },
-  research: {
-    optional: [],
-    required: []
-  },
-  titles: {
-    optional: ["brief"],
-    required: ["article"]
-  },
-  "visual-plan": {
-    optional: ["outline"],
-    required: ["article", "titles"]
-  }
-};
-var portableRelativePathSchema = z5.string().trim().min(1).max(240).refine((value) => !value.startsWith("/") && !value.includes("\\"), {
-  message: "path must use portable relative path syntax"
-}).refine((value) => !/[:*?"<>|]/u.test(value) && !value.includes(String.fromCharCode(0)), {
-  message: "path contains a non-portable character"
-}).refine(
-  (value) => {
-    const segments = value.split("/");
-    return segments.every(
-      (segment) => segment.length > 0 && segment !== "." && segment !== ".." && !segment.endsWith(" ") && !segment.endsWith(".")
-    );
-  },
-  {
-    message: "path must stay inside the project directory"
-  }
-);
-var contentProjectArtifactPathsSchema = z5.object({
-  article: portableRelativePathSchema,
-  brief: portableRelativePathSchema,
-  delivery: portableRelativePathSchema,
-  outline: portableRelativePathSchema,
-  "quality-review": portableRelativePathSchema,
-  research: portableRelativePathSchema,
-  titles: portableRelativePathSchema,
-  "visual-plan": portableRelativePathSchema
-}).strict().superRefine((paths, context) => {
-  const values = Object.values(paths);
-  if (new Set(values).size !== values.length) {
-    context.addIssue({
-      code: "custom",
-      message: "artifact paths must be unique"
-    });
-  }
-  if (values.some(
-    (value, index) => values.some(
-      (otherValue, otherIndex) => index !== otherIndex && (value.startsWith(`${otherValue}/`) || otherValue.startsWith(`${value}/`))
-    )
-  )) {
-    context.addIssue({
-      code: "custom",
-      message: "artifact paths must not contain one another"
-    });
-  }
-});
-var contentProjectManifestSchema = z5.object({
-  artifacts: contentProjectArtifactPathsSchema,
-  assetsDirectory: portableRelativePathSchema,
-  checkpointsDirectory: portableRelativePathSchema,
-  createdAt: z5.iso.datetime(),
-  projectId: z5.uuid(),
-  schemaVersion: z5.literal("1"),
-  title: z5.string().trim().min(1).max(160),
-  workflowId: z5.literal(CONTENT_WORKFLOW_ID)
-}).strict().superRefine((manifest, context) => {
-  const artifactPaths = Object.values(manifest.artifacts);
-  const overlapsDirectory = (artifactPath, directory) => artifactPath === directory || artifactPath.startsWith(`${directory}/`) || directory.startsWith(`${artifactPath}/`);
-  if (artifactPaths.some(
-    (artifactPath) => overlapsDirectory(artifactPath, manifest.assetsDirectory)
-  )) {
-    context.addIssue({
-      code: "custom",
-      message: "assets directory must not overlap an artifact path"
-    });
-  }
-  if (artifactPaths.some(
-    (artifactPath) => overlapsDirectory(artifactPath, manifest.checkpointsDirectory)
-  )) {
-    context.addIssue({
-      code: "custom",
-      message: "checkpoints directory must not overlap an artifact path"
-    });
-  }
-  if (manifest.assetsDirectory === manifest.checkpointsDirectory || manifest.assetsDirectory.startsWith(`${manifest.checkpointsDirectory}/`) || manifest.checkpointsDirectory.startsWith(`${manifest.assetsDirectory}/`)) {
-    context.addIssue({
-      code: "custom",
-      message: "assets and checkpoints directories must not overlap"
-    });
-  }
-});
-var contentProjectArtifactBaseSchema = z5.object({
-  kind: contentArtifactKindSchema,
-  path: portableRelativePathSchema
-}).strict();
-var contentProjectArtifactStatusSchema = z5.discriminatedUnion("status", [
-  contentProjectArtifactBaseSchema.extend({
-    status: z5.literal("missing")
-  }),
-  contentProjectArtifactBaseSchema.extend({
-    bytes: z5.literal(0),
-    status: z5.literal("empty")
-  }),
-  contentProjectArtifactBaseSchema.extend({
-    bytes: z5.number().int().positive(),
-    sha256: z5.string().regex(/^[a-f0-9]{64}$/u),
-    status: z5.literal("ready")
-  })
-]);
-var contentStageArtifactStatusSchema = z5.enum(["complete", "awaiting-user", "blocked"]);
-var contentStageArtifactInputSchema = z5.object({
-  kind: contentArtifactKindSchema,
-  path: portableRelativePathSchema,
-  sha256: z5.string().regex(/^[a-f0-9]{64}$/u)
-}).strict();
-var contentQuoteSnapshotSchema = z5.object({
-  contentSha256: z5.string().regex(/^[a-f0-9]{64}$/u),
-  quoteId: z5.uuid()
-}).strict();
-var contentStageMetadataBaseShape = {
-  artifactStatus: contentStageArtifactStatusSchema,
-  contract: z5.literal("dxc-content-stage@1"),
-  createdAt: z5.iso.datetime(),
-  inputs: z5.array(contentStageArtifactInputSchema).max(CONTENT_ARTIFACT_KINDS.length),
-  projectId: z5.uuid(),
-  skill: z5.string().regex(/^dxc-[a-z0-9]+(?:-[a-z0-9]+)*@\d+\.\d+\.\d+$/u),
-  workflowId: z5.literal(CONTENT_WORKFLOW_ID)
-};
-var researchSourceSchema = z5.object({
-  id: z5.string().regex(/^source-[a-z0-9][a-z0-9-]{0,63}$/u),
-  locator: z5.string().trim().min(1).max(2048),
-  observedAt: z5.iso.datetime(),
-  stance: z5.enum(["support", "oppose", "supplement", "neutral", "not-applicable"]),
-  type: z5.enum(["primary", "public-fact", "public-opinion", "local-history", "user-provided"]),
-  verification: z5.enum(["verified", "unverified"])
-}).strict().superRefine((value, context) => {
-  if (["primary", "public-fact", "public-opinion"].includes(value.type)) {
-    try {
-      const url = new URL(value.locator);
-      if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new Error("unsupported protocol");
-      }
-    } catch {
-      context.addIssue({
-        code: "custom",
-        message: "public research sources require a complete HTTP(S) URL",
-        path: ["locator"]
-      });
-    }
-  }
-  if (value.type === "public-opinion" && !["support", "oppose", "supplement"].includes(value.stance)) {
-    context.addIssue({
-      code: "custom",
-      message: "public opinion sources require a stance",
-      path: ["stance"]
-    });
-  }
-});
-var researchStanceCoverageSchema = z5.object({
-  oppose: z5.enum(["covered", "not-found", "not-applicable"]),
-  supplement: z5.enum(["covered", "not-found", "not-applicable"]),
-  support: z5.enum(["covered", "not-found", "not-applicable"])
-}).strict();
-var researchStageArtifactFrontmatterSchema = z5.object({
-  coverageNote: z5.string().trim().min(1).max(1e3),
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    stage: z5.literal("research")
-  }).strict(),
-  externalOpinionStatus: z5.enum(["covered", "not-applicable", "user-skipped"]),
-  origin: z5.enum(["hotspot", "article", "keywords", "intent"]),
-  researchMode: z5.enum(["fact-only", "viewpoint-scan"]),
-  sourceCount: z5.number().int().nonnegative(),
-  sources: z5.array(researchSourceSchema).max(100),
-  stanceCoverage: researchStanceCoverageSchema
-}).strict().superRefine((value, context) => {
-  if (value.sourceCount !== value.sources.length) {
-    context.addIssue({
-      code: "custom",
-      message: "sourceCount must equal the number of structured sources",
-      path: ["sourceCount"]
-    });
-  }
-  if (new Set(value.sources.map((source) => source.id)).size !== value.sources.length) {
-    context.addIssue({
-      code: "custom",
-      message: "research source ids must be unique",
-      path: ["sources"]
-    });
-  }
-  if (new Set(value.sources.map((source) => source.locator)).size !== value.sources.length) {
-    context.addIssue({
-      code: "custom",
-      message: "research source locators must be unique",
-      path: ["sources"]
-    });
-  }
-  if (value.researchMode === "fact-only") {
-    const expectedStatus = value.origin === "hotspot" ? "user-skipped" : "not-applicable";
-    if (value.externalOpinionStatus !== expectedStatus) {
-      context.addIssue({
-        code: "custom",
-        message: `fact-only ${value.origin} research requires externalOpinionStatus ${expectedStatus}`,
-        path: ["externalOpinionStatus"]
-      });
-    }
-    if (Object.values(value.stanceCoverage).some((coverage) => coverage !== "not-applicable")) {
-      context.addIssue({
-        code: "custom",
-        message: "fact-only research must mark stance coverage not-applicable",
-        path: ["stanceCoverage"]
-      });
-    }
-    return;
-  }
-  if (value.externalOpinionStatus !== "covered") {
-    context.addIssue({
-      code: "custom",
-      message: "viewpoint-scan research requires covered external opinions",
-      path: ["externalOpinionStatus"]
-    });
-  }
-  const opinionSources = value.sources.filter(
-    (source) => source.type === "public-opinion" && source.verification === "verified"
-  );
-  if (opinionSources.length < 3) {
-    context.addIssue({
-      code: "custom",
-      message: "viewpoint-scan research requires at least three verified public opinions",
-      path: ["sources"]
-    });
-  }
-  for (const stance of ["support", "supplement"]) {
-    if (value.stanceCoverage[stance] !== "covered" || !opinionSources.some((source) => source.stance === stance)) {
-      context.addIssue({
-        code: "custom",
-        message: `viewpoint-scan research requires covered ${stance} material`,
-        path: ["stanceCoverage", stance]
-      });
-    }
-  }
-  const hasOpposition = opinionSources.some((source) => source.stance === "oppose");
-  if (hasOpposition && value.stanceCoverage.oppose !== "covered" || !hasOpposition && value.stanceCoverage.oppose !== "not-found") {
-    context.addIssue({
-      code: "custom",
-      message: "opposition coverage must be covered or explicitly recorded as not-found",
-      path: ["stanceCoverage", "oppose"]
-    });
-  }
-});
-var briefStageArtifactFrontmatterSchema = z5.object({
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    stage: z5.literal("brief")
-  }).strict(),
-  origin: z5.enum(["hotspot", "article", "keywords", "intent"]),
-  selectedAngle: z5.string().trim().min(1).nullable()
-}).strict().superRefine((value, context) => {
-  if (value.dxc.artifactStatus === "complete" && value.selectedAngle === null) {
-    context.addIssue({
-      code: "custom",
-      message: "completed brief requires selectedAngle",
-      path: ["selectedAngle"]
-    });
-  }
-});
-var outlineStageArtifactFrontmatterSchema = z5.object({
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    stage: z5.literal("outline")
-  }).strict(),
-  primaryEmotion: z5.string().trim().min(1),
-  structure: z5.string().trim().min(1)
-}).strict();
-var articleStageArtifactFrontmatterSchema = z5.object({
-  author: z5.string().trim().min(1),
-  commentsEnabled: z5.boolean().optional(),
-  coverImage: portableRelativePathSchema.optional(),
-  digest: z5.string().trim().min(1).optional(),
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    quoteSnapshots: z5.array(contentQuoteSnapshotSchema).max(50).default([]),
-    stage: z5.literal("article")
-  }).strict(),
-  dxc_wechat_template_hint: z5.string().trim().min(1).optional(),
-  goldenLinesPath: portableRelativePathSchema,
-  goldenLinesSha256: z5.string().regex(/^[a-f0-9]{64}$/u),
-  tags: z5.array(z5.string().trim().min(1)).default([]),
-  title: z5.string().trim().min(1)
-}).strict();
-var goldenLinePurposeSchema = z5.enum([
-  "cognitive-compression",
-  "emotional-resonance",
-  "action-prompt",
-  "value-statement"
-]);
-var goldenLinesSidecarSchema = z5.object({
-  lines: z5.array(
-    z5.object({
-      purpose: goldenLinePurposeSchema,
-      section: z5.string().trim().min(1).max(200),
-      text: z5.string().trim().min(1).max(500)
-    }).strict()
-  ).max(12),
-  schemaVersion: z5.literal("dxc-golden-lines@1")
-}).strict();
-var titlesStageArtifactFrontmatterSchema = z5.object({
-  articleSha256: z5.string().regex(/^[a-f0-9]{64}$/u),
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    stage: z5.literal("titles")
-  }).strict(),
-  selectedTitle: z5.string().trim().min(1).refine((value) => [...value].length <= 32, {
-    message: "selected title must not exceed 32 Unicode characters"
-  }).nullable()
-}).strict().superRefine((value, context) => {
-  if (value.dxc.artifactStatus === "complete" && value.selectedTitle === null) {
-    context.addIssue({
-      code: "custom",
-      message: "completed title artifact requires selectedTitle",
-      path: ["selectedTitle"]
-    });
-  }
-});
-var visualStageInlineAssetSchema = z5.object({
-  path: portableRelativePathSchema,
-  placement: z5.string().trim().min(1).max(200),
-  placementAnchor: z5.string().regex(/^after-heading:[^\r\n]{1,160}$/u),
-  purpose: z5.string().trim().min(1).max(300),
-  sha256: z5.string().regex(/^[a-f0-9]{64}$/u),
-  source: z5.enum(["agent-generated", "local-material"])
-}).strict();
-var visualPlanMaterializedArtifactFrontmatterSchema = z5.object({
-  assetsDirectory: portableRelativePathSchema,
-  coverAsset: portableRelativePathSchema,
-  coverSha256: z5.string().regex(/^[a-f0-9]{64}$/u),
-  coverSource: z5.enum(["agent-generated", "local-material"]),
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    stage: z5.literal("visual-plan")
-  }).strict(),
-  inlineAssets: z5.array(visualStageInlineAssetSchema).max(20),
-  inlineImagesSupported: z5.literal(true)
-}).strict();
-var visualGenerationPlannedAssetSchema = z5.object({
-  placementAnchor: z5.string().regex(/^after-heading:[^\r\n]{1,160}$/u).optional(),
-  purpose: z5.string().trim().min(1).max(300),
-  role: z5.enum(["cover", "inline"]),
-  source: z5.literal("agent-generated")
-}).strict().superRefine((asset, context) => {
-  if (asset.role === "inline" && asset.placementAnchor === void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "inline proposal requires placementAnchor",
-      path: ["placementAnchor"]
-    });
-  }
-  if (asset.role === "cover" && asset.placementAnchor !== void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "cover proposal must not have placementAnchor",
-      path: ["placementAnchor"]
-    });
-  }
-});
-var visualGenerationPlanSchema = z5.object({
-  chargesQuota: z5.boolean(),
-  dataTransit: z5.enum(["local-only", "agent-provider", "dxc-cloud"]),
-  executionLocation: z5.enum(["local-device", "agent-hosted"]),
-  maxAttempts: z5.number().int().min(1).max(2),
-  plannedAssets: z5.array(visualGenerationPlannedAssetSchema).min(1).max(20),
-  retryPolicy: z5.enum(["never", "verified-no-asset-no-charge-once"])
-}).strict().superRefine((value, context) => {
-  if (value.plannedAssets.filter((asset) => asset.role === "cover").length > 1) {
-    context.addIssue({
-      code: "custom",
-      message: "generation proposal allows at most one generated cover",
-      path: ["plannedAssets"]
-    });
-  }
-  if (value.maxAttempts === 1 && value.retryPolicy !== "never" || value.maxAttempts === 2 && value.retryPolicy !== "verified-no-asset-no-charge-once") {
-    context.addIssue({
-      code: "custom",
-      message: "maxAttempts=1 requires retryPolicy=never; maxAttempts=2 requires verified-no-asset-no-charge-once",
-      path: ["retryPolicy"]
-    });
-  }
-});
-var visualPlanGenerationProposalFrontmatterSchema = z5.object({
-  assetsDirectory: portableRelativePathSchema,
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    artifactStatus: z5.literal("awaiting-user"),
-    stage: z5.literal("visual-plan")
-  }).strict(),
-  generation: visualGenerationPlanSchema,
-  inlineImagesSupported: z5.literal(true),
-  planned: z5.literal(true)
-}).strict();
-var visualPlanStageArtifactFrontmatterSchema = z5.union([
-  visualPlanMaterializedArtifactFrontmatterSchema,
-  visualPlanGenerationProposalFrontmatterSchema
-]);
-var qualityReviewStageArtifactFrontmatterSchema = z5.object({
-  blockerCount: z5.number().int().nonnegative(),
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    stage: z5.literal("quality-review")
-  }).strict(),
-  verdict: z5.enum(["pass", "block"]),
-  researchCoverage: z5.enum(["not-applicable", "pass", "warning"]),
-  warningCount: z5.number().int().nonnegative()
-}).strict().superRefine((value, context) => {
-  if (value.verdict === "pass" && value.blockerCount !== 0) {
-    context.addIssue({
-      code: "custom",
-      message: "passing review must have zero blockers",
-      path: ["blockerCount"]
-    });
-  }
-  if (value.verdict === "block" && value.blockerCount === 0) {
-    context.addIssue({
-      code: "custom",
-      message: "blocked review must report at least one blocker",
-      path: ["blockerCount"]
-    });
-  }
-  if (value.researchCoverage === "warning" && value.warningCount === 0) {
-    context.addIssue({
-      code: "custom",
-      message: "research coverage warnings must be counted",
-      path: ["warningCount"]
-    });
-  }
-});
-var deliveryStageArtifactFrontmatterSchema = z5.object({
-  accountId: z5.uuid(),
-  dxc: z5.object({
-    ...contentStageMetadataBaseShape,
-    stage: z5.literal("delivery")
-  }).strict(),
-  idempotencyKey: z5.string().trim().min(1).max(200),
-  intentId: z5.uuid().nullable(),
-  mediaId: z5.string().trim().min(1).max(256).nullable().optional(),
-  previewExpiresAt: z5.iso.datetime(),
-  previewSelectionRevision: z5.number().int().nonnegative(),
-  retryAttempt: z5.number().int().nonnegative().default(0),
-  retryOfIntentId: z5.uuid().nullable().optional(),
-  rootSnapshotHash: z5.string().regex(/^[a-f0-9]{64}$/u),
-  rootSnapshotId: z5.uuid(),
-  selectedSnapshotHash: z5.string().regex(/^[a-f0-9]{64}$/u),
-  selectedSnapshotId: z5.uuid(),
-  state: z5.enum(["previewed", "processing", "completed", "requires-attention", "failed"]),
-  templateId: z5.string().regex(/^wechat-[a-z0-9-]+@\d+$/u)
-}).strict().superRefine((value, context) => {
-  if (value.dxc.artifactStatus === "complete" && (value.state !== "completed" || value.intentId === null || value.mediaId === void 0 || value.mediaId === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "completed delivery requires completed state, intentId, and mediaId",
-      path: ["state"]
-    });
-  }
-  if (value.retryAttempt === 0 && value.retryOfIntentId !== void 0 && value.retryOfIntentId !== null || value.retryAttempt > 0 && (value.retryOfIntentId === void 0 || value.retryOfIntentId === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "retryAttempt and retryOfIntentId must describe the same retry generation",
-      path: ["retryOfIntentId"]
-    });
-  }
-});
-function contentStageArtifactFrontmatterSchema(stage) {
-  switch (stage) {
-    case "research":
-      return researchStageArtifactFrontmatterSchema;
-    case "brief":
-      return briefStageArtifactFrontmatterSchema;
-    case "outline":
-      return outlineStageArtifactFrontmatterSchema;
-    case "article":
-      return articleStageArtifactFrontmatterSchema;
-    case "titles":
-      return titlesStageArtifactFrontmatterSchema;
-    case "visual-plan":
-      return visualPlanStageArtifactFrontmatterSchema;
-    case "quality-review":
-      return qualityReviewStageArtifactFrontmatterSchema;
-    case "delivery":
-      return deliveryStageArtifactFrontmatterSchema;
-  }
-}
-var stepCheckpointStatusSchema = z5.enum([
-  "running",
-  "awaiting-user",
-  "completed",
-  "failed",
-  "skipped"
-]);
-var executionLocationSchema = z5.enum(["local-device", "agent-hosted", "unknown"]);
-var dataTransitSchema = z5.enum(["local-only", "agent-provider", "dxc-cloud", "unknown"]);
-var stepConfirmationStatusSchema = z5.enum(["not-required", "pending", "confirmed"]);
-var checkpointArtifactSchema = z5.object({
-  bytes: z5.number().int().positive(),
-  kind: contentArtifactKindSchema,
-  path: portableRelativePathSchema,
-  sha256: z5.string().regex(/^[a-f0-9]{64}$/u)
-}).strict();
-var stageArtifactReferenceSchema = z5.object({
-  bytes: z5.number().int().positive().optional(),
-  kind: contentArtifactKindSchema,
-  path: portableRelativePathSchema,
-  sha256: z5.string().regex(/^[a-f0-9]{64}$/u).optional()
-}).strict();
-var stepCheckpointMetadataSchema = z5.object({
-  summary: z5.string().trim().min(1).max(500)
-}).strict();
-var stepConfirmationBindingSchema = z5.object({
-  confirmedAt: z5.iso.datetime().nullable(),
-  confirmedBy: z5.string().trim().min(1).max(160).nullable(),
-  requestedAt: z5.iso.datetime(),
-  snapshotHash: z5.string().regex(/^[a-f0-9]{64}$/u),
-  snapshotType: z5.enum(["stage-artifact", "render-snapshot"]),
-  status: z5.enum(["pending", "confirmed"])
-}).strict().superRefine((binding, context) => {
-  if (binding.status === "confirmed" && (binding.confirmedAt === null || binding.confirmedBy === null)) {
-    context.addIssue({
-      code: "custom",
-      message: "confirmed binding requires confirmation actor and time"
-    });
-  }
-  if (binding.status === "pending" && (binding.confirmedAt !== null || binding.confirmedBy !== null)) {
-    context.addIssue({
-      code: "custom",
-      message: "pending binding must not include confirmation actor or time"
-    });
-  }
-});
-var externalActionAuthorizationSchema = z5.object({
-  action: z5.literal("image-generation"),
-  confirmedAt: z5.iso.datetime(),
-  confirmedBy: z5.string().trim().min(1).max(160),
-  planSnapshotHash: z5.string().regex(/^[a-f0-9]{64}$/u),
-  plan: visualGenerationPlanSchema,
-  requestedAt: z5.iso.datetime()
-}).strict();
-var stepCheckpointBaseShape = {
-  artifact: checkpointArtifactSchema.optional(),
-  completedAt: z5.iso.datetime().optional(),
-  confirmation: stepConfirmationStatusSchema,
-  errorCode: z5.string().regex(/^[A-Z][A-Z0-9_]{2,63}$/u).optional(),
-  execution: z5.object({
-    dataTransit: dataTransitSchema,
-    location: executionLocationSchema
-  }).strict(),
-  projectId: z5.uuid(),
-  revision: z5.number().int().positive(),
-  skill: z5.object({
-    name: z5.string().regex(/^dxc-[a-z0-9]+(?:-[a-z0-9]+)*$/u),
-    version: z5.union([z5.string().regex(/^\d+\.\d+\.\d+$/u), z5.literal("unknown")])
-  }).strict(),
-  stage: contentArtifactKindSchema,
-  startedAt: z5.iso.datetime(),
-  status: stepCheckpointStatusSchema,
-  updatedAt: z5.iso.datetime(),
-  workflowId: z5.literal(CONTENT_WORKFLOW_ID)
-};
-var stepCheckpointSchema = z5.discriminatedUnion("checkpointVersion", [
-  z5.object({
-    ...stepCheckpointBaseShape,
-    checkpointVersion: z5.literal("1")
-  }).strict(),
-  z5.object({
-    ...stepCheckpointBaseShape,
-    checkpointVersion: z5.literal("2"),
-    inputs: z5.array(stageArtifactReferenceSchema).max(CONTENT_ARTIFACT_KINDS.length),
-    metadata: stepCheckpointMetadataSchema,
-    outputs: z5.array(stageArtifactReferenceSchema).min(1).max(CONTENT_ARTIFACT_KINDS.length),
-    waitingFor: z5.string().trim().min(1).max(500).nullable()
-  }).strict(),
-  z5.object({
-    ...stepCheckpointBaseShape,
-    checkpointVersion: z5.literal("3"),
-    confirmationBinding: stepConfirmationBindingSchema.nullable(),
-    inputs: z5.array(stageArtifactReferenceSchema).max(CONTENT_ARTIFACT_KINDS.length),
-    metadata: stepCheckpointMetadataSchema,
-    outputs: z5.array(stageArtifactReferenceSchema).min(1).max(CONTENT_ARTIFACT_KINDS.length),
-    waitingFor: z5.string().trim().min(1).max(500).nullable()
-  }).strict(),
-  z5.object({
-    ...stepCheckpointBaseShape,
-    authorizations: z5.array(externalActionAuthorizationSchema).max(20),
-    checkpointVersion: z5.literal("4"),
-    confirmationBinding: stepConfirmationBindingSchema.nullable(),
-    confirmationPurpose: z5.enum(["external-action", "stage-completion"]).nullable(),
-    inputs: z5.array(stageArtifactReferenceSchema).max(CONTENT_ARTIFACT_KINDS.length),
-    metadata: stepCheckpointMetadataSchema,
-    outputs: z5.array(stageArtifactReferenceSchema).min(1).max(CONTENT_ARTIFACT_KINDS.length),
-    waitingFor: z5.string().trim().min(1).max(500).nullable()
-  }).strict()
-]).superRefine((checkpoint, context) => {
-  if (checkpoint.artifact !== void 0 && checkpoint.artifact.kind !== checkpoint.stage) {
-    context.addIssue({
-      code: "custom",
-      message: "checkpoint artifact kind must match its stage"
-    });
-  }
-  if ((checkpoint.status === "awaiting-user" || checkpoint.status === "completed") && checkpoint.artifact === void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "awaiting-user and completed checkpoints require an artifact"
-    });
-  }
-  if (checkpoint.artifact !== void 0 && checkpoint.status !== "awaiting-user" && checkpoint.status !== "completed" && !(checkpoint.checkpointVersion === "4" && checkpoint.status === "running" && checkpoint.stage === "visual-plan" && checkpoint.authorizations.length > 0)) {
-    context.addIssue({
-      code: "custom",
-      message: "only awaiting-user and completed checkpoints may bind an artifact"
-    });
-  }
-  if (checkpoint.status === "awaiting-user" && checkpoint.confirmation !== "pending") {
-    context.addIssue({
-      code: "custom",
-      message: "awaiting-user checkpoints require pending confirmation"
-    });
-  }
-  if (checkpoint.confirmation === "pending" && checkpoint.status !== "awaiting-user") {
-    context.addIssue({
-      code: "custom",
-      message: "pending confirmation is only valid while awaiting the user"
-    });
-  }
-  if (checkpoint.status === "completed" && (checkpoint.completedAt === void 0 || checkpoint.checkpointVersion === "1" && checkpoint.confirmation !== "confirmed")) {
-    context.addIssue({
-      code: "custom",
-      message: "completed checkpoint is missing required completion metadata"
-    });
-  }
-  if ((checkpoint.status === "failed" || checkpoint.status === "skipped") && checkpoint.completedAt === void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "terminal checkpoints require completion time"
-    });
-  }
-  if (checkpoint.status !== "completed" && checkpoint.status !== "failed" && checkpoint.status !== "skipped" && checkpoint.completedAt !== void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "non-terminal checkpoints must not include completion time"
-    });
-  }
-  if (checkpoint.status === "failed" && checkpoint.errorCode === void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "failed checkpoints require an error code"
-    });
-  }
-  if (checkpoint.status !== "failed" && checkpoint.errorCode !== void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "only failed checkpoints may include an error code"
-    });
-  }
-  if (checkpoint.confirmation === "confirmed" && checkpoint.status !== "completed") {
-    context.addIssue({
-      code: "custom",
-      message: "confirmed checkpoints must be completed"
-    });
-  }
-  if (checkpoint.checkpointVersion === "3" || checkpoint.checkpointVersion === "4") {
-    if (checkpoint.confirmation === "pending" && checkpoint.confirmationBinding?.status !== "pending") {
-      context.addIssue({
-        code: "custom",
-        message: "pending confirmation must bind the reviewed snapshot"
-      });
-    }
-    if (checkpoint.confirmation === "confirmed" && checkpoint.confirmationBinding?.status !== "confirmed") {
-      context.addIssue({
-        code: "custom",
-        message: "confirmed checkpoint must bind actor, time, and snapshot"
-      });
-    }
-    if (checkpoint.confirmation === "not-required" && checkpoint.confirmationBinding !== null) {
-      context.addIssue({
-        code: "custom",
-        message: "confirmation binding is only valid for confirmation checkpoints"
-      });
-    }
-  }
-  if (checkpoint.checkpointVersion === "4") {
-    if (checkpoint.authorizations.length > 0 && checkpoint.stage !== "visual-plan") {
-      context.addIssue({
-        code: "custom",
-        message: "image generation authorizations are only valid for visual-plan"
-      });
-    }
-    if (checkpoint.stage === "visual-plan" && checkpoint.status === "running" && checkpoint.authorizations.length > 0 && checkpoint.artifact === void 0) {
-      context.addIssue({
-        code: "custom",
-        message: "authorized visual-plan running checkpoint must bind its proposal artifact"
-      });
-    }
-    if (checkpoint.confirmationBinding === null && checkpoint.confirmationPurpose !== null) {
-      context.addIssue({
-        code: "custom",
-        message: "confirmation purpose requires a confirmation binding"
-      });
-    }
-    if (checkpoint.confirmationBinding !== null && checkpoint.confirmationPurpose === null) {
-      context.addIssue({
-        code: "custom",
-        message: "confirmation binding requires a confirmation purpose"
-      });
-    }
-    if (checkpoint.confirmationPurpose === "external-action" && (checkpoint.stage !== "visual-plan" || checkpoint.status !== "awaiting-user" || checkpoint.confirmation !== "pending")) {
-      context.addIssue({
-        code: "custom",
-        message: "external-action confirmation is only valid for a pending visual plan"
-      });
-    }
-  }
-});
-var stepCheckpointInspectionSchema = z5.discriminatedUnion("state", [
-  z5.object({
-    path: portableRelativePathSchema,
-    stage: contentArtifactKindSchema,
-    state: z5.literal("missing")
-  }).strict(),
-  z5.object({
-    checkpoint: stepCheckpointSchema,
-    path: portableRelativePathSchema,
-    stage: contentArtifactKindSchema,
-    state: z5.literal("valid")
-  }).strict(),
-  z5.object({
-    checkpoint: stepCheckpointSchema,
-    path: portableRelativePathSchema,
-    reason: z5.enum([
-      "artifact-changed",
-      "artifact-empty",
-      "artifact-missing",
-      "input-artifact-changed",
-      "input-artifact-empty",
-      "input-artifact-missing"
-    ]),
-    stage: contentArtifactKindSchema,
-    state: z5.literal("stale")
-  }).strict()
-]);
-var contentProjectInitResultSchema = z5.object({
-  command: z5.literal("project.init"),
-  data: z5.object({
-    assetsDirectory: portableRelativePathSchema,
-    checkpointsDirectory: portableRelativePathSchema,
-    knowledgeBootstrap: z5.object({
-      articleCount: z5.number().int().nonnegative(),
-      recommendedCommand: z5.string().trim().min(1),
-      status: z5.enum(["ready", "import-recommended"])
-    }).strict(),
-    manifest: contentProjectManifestSchema,
-    manifestPath: z5.literal("dxc.project.json")
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentProjectStatusResultSchema = z5.object({
-  command: z5.literal("project.status"),
-  data: z5.object({
-    artifacts: z5.array(contentProjectArtifactStatusSchema).length(CONTENT_ARTIFACT_KINDS.length),
-    assetsDirectory: portableRelativePathSchema,
-    assetsDirectoryReady: z5.boolean(),
-    checkpoints: z5.array(stepCheckpointInspectionSchema).length(CONTENT_ARTIFACT_KINDS.length),
-    checkpointsDirectory: portableRelativePathSchema,
-    manifest: contentProjectManifestSchema,
-    manifestPath: z5.literal("dxc.project.json"),
-    nextStage: contentArtifactKindSchema.nullable(),
-    recoveryPlan: z5.array(
-      z5.object({
-        action: z5.literal("rerun-stage"),
-        command: z5.string().trim().min(1).max(500),
-        reason: z5.enum([
-          "artifact-changed",
-          "artifact-empty",
-          "artifact-missing",
-          "input-artifact-changed",
-          "input-artifact-empty",
-          "input-artifact-missing"
-        ]),
-        stage: contentArtifactKindSchema
-      }).strict()
-    ),
-    workflowStatus: z5.enum([
-      "not-started",
-      "in-progress",
-      "waiting-user",
-      "blocked",
-      "complete"
-    ])
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentProjectIndexEntrySchema = z5.object({
-  directory: z5.string().trim().min(1).max(4096),
-  projectId: z5.uuid(),
-  title: z5.string().trim().min(1).max(160),
-  updatedAt: z5.iso.datetime()
-}).strict();
-var contentProjectIndexSchema = z5.object({
-  projects: z5.array(contentProjectIndexEntrySchema).max(1e3),
-  schemaVersion: z5.literal("1")
-}).strict();
-var contentProjectResolutionSchema = contentProjectIndexEntrySchema.extend({
-  nextStage: contentArtifactKindSchema.nullable(),
-  workflowStatus: z5.enum(["not-started", "in-progress", "waiting-user", "blocked", "complete"])
-}).strict();
-var contentProjectResolveResultSchema = z5.object({
-  command: z5.literal("project.resolve"),
-  data: z5.object({
-    match: z5.enum(["none", "single", "multiple"]),
-    projects: z5.array(contentProjectResolutionSchema).max(1e3),
-    query: z5.string().trim().min(1).max(160).nullable()
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentProjectCheckpointResultSchema = z5.object({
-  command: z5.literal("project.checkpoint"),
-  data: z5.object({
-    artifactMutations: z5.array(
-      z5.object({
-        afterSha256: z5.string().regex(/^[a-f0-9]{64}$/u),
-        beforeSha256: z5.string().regex(/^[a-f0-9]{64}$/u).nullable(),
-        path: portableRelativePathSchema
-      }).strict()
-    ),
-    checkpoint: stepCheckpointSchema,
-    checkpointPath: portableRelativePathSchema,
-    guidance: z5.object({
-      action: z5.enum(["authorize-external-action", "confirm-stage"]),
-      message: z5.string().trim().min(1).max(500),
-      suggestedFlag: z5.literal("--confirm")
-    }).strict().nullable()
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentProjectCommandSchema = z5.enum([
-  "project.init",
-  "project.resolve",
-  "project.status",
-  "project.checkpoint",
-  "project.preview"
-]);
-var contentProjectErrorResultSchema = z5.object({
-  command: contentProjectCommandSchema,
-  error: z5.object({
-    code: z5.enum([
-      "DXC_PROJECT_EXISTS",
-      "DXC_PROJECT_INVALID",
-      "DXC_PROJECT_IO_FAILED",
-      "DXC_PROJECT_NOT_FOUND",
-      "DXC_PROJECT_STAGE_INVALID"
-    ]),
-    fields: z5.array(z5.string().trim().min(1).max(200)).max(20).optional(),
-    message: z5.string().trim().min(1),
-    reason: z5.string().regex(/^[A-Z][A-Z0-9_]{2,63}$/u).optional(),
-    recovery: z5.string().trim().min(1).max(500).optional(),
-    stage: contentArtifactKindSchema.optional()
-  }).strict(),
-  ok: z5.literal(false)
-}).strict();
-var contentProfileAnswerSchema = z5.object({
-  note: z5.string().trim().max(500).optional(),
-  questionId: z5.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u),
-  selectedOptionIds: z5.array(z5.string().regex(/^[a-z][a-z0-9.-]{1,63}$/u)).min(1).max(8)
-}).strict().superRefine((answer, context) => {
-  if (new Set(answer.selectedOptionIds).size !== answer.selectedOptionIds.length) {
-    context.addIssue({
-      code: "custom",
-      message: "selected options must be unique"
-    });
-  }
-});
-var contentProfileUserMemorySchema = z5.object({
-  confirmationPolicy: z5.enum(["guided", "review-every-stage", "auto-until-delivery"]).optional(),
-  contentValuePromise: z5.string().trim().min(1).max(500),
-  coreValues: z5.string().trim().min(1).max(500).optional(),
-  creatorRole: z5.string().trim().min(1).max(120),
-  displayName: z5.string().trim().min(1).max(120),
-  historyDirectory: z5.string().trim().min(1).max(4096).optional(),
-  penName: z5.string().trim().min(1).max(120).optional(),
-  pointOfView: z5.string().trim().min(1).max(120).optional(),
-  primaryDomains: z5.array(z5.string().trim().min(1).max(120)).min(1).max(5),
-  primaryPlatform: z5.literal("wechat-official-account"),
-  publishingCadence: z5.string().trim().min(1).max(120).optional(),
-  redLines: z5.string().trim().min(1).max(500).optional(),
-  targetAudience: z5.string().trim().min(1).max(500),
-  titlePreferences: z5.string().trim().min(1).max(500).optional(),
-  visualPreferences: z5.string().trim().min(1).max(500).optional(),
-  visualGenerationAuthorization: z5.object({
-    maxImagesPerRun: z5.number().int().min(1).max(20),
-    mode: z5.literal("auto-within-limit")
-  }).strict().optional(),
-  writingVoice: z5.string().trim().min(1).max(500).optional()
-}).strict().superRefine((user, context) => {
-  if (user.primaryDomains !== void 0 && new Set(user.primaryDomains).size !== user.primaryDomains.length) {
-    context.addIssue({
-      code: "custom",
-      message: "primary domains must be unique",
-      path: ["primaryDomains"]
-    });
-  }
-});
-var contentProfileInputSchema = z5.object({
-  answers: z5.array(contentProfileAnswerSchema).max(32).default([]),
-  questionnaireVersion: z5.literal(CONTENT_PROFILE_QUESTIONNAIRE_VERSION),
-  user: contentProfileUserMemorySchema
-}).strict().superRefine((input, context) => {
-  const questionIds = input.answers.map((answer) => answer.questionId);
-  if (new Set(questionIds).size !== questionIds.length) {
-    context.addIssue({
-      code: "custom",
-      message: "profile answers must use unique question IDs"
-    });
-  }
-});
-var { primaryPlatform: ignoredProfileUpdatePrimaryPlatform, ...contentProfileUpdateUserShape } = contentProfileUserMemorySchema.shape;
-var contentProfileUpdateInputSchema = z5.object({
-  answers: z5.array(contentProfileAnswerSchema).min(1).max(32).optional(),
-  user: z5.object(contentProfileUpdateUserShape).partial().optional()
-}).strict().superRefine((input, context) => {
-  if (input.answers === void 0 && input.user === void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "profile update must include answers or user fields"
-    });
-  }
-  if (input.answers === void 0) {
-    return;
-  }
-  const questionIds = input.answers.map((answer) => answer.questionId);
-  if (new Set(questionIds).size !== questionIds.length) {
-    context.addIssue({
-      code: "custom",
-      message: "profile answers must use unique question IDs",
-      path: ["answers"]
-    });
-  }
-});
-var contentProfileSchema = contentProfileInputSchema.extend({
-  createdAt: z5.iso.datetime(),
-  profileId: z5.uuid(),
-  schemaVersion: z5.literal("1"),
-  updatedAt: z5.iso.datetime()
-}).strict();
-var contentProfileSaveResultSchema = z5.object({
-  command: z5.literal("profile.save"),
-  data: z5.object({
-    profile: contentProfileSchema,
-    profilePath: z5.literal("~/.dxc/content-profile.json"),
-    userMemoryPath: z5.literal("~/.dxc/USER.md")
-  }).strict(),
-  ok: z5.literal(true)
-}).strict();
-var contentProfileUpdateResultSchema = contentProfileSaveResultSchema.extend({
-  command: z5.literal("profile.update")
-});
-var contentProfileStatusResultSchema = z5.object({
-  command: z5.literal("profile.status"),
-  data: z5.discriminatedUnion("configured", [
-    z5.object({
-      configured: z5.literal(false),
-      profilePath: z5.literal("~/.dxc/content-profile.json"),
-      userMemoryPath: z5.literal("~/.dxc/USER.md")
-    }).strict(),
-    z5.object({
-      configured: z5.literal(true),
-      profile: contentProfileSchema,
-      profilePath: z5.literal("~/.dxc/content-profile.json"),
-      userMemoryPath: z5.literal("~/.dxc/USER.md")
-    }).strict()
-  ]),
-  ok: z5.literal(true)
-}).strict();
-var contentProfileCommandSchema = z5.enum([
-  "profile.save",
-  "profile.status",
-  "profile.update"
-]);
-var CONTENT_MEMORY_KINDS = [
-  "audience-change",
-  "brand-context",
-  "business-context",
-  "temporary-campaign",
-  "writing-preference"
-];
-var contentMemoryKindSchema = z5.enum(CONTENT_MEMORY_KINDS);
-var contentMemoryScopeSchema = z5.enum(["global", "project"]);
-var contentMemoryInputSchema = z5.object({
-  content: z5.string().trim().min(1).max(500),
-  expiresAt: z5.iso.datetime().optional(),
-  kind: contentMemoryKindSchema,
-  scope: contentMemoryScopeSchema
-}).strict().superRefine((input, context) => {
-  if (input.kind === "temporary-campaign" && input.expiresAt === void 0) {
-    context.addIssue({
-      code: "custom",
-      message: "temporary campaign memory requires an expiry time",
-      path: ["expiresAt"]
-    });
-  }
-});
-var contentMemoryRecordSchema = contentMemoryInputSchema.extend({
-  createdAt: z5.iso.datetime(),
-  id: z5.uuid(),
-  source: z5.literal("user-stated"),
-  status: z5.enum(["active", "archived", "expired"]),
-  updatedAt: z5.iso.datetime()
-});
-var contentMemoryStoreSchema = z5.object({
-  memories: z5.array(contentMemoryRecordSchema).max(100),
-  schemaVersion: z5.literal("1")
-}).strict();
-var contentMemoryResultDataSchema = z5.object({
-  memories: z5.array(contentMemoryRecordSchema),
-  memoryPath: z5.literal("~/.dxc/content-memory.json")
-}).strict();
-var contentMemoryAddResultSchema = z5.object({
-  command: z5.literal("memory.add"),
-  data: contentMemoryResultDataSchema.extend({ memory: contentMemoryRecordSchema }),
-  ok: z5.literal(true)
-}).strict();
-var contentMemoryArchiveResultSchema = z5.object({
-  command: z5.literal("memory.archive"),
-  data: contentMemoryResultDataSchema.extend({ memory: contentMemoryRecordSchema }),
-  ok: z5.literal(true)
-}).strict();
-var contentMemoryListResultSchema = z5.object({
-  command: z5.literal("memory.list"),
-  data: contentMemoryResultDataSchema,
-  ok: z5.literal(true)
-}).strict();
-var contentMemoryCommandSchema = z5.enum(["memory.add", "memory.archive", "memory.list"]);
-var contentMemoryErrorResultSchema = z5.object({
-  command: contentMemoryCommandSchema,
-  error: z5.object({
-    code: z5.enum([
-      "DXC_MEMORY_INPUT_INVALID",
-      "DXC_MEMORY_INVALID",
-      "DXC_MEMORY_IO_FAILED",
-      "DXC_MEMORY_NOT_FOUND"
-    ]),
-    message: z5.string().trim().min(1)
-  }).strict(),
-  ok: z5.literal(false)
-}).strict();
-var contentProfileErrorResultSchema = z5.object({
-  command: contentProfileCommandSchema,
-  error: z5.object({
-    code: z5.enum(["DXC_PROFILE_INPUT_INVALID", "DXC_PROFILE_INVALID", "DXC_PROFILE_IO_FAILED"]),
-    fields: z5.array(z5.string().trim().min(1)).optional(),
-    hint: z5.string().trim().min(1).optional(),
-    message: z5.string().trim().min(1)
-  }).strict(),
-  ok: z5.literal(false)
-}).strict();
-var dxcSkillLifecycleSchema = z5.enum(["available", "planned"]);
-var dxcSkillExecutionSchema = z5.enum(["agent", "agent-cli", "agent-cli-cloud"]);
-var dxcSkillImplementationLevelSchema = z5.enum([
-  "agent-guided",
-  "agent-local-tools",
-  "local-cloud-end-to-end"
-]);
-var dxcSkillVerificationLevelSchema = z5.enum([
-  "contract-tested",
-  "local-integration-tested",
-  "real-platform-smoke"
-]);
-var dxcContentSkillDescriptorSchema = z5.object({
-  description: z5.string().trim().min(1).max(300),
-  execution: dxcSkillExecutionSchema,
-  implementationLevel: dxcSkillImplementationLevelSchema,
-  inputArtifacts: z5.array(contentArtifactKindSchema),
-  knownGaps: z5.array(z5.string().trim().min(1).max(300)).max(10),
-  name: z5.string().regex(/^dxc-[a-z0-9]+(?:-[a-z0-9]+)*$/u),
-  optionalInputArtifacts: z5.array(contentArtifactKindSchema).default([]),
-  outputArtifacts: z5.array(contentArtifactKindSchema).min(1),
-  requiresHumanConfirmation: z5.boolean(),
-  stage: contentArtifactKindSchema,
-  status: dxcSkillLifecycleSchema,
-  verificationLevel: dxcSkillVerificationLevelSchema,
-  version: z5.string().regex(/^\d+\.\d+\.\d+$/u).nullable()
-}).strict().superRefine((descriptor, context) => {
-  if (descriptor.status === "available" && descriptor.version === null) {
-    context.addIssue({
-      code: "custom",
-      message: "available skills must declare a version"
-    });
-  }
-  if (descriptor.status === "planned" && descriptor.version !== null) {
-    context.addIssue({
-      code: "custom",
-      message: "planned skills must not declare a released version"
-    });
-  }
-  if (!descriptor.outputArtifacts.includes(descriptor.stage)) {
-    context.addIssue({
-      code: "custom",
-      message: "skill output artifacts must include its workflow stage"
-    });
-  }
-  if (new Set(descriptor.inputArtifacts).size !== descriptor.inputArtifacts.length) {
-    context.addIssue({
-      code: "custom",
-      message: "input artifacts must be unique"
-    });
-  }
-  if (new Set(descriptor.optionalInputArtifacts).size !== descriptor.optionalInputArtifacts.length) {
-    context.addIssue({
-      code: "custom",
-      message: "optional input artifacts must be unique"
-    });
-  }
-  if (descriptor.optionalInputArtifacts.some(
-    (artifact) => descriptor.inputArtifacts.includes(artifact)
-  )) {
-    context.addIssue({
-      code: "custom",
-      message: "required and optional input artifacts must not overlap"
-    });
-  }
-  if (new Set(descriptor.outputArtifacts).size !== descriptor.outputArtifacts.length) {
-    context.addIssue({
-      code: "custom",
-      message: "output artifacts must be unique"
-    });
-  }
-});
-var dxcSkillCatalogSchema = z5.object({
-  orchestrator: z5.object({
-    name: z5.literal("dxc-content-workflow"),
-    status: z5.literal("available"),
-    version: z5.string().regex(/^\d+\.\d+\.\d+$/u)
-  }).strict(),
-  schemaVersion: z5.literal("1"),
-  steps: z5.array(dxcContentSkillDescriptorSchema).length(CONTENT_ARTIFACT_KINDS.length),
-  workflowId: z5.literal(CONTENT_WORKFLOW_ID)
-}).strict().superRefine((catalog, context) => {
-  const names = catalog.steps.map((step) => step.name);
-  if (new Set(names).size !== names.length) {
-    context.addIssue({
-      code: "custom",
-      message: "skill names must be unique"
-    });
-  }
-  const stages = catalog.steps.map((step) => step.stage);
-  if (new Set(stages).size !== CONTENT_ARTIFACT_KINDS.length || !CONTENT_ARTIFACT_KINDS.every((kind) => stages.includes(kind))) {
-    context.addIssue({
-      code: "custom",
-      message: "catalog must define exactly one skill for every workflow stage"
-    });
-  }
-});
-
-// packages/contracts/src/index.ts
-var PROTOCOL_VERSION = "1";
-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),
-    protocolVersion: 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 wechatDraftSmokeStatusSchema = z6.enum([
-  "QUEUED",
-  "PREPARING",
-  "UPLOADING_ASSETS",
-  "ASSET_UPLOAD_UNVERIFIED",
-  "CREATING_DRAFT",
-  "VERIFYING",
-  "SUCCEEDED",
-  "CREATED_UNVERIFIED",
-  "FAILED"
-]);
-var wechatDraftSmokeSnapshotSchema = z6.object({
-  articleVersion: z6.literal("wechat-draft-smoke@1"),
-  author: z6.string().trim().min(1),
-  commentsEnabled: z6.boolean(),
-  coverHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  coverLabel: z6.string().trim().min(1),
-  digest: z6.string().trim().min(1),
-  htmlHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  rendererVersion: z6.string().trim().min(1),
-  snapshotHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  sourceHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  templateId: z6.literal("wechat-minimal@1"),
-  title: z6.string().trim().min(1)
-}).strict();
-var createWechatDraftSmokeIntentRequestSchema = z6.object({
-  accountId: z6.uuid(),
-  confirmed: z6.literal(true),
-  snapshotHash: z6.string().regex(/^[a-f0-9]{64}$/u)
-}).strict();
-var wechatDraftSmokePreviewRequestSchema = z6.object({
-  accountId: z6.uuid()
-}).strict();
-var wechatDraftSmokePreviewResponseSchema = z6.object({
-  account: wechatAccountSchema,
-  snapshot: wechatDraftSmokeSnapshotSchema
-}).strict();
-var wechatDraftSmokeIntentSchema = z6.object({
-  accountId: z6.uuid(),
-  createdAt: z6.iso.datetime(),
-  errorCode: z6.string().trim().min(1).optional(),
-  id: z6.uuid(),
-  mediaId: z6.string().trim().min(1).max(128).optional(),
-  snapshotHash: z6.string().regex(/^[a-f0-9]{64}$/u),
-  status: wechatDraftSmokeStatusSchema,
-  updatedAt: z6.iso.datetime(),
-  verification: z6.object({
-    authorMatched: z6.boolean(),
-    contentMatched: z6.boolean(),
-    digestMatched: z6.boolean(),
-    titleMatched: z6.boolean()
-  }).strict().optional()
-}).strict();
-var wechatDraftSmokeIntentResponseSchema = z6.object({
-  intent: wechatDraftSmokeIntentSchema
-}).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";
-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);
-  }
-}
-
-export {
-  __require,
-  __esm,
-  __commonJS,
-  __export,
-  __toESM,
-  __toCommonJS,
-  publishingUploadSessionSchema,
-  publishingUploadReceiptSchema,
-  publishingArticleSchema,
-  publishingRenderSnapshotSchema,
-  publishingPreviewLinkSchema,
-  publishingPreviewSelectionStateSchema,
-  createPublishingApprovalRequestSchema,
-  publishingApprovalSchema,
-  createPublishingDraftIntentRequestSchema,
-  publishingDraftIntentResponseSchema,
-  CONTENT_WORKFLOW_ID,
-  CONTENT_ARTIFACT_KINDS,
-  contentArtifactKindSchema,
-  CONTENT_STAGE_SKILLS,
-  CONTENT_STAGE_INPUTS,
-  portableRelativePathSchema,
-  contentProjectManifestSchema,
-  goldenLinesSidecarSchema,
-  titlesStageArtifactFrontmatterSchema,
-  visualPlanStageArtifactFrontmatterSchema,
-  deliveryStageArtifactFrontmatterSchema,
-  contentStageArtifactFrontmatterSchema,
-  stepCheckpointStatusSchema,
-  executionLocationSchema,
-  dataTransitSchema,
-  stepCheckpointSchema,
-  contentProjectInitResultSchema,
-  contentProjectStatusResultSchema,
-  contentProjectIndexSchema,
-  contentProjectResolveResultSchema,
-  contentProjectCheckpointResultSchema,
-  contentProjectErrorResultSchema,
-  contentProfileInputSchema,
-  contentProfileUpdateInputSchema,
-  contentProfileSchema,
-  contentProfileSaveResultSchema,
-  contentProfileUpdateResultSchema,
-  contentProfileStatusResultSchema,
-  contentMemoryInputSchema,
-  contentMemoryStoreSchema,
-  contentMemoryAddResultSchema,
-  contentMemoryArchiveResultSchema,
-  contentMemoryListResultSchema,
-  contentMemoryErrorResultSchema,
-  contentProfileErrorResultSchema,
-  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,
-  contentKnowledgeModelSchema,
-  contentKnowledgeImportResultSchema,
-  contentKnowledgeQuoteListResultSchema,
-  contentKnowledgeQuoteMutationResultSchema,
-  contentKnowledgeQuoteInitResultSchema,
-  contentKnowledgeQuoteStatusResultSchema,
-  contentKnowledgeQuoteSyncResultSchema,
-  contentKnowledgeSearchResultSchema,
-  contentKnowledgeStatusResultSchema,
-  contentKnowledgeRemoveResultSchema,
-  contentKnowledgeErrorResultSchema,
-  sourceFetchKindSchema,
-  sourceFetchResultSchema,
-  sourceFetchErrorResultSchema,
-  CONTENT_MONITOR_SCHEMA_VERSION,
-  contentMonitorSourceSchema,
-  contentMonitorAddResultSchema,
-  contentMonitorListResultSchema,
-  contentMonitorRunResultSchema,
-  contentMonitorStatusResultSchema,
-  contentMonitorRemoveResultSchema,
-  contentMonitorErrorResultSchema,
-  PROTOCOL_VERSION,
-  versionResultSchema,
-  doctorResultSchema,
-  articleBundleSchema,
-  preflightResultSchema,
-  wechatRenderResultSchema,
-  createDeviceBindingSessionResponseSchema,
-  proveDeviceBindingSessionResponseSchema,
-  deviceSessionStatusResponseSchema,
-  createWechatLoginSessionResponseSchema,
-  wechatLoginSessionResponseSchema,
-  createWechatAuthorizationSessionResponseSchema,
-  wechatAuthorizationSessionResponseSchema,
-  wechatAccountsResponseSchema,
-  wechatDraftSmokePreviewResponseSchema,
-  wechatDraftSmokeIntentResponseSchema,
-  apiErrorResponseSchema,
-  LocalStateError,
-  ensurePrivateDirectory,
-  ensurePrivateRegularFile,
-  readPrivateFile,
-  readPrivateBuffer,
-  writePrivateJson,
-  writePrivateBuffer
-};