@deployxai/dxc 0.1.3 → 0.1.4

package/dist/chunks/chunk-JGUPNE36.js

@@ -0,0 +1,2077 @@
+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)
+  }).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 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(),
+  snapshotHash: sha256Schema,
+  snapshotId: z4.uuid()
+}).strict();
+var createPublishingDraftIntentRequestSchema = z4.object({
+  approvalId: z4.uuid()
+}).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.5.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.1.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: ["research"],
+    required: ["brief", "outline"]
+  },
+  brief: {
+    optional: [],
+    required: ["research"]
+  },
+  delivery: {
+    optional: ["visual-plan", "quality-review"],
+    required: ["article", "titles"]
+  },
+  outline: {
+    optional: ["research"],
+    required: ["brief"]
+  },
+  "quality-review": {
+    optional: ["research", "visual-plan"],
+    required: ["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 researchStageArtifactFrontmatterSchema = z5.object({
+  dxc: z5.object({
+    ...contentStageMetadataBaseShape,
+    stage: z5.literal("research")
+  }).strict(),
+  origin: z5.enum(["hotspot", "article", "keywords", "intent"]),
+  sourceCount: z5.number().int().nonnegative()
+}).strict();
+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(),
+  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 visualPlanStageArtifactFrontmatterSchema = 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 qualityReviewStageArtifactFrontmatterSchema = z5.object({
+  blockerCount: z5.number().int().nonnegative(),
+  dxc: z5.object({
+    ...contentStageMetadataBaseShape,
+    stage: z5.literal("quality-review")
+  }).strict(),
+  verdict: z5.enum(["pass", "block"]),
+  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"]
+    });
+  }
+});
+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(),
+  snapshotHash: z5.string().regex(/^[a-f0-9]{64}$/u),
+  snapshotId: z5.uuid(),
+  state: z5.enum(["previewed", "processing", "completed", "requires-attention", "failed"])
+}).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"]
+    });
+  }
+});
+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 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()
+]).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") {
+    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") {
+    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"
+      });
+    }
+  }
+});
+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(),
+    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({
+    checkpoint: stepCheckpointSchema,
+    checkpointPath: portableRelativePathSchema,
+    guidance: z5.object({
+      action: z5.literal("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"
+]);
+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"
+    ]),
+    message: z5.string().trim().min(1)
+  }).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"]),
+    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,
+  createPublishingApprovalRequestSchema,
+  publishingApprovalSchema,
+  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
+};