@waron97/prbot 3.2.1 → 3.4.0

package/src/agrippa/commands/pb.js

@@ -18,6 +18,7 @@ import { dirname, join } from 'path';
 import search from '@inquirer/search';
 import { parse as yamlParse } from 'yaml';
 import { fuzzyMatch } from '../../lib/fuzzy.js';
+import { log, warn } from '../../lib/logger.js';
 import { readConfig } from '../lib/config.js';
 import {
     addNode,
@@ -37,32 +38,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;
 }
 
@@ -103,7 +121,7 @@ function validate(dir) {
     try {
         recompose(projectReader(dir));
     } catch (e) {
-        console.warn(`WARNING: project no longer recomposes cleanly: ${e.message}`);
+        warn(`WARNING: project no longer recomposes cleanly: ${e.message}`);
     }
 }
 
@@ -122,27 +140,33 @@ async function pbFormat(opts) {
         if (!n.layout) missing++;
     });
     validate(dir);
-    console.log(
+    log(
         `Formatted ${dir} (${nodes} node(s) laid out${missing ? `, ${missing} without layout` : ''}).`
     );
     const issues = lintAll(structure);
     if (issues.length) {
-        console.warn('Diagram issues:');
-        for (const w of issues) console.warn(`  ! ${w}`);
+        warn('Diagram issues:');
+        for (const w of issues) warn(`  ! ${w}`);
     }
 }
 
 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 };
 
@@ -157,13 +181,13 @@ async function pbAdd(opts) {
         saveStructure(dir, structure);
         saveManifest(dir, manifest);
         validate(dir);
-        console.log(
+        log(
             `Added ${result.type} ${result.id}${result.file ? ` (${result.file})` : ''} between ${opts.from} → ${opts.to}.`
         );
-        console.log(`  ${opts.from} → ${result.id}  (${result.edgeId}, retargeted)`);
-        console.log(`  ${result.id} → ${opts.to}  (${result.newEdgeId})`);
-        for (const w of result.warnings || []) console.warn(`  ! ${w}`);
-        console.log('Run `agrippa pb format` to lay it out.');
+        log(`  ${opts.from} → ${result.id}  (${result.edgeId}, retargeted)`);
+        log(`  ${result.id} → ${opts.to}  (${result.newEdgeId})`);
+        for (const w of result.warnings || []) warn(`  ! ${w}`);
+        log('Run `agrippa pb format` to lay it out.');
         return;
     }
 
@@ -177,10 +201,8 @@ async function pbAdd(opts) {
     saveStructure(dir, structure);
     saveManifest(dir, manifest);
     validate(dir);
-    console.log(`Added ${result.type} ${result.id}${result.file ? ` (${result.file})` : ''}.`);
-    console.log(
-        'Connect it with `agrippa pb connect`, then run `agrippa pb format` to lay it out.'
-    );
+    log(`Added ${result.type} ${result.id}${result.file ? ` (${result.file})` : ''}.`);
+    log('Connect it with `agrippa pb connect`, then run `agrippa pb format` to lay it out.');
 }
 
 async function pbRemove(opts) {
@@ -192,7 +214,7 @@ async function pbRemove(opts) {
     saveStructure(dir, structure);
     saveManifest(dir, manifest);
     validate(dir);
-    console.log(
+    log(
         `Removed ${result.removed.length} node(s) [${result.removed.join(', ')}], ` +
             `${result.removedEdges} dangling edge(s), ${deletes.length} file(s).`
     );
@@ -212,11 +234,11 @@ async function pbConnect(opts) {
     });
     saveStructure(dir, structure);
     validate(dir);
-    console.log(
+    log(
         `Connected ${result.from} → ${result.to} (${result.id})${opts.default ? ' [default]' : ''}.`
     );
-    for (const w of result.warnings || []) console.warn(`  ! ${w}`);
-    console.log('Run `agrippa pb format` to route it.');
+    for (const w of result.warnings || []) warn(`  ! ${w}`);
+    log('Run `agrippa pb format` to route it.');
 }
 
 async function pbDisconnect(opts) {
@@ -227,7 +249,7 @@ async function pbDisconnect(opts) {
     const { result } = disconnect(structure, { id: opts.id, from: opts.from, to: opts.to });
     saveStructure(dir, structure);
     validate(dir);
-    console.log(`Removed ${result.removed} edge(s)${result.id ? ` (${result.id})` : ''}.`);
+    log(`Removed ${result.removed} edge(s)${result.id ? ` (${result.id})` : ''}.`);
 }
 
 async function pbSetDefault(opts) {
@@ -238,11 +260,11 @@ async function pbSetDefault(opts) {
     const { result } = setDefault(structure, { id: opts.id, from: opts.from, to: opts.to });
     saveStructure(dir, structure);
     validate(dir);
-    console.log(
+    log(
         `Default flow on ${result.from} is now ${result.id} (→ ${result.to})` +
             `${result.prev && result.prev !== result.id ? `, was ${result.prev}` : ''}.`
     );
-    for (const w of result.warnings || []) console.warn(`  ! ${w}`);
+    for (const w of result.warnings || []) warn(`  ! ${w}`);
 }
 
 async function pbList(opts) {
@@ -252,7 +274,7 @@ async function pbList(opts) {
     for (const r of rows) {
         const where = r.parent ? `  [in ${r.parent}]` : '';
         const label = r.name ? `  "${r.name}"` : '';
-        console.log(`${r.id}  (${r.type})${label}${where}`);
+        log(`${r.id}  (${r.type})${label}${where}`);
         for (const e of r.edges) {
             const tag = [
                 e.isDefault && '[default]',
@@ -261,10 +283,10 @@ async function pbList(opts) {
             ]
                 .filter(Boolean)
                 .join(' ');
-            console.log(`    → ${e.target}  (${e.id})${tag ? `  ${tag}` : ''}`);
+            log(`    → ${e.target}  (${e.id})${tag ? `  ${tag}` : ''}`);
         }
     }
-    console.log(`\n${rows.length} node(s).`);
+    log(`\n${rows.length} node(s).`);
 }
 
 async function pbPreview(opts) {
@@ -273,7 +295,7 @@ async function pbPreview(opts) {
     const svg = toSvg(structure);
     const out = opts.out || join(dir, 'preview.svg');
     writeFileSync(out, svg, 'utf-8');
-    console.log(`Wrote ${out} (${svg.length} bytes).`);
+    log(`Wrote ${out} (${svg.length} bytes).`);
 }
 
 async function pbLint(opts) {
@@ -281,11 +303,21 @@ async function pbLint(opts) {
     const { structure } = loadProject(dir);
     const issues = lintAll(structure);
     if (!issues.length) {
-        console.log('No issues.');
+        log('No issues.');
     } else {
-        for (const w of issues) console.warn(`  ! ${w}`);
+        for (const w of issues) warn(`  ! ${w}`);
         process.exitCode = 1;
     }
 }
 
-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

@@ -1,9 +1,11 @@
 import { dirname } from 'path';
 import inquirer from 'inquirer';
 import { getToken } from '../../lib/auth.js';
+import { log, warn } from '../../lib/logger.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,9 +16,10 @@ import {
     writeCodeFile,
     writeWorkflowDoc,
 } from '../lib/workspace.js';
+import { pullLrpEntry } from './pullLrp.js';
 import { pullPbEntry } from './pullPb.js';
 
-async function pull() {
+async function pull(opts = {}) {
     const config = readConfig();
     loadEffectiveEnv(config);
 
@@ -27,19 +30,23 @@ async function pull() {
     // Stale-file check
     const stale = config.workspace.filter((e) => !fileExists(e.path));
     if (stale.length) {
-        console.log('\nThe following tracked files no longer exist on disk:');
-        stale.forEach((e) => console.log(`  - ${e.path}  (${e.name})`));
-        const { cleanup } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'cleanup',
-                message: 'Remove these entries from the workspace config?',
-                default: true,
-            },
-        ]);
-        if (cleanup) {
-            config.workspace = config.workspace.filter((e) => fileExists(e.path));
-            writeConfig(config);
+        log('\nThe following tracked files no longer exist on disk:');
+        stale.forEach((e) => log(`  - ${e.path}  (${e.name})`));
+        if (opts.nonInteractive) {
+            log('  (non-interactive: leaving them tracked; run interactively to clean up)');
+        } else {
+            const { cleanup } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'cleanup',
+                    message: 'Remove these entries from the workspace config?',
+                    default: true,
+                },
+            ]);
+            if (cleanup) {
+                config.workspace = config.workspace.filter((e) => fileExists(e.path));
+                writeConfig(config);
+            }
         }
     }
 
@@ -50,11 +57,13 @@ 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...');
+        log('Fetching remote code...');
         const remoteCodeMap = await fetchRemoteCode(token, ripUrl, pullable);
 
         const classified = pullable.map((entry) => {
@@ -81,12 +90,12 @@ async function pull() {
         const changed = classified.filter((e) => e.status !== 'unchanged');
 
         if (!changed.length) {
-            console.log('Everything is up to date.');
+            log('Everything is up to date.');
         } else {
-            const selected = await selectEntries(changed, 'pull (overwrites local files)');
+            const selected = await selectEntries(changed, 'pull (overwrites local files)', opts);
 
             if (!selected.length) {
-                console.log('Nothing selected. No changes made.');
+                log('Nothing selected. No changes made.');
             } else {
                 for (const entry of selected) {
                     writeCodeFile(entry.path, entry.remoteCode);
@@ -101,15 +110,18 @@ async function pull() {
                     }
                 }
                 writeConfig(config);
-                console.log(`\nPulled ${selected.length} record(s).`);
+                log(`\nPulled ${selected.length} record(s).`);
             }
         }
     } else {
-        console.log('No tracked resources. Run `agrippa clone` first.');
+        log('No tracked resources. Run `agrippa clone` first.');
     }
 
     // ── refresh tracked process-builder wizards ───────────────────────────────
-    await pullPbEntries(token, config);
+    await pullPbEntries(token, config, opts);
+
+    // ── refresh tracked long-running processes ────────────────────────────────
+    await pullLrpEntries(token, config, opts);
 
     // ── discover new phases on tracked workflows ──────────────────────────────
     await discoverNewPhases(token, ripUrl, config, changedWorkflowIds);
@@ -120,13 +132,13 @@ async function pull() {
 //   unchanged    local === remote semantically → nothing to do
 //   fast-forward remote changed, local untouched since pull → safe overwrite
 //   conflict     local diverged from checksum_at_pull → overwrite loses local work
-async function pullPbEntries(token, config) {
+async function pullPbEntries(token, config, opts = {}) {
     const entries = config.workspace.filter((e) => e.object_type === 'process_builder');
     if (!entries.length) return;
     if (!process.env.PB_URL)
         throw new Error('PB_URL is not configured. Run `prbot init` or set it in agrippa.yaml.');
 
-    console.log('Checking process-builder wizards...');
+    log('Checking process-builder wizards...');
     const classified = [];
     for (const entry of entries) {
         let upstream = null;
@@ -136,7 +148,7 @@ async function pullPbEntries(token, config) {
             upstream = null;
         }
         if (!upstream) {
-            console.warn(`  ${entry.name}: could not fetch upstream, skipping`);
+            warn(`  ${entry.name}: could not fetch upstream, skipping`);
             continue;
         }
         const localSemantic = localChecksum(projectReader(entry.path));
@@ -151,13 +163,13 @@ async function pullPbEntries(token, config) {
 
     const changed = classified.filter((e) => e.status !== 'unchanged');
     if (!changed.length) {
-        console.log('Wizards are up to date.');
+        log('Wizards are up to date.');
         return;
     }
 
-    const selected = await selectEntries(changed, 'pull (overwrites local wizard files)');
+    const selected = await selectEntries(changed, 'pull (overwrites local wizard files)', opts);
     if (!selected.length) {
-        console.log('No wizards selected.');
+        log('No wizards selected.');
         return;
     }
 
@@ -173,10 +185,79 @@ async function pullPbEntries(token, config) {
             if (res.newStatus) config.workspace[idx].status = res.newStatus;
         }
         const note = res.diffs.length ? ` (WARNING: ${res.diffs.length} round-trip diff(s))` : '';
-        console.log(`  ${entry.name} → refreshed${note}`);
+        log(`  ${entry.name} → refreshed${note}`);
     }
     writeConfig(config);
-    console.log(`\nPulled ${selected.length} wizard(s). Local backups in .backup/${backupTs}/`);
+    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, opts = {}) {
+    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.'
+        );
+
+    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) {
+            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) {
+        log('Long-running processes are up to date.');
+        return;
+    }
+
+    const selected = await selectEntries(changed, 'pull (overwrites local LRP files)', opts);
+    if (!selected.length) {
+        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))` : '';
+        log(`  ${entry.name} → refreshed${note}`);
+    }
+    writeConfig(config);
+    log(
+        `\nPulled ${selected.length} long-running process(es). Local backups in .backup/${backupTs}/`
+    );
 }
 
 async function discoverNewPhases(token, ripUrl, config, changedWorkflowIds = new Set()) {
@@ -218,7 +299,7 @@ async function discoverNewPhases(token, ripUrl, config, changedWorkflowIds = new
                 checksum_at_pull: computeChecksum(phase.code),
                 name: `${wfName} / ${phase.name}`,
             });
-            console.log(`  new phase: ${filePath}`);
+            log(`  new phase: ${filePath}`);
             newCount++;
             wfChanged = true;
         }
@@ -231,14 +312,14 @@ async function discoverNewPhases(token, ripUrl, config, changedWorkflowIds = new
                 const structure = await describeWorkflow(token, ripUrl, wfId);
                 writeWorkflowDoc(basePath, structure);
             } catch (err) {
-                console.warn(`  could not refresh workflow.yml for ${wfName}: ${err.message}`);
+                warn(`  could not refresh workflow.yml for ${wfName}: ${err.message}`);
             }
         }
     }
 
     if (newCount) {
         writeConfig(config);
-        console.log(`Added ${newCount} new phase(s) from tracked workflows.`);
+        log(`Added ${newCount} new phase(s) from tracked workflows.`);
     }
 }
 
@@ -267,18 +348,32 @@ async function fetchRemoteCode(token, ripUrl, workspace) {
     return map;
 }
 
-async function selectEntries(changed, verb, mode = 'pull') {
-    const badgeFor = (status) => {
-        if (mode === 'push') {
-            return status === 'fast-forward' ? '↑ safe' : '⚠ conflict';
+// `changed` only ever contains `fast-forward` and `conflict` entries (the
+// caller already filtered out `unchanged`). `conflict` means local and remote
+// have both diverged from the last-known-good baseline — applying it blindly
+// can silently lose either side's work, so it is never preselected and is
+// refused outright in `--non-interactive` mode instead of being silently
+// skipped or applied.
+async function selectEntries(changed, verb, opts = {}) {
+    const conflicts = changed.filter((e) => e.status === 'conflict');
+
+    if (opts.nonInteractive) {
+        if (conflicts.length) {
+            throw new Error(
+                `CONFLICT: refusing to ${verb} non-interactively — ${conflicts.length} resource(s) ` +
+                    `in conflict: ${conflicts.map((e) => e.name).join(', ')}. Resolve interactively ` +
+                    `or re-run once the conflicting side is reconciled.`
+            );
         }
-        return status === 'fast-forward' ? '↑ safe' : '⚠ conflict';
-    };
+        return changed;
+    }
+
+    const badgeFor = (status) => (status === 'fast-forward' ? '↑ safe' : '⚠ conflict');
 
     const choices = changed.map((e) => ({
         name: `${e.name}  [${badgeFor(e.status)}]`,
         value: e,
-        checked: true,
+        checked: e.status !== 'conflict',
     }));
 
     const { selected } = await inquirer.prompt([

package/src/agrippa/commands/pullLrp.js

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fetchUpstream } from '../lib/lrpApi.js';
+import { checksumOfPayload, comparePayload, decompose, recompose } 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: checksumOfPayload(rebuilt),
+        newRow: upstream.row,
+        diffs,
+    };
+}
+
+export { pullLrpEntry };

package/src/agrippa/commands/pullPb.js

@@ -1,8 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
-import { computeChecksum } from '../lib/checksum.js';
 import { getProcess } from '../lib/pbApi.js';
-import { comparePayload, decompose, recompose, stableStringify } from '../lib/pbProject.js';
+import { checksumOfPayload, comparePayload, decompose, recompose } from '../lib/pbProject.js';
 import { projectReader, writeProject } from '../lib/pbWorkspace.js';
 
 // Delete files under <baseDir>/<sub> that are not in the fresh decompose map, so
@@ -44,7 +43,7 @@ async function pullPbEntry(token, entry, backupDir, backupTs) {
     const diffs = comparePayload(upstream, rebuilt);
 
     return {
-        newChecksum: computeChecksum(stableStringify(rebuilt)),
+        newChecksum: checksumOfPayload(rebuilt),
         newUpdatedDate: upstream.updated_date,
         newStatus: upstream.status,
         diffs,