@avocadostudio-ai/orchestrator-core 0.3.2 → 0.3.3

package/dist/http/variations-actions.d.ts

@@ -17,8 +17,8 @@
  * wire bytes for callers that don't already have an SSE writer. Neither Fastify
  * nor `Response` appears in this file.
  */
-import { type VariationRequestBody, type VariationPipelineContext, type VariationResult, type VariationImageUpdate } from "../chat/variation-pipeline.js";
-import type { ActionResult } from "./history-actions.js";
+import { type VariationRequestBody, type VariationPipelineContext, type VariationResult, type VariationImageUpdate } from "../chat/variation-pipeline.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 export type { VariationRequestBody, VariationPipelineContext };
 export type ParsedVariationRequest = {

package/dist/index.d.ts

@@ -2,3 +2,10 @@ export { createOrchestrator, type CreateOrchestratorConfig, type OrchestratorHan
 export type { OrchestratorAuth, AuthContext } from "./handler/auth.ts";
 export type { CmsAdapter, CmsCapabilities, CmsInlineAsset, CmsPublishContext, CmsPublishResult, CmsPerspective, CmsReadOptions, CmsMediaItem, CmsMediaPage, CmsMediaQuery, ResolvedCapabilities } from "./cms/adapter.ts";
 export { jsonFileAdapter, editorApiAdapter, resolveCapabilities, cmsMediaSource, cmsMediaLabel, type JsonFileAdapterOptions, type EditorApiAdapterOptions, type CmsMediaSource, type CmsMediaSourceConfig } from "./cms/index.ts";
+export { registerPublishTarget, selectPublishTarget, getPublishTarget, listPublishTargets } from "./publish/publish-target-registry.ts";
+export type { PublishTarget, PublishContext, PublishOutcome, PublishStatus, PublishResult } from "./publish/publish-target.ts";
+export { SqliteDurableStore, InMemoryDurableStore, getDurableStore, resetDurableStore, setDurableStore, durableStoreIsEphemeral, type SqliteDurableStoreOptions, type InMemoryDurableStoreOptions, type DurableStore, type FindingInput, type FindingRecord, type FindingQuery, type FindingSeverity, type FindingStatus, type FindingEvidence, type CheckRunInput, type CheckRunRecord, type CheckRunPatch, type CheckRunTrigger, type MemoryInput, type MemoryRecord, type MemoryQuery, type MemoryScope, type MemoryKind, type MemorySource, type MemoryStatus, type CorrectionInput, type CorrectionRecord, type CorrectionQuery, type CorrectionOutcome, type ProposalInput, type ProposalRecord, type ProposalQuery, type ProposalStatus } from "./durable/index.ts";
+export { runDraftChecks, runChecksForSession, scheduleChecksAfterApply, scheduleChecksAfterPublish, cancelScheduledChecks, fingerprintFor, DRAFT_RULES, walkPageFields, fieldText, type RunChecksArgs, type CheckRule, type CheckContext, type RuleFinding, type FieldEntry, type SiteView } from "./checks/index.ts";
+export { runChecksAction, listFindingsAction, listCheckRunsAction, updateFindingAction, type RunChecksParams, type ListFindingsParams, type UpdateFindingParams, type ChecksScope } from "./http/checks-actions.ts";
+export { durableHealth, noteDurableFailure, isDiscardInFlight } from "./durable/durable-store-singleton.ts";
+export { loadPendingPlan, savePendingPlan, clearPendingPlan, peekPendingPlan } from "./durable/pending-plan-store.ts";

package/dist/index.js

@@ -19,3 +19,30 @@
 // The Fastify HTTP wrapper lives in apps/orchestrator and imports from here.
 export { createOrchestrator } from "./handler/create-orchestrator.js";
 export { jsonFileAdapter, editorApiAdapter, resolveCapabilities, cmsMediaSource, cmsMediaLabel } from "./cms/index.js";
+// The publish-target plugin point. `docs-site/integration/publishing.mdx` has
+// documented this as the way to publish somewhere we do not ship a target for
+// since before the package had an export map, and told the reader to import it
+// from `"./publish/publish-target-registry.js"` — a relative path into *this*
+// repository, pasted into their file. It cannot resolve from anywhere, and
+// there was no specifier that could: the symbol was not exported here, so a
+// registry consumer had no reachable way to register a target at all.
+//
+// The interface was always meant to be public — `architecture.mdx` calls it the
+// integration point for "S3, GitLab Pages, Netlify, a CMS API, a custom CI/CD
+// pipeline". Only the export was missing.
+export { registerPublishTarget, selectPublishTarget, getPublishTarget, listPublishTargets } from "./publish/publish-target-registry.js";
+// The durable substrate for findings, memory, corrections and proposals. It is
+// public because the implementation is meant to be replaceable: a library-mode
+// host on a serverless platform has no persistent disk for a SQLite file, and
+// every record here would otherwise die with the process. `DurableStore` is the
+// seam a Neon- or Turso-backed store fills — which is only true if a consumer
+// installing from the registry can reach the type.
+export { SqliteDurableStore, InMemoryDurableStore, getDurableStore, resetDurableStore, setDurableStore, durableStoreIsEphemeral } from "./durable/index.js";
+// The draft-tier checks: pure functions of a PageDoc and the block manifest,
+// producing findings into the durable store. Public so an integrator can run
+// them (or add a rule of their own) against a site we do not host.
+export { runDraftChecks, runChecksForSession, scheduleChecksAfterApply, scheduleChecksAfterPublish, cancelScheduledChecks, fingerprintFor, DRAFT_RULES, walkPageFields, fieldText } from "./checks/index.js";
+// The checks HTTP surface, mounted by both transports.
+export { runChecksAction, listFindingsAction, listCheckRunsAction, updateFindingAction } from "./http/checks-actions.js";
+export { durableHealth, noteDurableFailure, isDiscardInFlight } from "./durable/durable-store-singleton.js";
+export { loadPendingPlan, savePendingPlan, clearPendingPlan, peekPendingPlan } from "./durable/pending-plan-store.js";

package/dist/nlp/deterministic-planner-context.d.ts

@@ -46,6 +46,22 @@ export declare function selectedBlockSnapshot(args: {
     selectedEditablePath: string | null;
     selectedEditableValue: {} | null;
 } | null;
+/**
+ * How an item in a list prop gets named to the planner, in precedence order.
+ *
+ * A list whose items match none of these reaches the planner as a bare count,
+ * and the planner then cannot answer "update the FAQ entry about freezing" —
+ * it knows there are three entries and nothing about any of them. It says so,
+ * correctly, and asks which one. Three of the twelve list fields in the block
+ * registry were in that state: `FAQAccordion.items` names its question `q`,
+ * `Testimonials.items` has `author`/`quote`, and `Gallery.images` has
+ * `caption`/`alt`. None of those were listed here.
+ *
+ * `arrayPropLabelKeys` is asserted against the block registry by a test, so a
+ * new block with a differently-named item field fails there rather than
+ * silently costing the planner a clarification round-trip.
+ */
+export declare const ARRAY_PROP_LABEL_KEYS: readonly ["label", "title", "heading", "question", "q", "name", "author", "caption", "alt", "quote", "value", "text"];
 export declare function arrayPropLengths(props: Record<string, unknown>): Record<string, {
     length: number;
     labels?: string[];

package/dist/nlp/deterministic-planner-context.js

@@ -184,6 +184,35 @@ export function selectedBlockSnapshot(args) {
 // ---------------------------------------------------------------------------
 // Array prop metadata
 // ---------------------------------------------------------------------------
+/**
+ * How an item in a list prop gets named to the planner, in precedence order.
+ *
+ * A list whose items match none of these reaches the planner as a bare count,
+ * and the planner then cannot answer "update the FAQ entry about freezing" —
+ * it knows there are three entries and nothing about any of them. It says so,
+ * correctly, and asks which one. Three of the twelve list fields in the block
+ * registry were in that state: `FAQAccordion.items` names its question `q`,
+ * `Testimonials.items` has `author`/`quote`, and `Gallery.images` has
+ * `caption`/`alt`. None of those were listed here.
+ *
+ * `arrayPropLabelKeys` is asserted against the block registry by a test, so a
+ * new block with a differently-named item field fails there rather than
+ * silently costing the planner a clarification round-trip.
+ */
+export const ARRAY_PROP_LABEL_KEYS = [
+    "label",
+    "title",
+    "heading",
+    "question",
+    "q",
+    "name",
+    "author",
+    "caption",
+    "alt",
+    "quote",
+    "value",
+    "text"
+];
 export function arrayPropLengths(props) {
     const out = {};
     for (const [key, value] of Object.entries(props)) {
@@ -192,13 +221,10 @@ export function arrayPropLengths(props) {
         const labels = [];
         for (const item of value) {
             if (typeof item === "object" && item !== null) {
-                const labelValue = item.label ??
-                    item.title ??
-                    item.heading ??
-                    item.question ??
-                    item.name;
-                if (typeof labelValue === "string")
-                    labels.push(labelValue);
+                const record = item;
+                const labelKey = ARRAY_PROP_LABEL_KEYS.find((candidate) => typeof record[candidate] === "string");
+                if (labelKey)
+                    labels.push(record[labelKey]);
             }
         }
         out[key] = labels.length > 0 ? { length: value.length, labels } : { length: value.length };

package/dist/nlp/plan-normalizer.js

@@ -711,6 +711,19 @@ export function normalizePlanCandidate(input, args) {
         return args.currentPage.blocks[idx - 1]?.id;
     };
     const usedBlockIds = new Set((args?.currentPage?.blocks ?? []).map((b) => b.id));
+    /**
+     * Block ids this pass renamed, old → new.
+     *
+     * Renaming an `add_block` id is only safe if the rest of the plan follows it.
+     * A plan that adds `b_hero_x` and then updates `b_hero_x` means the block it
+     * just added; leave the reference pointing at the colliding name and the
+     * update lands on the *existing* block instead — content written over the
+     * wrong block, which is the failure mode this repo keeps re-shipping. Ops are
+     * normalized in order, so only ops after the rename are rewritten: a
+     * reference that came *before* the add_block can only have meant the block
+     * that was already there.
+     */
+    const renamedBlockIds = new Map();
     let createdPageSlug;
     let droppedPageLevelUpdate = false;
     // itemIds already claimed by a remove_item freeze in THIS plan — used to spot
@@ -972,6 +985,19 @@ export function normalizePlanCandidate(input, args) {
             raw.afterBlockId =
                 raw.after_block_id ?? raw.after ?? raw.insertAfterId ?? beforeToAfter(raw.beforeId ?? raw.insertBeforeId);
         }
+        // Follow any add_block id an earlier op in this plan had to uniquify. Runs
+        // after the alias resolution above so `after_block_id` and friends are
+        // already folded into the canonical keys. See `renamedBlockIds`.
+        if (renamedBlockIds.size > 0) {
+            for (const key of ["blockId", "afterBlockId", "newBlockId"]) {
+                const value = raw[key];
+                if (typeof value === "string") {
+                    const renamed = renamedBlockIds.get(value);
+                    if (renamed)
+                        raw[key] = renamed;
+                }
+            }
+        }
         if (!raw.afterPageSlug) {
             raw.afterPageSlug =
                 raw.afterPageSlug ??
@@ -1246,15 +1272,37 @@ export function normalizePlanCandidate(input, args) {
                     block.props = {};
                 }
             }
-            if ((!block.id || typeof block.id !== "string") && typeof block.type === "string") {
-                let fallbackId = `b_${String(block.type).toLowerCase()}_${Date.now()}`;
+            /*
+             * The model authors this id. Nothing in the `add_block` prompt says how
+             * to build one, so it free-associates from the page and the block type —
+             * `b_featuregrid_wellness` for a FeatureGrid on /avocado-wellness. That is
+             * a near-deterministic function of the prompt, so the same request asked
+             * twice produces the same id twice, and the second one dies in the ops
+             * engine on "Block id … already exists", taking the whole plan down with
+             * it: a committing apply is all-or-nothing.
+             *
+             * `usedBlockIds` is seeded from the page's existing blocks and knew this
+             * all along. It was consulted only when the model *omitted* an id, which
+             * is the one case that cannot collide; a supplied id went through
+             * untouched and was never even registered, so two ops in one plan could
+             * pick the same name. Uniquify instead — a fourth FeatureGrid is a
+             * legitimate reading of "populate this page", and only the label was
+             * wrong. The engine's own check stays as the backstop and must never be
+             * relaxed into an overwrite.
+             */
+            const suppliedId = typeof block.id === "string" && block.id.length > 0 ? block.id : null;
+            const idStem = suppliedId ?? (typeof block.type === "string" ? `b_${String(block.type).toLowerCase()}_${Date.now()}` : null);
+            if (idStem) {
+                let candidate = idStem;
                 let sfx = 0;
-                while (usedBlockIds.has(fallbackId)) {
+                while (usedBlockIds.has(candidate)) {
                     sfx++;
-                    fallbackId = `b_${String(block.type).toLowerCase()}_${Date.now()}_${sfx}`;
+                    candidate = `${idStem}_${sfx}`;
                 }
-                usedBlockIds.add(fallbackId);
-                block.id = fallbackId;
+                usedBlockIds.add(candidate);
+                if (suppliedId && candidate !== suppliedId)
+                    renamedBlockIds.set(suppliedId, candidate);
+                block.id = candidate;
             }
             raw.block = block;
             // Remap heading→title for non-Hero blocks (LLMs often confuse heading/title)

package/dist/ops/destructive-action-gate.js

@@ -24,12 +24,17 @@ function slugsTouchedByOps(ops) {
             set.add(op.toPageSlug);
             continue;
         }
+        // rename_page: one page, under two names. Counting both slugs made every
+        // rename look like a cross-page plan and held it for approval — the same
+        // miscount duplicate_page and duplicate_block are special-cased for above.
+        if (op.op === "rename_page") {
+            set.add(typeof op.newPageSlug === "string" ? op.newPageSlug : op.pageSlug);
+            continue;
+        }
         if ("pageSlug" in op && typeof op.pageSlug === "string")
             set.add(op.pageSlug);
         if (op.op === "duplicate_block" && typeof op.toPageSlug === "string")
             set.add(op.toPageSlug);
-        if (op.op === "rename_page" && typeof op.newPageSlug === "string")
-            set.add(op.newPageSlug);
     }
     return Array.from(set);
 }

package/dist/ops/ops-engine.d.ts

@@ -22,7 +22,18 @@ export declare function isNoEffectiveChangeError(reason: string): boolean;
  */
 export declare function isAlreadyCurrentError(reason: string): boolean;
 export declare function classifyGuardrailError(reason: string): GuardrailErrorCategory;
-export declare function formatValidationError(reason: string): string;
+/**
+ * `category` is the one the failure was actually thrown with, for callers that
+ * still hold it. Without it this falls back to reading the category back out of
+ * the message, which is a guess — see `isRepairEligibleCategory`.
+ */
+export declare function formatValidationError(reason: string, category?: GuardrailErrorCategory): string;
+/**
+ * The deterministic repair pass exists for plans that are structurally wrong
+ * but fixable — a bad prop name, an id that clashes. Anything else is either
+ * hopeless or not the planner's fault, and re-prompting it wastes a model call.
+ */
+export declare function isRepairEligibleCategory(category: GuardrailErrorCategory): category is "schema_violation";
 export declare function isDeterministicRepairEligible(reason: string): boolean;
 /**
  * Extracts structured fields from a planner schema_violation reason so the

package/dist/ops/ops-engine.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { blockSchemas, operationSchema, validateBlockProps, findManifestSchemaIssue, isChrome, isInBlockCatalogue, catalogueBlockTypes, mapSemanticThemeTokens, generateItemId, isRichTextDoc, fromMarkdown, mergeRichTextDoc } from "@avocadostudio-ai/shared";
+import { blockSchemas, operationSchema, validateBlockProps, findManifestSchemaIssue, isChrome, getMediaFields, isInBlockCatalogue, catalogueBlockTypes, mapSemanticThemeTokens, generateItemId, isRichTextDoc, fromMarkdown, mergeRichTextDoc } from "@avocadostudio-ai/shared";
 import { normalizeRouteCandidate } from "../nlp/intent-helpers.js";
 import { pageIdFromSlug, pageTitleFromSlug } from "../nlp/plan-normalizer.js";
 import { OperationError, toErrorDetail as _unifiedToErrorDetail } from "../errors.js";
@@ -88,7 +88,17 @@ function remapRouteReference(value, fromSlug, toSlug) {
     }
     return value;
 }
-function rewriteRouteLinksInValue(input, fromSlug, toSlug) {
+/**
+ * Rewrite every route reference under `input` from `fromSlug` to `toSlug`.
+ *
+ * The walk is permissive by design — it remaps any string that starts with the
+ * old slug, whatever prop holds it — because a custom block ships no field
+ * metadata and its links still have to survive a rename. `mediaKeys` is the one
+ * exception: props that address a *resource* rather than a page. Renaming
+ * `/pricing` to `/plans` does not move `/pricing/demo.mp4`, and before this the
+ * walker rewrote that path too, quietly breaking the asset.
+ */
+function rewriteRouteLinksInValue(input, fromSlug, toSlug, mediaKeys) {
     if (typeof input === "string") {
         const mapped = remapRouteReference(input, fromSlug, toSlug);
         return { value: mapped, changed: mapped !== input };
@@ -96,7 +106,7 @@ function rewriteRouteLinksInValue(input, fromSlug, toSlug) {
     if (Array.isArray(input)) {
         let changed = false;
         const next = input.map((item) => {
-            const mapped = rewriteRouteLinksInValue(item, fromSlug, toSlug);
+            const mapped = rewriteRouteLinksInValue(item, fromSlug, toSlug, mediaKeys);
             if (mapped.changed)
                 changed = true;
             return mapped.value;
@@ -109,11 +119,8 @@ function rewriteRouteLinksInValue(input, fromSlug, toSlug) {
     let changed = false;
     const next = {};
     for (const [key, value] of Object.entries(source)) {
-        if (typeof value === "string" && key.toLowerCase().includes("href")) {
-            const mapped = remapRouteReference(value, fromSlug, toSlug);
-            if (mapped !== value)
-                changed = true;
-            next[key] = mapped;
+        if (mediaKeys.has(key)) {
+            next[key] = value;
             continue;
         }
         if (typeof value === "string" && key === "body") {
@@ -128,7 +135,7 @@ function rewriteRouteLinksInValue(input, fromSlug, toSlug) {
             next[key] = rewritten;
             continue;
         }
-        const mapped = rewriteRouteLinksInValue(value, fromSlug, toSlug);
+        const mapped = rewriteRouteLinksInValue(value, fromSlug, toSlug, mediaKeys);
         if (mapped.changed)
             changed = true;
         next[key] = mapped.value;
@@ -138,7 +145,7 @@ function rewriteRouteLinksInValue(input, fromSlug, toSlug) {
 function rewriteLinksToRenamedPage(page, fromSlug, toSlug) {
     let changed = false;
     const nextBlocks = page.blocks.map((block) => {
-        const mapped = rewriteRouteLinksInValue(block.props, fromSlug, toSlug);
+        const mapped = rewriteRouteLinksInValue(block.props, fromSlug, toSlug, getMediaFields(block.type));
         if (!mapped.changed)
             return block;
         changed = true;
@@ -208,16 +215,36 @@ export function classifyGuardrailError(reason) {
         lower.includes("required") ||
         lower.includes("unknown props") ||
         lower.includes("out of range") ||
-        lower.includes("must be")) {
+        lower.includes("must be") ||
+        // Every "already exists" this engine raises — a duplicate block id, a page
+        // slug that is taken — it raises *as* a schema_violation. This list did not
+        // know the word, so a plan one renamed id away from applying classified as
+        // `internal_error`, which the repair pass refuses to touch. Callers holding
+        // the thrown error should prefer its `category` over this function; the
+        // keyword is here for the paths that only ever had the string.
+        lower.includes("already exists")) {
         return "schema_violation";
     }
     return "internal_error";
 }
-export function formatValidationError(reason) {
-    return `${classifyGuardrailError(reason)}: ${reason}`;
+/**
+ * `category` is the one the failure was actually thrown with, for callers that
+ * still hold it. Without it this falls back to reading the category back out of
+ * the message, which is a guess — see `isRepairEligibleCategory`.
+ */
+export function formatValidationError(reason, category) {
+    return `${category ?? classifyGuardrailError(reason)}: ${reason}`;
+}
+/**
+ * The deterministic repair pass exists for plans that are structurally wrong
+ * but fixable — a bad prop name, an id that clashes. Anything else is either
+ * hopeless or not the planner's fault, and re-prompting it wastes a model call.
+ */
+export function isRepairEligibleCategory(category) {
+    return category === "schema_violation";
 }
 export function isDeterministicRepairEligible(reason) {
-    return classifyGuardrailError(reason) === "schema_violation";
+    return isRepairEligibleCategory(classifyGuardrailError(reason));
 }
 /**
  * Extracts structured fields from a planner schema_violation reason so the

package/dist/publish/publish-target-registry.js

@@ -10,7 +10,7 @@ import { DeployHookPublishTarget } from "./targets/deploy-hook.js";
  * handling requests:
  *
  * ```ts
- * import { registerPublishTarget } from "./publish/publish-target-registry.js"
+ * import { registerPublishTarget } from "@avocadostudio-ai/orchestrator-core"
  * registerPublishTarget(new S3PublishTarget())
  * ```
  *

package/dist/publish/publish-target.d.ts

@@ -6,7 +6,7 @@ import type { PublishTracker } from "../state/session-state.ts";
  * up writing content. Built-ins cover git + Vercel, a site-contract POST, and
  * a raw Vercel deploy hook. Third parties (S3, GitLab Pages, custom CI, etc.)
  * implement {@link PublishTarget} and register via
- * {@link registerPublishTarget} from `./publish-target-registry.js`.
+ * {@link registerPublishTarget} from `@avocadostudio-ai/orchestrator-core`.
  *
  * The route handler's job shrinks to: build {@link PublishContext}, call
  * {@link selectPublishTarget}, invoke `target.publish(ctx)`, save the returned

package/dist/state/session-state.js

@@ -3,6 +3,7 @@ import { dirname, resolve } from "node:path";
 import { demoPublishedPages, demoSiteConfig, ensureItemIds, IMAGE_PLACEHOLDER } from "@avocadostudio-ai/shared";
 import { toErrorDetail as _unifiedToErrorDetail } from "../errors.js";
 import { archiveMigratedJson, getStore, notePersistenceFailure, notePersistenceSuccess, readLegacyJson, resolveDbFile, resolveJsonMigrationTtlDays, sweepStaleMigrations, } from "./sqlite-store-singleton.js";
+import { discardPendingProposalsForSession, sweepExpiredProposals } from "../durable/durable-store-singleton.js";
 // Re-exported so callers that already depend on this module for state can ask
 // whether that state is actually being kept, without a second import path.
 export { persistenceHealth, persistenceWarning } from "./sqlite-store-singleton.js";
@@ -173,6 +174,9 @@ export function forgetSession(sessionKey) {
     pendingClarificationBySession.delete(sessionKey);
     chatHistoryBySession.delete(sessionKey);
     pendingApprovalPlanBySession.delete(sessionKey);
+    // Session ids are caller-supplied and routinely reused, so a pending proposal
+    // left behind here would rehydrate into the *next* session with this id.
+    discardPendingProposalsForSession(sessionKey);
     imageSourcePreferenceBySession.delete(sessionKey);
     publishStatusBySession.delete(sessionKey);
     capabilitiesBySession.delete(sessionKey);
@@ -1091,12 +1095,15 @@ const EPHEMERAL_MAP_CAP = 500; // max entries for maps without timestamps
  */
 export function evictStaleEphemeralMaps() {
     const now = Date.now();
-    // pendingApprovalPlanBySession: has createdAt — evict by age
+    // pendingApprovalPlanBySession: has createdAt — evict by age. The durable
+    // mirror carries the same TTL as `expiresAt`, so both halves age out together
+    // rather than the Map forgetting a plan the store would hand straight back.
     for (const [key, plan] of pendingApprovalPlanBySession) {
         if (now - new Date(plan.createdAt).getTime() > APPROVAL_PLAN_TTL_MS) {
             pendingApprovalPlanBySession.delete(key);
         }
     }
+    sweepExpiredProposals();
     // publishStatusBySession: has updatedAt — evict by age
     for (const [key, tracker] of publishStatusBySession) {
         if (now - new Date(tracker.updatedAt).getTime() > PUBLISH_STATUS_TTL_MS) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avocadostudio-ai/orchestrator-core",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
@@ -23,8 +23,8 @@
     "openai": "^4.87.1",
     "sharp": "^0.34.5",
     "zod": "^4.3.6",
-    "@avocadostudio-ai/migration-sdk": "^0.3.2",
-    "@avocadostudio-ai/shared": "^0.3.2"
+    "@avocadostudio-ai/shared": "^0.3.3",
+    "@avocadostudio-ai/migration-sdk": "^0.3.3"
   },
   "devDependencies": {
     "@google/genai": "^1.46.0",