emdash-emit 0.1.12 → 0.1.14

package/dist/sync/push.js

@@ -31,11 +31,11 @@ import { classifyCodeFenceLines } from '../client/portable-text.js';
 import { computeArticleRelativePath, extractDatePrefixFromPath, parseMarkdown, serializeMarkdown, } from '../utils/frontmatter.js';
 import { loadLocalTaxonomyMaps, loadLocalTaxonomyCandidates } from './taxonomies.js';
 import { runPreflightChecks } from './preflight.js';
-import { calculateHash, CONFLICTS_SUBDIR, isQuarantinedRelativePath } from './pull.js';
+import { calculateHash, CONFLICTS_SUBDIR, isQuarantinedRelativePath, quarantineLocalCopy, } from './pull.js';
 import { hybrid3WayMerge } from './merge.js';
 import { syncRemoteBylines } from './bylines.js';
 import { updateConfigSyncedVersion } from '../utils/config.js';
-import { fetchAssignedTaxonomies } from './terms.js';
+import { fetchAssignedTaxonomies, computeTaxonomyHash } from './terms.js';
 import { fetchRemoteMediaDetail, resolveImageMimeType, toRootRelativeMediaUrl, uploadMediaFile, } from '../client/media.js';
 import { promoteDraftMediaFile } from './media.js';
 export class PushValidationError extends Error {
@@ -359,6 +359,19 @@ async function uploadAndRewriteDraftImages(body, draftImages, options, fetchFn)
     const rewrittenBody = rewriteDraftImagesInBody(body, draftImages, uploadedByAbsPath);
     return { body: rewrittenBody, uploadedByAbsPath };
 }
+function throwRemoteArticleDeleted(collection, id, targetFilePath, endpoint) {
+    throw new ApiError({
+        endpoint,
+        code: 'REMOTE_ARTICLE_DELETED',
+        status: 404,
+        message: `Article ${id} (${targetFilePath}) was deleted on the remote server.`,
+        suggestion: [
+            '1. Keep your edits and re-create as a new article: remove the `id:` field from frontmatter, then "emit push <file>".',
+            `2. Discard local edits and untrack: "emit pull ${id} --force"   (local copy is preserved under posts/conflicts/)`,
+            `3. Delete with rescue backup: "emit delete ${targetFilePath} --discard-local-edits"`,
+        ].join('\n  '),
+    });
+}
 /**
  * Pushes a local markdown article to remote EmDash with full preflight guards,
  * two-tier lock lease protection, and automatic 3-way merge on conflict.
@@ -446,8 +459,7 @@ export async function pushArticle(targetFilePath, options) {
             };
         }
     }
-    // 1. Run Preflight Guards G2 - G11
-    // Guard against blind re-push when article is marked delete_pending (unconfirmed remote deletion)
+    // 1. Guard against blind re-push when article is marked delete_pending (G16)
     if (syncState?.deletePending === 1 && !options.revive && !options.force) {
         throw new ApiError({
             endpoint: `/_emdash/api/content/${collection}/${id}`,
@@ -457,16 +469,8 @@ export async function pushArticle(targetFilePath, options) {
             suggestion: `To intentionally revive and push this article to remote, pass --revive (or --force): "emit push ${targetFilePath} --revive"`,
         });
     }
-    // Guard against blind re-push when previous taxonomy conflict is still pending
-    if (syncState?.conflictPending === 1 && !options.resolveTaxonomy && !options.force) {
-        throw new ApiError({
-            endpoint: `/_emdash/api/content/${collection}/${id}`,
-            code: 'TAXONOMY_CONFLICT_PENDING',
-            status: 409,
-            message: `Article ${id} (${targetFilePath}) has an unresolved taxonomy conflict from a previous sync.`,
-            suggestion: `Pass --resolve-taxonomy=union|local|remote (or --force) to explicitly resolve and confirm: "emit push ${targetFilePath} --resolve-taxonomy=union"`,
-        });
-    }
+    // 2. Preflight Guards (including G6: UNRESOLVED_CONFLICT_MARKERS)
+    // Evaluated before taxonomy conflict pending so markers in markdown body are caught first
     const preflight = runPreflightChecks(targetFilePath, parsed, {
         allowPublish: options.allowPublish,
         knownTaxonomies,
@@ -480,6 +484,31 @@ export async function pushArticle(targetFilePath, options) {
     }
     // Update parsed with cleaned body (e.g. trimmed duplicate heading)
     parsed.body = preflight.cleanedBody;
+    // 3. Guard against blind re-push when taxonomy conflict is still pending (G15)
+    const isTaxConflictPending = syncState?.taxonomyConflictPending !== undefined
+        ? syncState.taxonomyConflictPending === 1
+        : syncState?.conflictPending === 1 && (syncState?.bodyConflictPending ?? 0) === 0;
+    if (isTaxConflictPending && !options.resolveTaxonomy && !options.force) {
+        throw new ApiError({
+            endpoint: `/_emdash/api/content/${collection}/${id}`,
+            code: 'TAXONOMY_CONFLICT_PENDING',
+            status: 409,
+            message: `Article ${id} (${targetFilePath}) has an unresolved taxonomy conflict from a previous sync.`,
+            suggestion: `Pass --resolve-taxonomy=union|local|remote (or --force) to explicitly resolve and confirm: "emit push ${targetFilePath} --resolve-taxonomy=union"`,
+        });
+    }
+    // 4. Guard against blind re-push when previous taxonomy update failed (G17)
+    if (syncState?.taxonomyApplyPending === 1 &&
+        !options.allowUnappliedTaxonomies &&
+        !options.force) {
+        throw new ApiError({
+            endpoint: `/_emdash/api/content/${collection}/${id}`,
+            code: 'TAXONOMY_APPLY_PENDING',
+            status: 409,
+            message: `Article ${id} (${targetFilePath}) has an unconfirmed taxonomy assignment from a previous failed update.`,
+            suggestion: `Run "emit pull-taxonomies" to synchronize taxonomy definitions, then re-push (or pass --allow-unapplied-taxonomies / --force).`,
+        });
+    }
     const currentRev = syncState?.remoteRev || baseSnapshot?.rev || '';
     const warnings = [...preflight.warnings];
     // Load local bylines map for converting frontmatter byline slugs to ULIDs
@@ -508,8 +537,9 @@ export async function pushArticle(targetFilePath, options) {
     const isNewArticle = !syncState;
     // Helper to synchronize taxonomy assignments
     const syncArticleTaxonomies = async (articleId) => {
+        const failures = [];
         if (!parsed.frontmatter.taxonomies)
-            return;
+            return failures;
         const taxMaps = taxonomyMaps;
         const updateTaxonomy = async (taxonomyName, termSlugsOrIds) => {
             const slugMap = taxMaps.slugToId[taxonomyName] || {};
@@ -535,7 +565,7 @@ export async function pushArticle(targetFilePath, options) {
                     : null;
                 const prevTerms = taxonomyName === 'category' ? baseFm?.taxonomies?.categories : baseFm?.taxonomies?.tags;
                 if (prevTerms && prevTerms.length > 0) {
-                    if (!options.allowWipeTaxonomies && !options.force) {
+                    if (!options.allowWipeTaxonomies && !options.force && !options.resolveTaxonomy) {
                         throw new ApiError({
                             endpoint: `/_emdash/api/content/${collection}/${articleId}/terms/${taxonomyName}`,
                             code: 'DESTRUCTIVE_TAXONOMY_WIPE',
@@ -558,6 +588,12 @@ export async function pushArticle(targetFilePath, options) {
             });
             if (!termRes.ok) {
                 const errBody = await termRes.text().catch(() => '');
+                failures.push({
+                    taxonomy: taxonomyName,
+                    status: termRes.status,
+                    error: errBody || termRes.statusText,
+                    endpoint: termsUrl,
+                });
                 warnings.push(`Failed to update ${taxonomyName} terms: ${termRes.statusText} ${errBody}`);
             }
         };
@@ -567,6 +603,7 @@ export async function pushArticle(targetFilePath, options) {
         if (parsed.frontmatter.taxonomies.tags) {
             await updateTaxonomy('tag', parsed.frontmatter.taxonomies.tags);
         }
+        return failures;
     };
     if (isNewArticle) {
         // [P2-P4] Upload/resolve standalone draft images and rewrite body
@@ -600,7 +637,8 @@ export async function pushArticle(targetFilePath, options) {
         // Update parsed frontmatter with the actual ID returned by EmDash
         parsed.frontmatter.id = actualId;
         // Sync taxonomies for newly created article
-        await syncArticleTaxonomies(actualId);
+        const taxFailures = await syncArticleTaxonomies(actualId);
+        const hasTaxFailures = taxFailures.length > 0;
         const currentPrefix = extractDatePrefixFromPath(fullPath);
         const dateInput = parsed.frontmatter.publishedAt || currentPrefix || createdItem.createdAt || null;
         const newRelPath = computeArticleRelativePath(parsed.frontmatter.collection, parsed.frontmatter.status, actualId, parsed.frontmatter.title || parsed.frontmatter.slug, dateInput);
@@ -625,6 +663,9 @@ export async function pushArticle(targetFilePath, options) {
         }
         // [P6] Promote uploaded draft images from media/drafts/ into media/ and commit media_state
         finalizePromotedDraftImages(preflight.draftImages, uploadedByAbsPath, options, warnings);
+        const finalTaxHash = hasTaxFailures
+            ? null
+            : computeTaxonomyHash(parsed.frontmatter.taxonomies?.categories, parsed.frontmatter.taxonomies?.tags);
         // Update Base snapshot and Sync state
         options.cache.saveBaseSnapshot({
             id: actualId,
@@ -643,8 +684,23 @@ export async function pushArticle(targetFilePath, options) {
             slug: parsed.frontmatter.slug,
             lastSyncedAt: Math.floor(Date.now() / 1000),
             conflictPending: 0,
+            bodyConflictPending: 0,
+            taxonomyConflictPending: 0,
             conflictCopyHash: null,
+            conflictCopyPath: null,
+            conflictAt: null,
+            remoteTaxonomyHash: finalTaxHash,
+            taxonomyApplyPending: hasTaxFailures ? 1 : 0,
         });
+        if (hasTaxFailures) {
+            throw new ApiError({
+                endpoint: taxFailures[0].endpoint,
+                code: 'TAXONOMY_UPDATE_FAILED',
+                status: taxFailures[0].status || 400,
+                message: `Failed to update ${taxFailures.map((f) => f.taxonomy).join(', ')} terms on remote: ${taxFailures.map((f) => f.error).join('; ')}`,
+                suggestion: 'Run "emit pull-taxonomies" to update local definitions, verify taxonomy permissions, and retry push.',
+            });
+        }
         return {
             success: true,
             id: actualId,
@@ -665,14 +721,66 @@ export async function pushArticle(targetFilePath, options) {
         let payload = localToApiPayload(parsed, currentRev, effectiveOptions);
         warnings.push(...preserveOrResolveFeaturedImage(payload, parsed.frontmatter.featuredImage, options.cache, id, options.workspaceRoot));
         const putUrl = new URL(`/_emdash/api/content/${collection}/${id}`, options.origin).toString();
-        let res = await fetchFn(putUrl, {
-            method: 'PUT',
-            headers: {
-                Authorization: `Bearer ${options.token}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(payload),
-        });
+        // R1: Pre-PUT Taxonomy Audit to detect out-of-band remote taxonomy changes
+        let remoteTaxAudit = null;
+        let taxonomyDivergenceDetected = false;
+        const baseFm = baseSnapshot?.frontmatterYaml
+            ? JSON.parse(baseSnapshot.frontmatterYaml)
+            : null;
+        const hasLocalTaxonomies = Boolean(parsed.frontmatter.taxonomies &&
+            (parsed.frontmatter.taxonomies.categories !== undefined ||
+                parsed.frontmatter.taxonomies.tags !== undefined));
+        const hasBaseTaxonomies = Boolean(baseFm?.taxonomies && (baseFm.taxonomies.categories || baseFm.taxonomies.tags));
+        if ((hasLocalTaxonomies || hasBaseTaxonomies) && !options.noTaxonomyAudit) {
+            remoteTaxAudit = await fetchAssignedTaxonomies({
+                origin: options.origin,
+                token: options.token,
+                collection,
+                id,
+                fetchFn,
+            });
+            if (remoteTaxAudit.categories === null && remoteTaxAudit.tags === null) {
+                warnings.push('⚠️ Remote taxonomy state unknown (could not audit remote terms).');
+            }
+            else {
+                if (remoteTaxAudit.categories === null) {
+                    warnings.push('⚠️ Remote category taxonomy state unknown (could not audit categories).');
+                }
+                if (remoteTaxAudit.tags === null) {
+                    warnings.push('⚠️ Remote tag taxonomy state unknown (could not audit tags).');
+                }
+                const baselineTaxHash = syncState?.remoteTaxonomyHash ||
+                    (baseFm?.taxonomies
+                        ? computeTaxonomyHash(baseFm.taxonomies.categories, baseFm.taxonomies.tags)
+                        : null);
+                const currentRemoteCats = remoteTaxAudit.categories !== null
+                    ? remoteTaxAudit.categories
+                    : baseFm?.taxonomies?.categories || [];
+                const currentRemoteTags = remoteTaxAudit.tags !== null ? remoteTaxAudit.tags : baseFm?.taxonomies?.tags || [];
+                const currentRemoteTaxHash = computeTaxonomyHash(currentRemoteCats, currentRemoteTags);
+                if (baselineTaxHash && currentRemoteTaxHash !== baselineTaxHash) {
+                    taxonomyDivergenceDetected = true;
+                }
+            }
+        }
+        let res = taxonomyDivergenceDetected
+            ? {
+                status: 409,
+                ok: false,
+                json: async () => ({ error: { code: 'TAXONOMY_DIVERGENCE' } }),
+                text: async () => '',
+            }
+            : await fetchFn(putUrl, {
+                method: 'PUT',
+                headers: {
+                    Authorization: `Bearer ${options.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+            });
+        if (!taxonomyDivergenceDetected && (res.status === 404 || res.status === 410)) {
+            throwRemoteArticleDeleted(collection, id, targetFilePath, putUrl);
+        }
         // 3. Handle 409 Conflict
         if (res.status === 409) {
             const errJson = (await res.json().catch(() => ({})));
@@ -686,7 +794,7 @@ export async function pushArticle(targetFilePath, options) {
                     suggestion: 'Wait for the other user to finish editing or release their lock before retrying.',
                 });
             }
-            // True revision mismatch conflict: fetch remote latest and run Hybrid 3-Way Merge
+            // True revision mismatch conflict or taxonomy divergence: fetch remote latest and run Hybrid 3-Way Merge
             const getUrl = new URL(`/_emdash/api/content/${collection}/${id}`, options.origin).toString();
             const getRes = await fetchFn(getUrl, {
                 method: 'GET',
@@ -696,6 +804,9 @@ export async function pushArticle(targetFilePath, options) {
                 },
             });
             if (!getRes.ok) {
+                if (getRes.status === 404 || getRes.status === 410) {
+                    throwRemoteArticleDeleted(collection, id, targetFilePath, getUrl);
+                }
                 throw new ApiError({
                     message: `Failed to fetch latest remote version during conflict resolution: ${getRes.statusText}`,
                     code: 'CONFLICT_REMOTE_FETCH_FAILED',
@@ -706,14 +817,15 @@ export async function pushArticle(targetFilePath, options) {
             }
             const remoteItem = (await getRes.json());
             const remoteParsed = apiResponseToLocal(remoteItem, options);
-            // Fetch remote taxonomy assignments because GET /content/{collection}/{id} does not include them!
-            const remoteTax = await fetchAssignedTaxonomies({
-                origin: options.origin,
-                token: options.token,
-                collection,
-                id,
-                fetchFn,
-            });
+            // Fetch remote taxonomy assignments (reuse remoteTaxAudit if available)
+            const remoteTax = remoteTaxAudit ||
+                (await fetchAssignedTaxonomies({
+                    origin: options.origin,
+                    token: options.token,
+                    collection,
+                    id,
+                    fetchFn,
+                }));
             if (!remoteParsed.frontmatter.taxonomies) {
                 remoteParsed.frontmatter.taxonomies = {};
             }
@@ -745,10 +857,14 @@ export async function pushArticle(targetFilePath, options) {
             const mergeResult = hybrid3WayMerge(parsed, baseInfo, {
                 frontmatter: remoteParsed.frontmatter,
                 body: remoteParsed.body,
+            }, {
+                strategy: options.resolveTaxonomy,
             });
             warnings.push(...mergeResult.warnings);
-            // Check destructive taxonomy wipe guard during 3-way merge
-            if (mergeResult.wipeWarnings && mergeResult.wipeWarnings.length > 0) {
+            // Check destructive taxonomy wipe guard during 3-way merge (exempt if strategy is explicitly specified)
+            if (!options.resolveTaxonomy &&
+                mergeResult.wipeWarnings &&
+                mergeResult.wipeWarnings.length > 0) {
                 if (!options.allowWipeTaxonomies && !options.force) {
                     const details = mergeResult.wipeWarnings
                         .map((w) => `${w.name}: clearing ${w.remoteTerms.length} assignment(s)`)
@@ -773,30 +889,35 @@ export async function pushArticle(targetFilePath, options) {
                     warnings.push(`🏷️ Merged remote taxonomy change(s) for ${item.name}: ${parts.join(' ')}`);
                 }
             }
-            // If taxonomy conflict occurred, check if resolveTaxonomy strategy was explicitly provided
-            if (mergeResult.taxonomyConflicts && mergeResult.taxonomyConflicts.length > 0) {
-                if (options.resolveTaxonomy || options.force) {
-                    const strategy = options.resolveTaxonomy || 'union';
-                    if (strategy === 'local') {
-                        mergeResult.frontmatter.taxonomies = parsed.frontmatter.taxonomies;
-                    }
-                    else if (strategy === 'remote') {
-                        mergeResult.frontmatter.taxonomies = remoteParsed.frontmatter.taxonomies;
-                    }
-                    else {
-                        // 'union'
-                        const unionTaxonomies = {};
-                        const allTaxNames = new Set([
-                            ...Object.keys(parsed.frontmatter.taxonomies || {}),
-                            ...Object.keys(remoteParsed.frontmatter.taxonomies || {}),
-                        ]);
-                        for (const tName of allTaxNames) {
-                            const lTerms = parsed.frontmatter.taxonomies?.[tName] || [];
-                            const rTerms = remoteParsed.frontmatter.taxonomies?.[tName] || [];
-                            unionTaxonomies[tName] = Array.from(new Set([...lTerms, ...rTerms]));
-                        }
-                        mergeResult.frontmatter.taxonomies = unionTaxonomies;
+            // Log strategy adoptions
+            if (mergeResult.strategyAdoptions && mergeResult.strategyAdoptions.length > 0) {
+                for (const item of mergeResult.strategyAdoptions) {
+                    const parts = [];
+                    if (item.discardedAdded.length > 0)
+                        parts.push(`+${item.discardedAdded.join(', ')}`);
+                    if (item.discardedRemoved.length > 0)
+                        parts.push(`-${item.discardedRemoved.join(', ')}`);
+                    const discardedStr = parts.length > 0 ? `: discarded ${parts.join(' ')}` : '';
+                    warnings.push(`🏷️ Resolved '${item.name}' with strategy '${item.side}'${discardedStr}.`);
+                }
+            }
+            // Fallback post-merge resolution only if strategy was NOT specified and taxonomy conflicts occurred
+            if (!options.resolveTaxonomy &&
+                mergeResult.taxonomyConflicts &&
+                mergeResult.taxonomyConflicts.length > 0) {
+                if (options.force) {
+                    const strategy = 'union';
+                    const unionTaxonomies = {};
+                    const allTaxNames = new Set([
+                        ...Object.keys(parsed.frontmatter.taxonomies || {}),
+                        ...Object.keys(remoteParsed.frontmatter.taxonomies || {}),
+                    ]);
+                    for (const tName of allTaxNames) {
+                        const lTerms = parsed.frontmatter.taxonomies?.[tName] || [];
+                        const rTerms = remoteParsed.frontmatter.taxonomies?.[tName] || [];
+                        unionTaxonomies[tName] = Array.from(new Set([...lTerms, ...rTerms]));
                     }
+                    mergeResult.frontmatter.taxonomies = unionTaxonomies;
                     warnings.push(`Resolved taxonomy conflicts using strategy '${strategy}'.`);
                 }
                 else {
@@ -805,26 +926,36 @@ export async function pushArticle(targetFilePath, options) {
                 }
             }
             if (mergeResult.hasConflict) {
-                const isTaxonomyOnlyConflict = Boolean(mergeResult.taxonomyConflicts && mergeResult.taxonomyConflicts.length > 0) &&
-                    !mergeResult.body.includes('<<<<<<< local');
+                const isTaxonomyConflict = Boolean(mergeResult.taxonomyConflicts && mergeResult.taxonomyConflicts.length > 0);
+                const hasBodyConflict = Boolean(mergeResult.body.includes('<<<<<<< LOCAL') || mergeResult.body.includes('<<<<<<< local'));
+                const isTaxonomyOnlyConflict = isTaxonomyConflict && !hasBodyConflict;
                 const conflictedMarkdown = serializeMarkdown(mergeResult.frontmatter, mergeResult.body, options.candidates);
+                let quarantineRel = null;
                 // Only write conflict markers into the article body if body actually has conflicts
                 if (!isTaxonomyOnlyConflict) {
+                    const currentDisk = fs.readFileSync(fullPath, 'utf8');
+                    quarantineRel = quarantineLocalCopy(options.workspaceRoot, collection, targetFilePath, currentDisk, { isForce: false });
                     fs.writeFileSync(fullPath, conflictedMarkdown, 'utf8');
                 }
                 const conflictedHash = calculateHash(conflictedMarkdown);
                 // Update sync state:
-                // Do NOT overwrite localHash if taxonomy-only conflict, so `status` continues to report `modified`!
+                // Do NOT overwrite localHash with marker hash, so `status` remains clean when markers are cleaned up!
                 options.cache.saveSyncState({
                     id,
                     localFilePath: targetFilePath,
-                    localHash: isTaxonomyOnlyConflict ? syncState?.localHash || '' : conflictedHash,
+                    localHash: syncState?.localHash || '',
                     remoteRev: remoteParsed.rev,
                     status: parsed.frontmatter.status,
                     slug: parsed.frontmatter.slug,
                     lastSyncedAt: Math.floor(Date.now() / 1000),
                     conflictPending: 1,
+                    bodyConflictPending: hasBodyConflict ? 1 : 0,
+                    taxonomyConflictPending: isTaxonomyConflict ? 1 : 0,
                     conflictCopyHash: conflictedHash,
+                    conflictCopyPath: quarantineRel,
+                    conflictAt: Math.floor(Date.now() / 1000),
+                    remoteTaxonomyHash: computeTaxonomyHash(remoteParsed.frontmatter.taxonomies?.categories, remoteParsed.frontmatter.taxonomies?.tags),
+                    taxonomyApplyPending: 0,
                 });
                 options.cache.saveBaseSnapshot({
                     id,
@@ -858,17 +989,23 @@ export async function pushArticle(targetFilePath, options) {
                 body: JSON.stringify(payload),
             });
             if (!res.ok) {
+                if (res.status === 404 || res.status === 410) {
+                    throwRemoteArticleDeleted(collection, id, targetFilePath, putUrl);
+                }
                 const errText = await res.text().catch(() => '');
-                // Check if server rejected the merged taxonomy union (e.g. single category limit)
+                // Check if server rejected the merged taxonomy union or strategy (e.g. single category limit)
                 if ((res.status === 400 || res.status === 422) &&
-                    mergeResult.autoMergedTaxonomies &&
-                    mergeResult.autoMergedTaxonomies.length > 0) {
+                    ((mergeResult.autoMergedTaxonomies && mergeResult.autoMergedTaxonomies.length > 0) ||
+                        (mergeResult.strategyAdoptions && mergeResult.strategyAdoptions.length > 0))) {
+                    const wasStrategy = mergeResult.strategyAdoptions && mergeResult.strategyAdoptions.length > 0;
                     throw new ApiError({
                         message: `Remote server rejected the merged taxonomy union (HTTP ${res.status}): ${errText || res.statusText}`,
                         code: 'TAXONOMY_UNION_REJECTED',
                         status: res.status,
                         endpoint: putUrl,
-                        suggestion: 'The server may enforce constraints such as a single category per post. Pass --resolve-taxonomy=local or --resolve-taxonomy=remote to choose one side explicitly.',
+                        suggestion: wasStrategy
+                            ? 'The remote server rejected the taxonomy adopted by your strategy (e.g. single-category constraint). Switch strategy with "--resolve-taxonomy=remote" or edit the frontmatter manually before pushing.'
+                            : 'The remote server enforces constraints that reject combining local and remote taxonomy terms (e.g. single-category constraint). Resolve by explicitly choosing a side: "emit push <file> --resolve-taxonomy=local" (or remote), or edit the frontmatter manually.',
                     });
                 }
                 throw new ApiError({
@@ -881,6 +1018,9 @@ export async function pushArticle(targetFilePath, options) {
             }
         }
         if (!res.ok) {
+            if (res.status === 404 || res.status === 410) {
+                throwRemoteArticleDeleted(collection, id, targetFilePath, putUrl);
+            }
             const errText = await res.text().catch(() => '');
             throw new ApiError({
                 message: `Push failed: ${res.statusText}${errText ? ` - ${errText}` : ''}`,
@@ -894,7 +1034,8 @@ export async function pushArticle(targetFilePath, options) {
         const newRev = extractRev(updatedJson, currentRev);
         // 4. Post-push updates & Path tracking
         // Sync taxonomies on updated article
-        await syncArticleTaxonomies(id);
+        const taxFailures = await syncArticleTaxonomies(id);
+        const hasTaxFailures = taxFailures.length > 0;
         const currentPrefix = extractDatePrefixFromPath(fullPath);
         const existingSync = options.cache.getSyncState(parsed.frontmatter.id);
         const dateInput = parsed.frontmatter.publishedAt ||
@@ -932,11 +1073,21 @@ export async function pushArticle(targetFilePath, options) {
         // [P6] Promote uploaded draft images from media/drafts/ into media/ and commit media_state
         finalizePromotedDraftImages(preflight.draftImages, uploadedByAbsPath, options, warnings);
         // Update Base snapshot
+        const savedFrontmatter = { ...parsed.frontmatter };
+        if (hasTaxFailures && baseFm?.taxonomies) {
+            savedFrontmatter.taxonomies = { ...baseFm.taxonomies };
+        }
+        const finalTaxHash = hasTaxFailures
+            ? syncState?.remoteTaxonomyHash ||
+                (baseFm?.taxonomies
+                    ? computeTaxonomyHash(baseFm.taxonomies.categories, baseFm.taxonomies.tags)
+                    : null)
+            : computeTaxonomyHash(parsed.frontmatter.taxonomies?.categories, parsed.frontmatter.taxonomies?.tags);
         options.cache.saveBaseSnapshot({
             id,
             rev: finalRev,
             bodyMarkdown: parsed.body,
-            frontmatterYaml: JSON.stringify(parsed.frontmatter),
+            frontmatterYaml: JSON.stringify(savedFrontmatter),
             hash: newHash,
             savedAt: Math.floor(Date.now() / 1000),
         });
@@ -949,9 +1100,24 @@ export async function pushArticle(targetFilePath, options) {
             status: parsed.frontmatter.status,
             slug: parsed.frontmatter.slug,
             lastSyncedAt: Math.floor(Date.now() / 1000),
-            conflictPending: 0,
-            conflictCopyHash: null,
+            conflictPending: hasTaxFailures ? (syncState?.conflictPending ?? 0) : 0,
+            bodyConflictPending: hasTaxFailures ? (syncState?.bodyConflictPending ?? 0) : 0,
+            taxonomyConflictPending: hasTaxFailures ? (syncState?.taxonomyConflictPending ?? 0) : 0,
+            conflictCopyHash: hasTaxFailures ? syncState?.conflictCopyHash : null,
+            conflictCopyPath: hasTaxFailures ? syncState?.conflictCopyPath : null,
+            conflictAt: hasTaxFailures ? syncState?.conflictAt : null,
+            remoteTaxonomyHash: finalTaxHash,
+            taxonomyApplyPending: hasTaxFailures ? 1 : 0,
         });
+        if (hasTaxFailures) {
+            throw new ApiError({
+                endpoint: taxFailures[0].endpoint,
+                code: 'TAXONOMY_UPDATE_FAILED',
+                status: taxFailures[0].status || 400,
+                message: `Failed to update ${taxFailures.map((f) => f.taxonomy).join(', ')} terms on remote: ${taxFailures.map((f) => f.error).join('; ')}`,
+                suggestion: 'Run "emit pull-taxonomies" to update local definitions, verify taxonomy permissions, and retry push.',
+            });
+        }
         updateConfigSyncedVersion(options.workspaceRoot);
         return {
             success: true,