@aui.io/apollo 0.1.84 → 0.1.87

package/README.md

@@ -65,10 +65,10 @@ apollo validate
 # 5. Talk to it against the live runtime WITHOUT deploying, and read the trace
 apollo chat "I want to return an order" --local . --trace
 
-# 6. Push the change as a new version, then publish it when it is ready
+# 6. Push the change, then make that SAVE the one customers get, when it is ready
 apollo push -m "Describe the change"
-apollo version list
-apollo version publish <tag>
+apollo branch list
+apollo branch live <tag>          # `v3.7` ships exactly that save; `v3` ships its newest
 ```
 
 `apollo status` always tells you where you stand — which profile, organization, project,
@@ -87,7 +87,7 @@ to that agent.
 | **Project** | A container for agents | `project list / use / create` |
 | **Agent** | The program you edit and test | `agent list / create / import / use / unlink` |
 | **Checkout** | A local directory holding one agent: `.apollorc` + `bundle/src/` | `agent create / import` |
-| **Version** | A tagged snapshot of the program: draft → published → archived (publishing an older version is the rollback) | `version list / get / use / create / publish / archive`, `pull` / `push` |
+| **Version** | A tagged snapshot of the program: draft → published → archived (publishing an older version is the rollback) | `branch list / get / use / create / publish / archive`, `pull` / `push` |
 | **Runtime** | The engine build the checkout is pinned to | `runtime list / show / use` |
 
 ## Commands

package/node_modules/@aui.io/apollo-cli/dist/src/commands/bundles.js

@@ -3,18 +3,24 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { renderBundleAudit, renderValidation } from "@aui.io/apollo-core/bundle/validate.js";
 import { defaultCheckoutDir, listCheckouts, registerCheckout, } from "@aui.io/apollo-core/checkouts/registry.js";
+import { branchName, branchState, continuedName, parseVersionTag } from "@aui.io/apollo-core/api/management.js";
+import { requireUserId } from "@aui.io/apollo-core/config/index.js";
 import { ConfigError, ValidationError } from "@aui.io/apollo-core/errors/index.js";
 import { assertRuntimeAvailable } from "@aui.io/apollo-core/runtime-version/availability.js";
 import { adviseLocalBundle } from "@aui.io/apollo-core/services/advisor.js";
 import { buildAgent } from "@aui.io/apollo-core/services/builds.js";
 import { annotateRun, awaitRun, pullRun, receiptId, resolveRunId, startEvaluation, startRegression, } from "@aui.io/apollo-core/services/runs.js";
-import { importBundle, listVersions, localDiff, pullCheckout, pushBundle, remoteDiff, applyBundleFixes, bundleSourceRoot, validateLocalBundle, } from "@aui.io/apollo-core/services/bundles.js";
+import { branchLog, importBundle, listVersions, localDiff, pullCheckout, pushBundle, remoteDiff, applyBundleFixes, bundleSourceRoot, validateLocalBundle, } from "@aui.io/apollo-core/services/bundles.js";
+import { describeMerge, diffAgainst, fetchVersion, mergeFrom, } from "@aui.io/apollo-core/services/versions.js";
 import { checkoutSchemasDir, installSchemas, } from "@aui.io/apollo-core/schemas/install.js";
 import { createClients } from "@aui.io/apollo-core/services/clients.js";
 import { agentRuntimeVersion, listAgents, useVersion, } from "@aui.io/apollo-core/services/hierarchy.js";
 import { installAgentsPage } from "@aui.io/apollo-core/skills/agents-page.js";
 import { installSkills, } from "@aui.io/apollo-core/skills/install.js";
 import { resolvePickerId } from "./picker.js";
+/** `branch log`'s default page, and apollo's internal page cap. */
+const COMMIT_PAGE = 20;
+const MAX_COMMIT_PAGE = 1000;
 function renderDiff(diff) {
     const rows = [
         ...diff.added.map((file) => `A  ${file}`),
@@ -173,6 +179,16 @@ async function runAction(run, builder, kind, root, options) {
     }
     return true;
 }
+/** A pulled or imported commit that still carries a secret file on the server
+ *  (pushed before secret files stayed local): the file was not written and a
+ *  local copy is untouched, but the values are stored with that commit. */
+function warnServerSecrets(run, files, tag) {
+    if (!files?.length)
+        return;
+    run.output.warn(`${tag} still carries ${files.join(", ")} on the server, pushed before secret files stayed local. ` +
+        "It was not written here and any local copy is untouched, but its values are stored with that commit: " +
+        "rotate those credentials and keep them in the agent's vault (`apollo vault set <NAME>`).");
+}
 function capitalize(word) {
     return word.charAt(0).toUpperCase() + word.slice(1);
 }
@@ -530,20 +546,46 @@ export function registerBundles(program, runtime) {
     });
     program
         .command("diff")
-        .description("Compare local files with the last baseline")
+        .description("Compare local files with the last baseline, or with another version (a tag, a name, or live)")
+        .argument("[ref]", "a version to compare bundle/src with (fetched into bundle/tmp/versions/<tag>)")
         .option("--remote", "compare with the selected remote version")
-        .action(async (options) => {
+        .action(async (ref, options) => {
         const run = runtime();
         const management = createClients(run.context).management;
+        if (ref) {
+            const result = await diffAgainst(run.context, management, ref);
+            run.output.result(result, () => [
+                `${result.fetched.tag} → bundle/src${result.fetched.relation ? ` (${result.fetched.relation}${result.fetched.base ? `; common base ${result.fetched.base}` : ""})` : ""}; their copy: bundle/tmp/versions/${result.fetched.tag}/`,
+                renderDiff(result.diff),
+            ].join("\n"));
+            return;
+        }
         const diff = options.remote
             ? await remoteDiff(run.context, management)
             : await localDiff(run.context);
         run.output.result(diff, (value) => renderDiff(value));
     });
+    program
+        .command("merge-from")
+        .description("Bring another branch's changes into bundle/src (three-way over the commit both came from); disputed regions keep your text and are listed")
+        .argument("<ref>", "the version to bring in — a tag, a line (v2), a name, or live")
+        .option("--only <paths...>", "bring in only these program paths (a cherry-pick)")
+        .option("--dry-run", "report what would change without writing")
+        .option("--resolved", "every disputed region is decided at your text: a newer commit of your own branch becomes the checkout's base")
+        .action(async (ref, options) => {
+        const run = runtime();
+        const clients = createClients(run.context);
+        const merged = await mergeFrom(run.context, clients, ref, {
+            ...(options.only ? { only: options.only } : {}),
+            dryRun: options.dryRun === true,
+            resolved: options.resolved === true,
+        });
+        run.output.result(merged, () => describeMerge(merged));
+    });
     program
         .command("pull")
         .description("Pull the selected agent version plus the schemas, skills and AGENTS.md its runtime serves")
-        .option("--tag <tag>", "version tag")
+        .option("--tag <branch>", "switch to a branch and pull its newest commit (v2, its name, its newest tag, or live)")
         .option("--dir <directory>", "destination directory")
         .option("--force", "discard local bundle changes and match remote")
         .option("--skills <targets>", "comma-separated cursor,claude,opencode", "cursor,claude")
@@ -559,6 +601,7 @@ export function registerBundles(program, runtime) {
             skills: options.skills === false ? false : targets(String(options.skills)),
             schemas: options.schemas,
         });
+        warnServerSecrets(run, result.serverSecretFiles, result.pull.version_tag);
         run.output.result(result, () => {
             const removed = result.removed.length > 0
                 ? ` Removed ${result.removed.length} local file(s) not in the remote bundle.`
@@ -566,9 +609,13 @@ export function registerBundles(program, runtime) {
             return [
                 // Name the tag the pull landed on — a stale pin resolves to the
                 // tip of its line, and this is where the checkout learns that.
-                `Pulled ${Object.keys(result.files).length} files at ${result.pull.version_tag}${result.runtimeVersion ? ` on runtime ${result.runtimeVersion}` : ""}.${removed}`,
+                `Pulled ${Object.keys(result.files).length} files at ${result.pull.version_tag}${result.runtimeVersion ? ` on runtime ${result.runtimeVersion}` : ""}${result.live === result.pull.version_tag ? ", the commit customers get" : ""}.${removed}`,
+                ...liveGap(result.pull.version_tag, result.live),
                 result.build
-                    ? `Build bundle v${result.build.version}: ${result.build.written.length} file(s) into bundle/build.`
+                    ? `Build bundle v${result.build.version}: ${result.build.written.length} file(s) into bundle/build.` +
+                        (result.build.askedFor
+                            ? ` It belongs with ${result.build.programVersionTag ?? "another commit"}, not the ${result.build.askedFor} you pulled — nothing has been pushed for that commit yet.`
+                            : "")
                     : "",
                 result.certificate
                     ? `Certificate: ${result.certificate.revision ?? result.certificate.version} (${result.certificate.run}), ${result.certificate.cases.length} case(s) — bundle/build/certification.yaml.`
@@ -590,6 +637,7 @@ export function registerBundles(program, runtime) {
         .description("Validate and push local changes — a changed program mints a version, a changed bundle/build ships a build bundle")
         .option("-m, --message <message>", "commit message — recorded on the revision the push mints (not the version's label)")
         .option("--dry-run", "validate and show the diff without pushing")
+        .option("--new-version [name]", "push these changes as a new branch cut from the commit they are based on (the way out when the branch moved)")
         .action(async (options) => {
         const run = runtime();
         const clients = createClients(run.context);
@@ -598,6 +646,7 @@ export function registerBundles(program, runtime) {
         const result = await pushBundle(run.context, clients, {
             ...(options.message ? { commitMessage: options.message } : {}),
             dryRun: options.dryRun === true,
+            ...(options.newVersion !== undefined ? { newVersion: options.newVersion } : {}),
         });
         run.output.result(result, () => {
             // One report, both lanes: program paths bare, build paths prefixed —
@@ -623,10 +672,21 @@ export function registerBundles(program, runtime) {
                         // one place the CLI shows it, since `version list` lists versions
                         // (label, notes) and a revision's commit message lives elsewhere.
                         `Pushed ${result.push.new_version_tag}${result.runtimeVersion ? ` on runtime ${result.runtimeVersion}` : ""}${result.push.commit_message ? ` — "${result.push.commit_message}"` : ""}.`,
+                        ...(result.newBranch ? [newBranchLine(result.newBranch)] : []),
+                        ...(result.live
+                            ? [
+                                `Customers still get ${result.live}; \`apollo branch live ${result.push.new_version_tag}\` ships this.`,
+                            ]
+                            : []),
                     ]
                     : []),
                 ...(result.buildPush
-                    ? [`Pushed build bundle v${result.buildPush.version}.`]
+                    ? [
+                        `Pushed build bundle v${result.buildPush.version}` +
+                            (result.buildPush.program_version_tag
+                                ? ` — it belongs with ${result.buildPush.program_version_tag}.`
+                                : "."),
+                    ]
                     : []),
                 // Which gate cleared the pre-flight, when it was not the pinned one —
                 // a push that rode the fallback says so rather than reading as the
@@ -651,7 +711,7 @@ export function registerBundles(program, runtime) {
         .description("Pull a cloud agent into a local checkout (interactive without an id; shell-init cds)")
         .argument("[agent-id]", "agent id")
         .option("--name <filter>", "filter the interactive picker by name")
-        .option("--tag <tag>", "version tag (defaults to the live version)")
+        .option("--tag <branch>", "the branch to start on (v2, its name, its newest tag, or live); default: live, the branch customers are on")
         .option("--dir <directory>", "checkout directory (defaults to ~/apollo/<profile>/<env>/<name>-<id>)")
         .option("--skills <targets>", "comma-separated cursor,claude,opencode", "cursor,claude")
         .option("--force", "overwrite an existing local program")
@@ -705,6 +765,7 @@ export function registerBundles(program, runtime) {
             ...(options.tag ? { tag: options.tag } : {}),
             ...(runtimeVersion ? { runtimeVersion } : {}),
         });
+        warnServerSecrets(run, imported.serverSecretFiles, imported.pull.version_tag);
         // The public floor, filtered by the wire: the index the install
         // fetches carries only public skills, and its sweep deletes managed
         // packs the index no longer names (a re-import lands in the existing
@@ -757,8 +818,13 @@ export function registerBundles(program, runtime) {
                 : {}),
         }, () => [
             `Imported ${Object.keys(imported.files).length} files into ${destination}${runtimeVersion ? ` on runtime ${runtimeVersion}` : ""}.`,
+            `On ${branchName(imported.pull)} at ${imported.pull.version_tag}${imported.live === imported.pull.version_tag ? ", the commit customers get" : ""}.`,
+            ...liveGap(imported.pull.version_tag, imported.live),
             imported.build
-                ? `Build bundle v${imported.build.version}: ${imported.build.written.length} file(s) into bundle/build.`
+                ? `Build bundle v${imported.build.version}: ${imported.build.written.length} file(s) into bundle/build.` +
+                    (imported.build.askedFor
+                        ? ` It belongs with ${imported.build.programVersionTag ?? "another commit"}, not the ${imported.build.askedFor} you imported.`
+                        : "")
                 : "",
             authoringNote ?? "",
             removedSkills.length > 0
@@ -771,36 +837,152 @@ export function registerBundles(program, runtime) {
     registerVersions(program, runtime);
 }
 function registerVersions(program, runtime) {
-    const version = program.command("version").description("Manage agent versions");
-    version.command("list").action(async () => {
+    // A version IS a branch and a revision IS a commit — the model every
+    // surface speaks, so `branch` is the command. `version` stays as an alias:
+    // it is what this group was called, and anything already scripted against
+    // it keeps working.
+    const version = program
+        .command("branch")
+        .alias("version")
+        .description("Manage the agent's branches (lines of commits)");
+    version
+        .command("list")
+        .description("List the branches: name, state, newest commit, and the commit customers get")
+        .action(async () => {
         const run = runtime();
         const result = await listVersions(run.context, createClients(run.context).management);
+        const liveBranch = result.live_version_tag ? parseVersionTag(result.live_version_tag)?.major : undefined;
         run.output.result(result, (value) => value.results
-            .map((item) => `${item.version_tag}\t${item.status}\t${item.label ?? ""}`)
-            .join("\n") || "No versions.");
+            .map((item) => `${branchName(item)}\t${branchState(item.status)}\t${item.label ?? ""}\tnewest ${item.version_tag}${item.version_number === liveBranch ? `\tlive ${result.live_version_tag}` : ""}${item.parent_version_tag ? `\tfrom ${item.parent_version_tag}` : ""}`)
+            .join("\n") || "No branches.");
+    });
+    version
+        .command("log")
+        .argument("[ref]", "a branch (v2, its name, any of its commits, or live); default: the checkout's")
+        .option("--limit <n>", `how many commits, newest first (1 to ${MAX_COMMIT_PAGE})`)
+        .description("List a branch's commits, newest first, marking its newest and the live one")
+        .action(async (ref, options) => {
+        const run = runtime();
+        const limit = integer("--limit", options.limit) ?? COMMIT_PAGE;
+        if (limit < 1 || limit > MAX_COMMIT_PAGE) {
+            throw new ConfigError(`--limit takes 1 to ${MAX_COMMIT_PAGE} (got ${limit}).`);
+        }
+        const log = await branchLog(run.context, createClients(run.context).management, {
+            ...(ref ? { ref } : {}),
+            limit,
+        });
+        run.output.result(log, () => [
+            `${branchName(log.branch)}${log.branch.label ? ` (${log.branch.label})` : ""}: ${log.total} commit(s)${log.live ? `, live ${log.live}` : ""}`,
+            ...log.commits.map((commit) => `${commit.tag}\t${commit.created_at.slice(0, 16).replace("T", " ")} UTC\t${commit.author}\t${commit.message ?? ""}${commit.newest ? "\tnewest" : ""}${commit.live ? "\tlive" : ""}`),
+            log.total > log.commits.length
+                ? `${log.total - log.commits.length} older not shown (--limit ${Math.min(log.total, MAX_COMMIT_PAGE)} lists them).`
+                : "",
+        ]
+            .filter(Boolean)
+            .join("\n"));
+    });
+    version
+        .command("fetch")
+        .argument("<ref>", "a commit (v2.7), a branch (v2 = its newest commit), a branch name, or live")
+        .description("Pull another branch's program into bundle/tmp/versions/<tag>/ (scratch, never pushed)")
+        .action(async (ref) => {
+        const run = runtime();
+        const fetched = await fetchVersion(run.context, createClients(run.context).management, ref);
+        run.output.result(fetched, () => [
+            `Fetched ${fetched.tag}${fetched.version.label ? ` (${fetched.version.label})` : ""} — ${Object.keys(fetched.files).length} files into bundle/tmp/versions/${fetched.tag}/.`,
+            fetched.relation
+                ? `Relation to this checkout: ${fetched.relation}${fetched.base ? `; common base ${fetched.base}` : " — no common base, a merge would be two-way"}.`
+                : "",
+        ]
+            .filter(Boolean)
+            .join("\n"));
+    });
+    version
+        .command("label")
+        .argument("<ref>")
+        .argument("<name>", "the name people refer to the version by")
+        .description("Rename a branch — the name people refer to it by")
+        .action(async (ref, name) => {
+        const run = runtime();
+        const management = createClients(run.context).management;
+        const agentId = requiredAgent(run);
+        const selected = await management.resolveVersion(agentId, ref);
+        const result = await management.updateVersion(agentId, selected.id, { label: name });
+        run.output.result(result, () => `Renamed ${result.version_tag} to "${result.label ?? name}".`);
+    });
+    version
+        .command("lock")
+        .argument("<ref>")
+        .description("Close a branch to further commits — it says nothing about what customers get")
+        .action(async (ref) => {
+        const run = runtime();
+        const management = createClients(run.context).management;
+        const agentId = requiredAgent(run);
+        const selected = await management.resolveVersion(agentId, ref);
+        const result = await management.lockVersion(agentId, selected.id, run.context.userId ?? "apollo-cli");
+        run.output.result(result, () => `Locked ${result.version_tag} — no more commits land on it, and what customers get has not changed. ` +
+            `\`apollo branch live <ref>\` picks the commit they get; \`apollo branch unlock ${branchName(result)}\` reopens this one; ` +
+            `\`apollo branch create --from ${branchName(result)}\` continues the work in a new draft.`);
+    });
+    version
+        .command("unlock")
+        .argument("<ref>")
+        .description("Reopen a locked branch so commits land on it again")
+        .action(async (ref) => {
+        const run = runtime();
+        const management = createClients(run.context).management;
+        const agentId = requiredAgent(run);
+        const selected = await management.resolveVersion(agentId, ref);
+        const result = await management.unlockVersion(agentId, selected.id);
+        run.output.result(result, () => `Unlocked ${result.version_tag} — commits land on it again. ` +
+            `What customers get is unchanged: live is a commit, not a branch's status.`);
+    });
+    version
+        .command("live")
+        .argument("<ref>")
+        .description("Make one COMMIT live — the exact bundle customers get (also how you roll back)")
+        .action(async (ref) => {
+        const run = runtime();
+        const management = createClients(run.context).management;
+        const agentId = requiredAgent(run);
+        // A ref like `v3.7` names a COMMIT; `v3` or a label names the branch,
+        // and its newest commit goes live. `resolveRef` keeps the difference.
+        const { version: selected, tag } = await management.resolveRef(agentId, ref);
+        const live = await management.activateSave(agentId, selected.id, tag);
+        run.output.result(live, () => {
+            const got = live.active_version_tag ?? tag;
+            return got === tag
+                ? `Live: ${got}. Pushing to ${branchName(selected)} will not move it — \`apollo branch live\` does.`
+                : `Live: ${got} — NOT the ${tag} you asked for. This deployment ships a branch's newest commit only.`;
+        });
     });
     version
         .command("get")
-        .argument("<tag>")
-        .action(async (tag) => {
+        .argument("<ref>", "a commit (v2.7), a branch (v2 = its newest commit), a branch name, or live")
+        .description("Show one commit and its branch")
+        .action(async (ref) => {
         const run = runtime();
-        const item = await createClients(run.context).management.resolveVersion(requiredAgent(run), tag);
-        run.output.result(item, () => `${item.version_tag}\t${item.status}\t${item.label ?? ""}${item.notes ? `\n${item.notes}` : ""}`);
+        const { version: item, tag: commit } = await createClients(run.context).management.resolveRef(requiredAgent(run), ref);
+        run.output.result({ ...item, commit_tag: commit }, () => `${commit}\t${branchName(item)}\t${branchState(item.status)}\t${item.label ?? ""}${item.notes ? `\n${item.notes}` : ""}`);
     });
     version
         .command("use")
-        .argument("<tag>")
-        .description("Bind a version tag in this checkout (push base, pull default)")
-        .action(async (tag) => {
+        .argument("<branch>", "v2, its name, its newest commit's tag, or live (the branch customers are on)")
+        .description("Work on a branch in this checkout: pushes land on it and pull follows its newest commit")
+        .action(async (ref) => {
         const run = runtime();
-        const result = await useVersion(run.context, createClients(run.context).management, tag);
-        run.output.result(result, () => result.version.version_tag === tag.trim()
-            ? `Using ${result.version.version_tag} (${result.version.status}).`
-            : `Using ${result.version.version_tag} (${result.version.status}) — resolved from ${tag}.`);
+        const previous = run.context.versionTag;
+        const result = await useVersion(run.context, createClients(run.context).management, ref);
+        const moved = previous !== result.tag;
+        run.output.result(result, () => [
+            `Using ${branchName(result.version)} (${branchState(result.version.status)}) at ${result.tag}${result.live === result.tag ? ", the commit customers get" : ""}.${moved ? " `apollo pull` brings its files." : ""}`,
+            ...liveGap(result.tag, result.live),
+        ].join("\n"));
     });
     version
         .command("create")
-        .option("--from <tag>", "clone an existing version")
+        .description("Cut a new draft branch — from a branch's newest commit, from an exact commit (v3.7), from a template, or empty")
+        .option("--from <ref>", "cut from a branch or an exact commit (v3, v3.7, a branch name, or live)")
         .option("--template <id>", "create from a template")
         .option("--label <label>")
         .option("--notes <notes>")
@@ -808,28 +990,34 @@ function registerVersions(program, runtime) {
         const run = runtime();
         const management = createClients(run.context).management;
         const agentId = requiredAgent(run);
-        const fromVersion = options.from
-            ? (await management.resolveVersion(agentId, options.from)).id
-            : undefined;
+        const from = options.from ? await management.resolveRef(agentId, options.from) : undefined;
         const created = await management.createVersion(agentId, {
-            source: fromVersion ? "version" : options.template ? "template" : "empty",
-            ...(fromVersion ? { fromVersion } : {}),
+            source: from ? "version" : options.template ? "template" : "empty",
+            createdBy: requireUserId(run.context, "branch"),
+            ...(from ? { fromVersion: from.version.id, fromVersionTag: from.tag } : {}),
             ...(options.template ? { fromTemplate: options.template } : {}),
-            ...(options.label ? { label: options.label } : {}),
+            ...(options.label
+                ? { label: options.label }
+                : from
+                    ? { label: continuedName(from.version) }
+                    : {}),
             ...(options.notes ? { notes: options.notes } : {}),
         });
-        run.output.result(created, () => `Created ${created.version_tag}.`);
+        run.output.result(created, () => `Created ${created.version_tag}${from ? ` from ${from.tag}` : ""}.` +
+            ` \`apollo branch use ${branchName(created)}\` then \`apollo pull\` to work on it.`);
     });
     version
         .command("publish")
         .argument("<tag>")
+        .description("The old one-verb ladder: lock the branch AND ship its newest commit. Prefer `branch live`")
         .action(async (tag) => {
         const run = runtime();
         const management = createClients(run.context).management;
         const agentId = requiredAgent(run);
         const selected = await management.resolveVersion(agentId, tag);
         const result = await management.publishVersion(agentId, selected.id);
-        run.output.result(result, () => `Published ${result.version_tag}.`);
+        run.output.result(result, () => `Published ${result.version_tag} — locked the branch and shipped its newest commit. ` +
+            `\`apollo branch live <ref>\` ships a commit without locking anything, and can ship an older one.`);
     });
     version
         .command("archive")
@@ -848,4 +1036,22 @@ function requiredAgent(run) {
         throw new ConfigError("Select or import an agent first.");
     return run.context.agentId;
 }
+/** What a push that started a branch says: which branch, cut from where, and why. */
+function newBranchLine(started) {
+    const why = started.closed
+        ? `${started.closed.branch} is ${branchState(started.closed.status)}, so the push started`
+        : "The push started";
+    return `${why} a new branch: ${started.branch} "${started.label}", cut from ${started.from}. This checkout now works on ${started.branch}.`;
+}
+/** When a command followed `live` past the commit customers get: how far behind that is, and how to reach it. */
+function liveGap(at, live) {
+    if (live === undefined || live === at)
+        return [];
+    const behind = (parseVersionTag(at)?.revision ?? 0) - (parseVersionTag(live)?.revision ?? 0);
+    return [
+        `Customers get ${live}, ${behind} ${behind === 1 ? "commit" : "commits"} behind:`,
+        `  apollo chat --at live "…"          talk to it`,
+        `  apollo branch create --from live   start a fix from it`,
+    ];
+}
 //# sourceMappingURL=bundles.js.map