@sitecoreai-labs/sitecoreai-cli 0.1.2 → 0.2.1

package/dist/brief/recipe/instance-kind.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.briefInstanceKind = void 0;
+/**
+ * The `brief` recipe kind — wires the Sitecore Content Operations
+ * Brief instance API into the `sync` engine.
+ *
+ * `ref.id` is the brief's display NAME — recipes identify a brief by
+ * name, not UUID, mirroring how `campaign` identifies a project. The
+ * brief type is referenced by its stable codename (`briefTypeName`)
+ * and resolved to a server id at push-time via `listBriefTypes`.
+ *
+ * `apply` is straight CRUD: `createBrief` when the brief is absent,
+ * `updateBrief` (partial PUT) to converge an existing one. Repointing
+ * an existing brief at a different brief type is refused — the Brief
+ * API has no verified path for that.
+ *
+ * See docs/recipe-sync-architecture.md.
+ */
+const brief_1 = require("../../brief");
+const errors_1 = require("../../shared/errors");
+const client_1 = require("./client");
+const instance_diff_1 = require("./instance-diff");
+const instance_schema_1 = require("./instance-schema");
+/**
+ * Find a brief by its display name, paging the list endpoint until a
+ * match is found or the cursor is exhausted. The Brief list endpoint
+ * supports no server-side name filter (see `ListBriefsQuery`), so the
+ * walk is unavoidable.
+ */
+const findBriefByName = async (client, name) => {
+    let cursor;
+    for (;;) {
+        const page = await (0, brief_1.listBriefs)(client, cursor ? { next: cursor } : undefined);
+        const match = page.data.find((brief) => brief.name === name);
+        if (match)
+            return match;
+        if (!page.next || page.data.length === 0)
+            return null;
+        cursor = page.next;
+    }
+};
+/** Find a brief type by its codename (mirrors `briefTypeKind`'s helper). */
+const findTypeByName = async (client, name) => {
+    const page = await (0, brief_1.listBriefTypes)(client);
+    return page.data.find((type) => type.name === name) ?? null;
+};
+/** Enumerate every brief on the remote — fans out into the aggregate sync. */
+const list = async (ctx) => {
+    const client = await (0, client_1.resolveBriefClient)(ctx);
+    const refs = [];
+    let cursor;
+    for (;;) {
+        const page = await (0, brief_1.listBriefs)(client, cursor ? { next: cursor } : undefined);
+        for (const brief of page.data) {
+            refs.push({ kind: "brief", id: brief.name });
+        }
+        if (!page.next || page.data.length === 0)
+            return refs;
+        cursor = page.next;
+    }
+};
+/** Project a live brief into the recipe shape, dropping server ids/metadata. */
+const toRecipe = (brief, briefTypeName) => ({
+    name: brief.name,
+    briefTypeName,
+    locale: brief.locale || undefined,
+    status: brief.status,
+    isTemplate: brief.isTemplate,
+    fields: brief.fields ?? {},
+});
+/**
+ * Capture a live brief as a recipe. `null` when no brief has the name.
+ *
+ * The list endpoint omits the full nested `fields` map on some
+ * envelopes, so the matched id is re-read via `getBrief` for fidelity.
+ */
+const readCurrent = async (ref, ctx) => {
+    const client = await (0, client_1.resolveBriefClient)(ctx);
+    const found = await findBriefByName(client, ref.id);
+    if (!found)
+        return null;
+    const brief = await (0, brief_1.getBrief)(client, found.id);
+    // Resolve the brief-type codename. The brief carries a `Link` to its
+    // type with the id but not the codename, so a follow-up listTypes
+    // resolves it. If the type has been deleted (orphan brief), surface
+    // the id verbatim so the pulled recipe still round-trips.
+    const types = await (0, brief_1.listBriefTypes)(client);
+    const briefTypeName = types.data.find((type) => type.id === brief.briefType.id)?.name ?? brief.briefType.id;
+    return toRecipe(brief, briefTypeName);
+};
+/** Resolve a recipe's `briefTypeName` to its server id, or fail with a hint. */
+const resolveBriefTypeId = async (client, briefTypeName) => {
+    const type = await findTypeByName(client, briefTypeName);
+    if (!type) {
+        throw (0, errors_1.createScaiError)(`Brief type "${briefTypeName}" not found.`, "INPUT_INVALID", {
+            hint: "Push the brief-type recipe first, or check the `briefTypeName` codename with `scai ops brief types list`.",
+        });
+    }
+    return type.id;
+};
+/** Apply a plan — create the brief, or PUT-patch it onto the desired state. */
+const apply = async (plan, ref, ctx) => {
+    const client = await (0, client_1.resolveBriefClient)(ctx);
+    const applied = [];
+    const skipped = [];
+    // The single `stage: "instance"` change carries the full desired
+    // recipe; per-element `stage: "field"` changes are descriptive only.
+    const instanceChange = plan.changes.find((change) => change.meta?.stage === "instance");
+    if (!instanceChange) {
+        // Nothing to write — an all-noop plan.
+        for (const change of plan.changes)
+            skipped.push(change);
+        return { applied, skipped };
+    }
+    const recipe = instanceChange.meta?.recipe;
+    if (!recipe) {
+        throw (0, errors_1.createScaiError)("Brief plan change is missing its recipe payload.", "INPUT_INVALID", {
+            hint: "This is an internal diff error — change.meta.recipe was not set.",
+        });
+    }
+    if (instanceChange.kind === "create") {
+        const briefTypeId = await resolveBriefTypeId(client, recipe.briefTypeName);
+        const input = {
+            name: recipe.name,
+            briefTypeId,
+            ...(recipe.locale !== undefined && { locale: recipe.locale }),
+            ...(Object.keys(recipe.fields ?? {}).length > 0 && { fields: recipe.fields }),
+            ...(recipe.isTemplate !== undefined && { isTemplate: recipe.isTemplate }),
+        };
+        ctx.logger?.info(`Creating brief "${recipe.name}".`);
+        const created = await (0, brief_1.createBrief)(client, input);
+        // `createBrief` accepts no `status` field — POSTs land in the
+        // server default ("Draft"). If the recipe pins a different status,
+        // converge with a follow-up PUT so the post-apply state matches.
+        if (recipe.status && recipe.status !== created.status) {
+            ctx.logger?.info(`Setting brief "${recipe.name}" status to "${recipe.status}".`);
+            await (0, brief_1.updateBrief)(client, created.id, { status: recipe.status });
+        }
+    }
+    else {
+        const existing = await findBriefByName(client, ref.id);
+        if (!existing) {
+            throw (0, errors_1.createScaiError)(`Brief "${ref.id}" not found.`, "INPUT_INVALID", {
+                hint: "The brief was expected to exist for an update — check the name or push a create.",
+            });
+        }
+        // The Brief API has no verified path to repoint a brief at a
+        // different type. Surface that loudly instead of silently dropping
+        // the change.
+        const types = await (0, brief_1.listBriefTypes)(client);
+        const existingTypeName = types.data.find((type) => type.id === existing.briefType.id)?.name ?? existing.briefType.id;
+        if (existingTypeName !== recipe.briefTypeName) {
+            throw (0, errors_1.createScaiError)(`Cannot repoint brief "${recipe.name}" from type "${existingTypeName}" to "${recipe.briefTypeName}".`, "INPUT_INVALID", {
+                hint: "The Brief API has no verified path to change a brief's type. Delete and recreate the brief, or correct the recipe's briefTypeName.",
+            });
+        }
+        const patch = {
+            name: recipe.name,
+            ...(recipe.locale !== undefined && { locale: recipe.locale }),
+            ...(recipe.isTemplate !== undefined && { isTemplate: recipe.isTemplate }),
+            ...(recipe.status !== undefined && { status: recipe.status }),
+            fields: recipe.fields ?? {},
+        };
+        ctx.logger?.info(`Updating brief "${recipe.name}" (${existing.id}).`);
+        await (0, brief_1.updateBrief)(client, existing.id, patch);
+    }
+    applied.push(instanceChange);
+    // Per-element changes are converged by the single PUT (or POST).
+    for (const change of plan.changes) {
+        if (change === instanceChange)
+            continue;
+        if (change.kind === "noop")
+            skipped.push(change);
+        else
+            applied.push(change);
+    }
+    return { applied, skipped };
+};
+/** Compute the plan to converge a brief onto `desired`. */
+const plan = async (desired, ref, ctx) => (0, instance_diff_1.diffBriefInstance)(desired, await readCurrent(ref, ctx));
+/** The `brief` recipe kind. */
+exports.briefInstanceKind = {
+    name: "brief",
+    schema: instance_schema_1.BriefInstanceRecipeSchema,
+    readCurrent,
+    plan,
+    apply,
+    list,
+};

package/dist/brief/recipe/instance-schema.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `BriefInstanceRecipe` — the declarative definition of a Sitecore
+ * Content Operations *brief instance* (the unit of work — a populated
+ * brief built against a `BriefType` schema).
+ *
+ * Companion to `BriefTypeRecipeSchema` (this file's sibling `schema.ts`,
+ * which models the schema template). Brief instances reference their
+ * type by stable codename (`briefTypeName`) rather than UUID, exactly as
+ * a `campaign` recipe references nothing by id and identifies itself by
+ * `name`. See docs/recipe-sync-architecture.md.
+ *
+ * The schema captures the fields `createBrief` / `updateBrief` accept
+ * on the Brief API — `name`, `briefTypeName`, `locale`, `status`,
+ * `isTemplate`, and the per-field `fields` map. Sub-resources (tasks,
+ * comments, references, contributors, external mappings) are returned
+ * by the read endpoints but are not part of the brief write surface,
+ * so they stay out of the recipe.
+ */
+import { z } from "zod";
+/**
+ * Brief workflow status — the values the Brief API accepts on a write.
+ * Mirrors the `BriefStatus` wire type in `../api/schema.ts`; surfacing
+ * the literal set here means the model reads the enum directly off the
+ * recipe schema (and bad values fail at parse-time, not push-time).
+ *
+ * `InReview` is the wire form for the "In Review" UI label.
+ */
+export declare const BriefInstanceStatusSchema: z.ZodEnum<{
+    Draft: "Draft";
+    InReview: "InReview";
+    Approved: "Approved";
+    Canceled: "Canceled";
+    Archived: "Archived";
+}>;
+/**
+ * Field values on a brief instance, keyed by `BriefField.name`. The
+ * per-field shape varies by field `type` on the brief's type (RichText
+ * values are ProseMirror docs; DateTime is an ISO string; Timeline and
+ * Budget carry their own object shape). The shape is left as
+ * `z.unknown()` so any field type round-trips losslessly between
+ * `recipe pull` and `recipe push` without the recipe schema chasing
+ * the per-field encoding. Validation is deferred to the server.
+ */
+export declare const BriefInstanceFieldsSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+/** The full brief-instance recipe. */
+export declare const BriefInstanceRecipeSchema: z.ZodObject<{
+    name: z.ZodString;
+    briefTypeName: z.ZodString;
+    locale: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        Draft: "Draft";
+        InReview: "InReview";
+        Approved: "Approved";
+        Canceled: "Canceled";
+        Archived: "Archived";
+    }>>;
+    isTemplate: z.ZodOptional<z.ZodBoolean>;
+    fields: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/** A validated brief-instance recipe. */
+export type BriefInstanceRecipe = z.infer<typeof BriefInstanceRecipeSchema>;

package/dist/brief/recipe/instance-schema.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BriefInstanceRecipeSchema = exports.BriefInstanceFieldsSchema = exports.BriefInstanceStatusSchema = void 0;
+/**
+ * `BriefInstanceRecipe` — the declarative definition of a Sitecore
+ * Content Operations *brief instance* (the unit of work — a populated
+ * brief built against a `BriefType` schema).
+ *
+ * Companion to `BriefTypeRecipeSchema` (this file's sibling `schema.ts`,
+ * which models the schema template). Brief instances reference their
+ * type by stable codename (`briefTypeName`) rather than UUID, exactly as
+ * a `campaign` recipe references nothing by id and identifies itself by
+ * `name`. See docs/recipe-sync-architecture.md.
+ *
+ * The schema captures the fields `createBrief` / `updateBrief` accept
+ * on the Brief API — `name`, `briefTypeName`, `locale`, `status`,
+ * `isTemplate`, and the per-field `fields` map. Sub-resources (tasks,
+ * comments, references, contributors, external mappings) are returned
+ * by the read endpoints but are not part of the brief write surface,
+ * so they stay out of the recipe.
+ */
+const zod_1 = require("zod");
+/**
+ * Brief workflow status — the values the Brief API accepts on a write.
+ * Mirrors the `BriefStatus` wire type in `../api/schema.ts`; surfacing
+ * the literal set here means the model reads the enum directly off the
+ * recipe schema (and bad values fail at parse-time, not push-time).
+ *
+ * `InReview` is the wire form for the "In Review" UI label.
+ */
+exports.BriefInstanceStatusSchema = zod_1.z
+    .enum(["Draft", "InReview", "Approved", "Canceled", "Archived"])
+    .describe('Brief workflow status. Wire form — "InReview" is the "In Review" UI label. A brief must leave "Draft" before it can be linked to a campaign.');
+/**
+ * Field values on a brief instance, keyed by `BriefField.name`. The
+ * per-field shape varies by field `type` on the brief's type (RichText
+ * values are ProseMirror docs; DateTime is an ISO string; Timeline and
+ * Budget carry their own object shape). The shape is left as
+ * `z.unknown()` so any field type round-trips losslessly between
+ * `recipe pull` and `recipe push` without the recipe schema chasing
+ * the per-field encoding. Validation is deferred to the server.
+ */
+exports.BriefInstanceFieldsSchema = zod_1.z
+    .record(zod_1.z.string(), zod_1.z.unknown())
+    .default({})
+    .describe("Field values keyed by BriefField.name. Per-field value shape follows the brief type's field definitions (e.g. RichText is a ProseMirror doc node).");
+/** The full brief-instance recipe. */
+exports.BriefInstanceRecipeSchema = zod_1.z.object({
+    name: zod_1.z
+        .string()
+        .min(1)
+        .describe("Display name of the brief. Identifies the brief when pushing. Briefs are matched by name; the recipe pushes through to `createBrief` / `updateBrief`."),
+    briefTypeName: zod_1.z
+        .string()
+        .min(1)
+        .regex(/^[A-Za-z][A-Za-z0-9_]*$/, "Must start with a letter and contain only letters, digits, or underscores.")
+        .describe("Codename of the brief type this brief is built against — looked up at push-time and resolved to its server id. The brief type must already exist (push the type's recipe first if it doesn't)."),
+    locale: zod_1.z
+        .string()
+        .optional()
+        .describe('Brief locale — BCP-47-ish, e.g. "en-us". Omit to let the server default apply.'),
+    status: exports.BriefInstanceStatusSchema.optional().describe('Brief workflow status. Omit to leave at the server default ("Draft" on creation).'),
+    isTemplate: zod_1.z
+        .boolean()
+        .optional()
+        .describe("Whether the brief is a template (omit to leave at the server default)."),
+    fields: exports.BriefInstanceFieldsSchema,
+});

package/dist/brief/recipe/schema.js

@@ -69,7 +69,10 @@ exports.BudgetFieldSchema = zod_1.z
     type: zod_1.z.literal("Budget").describe("Discriminator — a budget/currency field."),
     ...briefFieldBaseShape,
     currencies: zod_1.z
-        .array(zod_1.z.string())
+        .array(zod_1.z
+        .string()
+        .length(3)
+        .regex(/^[A-Z]{3}$/, "ISO-4217 currency code must be 3 uppercase letters (e.g. `USD`)."))
         .describe('ISO-4217 currency codes the field accepts, e.g. ["USD", "EUR"].'),
 })
     .describe("A budget/currency field.");

package/dist/brief/tasks/index.d.ts

@@ -1,3 +1,4 @@
+import { type CreateBriefInput } from "../api/briefs";
 import { type CreateBriefTypeInput } from "../api/brief-types";
 import type { Brief, BriefComment, BriefStatus, BriefTask, BriefType, PagedResult } from "../api/schema";
 /**
@@ -100,6 +101,40 @@ export declare const runBriefCommentsList: (options: RunBriefBaseOptions & {
     briefId?: string;
     limit?: number;
 }) => Promise<PagedResult<BriefComment>>;
+/**
+ * Create a brief instance from a `CreateBriefInput`. Mirrors
+ * `runBriefTypeCreate` — honours `whatIf` for a plan-only dry run. The
+ * SDK `createBrief` is verified against the Agents tenant.
+ */
+export declare const runBriefCreate: (options: RunBriefBaseOptions & {
+    input: CreateBriefInput;
+    whatIf?: boolean;
+}) => Promise<Brief | {
+    plan: CreateBriefInput;
+}>;
+/**
+ * Update a brief instance by id with a partial patch (`PUT`). Accepts
+ * any subset of `CreateBriefInput` plus an optional `status`. Mirrors
+ * `runBriefTypeUpdate` — honours `whatIf` for a plan-only dry run. The
+ * status-only PUT path is verified (2026-05-15); other partial fields
+ * are wired the same way but not smoke-tested.
+ */
+export declare const runBriefUpdate: (options: RunBriefBaseOptions & {
+    briefId: string;
+    patch: Partial<CreateBriefInput> & {
+        status?: BriefStatus;
+    };
+    whatIf?: boolean;
+}) => Promise<{
+    id: string;
+} | {
+    plan: {
+        id: string;
+        patch: Partial<CreateBriefInput> & {
+            status?: BriefStatus;
+        };
+    };
+}>;
 /**
  * Delete a brief instance. Mirrors `runBriefTypeDelete` — honours
  * `whatIf` for a plan-only dry run. SDK `deleteBrief` is verified

package/dist/brief/tasks/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runBriefCommentAdd = exports.runBriefDelete = exports.runBriefCommentsList = exports.runBriefTodosList = exports.runBriefTypeDelete = exports.runBriefTypeUpdate = exports.runBriefTypeCreate = exports.runBriefTypeGet = exports.runBriefSetStatus = exports.runBriefTypes = exports.runBriefShow = exports.runBriefList = void 0;
+exports.runBriefCommentAdd = exports.runBriefDelete = exports.runBriefUpdate = exports.runBriefCreate = exports.runBriefCommentsList = exports.runBriefTodosList = exports.runBriefTypeDelete = exports.runBriefTypeUpdate = exports.runBriefTypeCreate = exports.runBriefTypeGet = exports.runBriefSetStatus = exports.runBriefTypes = exports.runBriefShow = exports.runBriefList = void 0;
 const logger_1 = require("../../shared/logger");
 const client_1 = require("../client");
 const briefs_1 = require("../api/briefs");
@@ -229,6 +229,67 @@ const runBriefCommentsList = async (options) => {
     return result;
 };
 exports.runBriefCommentsList = runBriefCommentsList;
+/**
+ * Create a brief instance from a `CreateBriefInput`. Mirrors
+ * `runBriefTypeCreate` — honours `whatIf` for a plan-only dry run. The
+ * SDK `createBrief` is verified against the Agents tenant.
+ */
+const runBriefCreate = async (options) => {
+    const { logger, client } = await prepareBriefClient(options);
+    if (options.whatIf) {
+        const plan = { plan: options.input };
+        if (logger.isJson()) {
+            writeJson(plan);
+        }
+        else {
+            logger.info(`Would create brief '${options.input.name}'.`, "yellow");
+            logger.info(`  Brief type:  ${options.input.briefTypeId}`);
+            if (options.input.locale)
+                logger.info(`  Locale:      ${options.input.locale}`);
+            const fieldCount = Object.keys(options.input.fields ?? {}).length;
+            logger.info(`  Fields:      ${fieldCount}`);
+        }
+        return plan;
+    }
+    const created = await (0, briefs_1.createBrief)(client, options.input);
+    if (logger.isJson()) {
+        writeJson(created);
+        return created;
+    }
+    logger.info(`Created brief ${created.id} (${created.name}).`, "green");
+    return created;
+};
+exports.runBriefCreate = runBriefCreate;
+/**
+ * Update a brief instance by id with a partial patch (`PUT`). Accepts
+ * any subset of `CreateBriefInput` plus an optional `status`. Mirrors
+ * `runBriefTypeUpdate` — honours `whatIf` for a plan-only dry run. The
+ * status-only PUT path is verified (2026-05-15); other partial fields
+ * are wired the same way but not smoke-tested.
+ */
+const runBriefUpdate = async (options) => {
+    const { logger, client } = await prepareBriefClient(options);
+    if (options.whatIf) {
+        const plan = { plan: { id: options.briefId, patch: options.patch } };
+        if (logger.isJson()) {
+            writeJson(plan);
+        }
+        else {
+            logger.info(`Would PUT-update brief ${options.briefId}.`, "yellow");
+            const keys = Object.keys(options.patch);
+            logger.info(`  Patch keys:  ${keys.length === 0 ? "(none)" : keys.join(", ")}`);
+        }
+        return plan;
+    }
+    await (0, briefs_1.updateBrief)(client, options.briefId, options.patch);
+    if (logger.isJson()) {
+        writeJson({ id: options.briefId });
+        return { id: options.briefId };
+    }
+    logger.info(`Updated brief ${options.briefId}.`, "green");
+    return { id: options.briefId };
+};
+exports.runBriefUpdate = runBriefUpdate;
 /**
  * Delete a brief instance. Mirrors `runBriefTypeDelete` — honours
  * `whatIf` for a plan-only dry run. SDK `deleteBrief` is verified

package/dist/campaigns/recipe/schema.d.ts

@@ -9,6 +9,21 @@
  * model reads it. See docs/recipe-sync-architecture.md.
  */
 import { z } from "zod";
+/**
+ * Server enum values **confirmed by observation** in HAR captures of the
+ * Sitecore Content Operations UI driving the Orchestrate API. Other
+ * values likely exist in the server's enum — `recipe pull` from a tenant
+ * with a live `IN_PROGRESS` campaign must still round-trip cleanly — so
+ * the schema accepts the known set as a strong hint and falls back to
+ * `z.string()`. JSON Schema renders this as `anyOf: [{ enum: [...] }, { type:
+ * "string" }]`, which the model reads as "prefer one of these values; new
+ * uppercase enums are acceptable too".
+ *
+ * Update the lists when more values are observed; the trailing
+ * `z.string()` keeps the schema permissive in the meantime.
+ */
+export declare const KNOWN_CAMPAIGN_STATUSES: readonly ["NOT_STARTED"];
+export declare const KNOWN_CAMPAIGN_FUNNEL_STAGES: readonly ["TOP"];
 /**
  * A task — the leaf work item of a campaign. Owned by a deliverable.
  * Identified within its deliverable by `name`; server ids are dropped
@@ -16,7 +31,9 @@ import { z } from "zod";
  */
 export declare const CampaignTaskSchema: z.ZodObject<{
     name: z.ZodString;
-    status: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        NOT_STARTED: "NOT_STARTED";
+    }>, z.ZodString]>>;
     dueDate: z.ZodOptional<z.ZodString>;
     priority: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
@@ -29,14 +46,20 @@ export declare const CampaignTaskSchema: z.ZodObject<{
  */
 export declare const CampaignDeliverableSchema: z.ZodObject<{
     name: z.ZodString;
-    status: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        NOT_STARTED: "NOT_STARTED";
+    }>, z.ZodString]>>;
     dueDate: z.ZodOptional<z.ZodString>;
-    funnelStage: z.ZodOptional<z.ZodString>;
+    funnelStage: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        TOP: "TOP";
+    }>, z.ZodString]>>;
     funnelTactics: z.ZodDefault<z.ZodArray<z.ZodString>>;
     labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
     tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
-        status: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            NOT_STARTED: "NOT_STARTED";
+        }>, z.ZodString]>>;
         dueDate: z.ZodOptional<z.ZodString>;
         priority: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
@@ -48,21 +71,29 @@ export declare const CampaignDeliverableSchema: z.ZodObject<{
 export declare const CampaignRecipeSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    status: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        NOT_STARTED: "NOT_STARTED";
+    }>, z.ZodString]>>;
     startDate: z.ZodOptional<z.ZodString>;
     dueDate: z.ZodOptional<z.ZodString>;
     brandKitId: z.ZodOptional<z.ZodString>;
     labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
     deliverables: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
-        status: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            NOT_STARTED: "NOT_STARTED";
+        }>, z.ZodString]>>;
         dueDate: z.ZodOptional<z.ZodString>;
-        funnelStage: z.ZodOptional<z.ZodString>;
+        funnelStage: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            TOP: "TOP";
+        }>, z.ZodString]>>;
         funnelTactics: z.ZodDefault<z.ZodArray<z.ZodString>>;
         labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
         tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
-            status: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                NOT_STARTED: "NOT_STARTED";
+            }>, z.ZodString]>>;
             dueDate: z.ZodOptional<z.ZodString>;
             priority: z.ZodOptional<z.ZodString>;
             description: z.ZodOptional<z.ZodString>;

package/dist/campaigns/recipe/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CampaignRecipeSchema = exports.CampaignDeliverableSchema = exports.CampaignTaskSchema = void 0;
+exports.CampaignRecipeSchema = exports.CampaignDeliverableSchema = exports.CampaignTaskSchema = exports.KNOWN_CAMPAIGN_FUNNEL_STAGES = exports.KNOWN_CAMPAIGN_STATUSES = void 0;
 /**
  * `CampaignRecipe` — the declarative definition of a Sitecore
  * Orchestrate campaign (a `project`, with its nested deliverables and
@@ -12,6 +12,33 @@ exports.CampaignRecipeSchema = exports.CampaignDeliverableSchema = exports.Campa
  * model reads it. See docs/recipe-sync-architecture.md.
  */
 const zod_1 = require("zod");
+/**
+ * ISO-8601 date-or-datetime — accepts `2026-05-26`, `2026-05-26T15:00:00Z`,
+ * or `2026-05-26T15:00:00.123+02:00`. Less strict than `z.string().datetime()`
+ * because the campaign API returns date-only values for some fields.
+ */
+const Iso8601 = zod_1.z
+    .string()
+    .regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2}))?$/, {
+    message: "must be an ISO-8601 date or datetime (e.g. `2026-05-26` or `2026-05-26T15:00:00Z`)",
+});
+/**
+ * Server enum values **confirmed by observation** in HAR captures of the
+ * Sitecore Content Operations UI driving the Orchestrate API. Other
+ * values likely exist in the server's enum — `recipe pull` from a tenant
+ * with a live `IN_PROGRESS` campaign must still round-trip cleanly — so
+ * the schema accepts the known set as a strong hint and falls back to
+ * `z.string()`. JSON Schema renders this as `anyOf: [{ enum: [...] }, { type:
+ * "string" }]`, which the model reads as "prefer one of these values; new
+ * uppercase enums are acceptable too".
+ *
+ * Update the lists when more values are observed; the trailing
+ * `z.string()` keeps the schema permissive in the meantime.
+ */
+exports.KNOWN_CAMPAIGN_STATUSES = ["NOT_STARTED"];
+exports.KNOWN_CAMPAIGN_FUNNEL_STAGES = ["TOP"];
+const CampaignStatusSchema = zod_1.z.union([zod_1.z.enum(exports.KNOWN_CAMPAIGN_STATUSES), zod_1.z.string()]);
+const CampaignFunnelStageSchema = zod_1.z.union([zod_1.z.enum(exports.KNOWN_CAMPAIGN_FUNNEL_STAGES), zod_1.z.string()]);
 /**
  * A task — the leaf work item of a campaign. Owned by a deliverable.
  * Identified within its deliverable by `name`; server ids are dropped
@@ -19,9 +46,12 @@ const zod_1 = require("zod");
  */
 exports.CampaignTaskSchema = zod_1.z.object({
     name: zod_1.z.string().min(1).describe("Task name. Identifies the task within its deliverable."),
-    status: zod_1.z.string().optional().describe('Task status — a server enum, e.g. "NOT_STARTED".'),
-    dueDate: zod_1.z.string().optional().describe("Task due date (ISO-8601)."),
-    priority: zod_1.z.string().optional().describe("Task priority — a server enum."),
+    status: CampaignStatusSchema.optional().describe('Task status — a server enum. Confirmed values: "NOT_STARTED". Other UPPER_SNAKE values may exist on the server; the schema accepts them but agents should prefer the confirmed set.'),
+    dueDate: Iso8601.optional().describe("Task due date (ISO-8601 date or datetime)."),
+    priority: zod_1.z
+        .string()
+        .optional()
+        .describe("Task priority — a server enum. No values have been observed yet; convention follows project-management norms (e.g. UPPERCASE strings). Schema is `string` until the enum set is captured."),
     description: zod_1.z.string().optional().describe("Task description. HTML."),
     assignee: zod_1.z.string().optional().describe('Assignee — an Auth0 user subject (e.g. "auth0|...").'),
     labels: zod_1.z.array(zod_1.z.string()).default([]).describe("Free-form labels on the task."),
@@ -35,9 +65,9 @@ exports.CampaignDeliverableSchema = zod_1.z.object({
         .string()
         .min(1)
         .describe("Deliverable name. Identifies the deliverable within its campaign."),
-    status: zod_1.z.string().optional().describe('Deliverable status — a server enum, e.g. "NOT_STARTED".'),
-    dueDate: zod_1.z.string().optional().describe("Deliverable due date (ISO-8601)."),
-    funnelStage: zod_1.z.string().optional().describe('Funnel stage — a server enum, e.g. "TOP".'),
+    status: CampaignStatusSchema.optional().describe('Deliverable status — a server enum. Confirmed values: "NOT_STARTED". Other UPPER_SNAKE values may exist on the server; the schema accepts them but agents should prefer the confirmed set.'),
+    dueDate: Iso8601.optional().describe("Deliverable due date (ISO-8601 date or datetime)."),
+    funnelStage: CampaignFunnelStageSchema.optional().describe('Funnel stage — a server enum. Confirmed values: "TOP". Other values likely exist (e.g. middle / bottom of funnel); the schema accepts them but agents should prefer the confirmed set.'),
     funnelTactics: zod_1.z.array(zod_1.z.string()).default([]).describe("Funnel tactics for the deliverable."),
     labels: zod_1.z.array(zod_1.z.string()).default([]).describe("Free-form labels on the deliverable."),
     tasks: zod_1.z
@@ -52,9 +82,9 @@ exports.CampaignRecipeSchema = zod_1.z.object({
         .min(1)
         .describe("Display name of the campaign (project). Identifies the campaign when pushing."),
     description: zod_1.z.string().optional().describe("Human description of the campaign."),
-    status: zod_1.z.string().optional().describe('Campaign status — a server enum, e.g. "NOT_STARTED".'),
-    startDate: zod_1.z.string().optional().describe("Campaign start date (ISO-8601)."),
-    dueDate: zod_1.z.string().optional().describe("Campaign due date (ISO-8601)."),
+    status: CampaignStatusSchema.optional().describe('Campaign status — a server enum. Confirmed values: "NOT_STARTED". Other UPPER_SNAKE values may exist on the server; the schema accepts them but agents should prefer the confirmed set.'),
+    startDate: Iso8601.optional().describe("Campaign start date (ISO-8601 date or datetime)."),
+    dueDate: Iso8601.optional().describe("Campaign due date (ISO-8601 date or datetime)."),
     brandKitId: zod_1.z
         .string()
         .optional()

package/dist/commands/agents/sync.js

@@ -91,7 +91,7 @@ const createDiffCommand = () => {
         const logger = (0, cli_tasks_1.toLogger)(options);
         const kind = resolveKind(options.kind);
         const ctx = buildContext(options, logger);
-        const recipe = (0, sync_1.loadRecipe)(options.file ?? "", kind.schema);
+        const recipe = await (0, sync_1.loadRecipe)(options.file ?? "", kind.schema);
         const plan = await (0, sync_1.syncDiff)(kind, recipe, { kind: kind.name, id: recipeName(recipe) }, ctx);
         printPlan(logger, plan);
     });
@@ -110,7 +110,7 @@ const createPushCommand = () => {
         const logger = (0, cli_tasks_1.toLogger)(options);
         const kind = resolveKind(options.kind);
         const ctx = buildContext(options, logger);
-        const recipe = (0, sync_1.loadRecipe)(options.file ?? "", kind.schema);
+        const recipe = await (0, sync_1.loadRecipe)(options.file ?? "", kind.schema);
         const mode = options.allowWrite ? "apply" : "what-if";
         const outcome = await (0, sync_1.syncPush)(kind, recipe, { kind: kind.name, id: recipeName(recipe) }, ctx, {
             mode,

package/dist/commands/brand/seed.js

@@ -70,7 +70,7 @@ const seedFromFile = async (options, logger) => {
         configPath,
         logger,
     };
-    const recipe = (0, sync_1.loadRecipe)(options.file ?? "", recipe_1.brandKitKind.schema);
+    const recipe = await (0, sync_1.loadRecipe)(options.file ?? "", recipe_1.brandKitKind.schema);
     const outcome = await (0, sync_1.syncPush)(recipe_1.brandKitKind, recipe, { kind: recipe_1.brandKitKind.name, id: recipe.name }, ctx, { mode: "apply", prune: false });
     if (options.format === "json") {
         process.stdout.write(JSON.stringify({ recipe: recipe.name, plan: outcome.plan, result: outcome.result }, null, 2) +