@waron97/prbot 3.2.1 → 3.4.0

package/src/agrippa/lib/pbProject.js

@@ -18,7 +18,15 @@
 import slugify from 'slugify';
 import { Document, visit, parse as yamlParse, stringify as yamlStringify } from 'yaml';
 import { computeChecksum } from './checksum.js';
-import { buildProcess, compareDiagram, compareProcess, diff, parseProcess } from './pbModel.js';
+import {
+    buildProcess,
+    compareDiagram,
+    compareProcess,
+    diagramGeometry,
+    diff,
+    normalizeProcessTree,
+    parseProcess,
+} from './pbModel.js';
 
 const MANIFEST_FILE = '.agrippa-pb.json';
 const STRUCTURE_FILE = 'structure.yaml';
@@ -52,7 +60,9 @@ const NODE_FIELDS = [
     'fields',
     'formKey',
     'attachedToRef',
-    'errorEventDefinition',
+    'eventDefinitions',
+    'calledElement',
+    'dataIO',
     'multiInstance',
     'documentation',
 ];
@@ -107,9 +117,12 @@ function geometryMaps(diagram) {
             if (s.attrs.isExpanded !== undefined)
                 expanded[s.attrs.bpmnElement] = s.attrs.isExpanded;
         }
+        // Always record the edge, even with zero waypoints (rare, but real —
+        // some exporters emit an empty <...:BPMNEdge>). Skipping on `.length`
+        // would drop the entry, so buildDiagram doesn't recreate the edge shape
+        // at all, losing a real (if degenerate) diagram element.
         for (const e of diagram.edges)
-            if (e.waypoints?.length)
-                waypoints[e.attrs.bpmnElement] = e.waypoints.map((w) => [w.x, w.y]);
+            waypoints[e.attrs.bpmnElement] = (e.waypoints || []).map((w) => [w.x, w.y]);
     }
     return { bounds, waypoints, expanded };
 }
@@ -121,6 +134,7 @@ function structEdge(e, geo) {
     if (e.name !== undefined) o.name = e.name;
     if (e.condition !== undefined) o.condition = e.condition;
     if (e.conditionType !== undefined) o.conditionType = e.conditionType;
+    if (e.conditionAttrs !== undefined) o.conditionAttrs = e.conditionAttrs;
     if (e.documentation !== undefined) o.documentation = e.documentation;
     if (geo.waypoints[e.id]) o.waypoints = geo.waypoints[e.id];
     return o;
@@ -166,6 +180,7 @@ function flattenNodes(structNodes, parentId, model, read, geo) {
             if (se.name !== undefined) e.name = se.name;
             if (se.condition !== undefined) e.condition = se.condition;
             if (se.conditionType !== undefined) e.conditionType = se.conditionType;
+            if (se.conditionAttrs !== undefined) e.conditionAttrs = se.conditionAttrs;
             if (se.documentation !== undefined) e.documentation = se.documentation;
             if (parentId) e.parent = parentId;
             if (se.waypoints) geo.waypoints[se.id] = se.waypoints;
@@ -219,7 +234,10 @@ function decompose(payload) {
     // back for the diagram).
     const structure = {
         process: model.process,
+        messages: model.messages,
         errors: model.errors,
+        signals: model.signals,
+        extraDefs: model.extraDefs,
         nodes: nestNodes(model, null, scriptsMap, geo),
         annotations: model.annotations.map((a) =>
             geo.bounds[a.id] ? { ...a, layout: geo.bounds[a.id] } : a
@@ -227,6 +245,9 @@ function decompose(payload) {
         associations: model.associations.map((a) =>
             geo.waypoints[a.id] ? { ...a, waypoints: geo.waypoints[a.id] } : a
         ),
+        groups: (model.groups || []).map((g) =>
+            geo.bounds[g.id] ? { ...g, layout: geo.bounds[g.id] } : g
+        ),
     };
     files[STRUCTURE_FILE] = stringifyStructure(structure);
 
@@ -259,17 +280,22 @@ function recompose(read) {
 
     const model = {
         process: structure.process,
+        messages: structure.messages || [],
         errors: structure.errors || [],
+        signals: structure.signals || [],
+        extraDefs: structure.extraDefs || [],
         nodes: [],
         edges: [],
         annotations: structure.annotations || [],
         associations: structure.associations || [],
+        groups: structure.groups || [],
     };
     const geo = { bounds: {}, waypoints: {}, expanded: {}, labelPos: {} };
     flattenNodes(structure.nodes, null, model, read, geo);
-    // annotation/association geometry (top-level lists carry it inline)
+    // annotation/association/group geometry (top-level lists carry it inline)
     for (const a of model.annotations) if (a.layout) geo.bounds[a.id] = a.layout;
     for (const a of model.associations) if (a.waypoints) geo.waypoints[a.id] = a.waypoints;
+    for (const g of model.groups) if (g.layout) geo.bounds[g.id] = g.layout;
 
     const built_page = buildProcess({ ns: manifest.ns, model, geo });
 
@@ -337,10 +363,69 @@ function stableStringify(value) {
     return JSON.stringify(value ?? null);
 }
 
+// Canonical form of a recomposed payload used ONLY for change-detection
+// checksums — never for the actual push payload (recompose() itself, and
+// what gets sent on push, are untouched). Routes built_page through the same
+// formatting/order-insensitive canonicalization already used by
+// comparePayload()'s 0-loss round-trip verification:
+//   - normalizeProcessTree drops insignificant whitespace text nodes (incl.
+//     the extraDefs `#text` padding between <definitions>-root siblings) and
+//     sorts declarations by id, so cosmetic reformatting doesn't count;
+//   - diagramGeometry keeps only x/y/width/height/isExpanded/waypoints, so
+//     `format`-only artifacts like labelPos never enter the comparison.
+// Without this, a push followed by an unmodified re-fetch could classify as
+// a phantom `conflict` instead of `unchanged` — see
+// ai_tasks/2026-07-16-lrp-clone/deferred_work.md items 1, 3, 4.
+//
+// `updated_date`/`modified_by` are server-managed bookkeeping, not process
+// content — Odoo/Symple bump them on any touch of the record, including ones
+// with no semantic effect (observed live: an integration service account
+// re-saving the wizard moved `updated_date`/`modified_by` on both the
+// top-level payload and a page wrapper with zero content diff otherwise, via
+// comparePayload). They exist at two levels: the top-level payload scalars,
+// and per-entry inside `payload.pages` (each page's audit wrapper, distinct
+// from the page *content* under `.page`, which is left untouched). Left in,
+// they permanently pin the object to `conflict` the moment anything server-
+// side touches it, regardless of actual content — worse than the cosmetic
+// built_page diffs above, since nothing local or an agrippa push causes them
+// to resync.
+const VOLATILE_AUDIT_FIELDS = ['updated_date', 'modified_by'];
+
+function canonicalForChecksum(payload) {
+    const { process, decls } = normalizeProcessTree(payload.built_page);
+    const rest = omit(payload, ['built_page', 'pages', ...VOLATILE_AUDIT_FIELDS]);
+    // Page order is not a stable identity — locally it's whatever order the
+    // manifest happened to record at last decompose, while a live upstream
+    // fetch can return the same set of pages in a different order (observed
+    // live: a fresh fetch came back with pages 1-3 cyclically rotated versus
+    // the local manifest, same guids, zero content difference). Sort by the
+    // page's own guid — stable, unlike array position — before hashing, the
+    // same trick normalizeProcessTree already uses for extraDefs decls.
+    const pages = [...(payload.pages || [])]
+        .sort((a, b) => (a.guid ?? '').localeCompare(b.guid ?? ''))
+        .map((p) => omit(p, VOLATILE_AUDIT_FIELDS));
+    return {
+        ...rest,
+        pages,
+        built_page_process: process,
+        built_page_decls: decls,
+        built_page_diagram: diagramGeometry(payload.built_page),
+    };
+}
+
+// Checksum of a recomposed payload, canonicalized so cosmetic round-trip
+// differences don't register as a change. Used for checksum_at_pull baselines
+// (clone/pull) and for the push/pull classifier (localChecksum/
+// remoteChecksumPb below) — keep every PB/LRP checksum call site on this one
+// function so baselines and comparisons stay on the same normalization.
+function checksumOfPayload(payload) {
+    return computeChecksum(stableStringify(canonicalForChecksum(payload)));
+}
+
 // Checksum of the recomposed payload — stable across runs, changes only when the
 // local files change. clonePb stores this as checksum_at_pull; push recomputes it.
 function localChecksum(read) {
-    return computeChecksum(stableStringify(recompose(read)));
+    return checksumOfPayload(recompose(read));
 }
 
 // Semantic checksum of a remote payload. Decompose → recompose normalises field
@@ -349,7 +434,7 @@ function localChecksum(read) {
 function remoteChecksumPb(payload) {
     const { files } = decompose(payload);
     const read = (p) => files[p] ?? '';
-    return computeChecksum(stableStringify(recompose(read)));
+    return checksumOfPayload(recompose(read));
 }
 
 // Enumerate the wizard's pages from the pages/*.yml files (the authoritative
@@ -388,6 +473,7 @@ export {
     comparePayload,
     verifyRoundTrip,
     stableStringify,
+    checksumOfPayload,
     localChecksum,
     remoteChecksumPb,
     enumeratePages,

package/src/agrippa/lib/pbScriptTemplate.js

@@ -0,0 +1,29 @@
+// Initial body scaffolded into a new scriptTask's .js file (mirrors the
+// `pbtemplate` editor snippet) so created scripts aren't empty.
+export const SCRIPT_TEMPLATE = `try {
+    // ----------------------------
+    // Input gathering
+    // ----------------------------
+
+    // ----------------------------
+    // Output variable initialization
+    // ----------------------------
+
+    // ----------------------------
+    // Logical Helpers
+    // ----------------------------
+
+    // ----------------------------
+    // Main Execution
+    // ----------------------------
+
+    // ----------------------------
+    // Output
+    // ----------------------------
+
+} catch (err) {
+    execution.setVariable('isAlive', false);
+    execution.setVariable('errorCode', '');
+    execution.setVariable('errorMessage', err.message);
+}
+`;

package/src/commands/autopr.js

@@ -6,6 +6,7 @@ import fetch from 'node-fetch';
 import { resolveAddonsPath } from '../lib/addons.js';
 import { fuzzyMatch } from '../lib/fuzzy.js';
 import { execGit } from '../lib/git.js';
+import { log } from '../lib/logger.js';
 import {
     appendPrToLine,
     appendRefsToLine,
@@ -120,7 +121,7 @@ async function createDevopsPR(branch, title, description) {
     return { id: data.pullRequestId, url: prUrl };
 }
 
-async function appendChecklistPrLink(taskId, currentChecklist, prUrl, prNumber) {
+async function appendChecklistPrLink(taskId, currentChecklist, prUrl) {
     const link = `<a href="${prUrl}">${prUrl}</a><br/>`;
     const updated = currentChecklist ? `${currentChecklist}\n${link}` : link;
     const url = `${process.env.TRIDENT_URL}/jsonrpc`;
@@ -191,8 +192,8 @@ async function selectSection(sections, candidates) {
     const scored = candidates.length > 0 ? scoreSections(sections, candidates) : [];
 
     if (candidates.length > 0) {
-        console.log(`\nTask fields: ${candidates.join(' | ')}`);
-        if (scored.length === 0) console.log('No matching sections found.');
+        log(`\nTask fields: ${candidates.join(' | ')}`);
+        if (scored.length === 0) log('No matching sections found.');
     }
 
     const scoredHeadings = new Set(scored.map((s) => s.heading));
@@ -224,13 +225,13 @@ async function autoprAmend(options) {
     const pr = await fetchActivePr(branch);
     const prNumber = pr.pullRequestId;
     const prUrl = `https://dev.azure.com/${DEVOPS_ORG}/${DEVOPS_PROJECT}/_git/${DEVOPS_REPO}/pullrequest/${prNumber}`;
-    console.log(`Found PR #${prNumber}: ${prUrl}`);
+    log(`Found PR #${prNumber}: ${prUrl}`);
 
     const ids = options.trident ?? [];
     const jiras = options.jira ?? [];
 
     const tasks = ids.length > 0 ? await Promise.all(ids.map(fetchTask)) : [];
-    tasks.forEach((t) => console.log(`Task: ${t.name}`));
+    tasks.forEach((t) => log(`Task: ${t.name}`));
 
     const newLinks = [
         ...ids.map((id) => `${process.env.TRIDENT_URL}/odoo/my-tasks/${id}`),
@@ -241,20 +242,18 @@ async function autoprAmend(options) {
             ? `${pr.description}\n${newLinks.join('\n')}`
             : newLinks.join('\n');
         await patchDevopsPrDescription(prNumber, updatedDescription);
-        console.log('PR description updated');
+        log('PR description updated');
     }
 
     for (let i = 0; i < ids.length; i++) {
-        await appendChecklistPrLink(ids[i], tasks[i].x_release_checklist, prUrl, prNumber);
+        await appendChecklistPrLink(ids[i], tasks[i].x_release_checklist, prUrl);
     }
-    if (ids.length > 0) console.log('Checklist updated');
+    if (ids.length > 0) log('Checklist updated');
 
     const content = readFileSync(changelogPath, 'utf-8');
     const existing = findLineByPrNumber(content, prNumber);
     if (!existing) {
-        console.log(
-            `Warning: no changelog line found for PR #${prNumber} — skipping changelog update`
-        );
+        log(`Warning: no changelog line found for PR #${prNumber} — skipping changelog update`);
         return;
     }
     const lines = content.split('\n');
@@ -264,8 +263,8 @@ async function autoprAmend(options) {
     await execGit(['add', 'CHANGELOG.md'], ADDONS_PATH);
     await execGit(['commit', '-m', '[DOC][CHANGELOG] Changelog'], ADDONS_PATH);
     await execGit(['push'], ADDONS_PATH);
-    console.log('Changelog updated and pushed');
-    console.log('\nReminder: squash the two changelog commits before merging the PR.');
+    log('Changelog updated and pushed');
+    log('\nReminder: squash the two changelog commits before merging the PR.');
 }
 
 async function autopr(options) {
@@ -278,15 +277,15 @@ async function autopr(options) {
     const hasTridents = ids.length > 0;
 
     const tasks = hasTridents ? await Promise.all(ids.map((id) => fetchTask(id))) : [];
-    tasks.forEach((t) => console.log(`Task: ${t.name}`));
+    tasks.forEach((t) => log(`Task: ${t.name}`));
 
     const content = readFileSync(changelogPath, 'utf-8');
 
-    const duplicate = hasTridents ? findDuplicateLine(content, ids, []) : null;
+    const duplicate = findDuplicateLine(content, ids, options.jira ?? []);
 
     let appendMode = false;
     if (duplicate) {
-        console.log(`\nExisting entry (line ${duplicate.lineNumber + 1}):\n  ${duplicate.line}`);
+        log(`\nExisting entry (line ${duplicate.lineNumber + 1}):\n  ${duplicate.line}`);
         const { confirm } = await inquirer.prompt([
             {
                 type: 'confirm',
@@ -315,19 +314,19 @@ async function autopr(options) {
     }
 
     await execGit(['checkout', '-b', branch], ADDONS_PATH);
-    console.log(`Branch created: ${branch}`);
+    log(`Branch created: ${branch}`);
     await execGit(['push', '-u', 'origin', branch], ADDONS_PATH);
 
     const prTitle = options.name ?? tasks[0]?.name ?? branch;
     const prDescription = buildPrDescription(ids, options.jira ?? []);
     const { id: prNumber, url: prUrl } = await createDevopsPR(branch, prTitle, prDescription);
-    console.log(`PR opened: #${prNumber} — ${prUrl}`);
+    log(`PR opened: #${prNumber} — ${prUrl}`);
 
     if (hasTridents) {
         for (let i = 0; i < ids.length; i++) {
-            await appendChecklistPrLink(ids[i], tasks[i].x_release_checklist, prUrl, prNumber);
+            await appendChecklistPrLink(ids[i], tasks[i].x_release_checklist, prUrl);
         }
-        console.log('Checklist updated');
+        log('Checklist updated');
     }
 
     const lines = content.split('\n');
@@ -365,12 +364,12 @@ async function autopr(options) {
     }
 
     await fs.writeFile(changelogPath, lines.join('\n'));
-    console.log('Changelog entry written');
+    log('Changelog entry written');
 
     await execGit(['add', 'CHANGELOG.md'], ADDONS_PATH);
     await execGit(['commit', '-m', '[DOC][CHANGELOG] Changelog'], ADDONS_PATH);
     await execGit(['push'], ADDONS_PATH);
-    console.log('Changelog committed and pushed');
+    log('Changelog committed and pushed');
 }
 
 export { autopr };

package/src/commands/changelog.js

@@ -4,6 +4,7 @@ import search from '@inquirer/search';
 import inquirer from 'inquirer';
 import { resolveAddonsPath } from '../lib/addons.js';
 import { fuzzyMatch } from '../lib/fuzzy.js';
+import { log } from '../lib/logger.js';
 
 function buildRefString(tridents, jiras, prNumber) {
     const refs = [];
@@ -116,7 +117,7 @@ async function changelog(prNumber, options) {
     const duplicate = findDuplicateLine(content, tridents, jiras);
     let appendMode = false;
     if (duplicate) {
-        console.log(`\nExisting entry (line ${duplicate.lineNumber + 1}):\n  ${duplicate.line}`);
+        log(`\nExisting entry (line ${duplicate.lineNumber + 1}):\n  ${duplicate.line}`);
         const { confirm } = await inquirer.prompt([
             {
                 type: 'confirm',
@@ -132,7 +133,7 @@ async function changelog(prNumber, options) {
         const lines = content.split('\n');
         lines[duplicate.lineNumber] = appendPrToLine(lines[duplicate.lineNumber], prNumber);
         await fs.writeFile(changelogPath, lines.join('\n'));
-        console.log('Updated existing line');
+        log('Updated existing line');
         return;
     }
 
@@ -176,7 +177,7 @@ async function changelog(prNumber, options) {
     lines.splice(endLine + 1, 0, newEntry);
 
     await fs.writeFile(changelogPath, lines.join('\n'));
-    console.log('Changelog entry added');
+    log('Changelog entry added');
 }
 
 function findLineByPrNumber(content, prNumber) {

package/src/commands/commit.js

@@ -3,6 +3,7 @@ import inquirer from 'inquirer';
 import searchList from 'inquirer-search-list';
 import { resolveAddonsPath } from '../lib/addons.js';
 import { execGit } from '../lib/git.js';
+import { log } from '../lib/logger.js';
 
 inquirer.registerPrompt('search-list', searchList);
 
@@ -50,7 +51,7 @@ function validateSameModule(files) {
     const allSameModule = modules.every((module) => `[${module}]` === currentModule);
 
     if (!allSameModule) {
-        console.log(chalk.red('Selected files are not of the same module'));
+        log(chalk.red('Selected files are not of the same module'));
         return null;
     }
 
@@ -59,8 +60,8 @@ function validateSameModule(files) {
 
 async function getFilesToCommit(stagedChanges, unstagedChanges) {
     if (stagedChanges.trim()) {
-        console.log(chalk.green('Staged changes:'));
-        console.log(stagedChanges);
+        log(chalk.green('Staged changes:'));
+        log(stagedChanges);
 
         return {
             filesToCheck: stagedChanges.trim().split('\n'),
@@ -71,9 +72,9 @@ async function getFilesToCommit(stagedChanges, unstagedChanges) {
     const unstagedFiles = unstagedChanges.trim().split('\n');
 
     while (true) {
-        console.log(chalk.yellow('No staged changes found.'));
-        console.log(chalk.yellow('Unstaged changes:'));
-        console.log(unstagedChanges);
+        log(chalk.yellow('No staged changes found.'));
+        log(chalk.yellow('Unstaged changes:'));
+        log(unstagedChanges);
 
         const answers = await inquirer.prompt([
             {
@@ -104,7 +105,7 @@ async function commit() {
         const stagedChanges = await execGit(['diff', '--cached', '--name-only'], ADDONS_PATH);
 
         if (!unstagedChanges.trim() && !stagedChanges.trim()) {
-            console.log(chalk.red('No changes found to commit.'));
+            log(chalk.red('No changes found to commit.'));
             return;
         }
 
@@ -115,7 +116,7 @@ async function commit() {
         } = await getFilesToCommit(stagedChanges, unstagedChanges);
 
         if (filesToCheck.length === 0) {
-            console.log(chalk.red('No files selected.'));
+            log(chalk.red('No files selected.'));
             return;
         }
 
@@ -167,13 +168,13 @@ async function commit() {
         }
 
         await execGit(['commit', '-m', commitMessage], ADDONS_PATH);
-        console.log(chalk.green('Commit created successfully!'));
+        log(chalk.green('Commit created successfully!'));
 
         const remainingUnstaged = await execGit(['diff', '--name-only'], ADDONS_PATH);
         const remainingStaged = await execGit(['diff', '--cached', '--name-only'], ADDONS_PATH);
 
         if (!remainingUnstaged.trim() && !remainingStaged.trim()) {
-            console.log(chalk.green('No more changes to commit.'));
+            log(chalk.green('No more changes to commit.'));
             break;
         }
 

package/src/commands/export.js

@@ -1,3 +1,4 @@
+import { log } from '../lib/logger.js';
 import { exportEmailTemplates } from './exportEmailTemplates.js';
 import { exportImperex } from './exportImperex.js';
 import { exportLrp } from './exportLrp.js';
@@ -5,7 +6,7 @@ import { exportPb } from './exportPb.js';
 import { exportWorkflow } from './exportWorkflow.js';
 
 function exportRip() {
-    console.log('Not implemented yet.');
+    log('Not implemented yet.');
 }
 
 export { exportPb, exportRip, exportImperex, exportEmailTemplates, exportWorkflow, exportLrp };

package/src/commands/exportPb.js

@@ -36,13 +36,30 @@ async function initiateExport(guid, token) {
     if (!response.ok) throw new Error(await response.text());
 }
 
+// No job/request id is returned by initiateExport, so the poll still
+// correlates by GUID + a corrected date window over the last few results —
+// a heuristic, not a stable identifier (see REL-ADP-PB-001; a real fix
+// depends on the ImportExport API exposing a request id, EXT-002). What we
+// can and do own locally is not hanging forever: an overall deadline.
+const PB_EXPORT_POLL_INTERVAL_MS = 3_000;
+const PB_EXPORT_POLL_TIMEOUT_MS = 120_000;
+
 async function pollExportResult(guid, requestTime, token) {
     const url = `${process.env.IMPORTEXPORT_URL}/export/info/processKey=ExportElement&subProcess=true&status=FAILED,COMPLETED&referenceId=process_builder`;
     // Server createDate is offset -1hr from system time; subtract 1hr+5s buffer
     const cutoff = requestTime - 3_605_000;
+    const deadline = requestTime + PB_EXPORT_POLL_TIMEOUT_MS;
 
     while (true) {
-        await new Promise((r) => setTimeout(r, 3000));
+        if (Date.now() > deadline) {
+            throw new Error(
+                `REMOTE_TIMEOUT: Process Builder export for guid ${guid} did not complete within ${
+                    PB_EXPORT_POLL_TIMEOUT_MS / 1000
+                }s`
+            );
+        }
+
+        await new Promise((r) => setTimeout(r, PB_EXPORT_POLL_INTERVAL_MS));
 
         const response = await fetch(url, {
             method: 'POST',
@@ -153,4 +170,4 @@ async function exportPb(opts) {
     }
 }
 
-export { exportPb };
+export { exportPb, pollExportResult };

package/src/commands/init.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import inquirer from 'inquirer';
 import { CONFIG_DIR, CONFIG_FILE } from '../config.js';
+import { log } from '../lib/logger.js';
 
 async function init() {
     if (!existsSync(CONFIG_DIR)) {
@@ -142,7 +143,7 @@ async function init() {
             .map(([k, v]) => `${k}=${v}`)
             .join('\n') + '\n'
     );
-    console.log(`Config written to ${CONFIG_FILE}`);
+    log(`Config written to ${CONFIG_FILE}`);
 }
 
 export { init };

package/src/commands/routine.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { select } from '@inquirer/prompts';
 import { parse } from 'yaml';
 import { CONFIG_DIR } from '../config.js';
-import { setSilent } from '../lib/logger.js';
+import { log, setSilent } from '../lib/logger.js';
 import { exportEmailTemplates } from './exportEmailTemplates.js';
 import { exportImperex } from './exportImperex.js';
 import { exportLrp } from './exportLrp.js';
@@ -52,39 +52,50 @@ function isNothingToCommit(err) {
 }
 
 async function runRoutine(routine) {
-    console.log(`Running Routine: ${routine.name}`);
+    log(`Running Routine: ${routine.name}`);
+
+    const failures = [];
 
     for (const step of routine.steps) {
         const label = `[${step.name}]`;
         const fn = COMMAND_MAP[step.command];
         if (!fn) {
-            console.log(`${label} Unknown command: ${step.command}`);
+            log(`${label} Unknown command: ${step.command}`);
+            failures.push(`${step.name}: unknown command "${step.command}"`);
             continue;
         }
 
-        console.log(`${label} Job started`);
+        log(`${label} Job started`);
         setSilent(true);
 
         try {
             await fn(stepOpts(step));
-            console.log(`${label} Done (committed)`);
+            log(`${label} Done (committed)`);
         } catch (err) {
             if (isNothingToCommit(err)) {
-                console.log(`${label} Done (nothing to commit)`);
+                log(`${label} Done (nothing to commit)`);
             } else {
-                console.log(`${label} Failed: ${err.message}`);
+                log(`${label} Failed: ${err.message}`);
+                failures.push(`${step.name}: ${err.message}`);
             }
         } finally {
             setSilent(false);
         }
     }
+
+    if (failures.length) {
+        throw new Error(
+            `Routine "${routine.name}" completed with ${failures.length} failed step(s):\n` +
+                failures.map((f) => `  - ${f}`).join('\n')
+        );
+    }
 }
 
 async function routine() {
     const routines = loadRoutines();
 
     if (!routines.length) {
-        console.log(
+        log(
             'No routines defined. Create ~/.config/prbot/routines.yaml or add routines: to agrippa.yaml.'
         );
         return;