@deployxai/dxc 0.1.7 → 0.1.12

package/dist/chunks/{chunk-N4CMLINP.js → chunk-BWOC5S2C.js}

@@ -596,6 +596,17 @@ var publishingPreviewLinkSchema = z4.object({
   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),
@@ -621,7 +632,8 @@ var publishingApprovalSchema = z4.object({
   }
 });
 var createPublishingDraftIntentRequestSchema = z4.object({
-  approvalId: z4.uuid()
+  approvalId: z4.uuid(),
+  previousIntentId: z4.uuid().optional()
 }).strict();
 var publishingDraftStatusSchema = z4.enum([
   "QUEUED",
@@ -1040,7 +1052,7 @@ var visualStageInlineAssetSchema = z5.object({
   sha256: z5.string().regex(/^[a-f0-9]{64}$/u),
   source: z5.enum(["agent-generated", "local-material"])
 }).strict();
-var visualPlanStageArtifactFrontmatterSchema = z5.object({
+var visualPlanMaterializedArtifactFrontmatterSchema = z5.object({
   assetsDirectory: portableRelativePathSchema,
   coverAsset: portableRelativePathSchema,
   coverSha256: z5.string().regex(/^[a-f0-9]{64}$/u),
@@ -1052,6 +1064,65 @@ var visualPlanStageArtifactFrontmatterSchema = z5.object({
   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({
@@ -1094,6 +1165,9 @@ var deliveryStageArtifactFrontmatterSchema = z5.object({
   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),
@@ -1108,6 +1182,13 @@ var deliveryStageArtifactFrontmatterSchema = z5.object({
       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) {
@@ -1175,6 +1256,14 @@ var stepConfirmationBindingSchema = z5.object({
     });
   }
 });
+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(),
@@ -1217,6 +1306,17 @@ var stepCheckpointSchema = z5.discriminatedUnion("checkpointVersion", [
     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) {
@@ -1231,7 +1331,7 @@ var stepCheckpointSchema = z5.discriminatedUnion("checkpointVersion", [
       message: "awaiting-user and completed checkpoints require an artifact"
     });
   }
-  if (checkpoint.artifact !== void 0 && checkpoint.status !== "awaiting-user" && checkpoint.status !== "completed") {
+  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"
@@ -1285,7 +1385,7 @@ var stepCheckpointSchema = z5.discriminatedUnion("checkpointVersion", [
       message: "confirmed checkpoints must be completed"
     });
   }
-  if (checkpoint.checkpointVersion === "3") {
+  if (checkpoint.checkpointVersion === "3" || checkpoint.checkpointVersion === "4") {
     if (checkpoint.confirmation === "pending" && checkpoint.confirmationBinding?.status !== "pending") {
       context.addIssue({
         code: "custom",
@@ -1305,6 +1405,38 @@ var stepCheckpointSchema = z5.discriminatedUnion("checkpointVersion", [
       });
     }
   }
+  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({
@@ -1359,6 +1491,20 @@ var contentProjectStatusResultSchema = z5.object({
     manifest: contentProjectManifestSchema,
     manifestPath: z5.literal("dxc.project.json"),
     nextStage: contentArtifactKindSchema.nullable(),
+    recoveryPlan: z5.array(
+      z5.object({
+        action: z5.literal("rerun-stage"),
+        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",
@@ -1395,10 +1541,17 @@ var contentProjectResolveResultSchema = z5.object({
 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.literal("confirm-stage"),
+      action: z5.enum(["authorize-external-action", "confirm-stage"]),
       message: z5.string().trim().min(1).max(500),
       suggestedFlag: z5.literal("--confirm")
     }).strict().nullable()
@@ -1421,7 +1574,11 @@ var contentProjectErrorResultSchema = z5.object({
       "DXC_PROJECT_NOT_FOUND",
       "DXC_PROJECT_STAGE_INVALID"
     ]),
-    message: z5.string().trim().min(1)
+    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();
@@ -2123,8 +2280,10 @@ export {
   publishingArticleSchema,
   publishingRenderSnapshotSchema,
   publishingPreviewLinkSchema,
+  publishingPreviewSelectionStateSchema,
   createPublishingApprovalRequestSchema,
   publishingApprovalSchema,
+  createPublishingDraftIntentRequestSchema,
   publishingDraftIntentResponseSchema,
   CONTENT_WORKFLOW_ID,
   CONTENT_ARTIFACT_KINDS,

package/dist/chunks/{chunk-NAL5UOUZ.js → chunk-PX25ABJR.js}

@@ -1,7 +1,7 @@
 import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
 import {
   sourceFetchResultSchema
-} from "./chunk-N4CMLINP.js";
+} from "./chunk-BWOC5S2C.js";
 
 // apps/cli/src/source.ts
 import { createHash } from "node:crypto";

package/dist/chunks/{knowledge-PWFALFEC.js → knowledge-RAGVN36S.js}

@@ -27,7 +27,7 @@ import {
   readPrivateFile,
   writePrivateBuffer,
   writePrivateJson
-} from "./chunk-N4CMLINP.js";
+} from "./chunk-BWOC5S2C.js";
 
 // apps/cli/src/knowledge.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";

package/dist/chunks/{monitor-CL5UXEO2.js → monitor-XTYUQFQT.js}

@@ -2,7 +2,7 @@ import { createRequire as __dxcCreateRequire } from "node:module"; const require
 import {
   SourceCli,
   SourceCliError
-} from "./chunk-NAL5UOUZ.js";
+} from "./chunk-PX25ABJR.js";
 import {
   CONTENT_MONITOR_SCHEMA_VERSION,
   LocalStateError,
@@ -14,7 +14,7 @@ import {
   contentMonitorStatusResultSchema,
   ensurePrivateRegularFile,
   sourceFetchKindSchema
-} from "./chunk-N4CMLINP.js";
+} from "./chunk-BWOC5S2C.js";
 
 // apps/cli/src/monitor.ts
 import { createHash, randomUUID as systemRandomUUID } from "node:crypto";