drupal-mcp-connector 2.21.0 → 2.23.0

package/.agents/commands/drupal-create-translation.md

@@ -1,11 +1,11 @@
 ---
-description: "Create a translation as an unpublished non-default draft (governed write). Adds the target language beside the default language; it does not PATCH langcode on the canonical entity. When an English working draft already exists, both live and working revision IDs are sent (If-Match) so Sentinel will add the language on that draft (#282). English live title, body, status, alias, default revision, and paragraph ERR pins stay unchanged. An existing translation is a conflict, not an overwrite. The response includes `_revisions.live` / `_revisions.working` when known. Computed `metatag` is omitted on the draft body because JSON:API resolves it from the live default (#283); use field_metatags. Continue a node draft with drupal_update_node and langcode; a paragraph with drupal_update_paragraph and langcode; media with drupal_update_media and langcode. Image alt is a relationship (same file UUID, meta.alt) — on media that is field_media_image, not a node image field. For paragraphs pass revisionId as the host pin. Requires Sentinel's draft-translation endpoint. Publication stays denied for content-tier callers."
-argument-hint: "<type> <id> <langcode> [site] [entityType] [attributes] [relationships] [revisionId] [dryRun]"
+description: "Create a translation as an unpublished non-default draft (governed write). Adds the target language beside the default language; it does not PATCH langcode on the canonical entity. When an English working draft already exists, both live and working revision IDs are sent (If-Match) so Sentinel will add the language on that draft (#282). English live title, body, status, alias, default revision, and paragraph ERR pins stay unchanged. An existing translation is a conflict, not an overwrite. Pass revise: true to open an unpublished draft over a language that is already published on the live revision and has no working copy (Sentinel X-MCP-Draft-Mode: revise). That requires MCP Sentinel 2.24.0 or later; an older host is refused before any write and the message names that version. dryRun uses the same translations endpoint and Sentinel's non-saving preflight. A working copy is refused. Paragraph revise is not supported. The response includes `_revisions.live` / `_revisions.working` when known. Computed `metatag` is omitted on the draft body because JSON:API resolves it from the live default (#283); use field_metatags. Continue a node draft with drupal_update_node and langcode; a paragraph with drupal_update_paragraph and langcode; media with drupal_update_media and langcode. Image alt is a relationship (same file UUID, meta.alt) — on media that is field_media_image, not a node image field. For paragraphs pass revisionId as the host pin. Requires Sentinel's draft-translation endpoint. Publication stays denied for content-tier callers."
+argument-hint: "<type> <id> <langcode> [site] [entityType] [attributes] [relationships] [revisionId] [dryRun] [revise]"
 ---
 
 Call the MCP tool `drupal_create_translation`.
 
-Create a translation as an unpublished non-default draft (governed write). Adds the target language beside the default language; it does not PATCH langcode on the canonical entity. When an English working draft already exists, both live and working revision IDs are sent (If-Match) so Sentinel will add the language on that draft (#282). English live title, body, status, alias, default revision, and paragraph ERR pins stay unchanged. An existing translation is a conflict, not an overwrite. The response includes `_revisions.live` / `_revisions.working` when known. Computed `metatag` is omitted on the draft body because JSON:API resolves it from the live default (#283); use field_metatags. Continue a node draft with drupal_update_node and langcode; a paragraph with drupal_update_paragraph and langcode; media with drupal_update_media and langcode. Image alt is a relationship (same file UUID, meta.alt) — on media that is field_media_image, not a node image field. For paragraphs pass revisionId as the host pin. Requires Sentinel's draft-translation endpoint. Publication stays denied for content-tier callers.
+Create a translation as an unpublished non-default draft (governed write). Adds the target language beside the default language; it does not PATCH langcode on the canonical entity. When an English working draft already exists, both live and working revision IDs are sent (If-Match) so Sentinel will add the language on that draft (#282). English live title, body, status, alias, default revision, and paragraph ERR pins stay unchanged. An existing translation is a conflict, not an overwrite. Pass revise: true to open an unpublished draft over a language that is already published on the live revision and has no working copy (Sentinel X-MCP-Draft-Mode: revise). That requires MCP Sentinel 2.24.0 or later; an older host is refused before any write and the message names that version. dryRun uses the same translations endpoint and Sentinel's non-saving preflight. A working copy is refused. Paragraph revise is not supported. The response includes `_revisions.live` / `_revisions.working` when known. Computed `metatag` is omitted on the draft body because JSON:API resolves it from the live default (#283); use field_metatags. Continue a node draft with drupal_update_node and langcode; a paragraph with drupal_update_paragraph and langcode; media with drupal_update_media and langcode. Image alt is a relationship (same file UUID, meta.alt) — on media that is field_media_image, not a node image field. For paragraphs pass revisionId as the host pin. Requires Sentinel's draft-translation endpoint. Publication stays denied for content-tier callers.
 
 Parse the arguments supplied with this command into this tool's parameters:
 
@@ -20,6 +20,7 @@ Parse the arguments supplied with this command into this tool's parameters:
 - `attributes` (object (pass as JSON)): Translated field values keyed by Drupal machine name
 - `relationships` (object (pass as JSON)): JSON:API relationships. Use for image alt (same file UUID, meta.alt).
 - `revisionId` (string): Paragraph revision id the host already pins. Required for Home-shaped non-default pins.
-- `dryRun` (boolean (true/false)): Validate without saving. Sentinel's non-saving translation preflight receives the real fields, applies them through field access and validates the entity. The result's `checks` block says what was checked.
+- `dryRun` (boolean (true/false)): Validate without saving. Sentinel's non-saving translation preflight receives the real fields, applies them through field access and validates the entity. The result's `checks` block says what was checked. With revise: true the preflight is the same translations endpoint.
+- `revise` (boolean (true/false)): Open an unpublished draft over a translation that is already published on the live default revision and has no working copy. Requires MCP Sentinel 2.24.0 or later. Omit it to create a language that does not exist yet.
 
 If a required parameter is missing, ask before calling — do not invent values. Coerce each value to its JSON type (booleans → true/false, numbers → numeric, object/array → parse JSON), then make the single tool call and summarize the result.

package/.agents/commands/drupal-update-media.md

@@ -1,11 +1,11 @@
 ---
-description: "Update a media entity's name, status, or field values. Partial: omitted fields (status included) are left untouched. Pass langcode to continue an unpublished working translation via Sentinel; this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first."
+description: "Update a media entity's name, status, or field values. Partial: omitted fields (status included) are left untouched. Pass langcode to continue an unpublished working translation via Sentinel; this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. A published translation with no working copy is opened with drupal_create_translation and revise: true, not with this tool."
 argument-hint: "<type> <id> [site] [name] [status] [fields] [langcode]"
 ---
 
 Call the MCP tool `drupal_update_media`.
 
-Update a media entity's name, status, or field values. Partial: omitted fields (status included) are left untouched. Pass langcode to continue an unpublished working translation via Sentinel; this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first.
+Update a media entity's name, status, or field values. Partial: omitted fields (status included) are left untouched. Pass langcode to continue an unpublished working translation via Sentinel; this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. A published translation with no working copy is opened with drupal_create_translation and revise: true, not with this tool.
 
 Parse the arguments supplied with this command into this tool's parameters:
 

package/.agents/commands/drupal-update-node.md

@@ -1,11 +1,11 @@
 ---
-description: "Update an existing node. Only include fields you want to change. For moderated content types, use moderationState (e.g. 'published') rather than status. When the target is published and moderated and you omit moderationState, the connector defaults the write to moderation_state 'draft' (forward revision) so live default revisions are not mutated by accident. Pass langcode to continue an unpublished working translation (Sentinel X-MCP-Draft-Langcode); this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. Entity-reference fields go in `relationships`, not `fields`. Paragraph / ERR identifiers are resolved to include meta.target_revision_id before PATCH; the write fails if any ref cannot be resolved (an unresolved identifier persists as an empty field). On moderated targets a non-saving PATCH preflight runs first — including on dryRun — against the same URL the write will hit. Existing node drafts use Sentinel's governed draft endpoint with verified live/working revision preconditions; translation-only drafts are discovered through Sentinel inventory (#297). Pass explicit langcode to continue an unpublished translation. Published languages are not converted into drafts; dryRun uses the same target. workingCopy:null from drupal_list_revisions is not proof the node is writable (possiblyPatchBlocked / #201). Preflight here does not un-orphan paragraphs already created; probe the host before creating dependents. A dryRun that returns without a refusal is not proof the write will succeed: field access and entity validation are checked only when Sentinel's draft endpoint ran, and the result's `checks` block says which checks ran."
+description: "Update an existing node. Only include fields you want to change. For moderated content types, use moderationState (e.g. 'published') rather than status. When the target is published and moderated and you omit moderationState, the connector defaults the write to moderation_state 'draft' (forward revision) so live default revisions are not mutated by accident. Pass langcode to continue an unpublished working translation (Sentinel X-MCP-Draft-Langcode); this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. A language that is already published and has no working copy is not continued here: call drupal_create_translation with revise: true. Entity-reference fields go in `relationships`, not `fields`. Paragraph / ERR identifiers are resolved to include meta.target_revision_id before PATCH; the write fails if any ref cannot be resolved (an unresolved identifier persists as an empty field). On moderated targets a non-saving PATCH preflight runs first — including on dryRun — against the same URL the write will hit. Existing node drafts use Sentinel's governed draft endpoint with verified live/working revision preconditions; translation-only drafts are discovered through Sentinel inventory (#297). Pass explicit langcode to continue an unpublished translation. A published language with no working copy is not converted into a draft by this tool; use drupal_create_translation with revise: true. dryRun uses the same target. workingCopy:null from drupal_list_revisions is not proof the node is writable (possiblyPatchBlocked / #201). Preflight here does not un-orphan paragraphs already created; probe the host before creating dependents. A dryRun that returns without a refusal is not proof the write will succeed: field access and entity validation are checked only when Sentinel's draft endpoint ran, and the result's `checks` block says which checks ran."
 argument-hint: "<type> <id> [site] [title] [body] [summary] [format] [status] [moderationState] [langcode] [fields] [relationships] [dryRun] [returning]"
 ---
 
 Call the MCP tool `drupal_update_node`.
 
-Update an existing node. Only include fields you want to change. For moderated content types, use moderationState (e.g. 'published') rather than status. When the target is published and moderated and you omit moderationState, the connector defaults the write to moderation_state 'draft' (forward revision) so live default revisions are not mutated by accident. Pass langcode to continue an unpublished working translation (Sentinel X-MCP-Draft-Langcode); this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. Entity-reference fields go in `relationships`, not `fields`. Paragraph / ERR identifiers are resolved to include meta.target_revision_id before PATCH; the write fails if any ref cannot be resolved (an unresolved identifier persists as an empty field). On moderated targets a non-saving PATCH preflight runs first — including on dryRun — against the same URL the write will hit. Existing node drafts use Sentinel's governed draft endpoint with verified live/working revision preconditions; translation-only drafts are discovered through Sentinel inventory (#297). Pass explicit langcode to continue an unpublished translation. Published languages are not converted into drafts; dryRun uses the same target. workingCopy:null from drupal_list_revisions is not proof the node is writable (possiblyPatchBlocked / #201). Preflight here does not un-orphan paragraphs already created; probe the host before creating dependents. A dryRun that returns without a refusal is not proof the write will succeed: field access and entity validation are checked only when Sentinel's draft endpoint ran, and the result's `checks` block says which checks ran.
+Update an existing node. Only include fields you want to change. For moderated content types, use moderationState (e.g. 'published') rather than status. When the target is published and moderated and you omit moderationState, the connector defaults the write to moderation_state 'draft' (forward revision) so live default revisions are not mutated by accident. Pass langcode to continue an unpublished working translation (Sentinel X-MCP-Draft-Langcode); this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. A language that is already published and has no working copy is not continued here: call drupal_create_translation with revise: true. Entity-reference fields go in `relationships`, not `fields`. Paragraph / ERR identifiers are resolved to include meta.target_revision_id before PATCH; the write fails if any ref cannot be resolved (an unresolved identifier persists as an empty field). On moderated targets a non-saving PATCH preflight runs first — including on dryRun — against the same URL the write will hit. Existing node drafts use Sentinel's governed draft endpoint with verified live/working revision preconditions; translation-only drafts are discovered through Sentinel inventory (#297). Pass explicit langcode to continue an unpublished translation. A published language with no working copy is not converted into a draft by this tool; use drupal_create_translation with revise: true. dryRun uses the same target. workingCopy:null from drupal_list_revisions is not proof the node is writable (possiblyPatchBlocked / #201). Preflight here does not un-orphan paragraphs already created; probe the host before creating dependents. A dryRun that returns without a refusal is not proof the write will succeed: field access and entity validation are checked only when Sentinel's draft endpoint ran, and the result's `checks` block says which checks ran.
 
 Parse the arguments supplied with this command into this tool's parameters:
 

package/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.23.0] - 2026-09-23
+
+### Added
+- **Revise a published translation (#376).** `drupal_create_translation` accepts
+  `revise: true` to open an unpublished draft over a language that is already
+  published on the live revision and has no working copy. The call uses
+  Sentinel's translations endpoint and `X-MCP-Draft-Mode: revise`, including
+  on `dryRun`. A host that does not advertise `revise_published_translation`
+  is refused before any write; the message names MCP Sentinel 2.24.0.
+  `drupal_update_node` and `drupal_update_media` with `langcode` name that
+  flag instead of sending the caller to a create that is certain to 409.
+  A plain create that hits the existing-language 409 says to pass `revise: true`
+  when the language is published and there is no working copy, and to continue
+  with the update tool when an unpublished working translation already exists.
+
+## [2.22.0] - 2026-09-20
+
+### Added
+- **Remote Drupal workflow prompts (#371).** The module-workflow loader fetches
+  `prompts/list` and `prompts/get` from `serverTools.url` (contrib `mcp_server`
+  `McpPromptConfig` entities) and merges them into the v1 path. A remote
+  workflow is listed only when local `serverTools.modules.workflows` names it
+  and every `{tool:alias}` is already in `serverTools.modules.tools`. Local
+  bodies remain the fallback when the catalog omits an enabled id. Write
+  workflows still require `mcp_write` and append that module writes are not
+  retried. See `docs/module-workflows.md`.
+
 ## [2.21.0] - 2026-09-19
 
 ### Added

package/README.md

@@ -88,7 +88,7 @@ See **[docs/architecture.md](docs/architecture.md)** for the backend abstraction
 | **Fields** | Describe a bundle's fields (type/required/cardinality, best-effort) |
 | **References** | Resolve a human name/title to an entity UUID for relationship fields |
 | **Bulk** | Bulk create/update with per-item partial-failure reporting |
-| **Translations** | List + create entity translations |
+| **Translations** | List, create, and revise published entity translations (`revise: true` on `drupal_create_translation`, MCP Sentinel 2.24.0+) |
 | **Paragraphs** | Create/update/get Paragraph components for embedding in host fields |
 | **Structure** | Menu links (list/create/update, incl. `parent` + `enabled`) + custom blocks (list/create) |
 | **Redirects** | Create active URL redirects (301/302) + update/repoint existing redirects (Redirect module) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drupal-mcp-connector",
-  "version": "2.21.0",
+  "version": "2.23.0",
   "description": "Drupal MCP Connector — multi-site MCP server for Drupal with JSON:API and GraphQL, governed writes, draft translations, content tools, audit reports, and an SSH Drush bridge.",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -64,7 +64,7 @@ import {
   loadWorkflows,
   toPromptDescriptor,
   renderWorkflowMessages,
-  moduleWorkflowProviders,
+  moduleWorkflowProvidersWithRemote,
   registerBuiltinWorkflows,
   replaceModuleWorkflows,
 } from "./lib/workflow-prompts.js";
@@ -231,8 +231,11 @@ const buildConnectorServer = createConnectorServerFactory({
     workflowNames: WORKFLOW_PROMPT_NAMES,
     workflowMessages: getPromptMessages,
     definitionsByName,
-    extraWorkflows: (tools, taken) => {
-      const loaded = loadWorkflows(moduleWorkflowProviders(listResolvableSiteConfigs()), { tools, taken });
+    extraWorkflows: async (tools, taken) => {
+      const loaded = loadWorkflows(
+        await moduleWorkflowProvidersWithRemote(listResolvableSiteConfigs()),
+        { tools, taken },
+      );
       replaceModuleWorkflows(loaded);
       return loaded;
     },

package/src/lib/patch-preflight.js

@@ -261,6 +261,11 @@ export async function resolveWorkingCopyPatchTarget(backend, { entityType, bundl
         return { resourceVersion: `id:${workingVid}`, workingCopy: null,
           liveVid, workingVid, inventory };
       }
+      if (!workingCopy) {
+        return {
+          resourceVersion: undefined, workingCopy: null, liveVid, workingVid: null, inventory,
+        };
+      }
     }
   }
   if (!workingCopy) {
@@ -425,14 +430,32 @@ export async function prepareGuardedPatch(backend, {
       throw new StaleCopyError();
     }
   }
-  if (target.inventory) assertInventoryDraftLanguage(target.inventory, langcode);
+  if (!langcode && target.inventory) assertInventoryDraftLanguage(target.inventory, langcode);
   if (langcode) {
-    if (!target.workingVid || !target.liveVid || String(target.workingVid) === String(target.liveVid)) {
+    const noWorking = !target.workingVid || !target.liveVid
+      || String(target.workingVid) === String(target.liveVid);
+    if (noWorking) {
+      const liveRow = (target.inventory?.live?.translations ?? [])
+        .find((row) => row?.langcode === langcode);
+      if (liveRow && liveRow.status === true) {
+        if (langcode === target.inventory?.defaultLangcode || liveRow.default === true) {
+          throw new Error(
+            "The default language is not opened with drupal_create_translation. " +
+            "Omit langcode to draft it. A canonical langcode PATCH is not attempted."
+          );
+        }
+        throw new Error(
+          "This language is published on the live revision and has no working copy. " +
+          "Revise it with drupal_create_translation and revise: true. " +
+          "A canonical langcode PATCH is not attempted."
+        );
+      }
       throw new Error(
         "No unpublished working translation for this language. " +
         "Create it with drupal_create_translation first; a canonical langcode PATCH is not attempted."
       );
     }
+    if (target.inventory) assertInventoryDraftLanguage(target.inventory, langcode);
     target.draftRevision = { liveVid: target.liveVid, workingVid: target.workingVid };
     try {
       await writeDraft(backend, {

package/src/lib/sentinel-draft.js

@@ -21,6 +21,36 @@ const MISSING_TRANSLATION_ENDPOINT =
 const MISSING_DRAFT_RE = /does not provide Sentinel's governed draft endpoint/;
 const MISSING_TRANSLATION_RE = /does not provide Sentinel's governed draft-translation endpoint/;
 
+/** Inventory operation that opens a draft over a published translation. */
+export const REVISE_PUBLISHED_TRANSLATION = "revise_published_translation";
+
+/**
+ * First MCP Sentinel release that honors `X-MCP-Draft-Mode: revise`.
+ * Older hosts keep the create 409 and have no path in between.
+ */
+export const MIN_SENTINEL_REVISE_VERSION = "2.24.0";
+
+/**
+ * Whether a translation inventory advertises published-translation revise.
+ * Absent on Sentinel releases before 2.24.0.
+ * @param {object} [meta] Inventory `meta`, or an object with `operations`.
+ * @returns {boolean}
+ */
+export function supportsRevisePublishedTranslation(meta) {
+  return Array.isArray(meta?.operations) && meta.operations.includes(REVISE_PUBLISHED_TRANSLATION);
+}
+
+/**
+ * Refusal when the host cannot revise a published translation.
+ * @returns {Error}
+ */
+export function reviseCapabilityError() {
+  return new Error(
+    `This Sentinel host cannot revise a published translation (missing ${REVISE_PUBLISHED_TRANSLATION}). ` +
+    `Update MCP Sentinel to ${MIN_SENTINEL_REVISE_VERSION} or later. No write was attempted.`,
+  );
+}
+
 /**
  * Whether a backend can issue Sentinel's JSON:API draft/translation routes.
  * Requires `capabilities().sentinelDraft` when that flag is present.
@@ -212,6 +242,7 @@ export async function writeDraft(backend, input, preflight = false) {
  */
 export async function createTranslationDraft(backend, input, preflight = false) {
   const { entityType, bundle, id, attributes = {}, relationships, draftRevision } = input;
+  const revise = input.revise === true;
   const langcode = assertDraftLangcode(input.langcode);
   if (entityType === "paragraph") {
     return createParagraphTranslationDraft(backend, {
@@ -234,6 +265,12 @@ export async function createTranslationDraft(backend, input, preflight = false)
   const data = { type: `${entityType}--${bundle}`, id, attributes: safeAttributes };
   if (relationships) data.relationships = relationships;
   const ifMatch = working ? `"${live}:${working}"` : `"${live}"`;
+  const headers = {
+    "If-Match": ifMatch,
+    "X-MCP-Draft-Preflight": preflight ? "1" : "0",
+    "X-MCP-Draft-Langcode": langcode,
+  };
+  if (revise) headers["X-MCP-Draft-Mode"] = "revise";
   let result;
   try {
     result = await sentinelDraftRequest(backend, {
@@ -241,11 +278,7 @@ export async function createTranslationDraft(backend, input, preflight = false)
       missingMessage: MISSING_TRANSLATION_ENDPOINT,
       options: {
         method: "POST",
-        headers: {
-          "If-Match": ifMatch,
-          "X-MCP-Draft-Preflight": preflight ? "1" : "0",
-          "X-MCP-Draft-Langcode": langcode,
-        },
+        headers,
         body: JSON.stringify({ data }),
       },
     });
@@ -256,6 +289,9 @@ export async function createTranslationDraft(backend, input, preflight = false)
     if (result?.meta?.draft_preflight !== true || String(result.meta.live) !== live) {
       throw new Error("The site did not confirm a non-saving translation preflight. Refusing to continue.");
     }
+    if (revise && result.meta.operation !== REVISE_PUBLISHED_TRANSLATION) {
+      throw reviseCapabilityError();
+    }
     return result;
   }
   if (!result?.data || result.data.id !== id || result.data.type !== data.type) {
@@ -274,7 +310,7 @@ export async function createTranslationDraft(backend, input, preflight = false)
  * alias. Permission, 5xx, and malformed inventory are not absence — they throw.
  * @param {object} backend
  * @param {{entityType: string, bundle: string, id: string, existing?: ?object}} ref
- * @returns {Promise<{liveVid: ?(number|string), workingVid: ?(number|string)}>}
+ * @returns {Promise<{liveVid: ?(number|string), workingVid: ?(number|string), operations: string[], inventory: ?object}>}
  */
 export async function resolveNodeTranslationPair(backend, { entityType, bundle, id, existing }) {
   const fromEntity = existing ? entityRevisionId(existing) : null;
@@ -284,7 +320,7 @@ export async function resolveNodeTranslationPair(backend, { entityType, bundle,
   } catch (error) {
     if (!isMissingTranslationEndpoint(error)) throw error;
     if (typeof backend.getEntity !== "function") {
-      return { liveVid: fromEntity, workingVid: undefined };
+      return { liveVid: fromEntity, workingVid: undefined, operations: [], inventory: null };
     }
     let workingCopy = null;
     try {
@@ -296,14 +332,71 @@ export async function resolveNodeTranslationPair(backend, { entityType, bundle,
     }
     const workingVid = workingCopy ? entityRevisionId(workingCopy) : null;
     const distinct = workingVid !== null && fromEntity !== null && String(workingVid) !== String(fromEntity);
-    return { liveVid: fromEntity, workingVid: distinct ? workingVid : undefined };
+    return {
+      liveVid: fromEntity,
+      workingVid: distinct ? workingVid : undefined,
+      operations: [],
+      inventory: null,
+    };
   }
   const liveVid = meta.live?.vid ?? fromEntity;
   const workingVid = meta.working?.vid;
   const distinct = workingVid !== undefined && workingVid !== null && workingVid !== ""
     && liveVid !== undefined && liveVid !== null
     && String(workingVid) !== String(liveVid);
-  return { liveVid, workingVid: distinct ? workingVid : undefined };
+  return {
+    liveVid,
+    workingVid: distinct ? workingVid : undefined,
+    operations: Array.isArray(meta.operations) ? meta.operations : [],
+    inventory: meta,
+  };
+}
+
+/**
+ * Turn Sentinel's create-conflict 409 into the next step that can succeed.
+ * Revise on a host that still says "already exists" did not honor the mode.
+ * @param {unknown} error
+ * @param {{revise?: boolean, inventory?: object|null, langcode?: string, entityType?: string}} [context]
+ * @returns {Error}
+ */
+export function explainExistingTranslation(error, { revise = false, inventory = null, langcode, entityType = "node" } = {}) {
+  const current = error instanceof Error ? error : new Error(String(error));
+  // The create conflict only. "A working copy already exists" is a different 409.
+  if (!/translation for this language already exists/i.test(current.message)) return current;
+  if (revise) {
+    return new Error(
+      "Sentinel did not revise the published translation; it still reports that the language already exists. " +
+      `Update MCP Sentinel to ${MIN_SENTINEL_REVISE_VERSION} or later. No draft was opened.`,
+      { cause: current },
+    );
+  }
+  const continuer = entityType === "media"
+    ? "drupal_update_media"
+    : entityType === "paragraph"
+      ? "drupal_update_paragraph"
+      : "drupal_update_node";
+  const liveRow = (inventory?.live?.translations ?? []).find((row) => row?.langcode === langcode);
+  const workingDistinct = inventory?.working?.vid && inventory?.live?.vid
+    && String(inventory.working.vid) !== String(inventory.live.vid);
+  const workingRow = (inventory?.working?.translations ?? []).find((row) => row?.langcode === langcode);
+  const defaultLang = inventory?.defaultLangcode;
+  if (liveRow && liveRow.status === true && !workingDistinct && langcode !== defaultLang && liveRow.default !== true) {
+    return new Error(
+      "A published translation for this language already exists and there is no working copy. " +
+      "Pass revise: true to drupal_create_translation to open an unpublished draft over it. " +
+      `${continuer} cannot open that draft.`,
+      { cause: current },
+    );
+  }
+  if (workingDistinct && workingRow && workingRow.status === false) {
+    return new Error(
+      "An unpublished working translation for this language already exists. " +
+      `Continue it with ${continuer} and langcode. ` +
+      "Do not create it again.",
+      { cause: current },
+    );
+  }
+  return current;
 }
 
 /**

package/src/lib/server-tools.js

@@ -13,7 +13,8 @@
  * call site performs the MCP session handshake — `initialize` (read the
  * `Mcp-Session-Id` response header) → `notifications/initialized` → `tools/call`
  * carrying that session id. The session is cached per site and transparently
- * re-initialised when the server expires it.
+ * re-initialised when the server expires it. `prompts/list` and `prompts/get`
+ * reuse the same session.
  *
  * Config (per site):
  *   "serverTools": { "url": "/mcp" }   // path is resolved against site.baseUrl
@@ -333,7 +334,7 @@ async function initializeSession(site, endpoint, key) {
     method: "initialize",
     params: {
       protocolVersion: MCP_PROTOCOL_VERSION,
-      capabilities: {},
+      capabilities: { prompts: {} },
       clientInfo: { name: CLIENT_NAME, version: CLIENT_VERSION },
     },
   };
@@ -442,6 +443,74 @@ export async function listServerTools(site, cursor) {
   });
 }
 
+/** Fetch one page of Drupal `McpPromptConfig` prompts. */
+export async function listServerPrompts(site, cursor) {
+  return requestServerTool(site, "prompts/list", cursor === undefined ? {} : { cursor }, {
+    maxBytes: SERVER_TOOL_MAX_BYTES, preserveErrors: true,
+  });
+}
+
+/**
+ * Fetch one Drupal prompt body. Pass no arguments so `{{token}}` placeholders
+ * stay intact for the connector's workflow renderer.
+ */
+export async function getServerPrompt(site, name) {
+  return requestServerTool(site, "prompts/get", { name, arguments: {} }, {
+    maxBytes: SERVER_TOOL_MAX_BYTES, preserveErrors: true,
+  });
+}
+
+/**
+ * Page `prompts/list` the same way as `tools/list`.
+ * @param {object} site Resolved site config.
+ * @param {Function} [list] Catalog page reader.
+ * @returns {Promise<object[]>} Prompt descriptors.
+ */
+export async function advertisedServerPrompts(site, list = listServerPrompts) {
+  const prompts = [];
+  const seen = new Set();
+  let cursor;
+  for (let page = 0; page < MAX_CATALOG_PAGES; page++) {
+    const result = await list(site, cursor);
+    if (!Array.isArray(result?.prompts)) {
+      throw new Error(`Server-tool catalog for site "${site._name}" is malformed: prompts/list returned no prompts array.`);
+    }
+    for (const prompt of result.prompts) {
+      if (prompt && typeof prompt.name === "string") prompts.push(prompt);
+    }
+    if (result.nextCursor === undefined || result.nextCursor === null) return prompts;
+    if (typeof result.nextCursor !== "string" || seen.has(result.nextCursor)) {
+      throw new Error(`Server-tool catalog for site "${site._name}" returned an invalid or repeated prompts cursor.`);
+    }
+    cursor = result.nextCursor;
+    seen.add(cursor);
+  }
+  throw new Error(`Server-tool catalog for site "${site._name}" exceeds ${MAX_CATALOG_PAGES} prompt pages.`);
+}
+
+/**
+ * Load listed prompt descriptors plus `prompts/get` bodies for the named ids.
+ * A get failure omits that id; the caller fail-closes rather than widening.
+ * @param {object} site Resolved site config.
+ * @param {string[]} names Workflow ids to fetch.
+ * @param {{list?: Function, get?: Function}} [deps]
+ * @returns {Promise<{list: object[], bodies: Map<string, object>}>}
+ */
+export async function fetchSiteWorkflowPrompts(site, names, { list = listServerPrompts, get = getServerPrompt } = {}) {
+  const listed = await advertisedServerPrompts(site, list);
+  const want = new Set(names ?? []);
+  const bodies = new Map();
+  for (const prompt of listed) {
+    if (!want.has(prompt.name)) continue;
+    try {
+      bodies.set(prompt.name, await get(site, prompt.name));
+    } catch {
+      // Fail closed for this id: no body, so the merge will not list it.
+    }
+  }
+  return { list: listed, bodies };
+}
+
 /** Shared bounded MCP request transport; size + abort are always attached. */
 async function requestServerTool(site, method, params, options) {
   const toolName = params.name ?? method;

package/src/lib/tool-prompts.js

@@ -239,7 +239,7 @@ export function getToolPromptMessages(promptName, args = {}, definitionsByName)
  * @param {Set<string>} options.workflowNames - Names of the hand-authored workflow prompts.
  * @param {(name: string, args: object) => Array<object>} options.workflowMessages
  * @param {Map<string,object>} options.definitionsByName - Built-in tool name → definition.
- * @param {(tools: Array<object>, taken: Set<string>) => object[]} [options.extraWorkflows]
+ * @param {(tools: Array<object>, taken: Set<string>) => object[]|Promise<object[]>} [options.extraWorkflows]
  *   Module-owned workflows visible for this request. Each item has name,
  *   description, arguments, and is renderable by extraWorkflowMessages.
  * @param {(workflow: object, args: object) => Array<object>} [options.extraWorkflowMessages]
@@ -256,7 +256,7 @@ export function createPromptSurface({
   async function visible() {
     const tools = await discover();
     const taken = new Set(staticPrompts.map((prompt) => prompt.name));
-    const extra = extraWorkflows ? extraWorkflows(tools, taken) : [];
+    const extra = extraWorkflows ? await extraWorkflows(tools, taken) : [];
     for (const workflow of extra) taken.add(workflow.name);
     // A reserved module name cannot match a built-in, but never let a remote
     // catalog shadow a static prompt if that invariant is ever broken.

package/src/lib/workflow-prompts.js

@@ -265,6 +265,148 @@ export function renderWorkflowMessages(workflow, args = {}) {
   return [{ role: "user", content: { type: "text", text } }];
 }
 
+/**
+ * Unique `{tool:alias}` names in instruction text, first-seen order.
+ *
+ * @param {string} instructions
+ * @returns {string[]}
+ */
+export function toolAliasesInInstructions(instructions) {
+  const aliases = [];
+  const seen = new Set();
+  for (const match of String(instructions ?? "").matchAll(/\{tool:([a-z][a-z0-9_]{0,47})\}/g)) {
+    if (seen.has(match[1])) continue;
+    seen.add(match[1]);
+    aliases.push(match[1]);
+  }
+  return aliases;
+}
+
+/**
+ * Join user-role text from a Drupal `prompts/get` result.
+ *
+ * @param {object} got
+ * @returns {string}
+ */
+export function instructionTextFromDrupalPrompt(got) {
+  const messages = Array.isArray(got?.messages) ? got.messages : [];
+  const parts = [];
+  for (const message of messages) {
+    if (message?.role !== "user") continue;
+    const content = message.content;
+    if (typeof content?.text === "string") {
+      parts.push(content.text);
+      continue;
+    }
+    if (Array.isArray(content)) {
+      for (const item of content) {
+        if (item?.type === "text" && typeof item.text === "string") parts.push(item.text);
+      }
+    }
+  }
+  return parts.join("\n").replace(/\{\{\s*([a-z][a-z0-9_]{0,47})\s*\}\}/g, "{arg:$1}");
+}
+
+/**
+ * `readOnly` is false when any named alias is a local write or delete.
+ *
+ * @param {string[]} aliases
+ * @param {object} toolsMap `serverTools.modules.tools`
+ * @returns {boolean}
+ */
+export function inferReadOnly(aliases, toolsMap) {
+  for (const alias of aliases) {
+    const operation = toolsMap?.[alias]?.operation;
+    if (operation === "write" || operation === "delete") return false;
+  }
+  return true;
+}
+
+/**
+ * Map a Drupal prompt list item + get body onto the v1 workflow definition.
+ * Returns null when the prompt cannot be a workflow (no `{tool:alias}`, an
+ * alias missing from the local tools map, or an unusable description).
+ *
+ * @param {string} id
+ * @param {object} listed
+ * @param {object} got
+ * @param {object} toolsMap
+ * @returns {object|null}
+ */
+export function workflowFromDrupalPrompt(id, listed, got, toolsMap) {
+  const instructions = instructionTextFromDrupalPrompt(got);
+  if (!instructions.trim()) return null;
+  const tools = toolAliasesInInstructions(instructions);
+  if (tools.length < 1) return null;
+  for (const alias of tools) {
+    if (!toolsMap?.[alias] || typeof toolsMap[alias] !== "object") return null;
+  }
+  const rawArgs = Array.isArray(listed?.arguments) ? listed.arguments : [];
+  const arguments_ = rawArgs.map((arg) => ({
+    name: arg?.name ?? arg?.machine_name,
+    description: arg?.description ?? "",
+    required: Boolean(arg?.required),
+  }));
+  const description = String(listed?.description ?? got?.description ?? "").trim() || "Module workflow.";
+  return {
+    id,
+    description,
+    readOnly: inferReadOnly(tools, toolsMap),
+    tools,
+    arguments: arguments_,
+    instructions,
+  };
+}
+
+/**
+ * Provider from site `serverTools.modules.workflows` maps, optionally merged
+ * with Drupal `prompts/list` + `prompts/get`. Local keys enable; remote bodies
+ * replace a local body when the catalog returns that id. A remote prompt that
+ * is not named locally is ignored. Fetch failures keep the v1 local bodies.
+ *
+ * @param {Array<object>} sites
+ * @param {{fetch?: Function}} [deps]
+ * @returns {Promise<object[]>}
+ */
+export async function moduleWorkflowProvidersWithRemote(sites, { fetch } = {}) {
+  const { fetchSiteWorkflowPrompts } = await import("./server-tools.js");
+  const load = fetch ?? fetchSiteWorkflowPrompts;
+  const providers = [];
+  for (const site of sites ?? []) {
+    const modules = site.serverTools?.modules;
+    if (!modules?.namespace || !modules.workflows || typeof modules.workflows !== "object") continue;
+    const enabled = [];
+    for (const [id, body] of Object.entries(modules.workflows)) {
+      if (id.startsWith("_") || !body || typeof body !== "object") continue;
+      enabled.push({ id: body.id ?? id, body });
+    }
+    let catalog;
+    try {
+      catalog = await load(site, enabled.map((item) => item.id));
+    } catch {
+      catalog = { list: [], bodies: new Map() };
+    }
+    const listedByName = new Map((catalog.list ?? []).map((prompt) => [prompt.name, prompt]));
+    const workflows = [];
+    for (const item of enabled) {
+      const listed = listedByName.get(item.id);
+      const got = catalog.bodies?.get(item.id);
+      if (listed && got) {
+        const mapped = workflowFromDrupalPrompt(item.id, listed, got, modules.tools ?? {});
+        if (mapped) workflows.push(mapped);
+        continue;
+      }
+      workflows.push({ ...item.body, id: item.id });
+    }
+    providers.push({
+      id: `config:${modules.namespace}`,
+      namespace: modules.namespace,
+      workflows,
+    });
+  }
+  return providers;
+}
+
 /**
  * Provider from site `serverTools.modules.workflows` maps.
  *

package/src/tools/media.js

@@ -319,7 +319,7 @@ export const definitions = [
   },
   {
     name: "drupal_update_media",
-    description: "Update a media entity's name, status, or field values. Partial: omitted fields (status included) are left untouched. Pass langcode to continue an unpublished working translation via Sentinel; this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first.",
+    description: "Update a media entity's name, status, or field values. Partial: omitted fields (status included) are left untouched. Pass langcode to continue an unpublished working translation via Sentinel; this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. A published translation with no working copy is opened with drupal_create_translation and revise: true, not with this tool.",
     inputSchema: {
       type: "object", required: ["type", "id"],
       properties: {

package/src/tools/nodes.js

@@ -644,7 +644,7 @@ export const definitions = [
   },
   {
     name: "drupal_update_node",
-    description: "Update an existing node. Only include fields you want to change. For moderated content types, use moderationState (e.g. 'published') rather than status. When the target is published and moderated and you omit moderationState, the connector defaults the write to moderation_state 'draft' (forward revision) so live default revisions are not mutated by accident. Pass langcode to continue an unpublished working translation (Sentinel X-MCP-Draft-Langcode); this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. Entity-reference fields go in `relationships`, not `fields`. Paragraph / ERR identifiers are resolved to include meta.target_revision_id before PATCH; the write fails if any ref cannot be resolved (an unresolved identifier persists as an empty field). On moderated targets a non-saving PATCH preflight runs first — including on dryRun — against the same URL the write will hit. Existing node drafts use Sentinel's governed draft endpoint with verified live/working revision preconditions; translation-only drafts are discovered through Sentinel inventory (#297). Pass explicit langcode to continue an unpublished translation. Published languages are not converted into drafts; dryRun uses the same target. workingCopy:null from drupal_list_revisions is not proof the node is writable (possiblyPatchBlocked / #201). Preflight here does not un-orphan paragraphs already created; probe the host before creating dependents. A dryRun that returns without a refusal is not proof the write will succeed: field access and entity validation are checked only when Sentinel's draft endpoint ran, and the result's `checks` block says which checks ran.",
+    description: "Update an existing node. Only include fields you want to change. For moderated content types, use moderationState (e.g. 'published') rather than status. When the target is published and moderated and you omit moderationState, the connector defaults the write to moderation_state 'draft' (forward revision) so live default revisions are not mutated by accident. Pass langcode to continue an unpublished working translation (Sentinel X-MCP-Draft-Langcode); this does not PATCH canonical langcode and will not create a missing translation — use drupal_create_translation first. A language that is already published and has no working copy is not continued here: call drupal_create_translation with revise: true. Entity-reference fields go in `relationships`, not `fields`. Paragraph / ERR identifiers are resolved to include meta.target_revision_id before PATCH; the write fails if any ref cannot be resolved (an unresolved identifier persists as an empty field). On moderated targets a non-saving PATCH preflight runs first — including on dryRun — against the same URL the write will hit. Existing node drafts use Sentinel's governed draft endpoint with verified live/working revision preconditions; translation-only drafts are discovered through Sentinel inventory (#297). Pass explicit langcode to continue an unpublished translation. A published language with no working copy is not converted into a draft by this tool; use drupal_create_translation with revise: true. dryRun uses the same target. workingCopy:null from drupal_list_revisions is not proof the node is writable (possiblyPatchBlocked / #201). Preflight here does not un-orphan paragraphs already created; probe the host before creating dependents. A dryRun that returns without a refusal is not proof the write will succeed: field access and entity validation are checked only when Sentinel's draft endpoint ran, and the result's `checks` block says which checks ran.",
     inputSchema: {
       type: "object", required: ["type", "id"],
       properties: {

package/src/tools/translations.js

@@ -34,9 +34,13 @@ import { paragraphRevisionId } from "../lib/err-relationships.js";
 import {
   assertDraftLangcode,
   createTranslationDraft,
+  explainExistingTranslation,
   isMissingTranslationEndpoint,
+  MIN_SENTINEL_REVISE_VERSION,
   readTranslationInventory,
   resolveNodeTranslationPair,
+  reviseCapabilityError,
+  supportsRevisePublishedTranslation,
   supportsSentinelDraft,
 } from "../lib/sentinel-draft.js";
 import { mapTranslationRow } from "../lib/translation-rows.js";
@@ -123,7 +127,7 @@ async function listTranslations({ site: siteName, entityType = "node", type, id
  */
 async function createTranslation({
   site: siteName, entityType = "node", type, id, langcode, attributes = {},
-  relationships, revisionId, dryRun = false,
+  relationships, revisionId, dryRun = false, revise = false,
 }) {
   validateMachineName(entityType, "entityType");
   validateMachineName(type, "type");
@@ -137,6 +141,12 @@ async function createTranslation({
   if (entityType !== "node" && entityType !== "paragraph" && entityType !== "media") {
     throw new Error("Governed translation create is implemented for nodes, paragraphs, and media.");
   }
+  if (revise && entityType === "paragraph") {
+    throw new Error(
+      "Revising a published paragraph translation is not supported. " +
+      "Paragraph draft writes continue an unpublished translation on the pinned revision only.",
+    );
+  }
 
   const backend = await resolveBackend(site);
   const existing = await backend.getEntity({ entityType, bundle: type, id });
@@ -158,6 +168,18 @@ async function createTranslation({
     draftRevision = await resolveNodeTranslationPair(backend, {
       entityType, bundle: type, id, existing,
     });
+    if (revise) {
+      if (!supportsRevisePublishedTranslation(draftRevision)) {
+        throw reviseCapabilityError();
+      }
+      if (draftRevision.workingVid) {
+        const continuer = entityType === "media" ? "drupal_update_media" : "drupal_update_node";
+        throw new Error(
+          "A working copy already exists. Continue that draft with " +
+          `${continuer} and langcode. Revise was not attempted.`,
+        );
+      }
+    }
     if (entityType === "node") {
       if (drafted.status === undefined && drafted.moderation_state === undefined) {
         drafted.moderation_state = "draft";
@@ -169,22 +191,46 @@ async function createTranslation({
     assertPublishAllowed(sec, drafted);
   }
 
+  const draftInput = {
+    entityType, bundle: type, id, langcode: targetLang, attributes: drafted, relationships, draftRevision,
+    revise: revise === true,
+  };
   if (dryRun) {
-    await createTranslationDraft(backend, {
-      entityType, bundle: type, id, langcode: targetLang, attributes: drafted, relationships, draftRevision,
-    }, true);
+    try {
+      await createTranslationDraft(backend, draftInput, true);
+    } catch (error) {
+      throw explainExistingTranslation(error, {
+        revise: revise === true,
+        inventory: draftRevision.inventory,
+        langcode: targetLang,
+        entityType,
+      });
+    }
     return {
-      dryRun: true, operation: "create_translation", entityType, bundle: type, id,
-      langcode: targetLang, attributes: drafted, ...(relationships ? { relationships } : {}),
+      dryRun: true,
+      operation: revise ? "revise_translation" : "create_translation",
+      entityType, bundle: type, id,
+      langcode: targetLang,
+      ...(revise ? { revise: true } : {}),
+      attributes: drafted,
+      ...(relationships ? { relationships } : {}),
       // createTranslationDraft throws unless the site confirmed a non-saving
       // preflight of this exact payload, so the claim holds when we get here.
-      ...dryRunChecks({ operation: "create_translation", preflight: PREFLIGHT_SENTINEL_DRAFT }),
+      ...dryRunChecks({ operation: revise ? "revise_translation" : "create_translation", preflight: PREFLIGHT_SENTINEL_DRAFT }),
     };
   }
 
-  const created = await createTranslationDraft(backend, {
-    entityType, bundle: type, id, langcode: targetLang, attributes: drafted, relationships, draftRevision,
-  });
+  let created;
+  try {
+    created = await createTranslationDraft(backend, draftInput);
+  } catch (error) {
+    throw explainExistingTranslation(error, {
+      revise: revise === true,
+      inventory: draftRevision.inventory,
+      langcode: targetLang,
+      entityType,
+    });
+  }
   const redacted = omitLiveComputedMetatag(redactCanonicalEntity(created, sec, entityType));
   if (entityType === "paragraph") return redacted;
   const workingVid = entityRevisionId(created) ?? draftRevision.workingVid;
@@ -229,6 +275,12 @@ export const definitions = [
       "working revision IDs are sent (If-Match) so Sentinel will add the language on that " +
       "draft (#282). English live title, body, status, alias, default revision, and " +
       "paragraph ERR pins stay unchanged. An existing translation is a conflict, not an overwrite. " +
+      "Pass revise: true to open an unpublished draft over a language that is already published " +
+      "on the live revision and has no working copy (Sentinel X-MCP-Draft-Mode: revise). " +
+      `That requires MCP Sentinel ${MIN_SENTINEL_REVISE_VERSION} or later; an older host is refused ` +
+      "before any write and the message names that version. dryRun uses the same translations " +
+      "endpoint and Sentinel's non-saving preflight. A working copy is refused. " +
+      "Paragraph revise is not supported. " +
       "The response includes `_revisions.live` / `_revisions.working` when known. " +
       "Computed `metatag` is omitted on the draft body because JSON:API resolves it from the live default (#283); use field_metatags. " +
       "Continue a node draft with drupal_update_node and langcode; a paragraph with " +
@@ -248,7 +300,8 @@ export const definitions = [
         attributes:    { type: "object", description: "Translated field values keyed by Drupal machine name" },
         relationships: { type: "object", description: "JSON:API relationships. Use for image alt (same file UUID, meta.alt)." },
         revisionId:    { type: "string", description: "Paragraph revision id the host already pins. Required for Home-shaped non-default pins." },
-        dryRun:        { type: "boolean", description: "Validate without saving. Sentinel's non-saving translation preflight receives the real fields, applies them through field access and validates the entity. The result's `checks` block says what was checked." },
+        dryRun:        { type: "boolean", description: "Validate without saving. Sentinel's non-saving translation preflight receives the real fields, applies them through field access and validates the entity. The result's `checks` block says what was checked. With revise: true the preflight is the same translations endpoint." },
+        revise:        { type: "boolean", description: "Open an unpublished draft over a translation that is already published on the live default revision and has no working copy. Requires MCP Sentinel 2.24.0 or later. Omit it to create a language that does not exist yet." },
       },
     },
   },