mandrel 2.12.0 → 2.14.0

package/.agents/scripts/lib/orchestration/plan-context.js

@@ -21,6 +21,7 @@ import { readFile } from 'node:fs/promises';
 import { getLimits } from '../config-resolver.js';
 import { findSimilarOpenStories } from '../duplicate-search.js';
 import { Logger } from '../Logger.js';
+import { parse as parseStoryBody } from '../story-body/story-body.js';
 import {
   renderAcceptanceSpecSystemPrompt,
   renderTechSpecSystemPrompt,
@@ -353,6 +354,111 @@ function resolveRiskHeuristics(config = {}) {
   return [];
 }
 
+/**
+ * Ceilings a seed's advisory complexity signals must fit for the plan
+ * workflow to **suggest** `/deliver-light` at Gate #1 (Story #4741 R3 plan-side
+ * handshake). Framework constants, not operator knobs — mirroring the
+ * conservative intent of `complexity-gate.js`'s `STORY_SHAPE_CEILINGS`
+ * (small, mostly-additive, non-sensitive) but read against the *seed-time*
+ * signals rather than an authored Story shape.
+ *
+ * The suggestion is **advisory only and never an automatic reroute**: it
+ * surfaces at Gate #1 for the operator to decide, and under `--yes` it is
+ * recorded on the envelope while planning proceeds unchanged. `/deliver-light`
+ * is a sibling Story; these ceilings define the plan side of the routing
+ * handshake independently of it.
+ *
+ *   - `maxArtifacts`           — enumerated seed items (one artifact each).
+ *   - `maxRiskHeuristicHits`   — any risk-heuristic hit disqualifies: risk
+ *                                is exactly what a light path should not carry.
+ *   - `maxSensitivePathClasses`— any sensitive-path class disqualifies, the
+ *                                same taxonomy close applies to a landed diff.
+ */
+const DELIVER_LIGHT_SUGGESTION_CEILINGS = Object.freeze({
+  maxArtifacts: 2,
+  maxRiskHeuristicHits: 0,
+  maxSensitivePathClasses: 0,
+});
+
+/**
+ * Derive the advisory `/deliver-light` suggestion from a seed's complexity
+ * signals (Story #4741 AC-6). Pure and total: a malformed / missing signal
+ * bag fails conservative (not suggested), never throws.
+ *
+ * `automatic: false` is part of the contract — the suggestion is surfaced for
+ * the operator, never a silent reroute of a non-interactive run.
+ *
+ * @param {object|null|undefined} complexitySignals
+ * @returns {{
+ *   suggested: boolean,
+ *   automatic: false,
+ *   advisory: true,
+ *   ceilings: typeof DELIVER_LIGHT_SUGGESTION_CEILINGS,
+ *   reasons: string[],
+ * }}
+ */
+export function buildDeliverLightSuggestion(complexitySignals) {
+  const ceilings = DELIVER_LIGHT_SUGGESTION_CEILINGS;
+  const advisory = /** @type {const} */ (true);
+  const automatic = /** @type {const} */ (false);
+  const s = complexitySignals ?? {};
+  const artifactCount = Number.isInteger(s.artifactCount)
+    ? s.artifactCount
+    : Number.POSITIVE_INFINITY;
+  const riskHits = Array.isArray(s.riskHeuristicHits)
+    ? s.riskHeuristicHits.length
+    : Number.POSITIVE_INFINITY;
+  const sensitive = Array.isArray(s.sensitivePathClasses)
+    ? s.sensitivePathClasses.length
+    : Number.POSITIVE_INFINITY;
+
+  const reasons = [];
+  if (artifactCount > ceilings.maxArtifacts) {
+    reasons.push(
+      `seed enumerates ${artifactCount} artifacts (> ${ceilings.maxArtifacts})`,
+    );
+  }
+  if (riskHits > ceilings.maxRiskHeuristicHits) {
+    reasons.push(`seed hits ${riskHits} risk-heuristic phrase(s)`);
+  }
+  if (sensitive > ceilings.maxSensitivePathClasses) {
+    reasons.push(
+      `predicted footprint touches ${sensitive} sensitive-path class(es)`,
+    );
+  }
+
+  const suggested = reasons.length === 0;
+  return {
+    suggested,
+    automatic,
+    advisory,
+    ceilings,
+    reasons: suggested
+      ? [
+          `seed fits the /deliver-light ceilings (≤${ceilings.maxArtifacts} artifacts, ` +
+            'no risk-heuristic hits, no sensitive-path classes) — the operator ' +
+            'may prefer /deliver-light for this scope',
+        ]
+      : reasons,
+  };
+}
+
+/**
+ * Attach the advisory `/deliver-light` suggestion to a complexity-signals bag
+ * as a **nested** field (Story #4741). Nesting — rather than a new top-level
+ * envelope key — keeps every existing per-mode envelope key set byte-stable
+ * (AC-5): the suggestion is derived from the signals it rides on.
+ *
+ * @param {object} complexitySignals
+ * @returns {object} the same signals plus `deliverLightSuggestion`.
+ */
+function withDeliverLightSuggestion(complexitySignals) {
+  return {
+    ...complexitySignals,
+    deliverLightSuggestion: buildDeliverLightSuggestion(complexitySignals),
+  };
+}
+
 /**
  * Count top-level enumerated items (`- `, `* `, `1. `) under the first
  * scope-shaped `## ` heading (Scope / MVP Scope / Proposed Scope / Work
@@ -588,13 +694,17 @@ async function buildSeedFileModeEnvelope({
     seed: { path: seedFilePath ?? null, content },
     // Advisory complexity signals only (Story #4722): no route, no routing
     // authority. The planner authors the trivial-vs-standard verdict; persist
-    // validates a lite claim against the authored Story's shape.
-    complexitySignals: buildComplexitySignals({
-      seedText: content,
-      config,
-      riskHeuristics: heuristics,
-      cwd,
-    }),
+    // validates a lite claim against the authored Story's shape. The nested
+    // `deliverLightSuggestion` is the advisory plan-side routing handshake
+    // (Story #4741 AC-6) — never an automatic reroute.
+    complexitySignals: withDeliverLightSuggestion(
+      buildComplexitySignals({
+        seedText: content,
+        config,
+        riskHeuristics: heuristics,
+        cwd,
+      }),
+    ),
     duplicates,
     docsContext,
     codebaseSnapshot: authoring.codebaseSnapshot,
@@ -748,12 +858,14 @@ async function buildTicketsModeEnvelope({
     mode: 'tickets',
     sourceTickets,
     seed: { text: seed, path: null },
-    complexitySignals: buildComplexitySignals({
-      seedText: seed,
-      config,
-      riskHeuristics: heuristics,
-      cwd,
-    }),
+    complexitySignals: withDeliverLightSuggestion(
+      buildComplexitySignals({
+        seedText: seed,
+        config,
+        riskHeuristics: heuristics,
+        cwd,
+      }),
+    ),
     duplicates,
     docsContext,
     codebaseSnapshot: authoring.codebaseSnapshot,
@@ -779,6 +891,122 @@ async function buildTicketsModeEnvelope({
   };
 }
 
+/**
+ * Parse a prior Story body into its acceptance criteria and delivered file
+ * map. Total: an unparseable body degrades to empty lists (a delta envelope
+ * grounded on whatever survived), never a throw.
+ *
+ * @param {string} priorBody
+ * @returns {{ priorAcceptance: string[], deliveredFiles: string[] }}
+ */
+function extractPriorArtifacts(priorBody) {
+  let parsed;
+  try {
+    parsed = parseStoryBody(priorBody).body;
+  } catch {
+    return { priorAcceptance: [], deliveredFiles: [] };
+  }
+  const priorAcceptance = Array.isArray(parsed.acceptance)
+    ? parsed.acceptance.filter((a) => typeof a === 'string' && a.length > 0)
+    : [];
+  const deliveredFiles = Array.isArray(parsed.changes)
+    ? parsed.changes
+        .map((c) => (c && typeof c === 'object' ? c.path : c))
+        .filter((p) => typeof p === 'string' && p.length > 0)
+    : [];
+  return { priorAcceptance, deliveredFiles };
+}
+
+/**
+ * Build the amendment (delta) envelope — `plan-context --amends #<id>`
+ * (Story #4741 AC-4, R3-A). The heavy-amendment counterpart to routing a
+ * light amendment through `/deliver-light`: instead of re-interrogating the
+ * repo from scratch (`buildAuthoringContext`'s codebase snapshot and the BDD /
+ * memory / feedback probes), the envelope composes a DELTA from what already
+ * exists — the prior Story's body, its acceptance criteria (the real
+ * contract), and its delivered file map — so a follow-up change plans from the
+ * shape already shipped.
+ *
+ * The semantic steps that reach the ticket are preserved: the open-Story
+ * duplicate search (excluding the amended Story itself), the risk heuristics,
+ * and the authoring system prompts all still ride the envelope. What is
+ * dropped is only the from-scratch repo interrogation the prior artifacts
+ * already stand in for — that is the round-trip diet, not an amputation.
+ *
+ * @param {{
+ *   amendsId: number,
+ *   provider: object,
+ *   config: object,
+ *   settings: object,
+ *   cwd?: string,
+ * }} args
+ * @returns {Promise<object>}
+ */
+async function buildAmendmentModeEnvelope({
+  amendsId,
+  provider,
+  config,
+  settings: _settings,
+  cwd,
+}) {
+  if (!provider || typeof provider.getTicket !== 'function') {
+    throw new Error(
+      '[plan-context] --amends requires provider.getTicket() to load the prior Story.',
+    );
+  }
+  const prior = await provider.getTicket(amendsId);
+  if (!prior) {
+    throw new Error(
+      `[plan-context] --amends #${amendsId}: prior Story not found — nothing to amend.`,
+    );
+  }
+  const priorBody = typeof prior.body === 'string' ? prior.body : '';
+  const { priorAcceptance, deliveredFiles } = extractPriorArtifacts(priorBody);
+
+  const heuristics = resolveRiskHeuristics(config);
+  const limits = getLimits(config);
+  const duplicates = await searchStoryDuplicates({
+    seed: priorBody,
+    provider,
+    config,
+    excludeIds: [amendsId],
+  });
+
+  return {
+    mode: 'amends',
+    amends: {
+      id: Number(prior.id ?? prior.number ?? amendsId),
+      title: prior.title ?? '',
+      priorBody,
+      priorAcceptance,
+      deliveredFiles,
+    },
+    // The prior body is the seed the delta is authored against.
+    seed: { text: priorBody, path: null },
+    complexitySignals: withDeliverLightSuggestion(
+      buildComplexitySignals({
+        seedText: priorBody,
+        config,
+        riskHeuristics: heuristics,
+        cwd,
+      }),
+    ),
+    duplicates,
+    // No plan temp dir and no from-scratch repo interrogation — the prior
+    // artifacts are the grounding, so there is no docs digest to anchor.
+    docsContext: null,
+    ticketSchema: TICKET_SCHEMA_DESCRIPTOR,
+    maxTickets: limits.maxTickets,
+    riskHeuristics: heuristics,
+    systemPrompts: buildSystemPrompts({
+      heuristics,
+      maxTickets: limits.maxTickets,
+    }),
+    planState: null,
+    planProfile: 'story-amendment',
+  };
+}
+
 /**
  * Build the single planner-context envelope.
  *
@@ -787,11 +1015,12 @@ async function buildTicketsModeEnvelope({
  * bound it (see {@link assertPlanContextWithinCeiling}).
  *
  * @param {{
- *   mode: 'seed-file'|'seed'|'tickets',
+ *   mode: 'seed-file'|'seed'|'tickets'|'amends',
  *   seedFilePath?: string,
  *   seedFileContent?: string,
  *   seedText?: string,
  *   ticketIds?: number[],
+ *   amendsId?: number,
  *   provider: object,
  *   config: object,
  *   settings: object,
@@ -805,6 +1034,7 @@ export async function buildPlanContext({
   seedFileContent,
   seedText,
   ticketIds,
+  amendsId,
   provider,
   config = {},
   settings = {},
@@ -817,6 +1047,7 @@ export async function buildPlanContext({
       seedFileContent,
       seedText,
       ticketIds,
+      amendsId,
       provider,
       config,
       settings,
@@ -835,11 +1066,21 @@ async function buildPlanContextEnvelope({
   seedFileContent,
   seedText,
   ticketIds,
+  amendsId,
   provider,
   config,
   settings,
   cwd,
 }) {
+  if (mode === 'amends') {
+    return buildAmendmentModeEnvelope({
+      amendsId,
+      provider,
+      config,
+      settings,
+      cwd,
+    });
+  }
   if (mode === 'seed-file') {
     if (!seedFilePath && typeof seedFileContent !== 'string') {
       throw new Error(
@@ -875,6 +1116,6 @@ async function buildPlanContextEnvelope({
     });
   }
   throw new Error(
-    `[plan-context] unknown mode "${mode}" — expected "seed", "seed-file", or "tickets".`,
+    `[plan-context] unknown mode "${mode}" — expected "seed", "seed-file", "tickets", or "amends".`,
   );
 }

package/.agents/scripts/lib/orchestration/story-deliver-terminal.js

@@ -61,6 +61,15 @@ export const TERMINAL_EXIT_CODES = Object.freeze({
   pending: 3,
   blocked: 1,
   failed: 1,
+  /**
+   * `escalated` reuses **2**, the code `/deliver-light` already documents for
+   * "the gate did not proceed light" — the escalation is that outcome made
+   * terminal, not a new one, so giving it a fresh code would fork a vocabulary
+   * callers already branch on. It stays distinct from `landed` (nothing was
+   * delivered) and from `blocked`/`failed` (nothing is wrong — the work simply
+   * belongs to `/plan`).
+   */
+  escalated: 2,
 });
 
 export const TERMINAL_STATUSES = Object.freeze([
@@ -68,13 +77,38 @@ export const TERMINAL_STATUSES = Object.freeze([
   'pending',
   'blocked',
   'failed',
+  'escalated',
 ]);
 
+/** Cap on the prompt echoed into an escalation's `/plan` next command. */
+const PLAN_PROMPT_MAX = 200;
+
+/**
+ * Render an operator prompt safe to sit inside the double quotes of the
+ * `/plan "<prompt>"` next command: collapse newlines (a next command is one
+ * line by contract), escape backslashes and double quotes so the quoting
+ * cannot be broken out of, and cap the length so a long prompt does not turn
+ * the envelope into a transcript. Total — a non-string yields the empty
+ * string, which the escalation builder rejects rather than emitting.
+ *
+ * @param {unknown} prompt
+ * @returns {string}
+ */
+function quoteForPlan(prompt) {
+  const text =
+    typeof prompt === 'string' ? prompt.replace(/\s+/g, ' ').trim() : '';
+  const capped =
+    text.length > PLAN_PROMPT_MAX
+      ? `${text.slice(0, PLAN_PROMPT_MAX - 1).trimEnd()}…`
+      : text;
+  return capped.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
 /**
  * The shared next-command vocabulary. Every producer of a "what now?"
- * answer — the `pending` terminal envelope and `deliver-recover.js` —
- * builds its command from here, so the two surfaces never drift into
- * naming different commands for the same observed state.
+ * answer — the `pending` terminal envelope, an `escalated` one, and
+ * `deliver-recover.js` — builds its command from here, so the surfaces never
+ * drift into naming different commands for the same observed state.
  */
 export const NEXT_COMMANDS = Object.freeze({
   /**
@@ -104,6 +138,18 @@ export const NEXT_COMMANDS = Object.freeze({
   /** Probe a stranded Story and print its single next command. */
   recover: (storyId) =>
     `node .agents/scripts/deliver-recover.js --story ${storyId}`,
+  /**
+   * Hand over-scope work to `/plan` — the next command of an `escalated`
+   * terminal (Story #4746).
+   *
+   * The only entry here that is a slash command rather than a script, and
+   * deliberately so: the other entries resume a Story that exists, while this
+   * one names work that has no Story yet and needs planning before it can have
+   * one. It is quoted for a shell but addressed to a **fresh session** — see
+   * the workflow's escalation section for why running it in the escalating
+   * session is forbidden.
+   */
+  escalateToPlan: (prompt) => `/plan "${quoteForPlan(prompt)}"`,
 });
 
 /** @type {Function|null} */
@@ -165,8 +211,9 @@ function compact(obj) {
  * this replaces.
  *
  * @param {object} args
- * @param {number} args.storyId
- * @param {'landed'|'pending'|'blocked'|'failed'} args.status
+ * @param {number|null} args.storyId `null` only for an `escalated` terminal,
+ *   which by construction never authored a Story.
+ * @param {'landed'|'pending'|'blocked'|'failed'|'escalated'} args.status
  * @param {string} args.phase
  * @param {string} [args.storyBranch]
  * @param {string} [args.baseBranch]
@@ -175,6 +222,7 @@ function compact(obj) {
  * @param {object|null} [args.tail]
  * @param {object|null} [args.blocked]
  * @param {object|null} [args.failure]
+ * @param {object|null} [args.escalation]
  * @param {string|null} [args.nextCommand]
  * @param {number} args.elapsedSeconds
  * @param {object|null} [args.waitBudget]
@@ -192,6 +240,7 @@ export function buildTerminalEnvelope({
   tail,
   blocked,
   failure,
+  escalation,
   nextCommand,
   elapsedSeconds = 0,
   waitBudget,
@@ -199,7 +248,10 @@ export function buildTerminalEnvelope({
 }) {
   const envelope = compact({
     kind: TERMINAL_ENVELOPE_KIND,
-    storyId: Number(storyId),
+    // `Number(null)` is 0, which would quietly satisfy nothing and confuse
+    // everything — a nullish storyId stays null and lets the schema decide
+    // whether this status is allowed to omit one.
+    storyId: storyId === null || storyId === undefined ? null : Number(storyId),
     status,
     phase,
     storyBranch: storyBranch ?? null,
@@ -209,6 +261,7 @@ export function buildTerminalEnvelope({
     tail: tail ?? null,
     blocked: blocked ?? null,
     failure: failure ?? null,
+    escalation: escalation ?? null,
     nextCommand: nextCommand ?? null,
     elapsedSeconds: Math.max(0, Number(elapsedSeconds) || 0),
     waitBudget: waitBudget ?? null,
@@ -225,6 +278,69 @@ export function buildTerminalEnvelope({
   return envelope;
 }
 
+/**
+ * Build the `escalated` terminal — the one envelope emitted before a Story
+ * exists (Story #4746).
+ *
+ * `/deliver-light`'s suitability gate already decided correctly when it
+ * overrode a `lite` self-verdict on shape; what it lacked was an outcome a
+ * session could not walk past. A mandrel-bench 2.13.0 light-arm run did
+ * exactly that — it read the gate's `escalate-plan`, then invoked `/plan`
+ * in the same session and delivered. The continuation was not harmless:
+ * planning inside a session already framed as small work authored ONE Story
+ * against the scenario's 3-5 contract, where a fresh `/plan` session on the
+ * identical seed authored four. Escalation silently produced the very
+ * under-decomposition the guard exists to prevent.
+ *
+ * So the outcome is a validated envelope with its own exit code, naming the
+ * `/plan` command that owns the work, and asserting per artifact that nothing
+ * was started. Every guarantee here is enforced by the schema rather than by
+ * prose: `storyId` must be null, `escalation.created.*` are pinned `false`.
+ *
+ * @param {{
+ *   prompt: string,
+ *   reasons?: string[],
+ *   elapsedSeconds?: number,
+ *   timestamp?: string,
+ * }} args
+ * @returns {object} The validated `escalated` envelope.
+ */
+export function buildEscalationTerminal({
+  prompt,
+  reasons,
+  elapsedSeconds = 0,
+  timestamp,
+}) {
+  const quoted = quoteForPlan(prompt);
+  if (quoted === '') {
+    // An escalation whose next command is `/plan ""` hands the operator
+    // nothing — the same walk-past-able non-outcome in envelope clothing.
+    throw new TypeError(
+      'buildEscalationTerminal: a non-empty prompt is required — the escalated terminal exists to name the /plan invocation that owns the work',
+    );
+  }
+  const recorded = (Array.isArray(reasons) ? reasons : []).filter(
+    (r) => typeof r === 'string' && r.trim() !== '',
+  );
+  return buildTerminalEnvelope({
+    storyId: null,
+    status: 'escalated',
+    phase: 'suitability-gate',
+    escalation: {
+      reasons:
+        recorded.length > 0
+          ? recorded
+          : ['predicted scope exceeds the light ceilings — escalate to /plan'],
+      // Not computed from anything: the escalation path returns before the
+      // receipt/init call sites, so these are the assertion that it did.
+      created: { receiptStory: false, storyBranch: false, worktree: false },
+    },
+    nextCommand: NEXT_COMMANDS.escalateToPlan(prompt),
+    elapsedSeconds,
+    ...(timestamp === undefined ? {} : { timestamp }),
+  });
+}
+
 /**
  * Resolve the process exit code for a terminal envelope.
  *

package/.agents/scripts/plan-context.js

@@ -17,6 +17,12 @@
  *   --tickets 123[,456…]      Analyze existing issue(s) into proper
  *                             Stories. Envelope carries `sourceTickets[]`.
  *
+ *   --amends 123 | #123       Amendment (delta) planning. Composes a DELTA
+ *                             envelope from the prior Story's body, its
+ *                             acceptance criteria, and its delivered file map
+ *                             instead of re-interrogating the repo from
+ *                             scratch (Story #4741). Envelope carries `amends`.
+ *
  * Flags:
  *   --out <path>     Write the envelope to <path> (parent dirs created).
  *                    `/plan` points this at `<plan-dir>/plan-context.json`,
@@ -83,6 +89,25 @@ export function parseTicketIds(raw) {
   return [...new Set(ids)];
 }
 
+/**
+ * Parse a single `--amends` id, tolerating a leading `#` (`#123` or `123`).
+ *
+ * @param {string} raw
+ * @returns {number}
+ */
+export function parseAmendsId(raw) {
+  if (typeof raw !== 'string' || raw.trim().length === 0) {
+    throw new Error('--amends requires a single prior Story id.');
+  }
+  const id = Number(raw.trim().replace(/^#/, ''));
+  if (!Number.isInteger(id) || id <= 0) {
+    throw new Error(
+      `--amends expects a positive integer Story id; got ${JSON.stringify(raw)}`,
+    );
+  }
+  return id;
+}
+
 /**
  * Build the envelope and write it to `stdout` as a single JSON line
  * (or pretty-printed with --pretty). Exported for tests.
@@ -96,6 +121,7 @@ export async function emitPlanContext({
   seedFileContent,
   seedText,
   ticketIds,
+  amendsId,
   provider,
   config,
   settings,
@@ -110,6 +136,7 @@ export async function emitPlanContext({
     seedFileContent,
     seedText,
     ticketIds,
+    amendsId,
     provider,
     config,
     settings,
@@ -139,14 +166,19 @@ export async function emitPlanContext({
       duplicates: (envelope.duplicates ?? []).length,
       // Advisory only (Story #4722): signals, no route — the planner owns
       // the trivial-vs-standard verdict and persist validates it by shape.
+      // The nested `deliverLightSuggestion` is the recorded plan-side routing
+      // handshake (Story #4741 AC-6) — advisory, never an automatic reroute.
       complexitySignals: envelope.complexitySignals
         ? {
             artifactCount: envelope.complexitySignals.artifactCount,
             riskHeuristicHits: envelope.complexitySignals.riskHeuristicHits,
             sensitivePathClasses:
               envelope.complexitySignals.sensitivePathClasses,
+            deliverLightSuggestion:
+              envelope.complexitySignals.deliverLightSuggestion ?? null,
           }
         : null,
+      amends: envelope.amends ? { id: envelope.amends.id } : null,
     };
     stdout.write(`${JSON.stringify(digest)}\n`);
   } else {
@@ -221,6 +253,7 @@ async function main() {
       seed: { type: 'string' },
       'seed-file': { type: 'string' },
       tickets: { type: 'string' },
+      amends: { type: 'string' },
       out: { type: 'string' },
       pretty: { type: 'boolean', default: false },
     },
@@ -234,16 +267,24 @@ async function main() {
     typeof seedFilePath === 'string' && seedFilePath.length > 0;
   const hasTickets =
     typeof values.tickets === 'string' && values.tickets.trim().length > 0;
-  const entryForms = [hasSeed, hasSeedFile, hasTickets].filter(Boolean).length;
+  const hasAmends =
+    typeof values.amends === 'string' && values.amends.trim().length > 0;
+  const entryForms = [hasSeed, hasSeedFile, hasTickets, hasAmends].filter(
+    Boolean,
+  ).length;
   if (entryForms !== 1) {
     throw new Error(
-      'Pass exactly one of --seed "<text>", --seed-file <path>, or --tickets <ids>.',
+      'Pass exactly one of --seed "<text>", --seed-file <path>, --tickets <ids>, or --amends <id>.',
     );
   }
 
   let mode;
   let ticketIds;
-  if (hasTickets) {
+  let amendsId;
+  if (hasAmends) {
+    mode = 'amends';
+    amendsId = parseAmendsId(values.amends);
+  } else if (hasTickets) {
     mode = 'tickets';
     ticketIds = parseTicketIds(values.tickets);
   } else if (hasSeedFile) {
@@ -288,6 +329,7 @@ async function main() {
         seedFilePath: hasSeedFile ? seedFilePath : undefined,
         seedText: hasSeed ? seedText : undefined,
         ticketIds,
+        amendsId,
         provider,
         config,
         settings,