@waron97/prbot 3.2.1 → 3.3.0

package/src/agrippa/commands/initPhase.js

@@ -100,27 +100,26 @@ async function initPhase() {
         return;
     }
 
-    const phase = await search({
-        message: 'Select a phase:',
-        source: (input) => {
-            const filtered = input ? phases.filter((p) => fuzzyMatch(p.name, input)) : phases;
-            return filtered.map((p) => ({ name: p.name, value: p }));
+    const { selectedPhases } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedPhases',
+            message: 'Select phases to initialize:',
+            choices: phases.map((p) => ({ name: p.name, value: p })),
+            loop: false,
         },
-    });
+    ]);
 
-    // Resolve result objects — API may return IDs or full objects
-    let results = phase.allowed_phase_result_ids || [];
-    if (results.length > 0 && typeof results[0] === 'number') {
-        results = await getPhaseResults(token, ripUrl, results);
+    if (!selectedPhases.length) {
+        console.log('No phases selected. Aborted.');
+        return;
     }
 
-    const code = generateCode(results);
-
     const { confirm } = await inquirer.prompt([
         {
             type: 'confirm',
             name: 'confirm',
-            message: `Initialize phase "${phase.name}"? This will overwrite existing code.`,
+            message: `Initialize ${selectedPhases.length} phase(s)? This will overwrite existing code.`,
             default: true,
         },
     ]);
@@ -130,29 +129,40 @@ async function initPhase() {
         return;
     }
 
-    // Delete existing configurator records for this phase
-    const existing = await getPhaseConfigurators(token, ripUrl, phase.id);
-    for (const cfg of existing) {
-        await deleteConfigurator(token, ripUrl, cfg.id);
+    for (const phase of selectedPhases) {
+        // Resolve result objects — API may return IDs or full objects
+        let results = phase.allowed_phase_result_ids || [];
+        if (results.length > 0 && typeof results[0] === 'number') {
+            results = await getPhaseResults(token, ripUrl, results);
+        }
+
+        const code = generateCode(results);
+
+        // Delete existing configurator records for this phase
+        const existing = await getPhaseConfigurators(token, ripUrl, phase.id);
+        for (const cfg of existing) {
+            await deleteConfigurator(token, ripUrl, cfg.id);
+        }
+
+        // Update phase code + set_result_automatically
+        await initPhaseRemote(token, ripUrl, phase.id, code);
+
+        // Create new configurator records for each result
+        const vars = results.map((_, i) => `RES${i + 1}`);
+        for (let i = 0; i < results.length; i++) {
+            await createConfigurator(token, ripUrl, {
+                result_value: vars[i],
+                code_phase_id: phase.id,
+                triplet_phase_result_id: results[i].id,
+            });
+        }
+
+        console.log(`Initialized phase "${phase.name}".`);
+        if (results.length > 0) {
+            console.log(`  ${results.length} configurator(s) created: ${vars.join(', ')}`);
+        }
     }
 
-    // Update phase code + set_result_automatically
-    await initPhaseRemote(token, ripUrl, phase.id, code);
-
-    // Create new configurator records for each result
-    const vars = results.map((_, i) => `RES${i + 1}`);
-    for (let i = 0; i < results.length; i++) {
-        await createConfigurator(token, ripUrl, {
-            result_value: vars[i],
-            code_phase_id: phase.id,
-            triplet_phase_result_id: results[i].id,
-        });
-    }
-
-    console.log(`Initialized phase "${phase.name}".`);
-    if (results.length > 0) {
-        console.log(`  ${results.length} configurator(s) created: ${vars.join(', ')}`);
-    }
     console.log(
         `Run 'agrippa pull' in workspaces that track this workflow to fetch the updated code.`
     );

package/src/agrippa/commands/pb.js

@@ -37,32 +37,49 @@ import { projectReader } from '../lib/pbWorkspace.js';
 
 // ---------- project resolution ----------
 
-async function resolveProjectPath(opts) {
+// Resolves against both process-builder wizards and long-running processes —
+// `structure.yaml`-level editing is identical for both (see pbEdit.js). PBs
+// select by --pb/--name matched against document_id; LRPs have no document_id
+// so the same flag matches against name instead.
+async function resolveProjectEntry(opts) {
     const config = readConfig();
-    const entries = (config.workspace || []).filter((e) => e.object_type === 'process_builder');
+    const entries = (config.workspace || []).filter(
+        (e) => e.object_type === 'process_builder' || e.object_type === 'long_running_process'
+    );
     if (!entries.length) {
         throw new Error(
-            'No process-builder wizards in this workspace. Clone one with `agrippa clone --pb`.'
+            'No process-builder wizards or long-running processes in this workspace. ' +
+                'Clone one with `agrippa clone --pb` or `agrippa clone --lrp`.'
         );
     }
     const sel = opts.pb || opts.name;
     if (sel) {
-        const entry = entries.find((e) => e.document_id === sel);
-        if (!entry) throw new Error(`No cloned wizard with document_id "${sel}"`);
-        return entry.path;
+        const entry = entries.find((e) => e.document_id === sel || e.name === sel);
+        if (!entry) throw new Error(`No cloned project with document_id/name "${sel}"`);
+        return entry;
     }
-    if (entries.length === 1) return entries[0].path;
+    if (entries.length === 1) return entries[0];
     const entry = await search({
-        message: 'Select a cloned wizard:',
+        message: 'Select a cloned project:',
         source: (input) => {
             const list = input
                 ? entries.filter(
-                      (e) => fuzzyMatch(e.name, input) || fuzzyMatch(e.document_id, input)
+                      (e) =>
+                          fuzzyMatch(e.name, input) ||
+                          (e.document_id && fuzzyMatch(e.document_id, input))
                   )
                 : entries;
-            return list.map((e) => ({ name: `${e.name}  (${e.document_id})`, value: e }));
+            return list.map((e) => ({
+                name: e.document_id ? `${e.name}  (${e.document_id})` : e.name,
+                value: e,
+            }));
         },
     });
+    return entry;
+}
+
+async function resolveProjectPath(opts) {
+    const entry = await resolveProjectEntry(opts);
     return entry.path;
 }
 
@@ -135,14 +152,20 @@ async function pbFormat(opts) {
 async function pbAdd(opts) {
     if (!opts.type)
         throw new Error(
-            '--type is required (e.g. scriptTask, serviceTask, userTask, exclusiveGateway, subProcess, endEvent...)'
+            '--type is required (e.g. scriptTask, serviceTask, userTask, exclusiveGateway, subProcess, endEvent, callActivity...)'
         );
     if ((opts.from || opts.to) && !(opts.from && opts.to))
         throw new Error('--from and --to must be used together');
     if (opts.from && opts.parent)
         throw new Error('--parent is implied by --from/--to; pass only one');
 
-    const dir = await resolveProjectPath(opts);
+    const projectEntry = await resolveProjectEntry(opts);
+    if (opts.type === 'userTask' && projectEntry.object_type === 'long_running_process') {
+        throw new Error(
+            'userTask is not valid on a long-running process — LRPs have no pages (user tasks are a process-builder-only concept).'
+        );
+    }
+    const dir = projectEntry.path;
     const { structure, manifest } = loadProject(dir);
     const ctx = { existingScripts: listScriptFiles(dir), documentId: manifest.document_id };
 
@@ -288,4 +311,14 @@ async function pbLint(opts) {
     }
 }
 
-export { pbFormat, pbAdd, pbRemove, pbConnect, pbDisconnect, pbSetDefault, pbList, pbPreview, pbLint };
+export {
+    pbFormat,
+    pbAdd,
+    pbRemove,
+    pbConnect,
+    pbDisconnect,
+    pbSetDefault,
+    pbList,
+    pbPreview,
+    pbLint,
+};

package/src/agrippa/commands/pull.js

@@ -4,6 +4,7 @@ import { getToken } from '../../lib/auth.js';
 import { describeWorkflow, getPhasesByIds, getPhasesByWorkflow, listMfas } from '../lib/api.js';
 import { computeChecksum } from '../lib/checksum.js';
 import { loadEffectiveEnv, readConfig, writeConfig } from '../lib/config.js';
+import { fetchUpstream } from '../lib/lrpApi.js';
 import { getProcess } from '../lib/pbApi.js';
 import { localChecksum, remoteChecksumPb } from '../lib/pbProject.js';
 import { projectReader } from '../lib/pbWorkspace.js';
@@ -14,6 +15,7 @@ import {
     writeCodeFile,
     writeWorkflowDoc,
 } from '../lib/workspace.js';
+import { pullLrpEntry } from './pullLrp.js';
 import { pullPbEntry } from './pullPb.js';
 
 async function pull() {
@@ -50,9 +52,11 @@ async function pull() {
     const changedWorkflowIds = new Set();
 
     // ── pull existing tracked entries ─────────────────────────────────────────
-    // process_builder wizards are refreshed separately (different checksum model);
-    // see pullPbEntries below.
-    const pullable = config.workspace.filter((e) => e.object_type !== 'process_builder');
+    // process_builder wizards and LRPs are refreshed separately (different
+    // checksum/identity model); see pullPbEntries/pullLrpEntries below.
+    const pullable = config.workspace.filter(
+        (e) => e.object_type !== 'process_builder' && e.object_type !== 'long_running_process'
+    );
     if (pullable.length) {
         console.log('Fetching remote code...');
         const remoteCodeMap = await fetchRemoteCode(token, ripUrl, pullable);
@@ -111,6 +115,9 @@ async function pull() {
     // ── refresh tracked process-builder wizards ───────────────────────────────
     await pullPbEntries(token, config);
 
+    // ── refresh tracked long-running processes ────────────────────────────────
+    await pullLrpEntries(token, config);
+
     // ── discover new phases on tracked workflows ──────────────────────────────
     await discoverNewPhases(token, ripUrl, config, changedWorkflowIds);
 }
@@ -179,6 +186,75 @@ async function pullPbEntries(token, config) {
     console.log(`\nPulled ${selected.length} wizard(s). Local backups in .backup/${backupTs}/`);
 }
 
+// Refresh tracked long-running processes from upstream. Same classification
+// concern as pullPbEntries, but entries are located by NAME (the tabulator id
+// changes on every save/version — never a stable key).
+async function pullLrpEntries(token, config) {
+    const entries = config.workspace.filter((e) => e.object_type === 'long_running_process');
+    if (!entries.length) return;
+    if (!process.env.IMPORTEXPORT_URL)
+        throw new Error(
+            'IMPORTEXPORT_URL is not configured. Run `prbot init` or set it in agrippa.yaml.'
+        );
+
+    console.log('Checking long-running processes...');
+    const classified = [];
+    for (const entry of entries) {
+        let upstream = null;
+        try {
+            upstream = await fetchUpstream(token, entry.name);
+        } catch {
+            upstream = null;
+        }
+        if (!upstream) {
+            console.warn(`  ${entry.name}: could not fetch upstream, skipping`);
+            continue;
+        }
+        const localSemantic = localChecksum(projectReader(entry.path));
+        const remoteSemantic = remoteChecksumPb(upstream.payload);
+        const pullChecksum = entry.checksum_at_pull;
+        let status;
+        if (localSemantic === remoteSemantic) status = 'unchanged';
+        else if (pullChecksum === localSemantic) status = 'fast-forward';
+        else status = 'conflict';
+        classified.push({ ...entry, upstream, status });
+    }
+
+    const changed = classified.filter((e) => e.status !== 'unchanged');
+    if (!changed.length) {
+        console.log('Long-running processes are up to date.');
+        return;
+    }
+
+    const selected = await selectEntries(changed, 'pull (overwrites local LRP files)');
+    if (!selected.length) {
+        console.log('No long-running processes selected.');
+        return;
+    }
+
+    const backupTs = new Date().toISOString().replace(/:/g, '-').replace('T', '_').slice(0, 19);
+    for (const entry of selected) {
+        const res = await pullLrpEntry(token, entry, '.backup', backupTs);
+        const idx = config.workspace.findIndex(
+            (e) => e.object_type === 'long_running_process' && e.name === entry.name
+        );
+        if (idx !== -1) {
+            config.workspace[idx].checksum_at_pull = res.newChecksum;
+            config.workspace[idx].tenant_id = res.newRow.tenantId;
+            config.workspace[idx].svg = res.newRow.bpmnFileSvg;
+            config.workspace[idx].description = res.newRow.description;
+            config.workspace[idx].version = res.newRow.version;
+            config.workspace[idx].status = res.newRow.status;
+        }
+        const note = res.diffs.length ? ` (WARNING: ${res.diffs.length} round-trip diff(s))` : '';
+        console.log(`  ${entry.name} → refreshed${note}`);
+    }
+    writeConfig(config);
+    console.log(
+        `\nPulled ${selected.length} long-running process(es). Local backups in .backup/${backupTs}/`
+    );
+}
+
 async function discoverNewPhases(token, ripUrl, config, changedWorkflowIds = new Set()) {
     // Build map of workflow_id → { workflow_name, basePath } from existing phase entries
     const workflows = new Map();

package/src/agrippa/commands/pullLrp.js

@@ -0,0 +1,55 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { computeChecksum } from '../lib/checksum.js';
+import { fetchUpstream } from '../lib/lrpApi.js';
+import { comparePayload, decompose, recompose, stableStringify } from '../lib/pbProject.js';
+import { projectReader, writeProject } from '../lib/pbWorkspace.js';
+
+// Delete files under <baseDir>/scripts that are not in the fresh decompose
+// map, so a refresh that renames/removes scripts doesn't leave orphans behind
+// (LRPs have no pages/ dir — no user tasks).
+function pruneOrphans(baseDir, files) {
+    const dir = join(baseDir, 'scripts');
+    if (!existsSync(dir)) return;
+    for (const f of readdirSync(dir)) {
+        if (!(`scripts/${f}` in files)) rmSync(join(dir, f));
+    }
+}
+
+// Refresh one cloned LRP from upstream (the pull counterpart of
+// pushLrpEntry): back up the current local state, re-decompose the upstream
+// XML, overwrite local files (pruning orphans), and verify the round-trip.
+// `entry.upstream` is the {row, payload} fetched during classification;
+// re-resolved by name if absent (id may have changed since the last pull).
+async function pullLrpEntry(token, entry, backupDir, backupTs) {
+    const upstream = entry.upstream ?? (await fetchUpstream(token, entry.name));
+    if (!upstream) throw new Error(`could not fetch upstream LRP "${entry.name}"`);
+
+    // 1. Backup the current local state (recomposed payload) before overwriting.
+    try {
+        const localPayload = recompose(projectReader(entry.path));
+        const backupPath = join(backupDir, backupTs, entry.path, 'local.json');
+        mkdirSync(dirname(backupPath), { recursive: true });
+        writeFileSync(backupPath, JSON.stringify(localPayload, null, 2), 'utf-8');
+    } catch {
+        // local files unreadable (e.g. mid-edit) — nothing safe to back up, proceed.
+    }
+
+    // 2. Decompose upstream → fresh file map; prune orphans; write.
+    const { files } = decompose(upstream.payload);
+    pruneOrphans(entry.path, files);
+    writeProject(entry.path, files);
+
+    // 3. Verify the freshly-written project reconstructs the upstream XML.
+    // (pages diff is expected noise for LRPs — see cloneLrp.js.)
+    const rebuilt = recompose(projectReader(entry.path));
+    const diffs = comparePayload(upstream.payload, rebuilt).filter((d) => !d.startsWith('pages:'));
+
+    return {
+        newChecksum: computeChecksum(stableStringify(rebuilt)),
+        newRow: upstream.row,
+        diffs,
+    };
+}
+
+export { pullLrpEntry };

package/src/agrippa/commands/push.js

@@ -5,11 +5,13 @@ import { getToken } from '../../lib/auth.js';
 import { updateMfa, updatePhase } from '../lib/api.js';
 import { computeChecksum } from '../lib/checksum.js';
 import { loadEffectiveEnv, readConfig, writeConfig } from '../lib/config.js';
+import { fetchUpstream } from '../lib/lrpApi.js';
 import { getProcess } from '../lib/pbApi.js';
 import { localChecksum, remoteChecksumPb } from '../lib/pbProject.js';
 import { projectReader } from '../lib/pbWorkspace.js';
 import { fileExists, readCodeFile } from '../lib/workspace.js';
 import { fetchRemoteCode, selectEntries } from './pull.js';
+import { deploy, pushLrpEntry } from './pushLrp.js';
 import { publish, pushPbEntry } from './pushPb.js';
 
 const BACKUP_DIR = '.backup';
@@ -46,11 +48,16 @@ async function push(opts = {}) {
         (e) => e.object_type === 'phase' || e.object_type === 'mfa'
     );
     const hasPb = config.workspace.some((e) => e.object_type === 'process_builder');
+    const hasLrp = config.workspace.some((e) => e.object_type === 'long_running_process');
     const ripUrl = process.env.RIP_URL;
     if (hasCode && !ripUrl)
         throw new Error('RIP_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
     if (hasPb && !process.env.PB_URL)
         throw new Error('PB_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
+    if (hasLrp && !process.env.IMPORTEXPORT_URL)
+        throw new Error(
+            'IMPORTEXPORT_URL is not configured. Run `prbot init` or set it in agrippa.yaml.'
+        );
 
     console.log('Fetching remote state...');
     const token = await getToken();
@@ -66,6 +73,14 @@ async function push(opts = {}) {
             upstreamMap.set(e.guid, null);
         }
     }
+    const lrpUpstreamMap = new Map();
+    for (const e of config.workspace.filter((x) => x.object_type === 'long_running_process')) {
+        try {
+            lrpUpstreamMap.set(e.name, await fetchUpstream(token, e.name));
+        } catch {
+            lrpUpstreamMap.set(e.name, null);
+        }
+    }
 
     // Classify every entry to a status badge — concern: overwriting remote work.
     const classified = config.workspace.map((entry) => {
@@ -81,6 +96,18 @@ async function push(opts = {}) {
             return { ...entry, upstream, status };
         }
 
+        if (entry.object_type === 'long_running_process') {
+            const upstream = lrpUpstreamMap.get(entry.name) ?? null;
+            const localSemantic = localChecksum(projectReader(entry.path));
+            const remoteSemantic = upstream ? remoteChecksumPb(upstream.payload) : null;
+            const pullChecksum = entry.checksum_at_pull;
+            let status;
+            if (localSemantic === remoteSemantic) status = 'unchanged';
+            else if (pullChecksum === remoteSemantic) status = 'fast-forward';
+            else status = 'conflict';
+            return { ...entry, upstream, status };
+        }
+
         const key = `${entry.object_type}:${entry.id}`;
         const remoteCode = remoteCodeMap.get(key) ?? null;
         const localCode = readCodeFile(entry.path);
@@ -108,10 +135,14 @@ async function push(opts = {}) {
 
     const backupTs = new Date().toISOString().replace(/:/g, '-').replace('T', '_').slice(0, 19);
 
-    // Back up remote code for phase/mfa before overwriting (pb backs up its own
-    // full upstream payload inside pushPbEntry).
+    // Back up remote code for phase/mfa before overwriting (pb/lrp back up
+    // their own full upstream payload inside pushPbEntry/pushLrpEntry).
     for (const entry of selected) {
-        if (entry.object_type !== 'process_builder' && entry.remoteCode != null) {
+        if (
+            entry.object_type !== 'process_builder' &&
+            entry.object_type !== 'long_running_process' &&
+            entry.remoteCode != null
+        ) {
             const backupPath = join(BACKUP_DIR, backupTs, entry.path);
             mkdirSync(dirname(backupPath), { recursive: true });
             writeFileSync(backupPath, (entry.remoteCode ?? '').trim() + '\n', 'utf-8');
@@ -119,15 +150,15 @@ async function push(opts = {}) {
     }
 
     const pushedPb = [];
+    const pushedLrp = [];
     let pushed = 0;
     for (const entry of selected) {
-        const idx = config.workspace.findIndex(
-            (e) =>
-                e.object_type === entry.object_type &&
-                (entry.object_type === 'process_builder'
-                    ? e.guid === entry.guid
-                    : e.id === entry.id)
-        );
+        const idx = config.workspace.findIndex((e) => {
+            if (e.object_type !== entry.object_type) return false;
+            if (entry.object_type === 'process_builder') return e.guid === entry.guid;
+            if (entry.object_type === 'long_running_process') return e.name === entry.name;
+            return e.id === entry.id;
+        });
 
         if (entry.object_type === 'process_builder') {
             const res = await pushPbEntry(token, entry, BACKUP_DIR, backupTs);
@@ -144,6 +175,19 @@ async function push(opts = {}) {
                 config.workspace[idx].status = res.newStatus || 'draft';
             }
             pushedPb.push({ entry, idx });
+        } else if (entry.object_type === 'long_running_process') {
+            const res = await pushLrpEntry(token, entry, BACKUP_DIR, backupTs);
+            console.log(`  ${entry.name} → saved`);
+            if (idx !== -1) {
+                config.workspace[idx].checksum_at_pull = res.newChecksum;
+                config.workspace[idx].tenant_id = res.newRow.tenantId;
+                config.workspace[idx].description = res.newRow.description;
+                config.workspace[idx].version = res.newRow.version;
+                config.workspace[idx].status = res.newRow.status;
+            }
+            // deployId is the fresh post-save id (re-resolved by name in
+            // pushLrpEntry); the pre-save id is dead once the save returns.
+            pushedLrp.push({ entry, idx, deployId: res.deployId });
         } else {
             const code = entry.localCode ?? '';
             if (entry.object_type === 'phase') await updatePhase(token, ripUrl, entry.id, code);
@@ -155,10 +199,13 @@ async function push(opts = {}) {
 
     console.log(`\nRemote backups written to ${BACKUP_DIR}/${backupTs}/`);
 
-    // Publish step for pushed wizards (now in "draft").
+    // Publish/deploy step for pushed wizards and LRPs.
     if (pushedPb.length) {
         await handlePublish(token, pushedPb, config, opts);
     }
+    if (pushedLrp.length) {
+        await handleDeploy(token, pushedLrp, config, opts);
+    }
 
     writeConfig(config);
     console.log(`\nPushed ${pushed} record(s).`);
@@ -187,4 +234,27 @@ async function handlePublish(token, pushedPb, config, opts) {
     }
 }
 
+async function handleDeploy(token, pushedLrp, config, opts) {
+    for (const { entry, idx, deployId } of pushedLrp) {
+        let doDeploy;
+        if (opts.skipPublish) doDeploy = false;
+        else if (opts.publish) doDeploy = true;
+        else {
+            ({ doDeploy } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'doDeploy',
+                    message: `Deploy "${entry.name}" now?`,
+                    default: false,
+                },
+            ]));
+        }
+        if (doDeploy) {
+            await deploy(token, deployId);
+            if (idx !== -1) config.workspace[idx].status = 'deployed';
+            console.log(`  deployed ${entry.name}`);
+        }
+    }
+}
+
 export { push };

package/src/agrippa/commands/pushLrp.js

@@ -0,0 +1,56 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { deployLrp, resolveLrpByName, saveLrp } from '../lib/lrpApi.js';
+import { localChecksum, recompose } from '../lib/pbProject.js';
+import { projectReader } from '../lib/pbWorkspace.js';
+
+// Push one LRP entry: back up upstream, re-resolve the CURRENT id/tenantId by
+// name (never trust a stored/stale id — it changes on every save/version),
+// and PATCH the recomposed XML back. Returns a summary; deploy is a separate
+// step (see deploy()), mirroring PB's push-then-publish split.
+//
+// The save bumps the version and mints a NEW id, so the pre-save id is stale
+// the moment saveLrp returns. Both the deploy target and the post-save
+// version/status must come from a fresh resolve-by-name AFTER the save — never
+// from the pre-save row or the PATCH response (which does not echo the new id).
+async function pushLrpEntry(token, entry, backupDir, backupTs) {
+    const read = projectReader(entry.path);
+    const localPayload = recompose(read);
+    const upstream = entry.upstream; // { row, payload } from push.js's classification
+
+    if (upstream) {
+        const backupPath = join(backupDir, backupTs, entry.path, 'upstream.xml');
+        mkdirSync(dirname(backupPath), { recursive: true });
+        writeFileSync(backupPath, upstream.payload.built_page, 'utf-8');
+    }
+
+    // Re-resolve immediately before saving — the row captured during
+    // classification may be stale if something else saved in between.
+    const row = await resolveLrpByName(token, entry.name);
+    const description = upstream?.row?.description ?? entry.description ?? '';
+    const saved = await saveLrp(
+        token,
+        { ...row, bpmnFileSvg: entry.svg ?? row.bpmnFileSvg },
+        localPayload.built_page,
+        description
+    );
+
+    // The save minted a new id and bumped the version — re-resolve by name to
+    // get the fresh row. deployBpmn must target this new id (the pre-save id is
+    // now dead: deploying it 200s but activates nothing), and the workspace
+    // entry's version/status must come from here, not the stale pre-save row.
+    const deployRow = await resolveLrpByName(token, entry.name);
+
+    return {
+        newChecksum: localChecksum(read),
+        newRow: { ...deployRow, description },
+        saved,
+        deployId: deployRow.id,
+    };
+}
+
+function deploy(token, id) {
+    return deployLrp(token, id);
+}
+
+export { pushLrpEntry, deploy };