@kedge/cli 0.10.0 → 0.10.1

package/README.md

@@ -0,0 +1,28 @@
+# @kedge/cli
+
+`kedge`, the command line of a [Kedge](https://www.npmjs.com/package/create-kedge)
+store. A new store comes from `npm create kedge@latest`; this package is one of
+its dependencies, run as `pnpm kedge <command>`.
+
+| Command | Does |
+|---|---|
+| `kedge dev` | The store on this machine, its admin at `/app/` |
+| `kedge check` | Typecheck, `generate --check`, `doctor`, then the store's tests |
+| `kedge doctor [--remote]` | The store's checks; `--remote` adds its Cloudflare credentials and resources |
+| `kedge generate` | Compose migrations and the lock from core, plugins and `local/` |
+| `kedge preview` | An isolated copy on Cloudflare, with `test/scenarios` run against it |
+| `kedge deploy` | Production: migrations first, then the Worker, under one recorded operation |
+| `kedge staff invite-owner <email>` | The first Owner's invite link (`--remote` for Cloudflare) |
+| `kedge keys create … --save` | A storefront or secret key, saved to the store's env file |
+| `kedge seed --sample apparel --url <url>` | Sample products |
+| `kedge smoke --url <url>` | A test order, placed; run again, the same order |
+| `kedge upgrade --to <version>` | Every `@kedge` package to a release, with its codemods |
+
+**For agents.** Exit `0` done, `1` refused or failed (the reason on stderr), `2`
+usage, `3` a person must act: the last line of stderr starts `for you:` and is one
+sentence to pass on. Run the same command again after they do; every command is
+safe to repeat. With `--json`, stdout is one object, `{"ok": true, ...}`,
+`{"ok": false, "error"}` or `{"ok": false, "handoff"}`.
+
+Cloudflare credentials come from the environment, then the store's `.env.local`,
+then `wrangler login`; `CLOUDFLARE_API_BASE_URL` is honoured for every call.

package/kedge-manifest.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.10.0",
-  "upgradesFrom": "0.9.0",
+  "version": "0.10.1",
+  "upgradesFrom": "0.10.0",
   "doStateFormat": 1,
   "migrations": {
     "0000_schema.sql": {
@@ -143,7 +143,8 @@
   "packages": {
     "@kedge/core": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
-      "package.json": "fe58d717c5be02f0eaaebef065ddd26fb60697d5cea7d804a88270d8d917c53e",
+      "README.md": "5cffa13dcc33f4c3c39adb020a8c589722a88ed904033de1f16385a8a3e67236",
+      "package.json": "9593f2661eb8c3b199da8260de0439e85a6a5bbd53c5f79904df19a9767b76f3",
       "src/access/audit.ts": "374bf28051543e2cfc3a92f6dd3b27525562eb76d12d0628951da855323be120",
       "src/access/context.ts": "bf4d50e4473ebe99aea6e6d673b0006595bb5bcf47e9f34c094fa4d9c6fea5e7",
       "src/access/permissions.ts": "0e71620cf6dcddd414bdba4634986366f6c37c8d94f419c4fdd289131b5771da",
@@ -190,6 +191,7 @@
     },
     "@kedge/db": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
+      "README.md": "02526e2c786cd6e421e6bbd3689cac5fe8641578092baf07902cd65d6d102569",
       "migrations/0000_schema.sql": "31d99f65263f43480cc25e249197a6555e33166e28785cf0859b7cfd2bed53ad",
       "migrations/0001_triggers.sql": "61f5a9a0aec224dc5b69778a4143f3476d5c814350979bfbbb9547269bd688f7",
       "migrations/0002_stock_bounds.sql": "4e4b63d22aacceb196a2a54caadee9619d392b83b2eb82a3396871f0538d914b",
@@ -221,7 +223,7 @@
       "migrations/0028_tracks_entities.sql": "bbdad5c12570bc528abd5b294fa4277b780940fcf773ea67403e9b2324321c12",
       "migrations/0029_cli_session.sql": "a883b970c2820a84ac3e0c65530681df488ecc0546ebf29a43bc9a5778e8c1f9",
       "migrations/0030_credential_ref.sql": "b06cee4958d222a93d0af1b6a57e260beb98a92a9a1b2ba4c7a895fc40b79201",
-      "package.json": "2d61ec5e5da2667b39cab8d57ef3a224c601aed3c9c44bd3d72a14451983f5a9",
+      "package.json": "311c0d8fa2fb339c4e8bda31d005e68233c5fd1f83ab116af5921e9cccd55792",
       "src/access-sql.ts": "51481f129f4614ba770218526048042aa0d118274ce7a737e0584037ea59dff0",
       "src/access.ts": "933e0fcaed1d0aca624df7556f3aab7368aa33793619b29e3ad10f610842db44",
       "src/admin.ts": "694d508e2bb51eda9134d163b049240688d5fdcd6783a66e2ae18bf9da21d140",
@@ -262,7 +264,8 @@
     },
     "@kedge/server": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
-      "package.json": "1e943bb847224dd1df5d310d51aaa221e71dcc0b1df9c8ce76028c8f0d7ca048",
+      "README.md": "1fb1bcd08cc11851accb343d6df724383706cf9324d58785d097431476524b26",
+      "package.json": "44dc6665b926a512f039e1b58b22530ba2300d39761e9adc7766f3e41b5832e2",
       "src/access.ts": "224341803cb2448ab9458c4757035abc7344c0748e261ffcf18a6b072c3ebfa0",
       "src/admin-routes.ts": "9c1f13283f1b11709c0d27512205d9ead59a9042a4df36fa1bec344184ad7d0e",
       "src/admin-shell.ts": "3b94e14e3cd8303fd7f3153a65ce7c3339203b58f74656c40839587ca996a7c3",
@@ -284,7 +287,8 @@
     },
     "@kedge/runtime-cf": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
-      "package.json": "8f28ac1819e6e1ae515b499709e5d0770abf11ebe0a004d6d78aad93d28a3aa1",
+      "README.md": "b678c333e82364c5e9349bb1aa4f64d1479678893b471ddc0c4ea41b769adef9",
+      "package.json": "0ee37754d1a8d0d663927c7504193befbc302c0ff63e0609eb6729e9371860db",
       "src/admin.ts": "2c005857fe2928b4e82777590f13f7a83e26edfa30b24f5463ee0c80932b2ca0",
       "src/cart-do.ts": "d7be874e440d41b716a96607341b82b0992a9da1656456322fca3634f6be8529",
       "src/clock-do.ts": "8d68b0ba01d16763fe7d13feee71d315bbc1ebbee7e5f8694a9d186c4ccab3a5",
@@ -310,12 +314,14 @@
     },
     "@kedge/plugin-sdk": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
-      "package.json": "ff1cf9398e25997dda431c9d671a89b95142ff1263ec4fd5be1078039bbf19ab",
+      "README.md": "685a9eede5493ce08535b0525cf30b1290d48ba9e75b3662239fb5b6e08d3baa",
+      "package.json": "c0ed2f482fdac69c049eb76eee53f5ee1ad9918dbd33714515e09a91ac214fd0",
       "src/index.ts": "cb2aa938e2065f6ca5f01a470b421ec0ca20599f149114051823e2510a76d11b"
     },
     "@kedge/testing": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
-      "package.json": "83a2a8ea4c49397908896974b716799f861992814b26cc67b1cf060ef08acb1b",
+      "README.md": "94da183c9b4fdb9617dbe93cfb169b81ce4bd6ed7c9a364d6d6ad3e62578d9cc",
+      "package.json": "1cd6b1b4d32fb197fc6a11ba1c7531e20e56cfb58245cb70a38937579442a77e",
       "src/budgets.ts": "4ffb780a7543d1d2c7c7e5dca7a2d4cdb363e3b0ee2801a928d928da8088e525",
       "src/http.ts": "59c4bb9d3df6885333103a05cddde0d03cc70008a416c99905422fbead034ee7",
       "src/index.ts": "c3705394753e6c6ecf3abfd19a3b1e672c61c33bda4ff8f2d54ece10f506b5cd",
@@ -327,6 +333,7 @@
     },
     "@kedge/docs": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
+      "README.md": "e131075a2958e014a2c2dcaa33882d04deeadedd52d2f692a04fe7d1af669905",
       "extending/admin.md": "4514c38097dc5442b1ec6761c337689dd1f0c76b1320184c1417c4bb34704464",
       "extending/contributions.md": "2f970bd64f1e131a408c494e867060907e8d2c83b9f89efd02ae4618aa49be5b",
       "extending/custom-fields.md": "ccdd0d83b8c54d72992b43cad3a7742c42b65009b863b44c71006ad7255fb900",
@@ -339,15 +346,16 @@
       "extending/timers.md": "6da7fc0a8eee314df7158df16e5670d194842d5de452032ba8be414b5dac4e7e",
       "extending/tracks.md": "3d85cd54a5060c35fe70b3bbea848c16ffd0a4e2e21e590b104408690a721ac6",
       "index.json": "4d0f56f56cd470c78e93c9b26ce251ee89fdb624dfd20febb1fc411b398182e9",
-      "package.json": "db16291c1918694a3a932643e6b5fb30fa74f6cc3ad4f73a6d3ea7cbc8279022",
+      "package.json": "df6d4c464cc5256ad388a943d959d4792373379148fdf235f25a5e759bcfc7a9",
       "reference/api.md": "114830d766ab3b81a5181f7b07b10012ac5ee15898c87fa9515c71cec60ec374",
       "reference/errors.md": "c4fa0dcb4d79d5a4888d7fc3ee525a045b21d3cb3ac158f5172dbb02880979f2",
       "skills/kedge-extend/SKILL.md": "7ce215445e99d87e401b7f2669c184f3fa263b75aabced2cdf5eefb398043013",
       "skills/kedge-plugin/SKILL.md": "21af3f112cfcdf2a1cd2eb8e9148a0558a4aebf29b1a057cb5ece09af8116d99",
       "skills/kedge-preview-deploy/SKILL.md": "4b794f84b8f639aff97f4d5e28c44ec8b44de00f6b7b5dc25500dff722891480",
-      "skills/kedge-start/SKILL.md": "6f37eebbed97f6a2f6be16a682eead0a540eef1df2e2b8af4e715bf0d9531b42",
+      "skills/kedge-start/SKILL.md": "04eed3cc12d66eaf1531b26671b0e90d44fd4eb81b394bb00d3e6a4e8c97e3c5",
       "skills/kedge-upgrade/SKILL.md": "97cba305676a22696d6d4e25d2c5e823b47fc0be04b12813d17b9dfd3c5a6c2e",
       "upgrading/0.10.0.md": "169efc96cdf80af167df6607c0db4d977e29c135858ba0c61f53d50d9facc676",
+      "upgrading/0.10.1.md": "d47ddc49f1724e0f3be55a7136d75cbcd8f0bf1128cc7ed2aa6e17cf884ac893",
       "upgrading/0.8.0.md": "b0ddd26993048ea1fdd0e76fb2707060cc4032ffb199a691278020361be95cf8",
       "upgrading/0.9.0.md": "d632d6143636351289684dd51dd51eb0be3e76975c4a42d65acdcee04549d21d",
       "upgrading/codemods/add-admin-assets.mjs": "fa5d069a3489889dcc095b309020d0e773004b3a39544457747491963492f0a1",
@@ -355,55 +363,57 @@
     },
     "@kedge/admin": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
+      "README.md": "1ce1a6d2a16995f6342c9bcc40ddbac0e2bc35cdcdf1ad24efe28aa5b85d79a3",
       "dist/_headers": "b1d979b2fdf27af6c0f41fdaee420f2a2b192f28dc855fec7491f8ffa685c9ba",
-      "dist/app/assets/account-BAdVy9E2.js": "8966c18f8606ea9f795c87ffe2023748f9134e0c96277e4a687ade3d92c189e2",
+      "dist/app/assets/account-pLgh_XLx.js": "cee500d077ab53d4607358d76d2f3d12e5b8f3fe0950023b104bbd32094e55d4",
       "dist/app/assets/card-CH9fCW35.js": "995ee7034e88909a04b07d559a7f520fb08df647e960606f54f5ab88c7201a3f",
       "dist/app/assets/display-CLAPxMXW.js": "4f4e029a0f62756c966c2da476c9f62b7bc59b521c84fa2af86b0f1e2ce51729",
-      "dist/app/assets/home-BCCZ6txc.js": "17737d164554aadbaacb71fc2387825e89eb68b19976282d83675df1657cbbc0",
+      "dist/app/assets/home-DrmfIxH8.js": "87154c23f458a95e797eca4189411a42b5ba6640a6fdc23270130c429940be87",
       "dist/app/assets/index-BA_54h5V.css": "0d7763f516591b37628f3bd5cad733d786783e78a092ff4ad74f0a4045394c73",
-      "dist/app/assets/index-kv11NdsY.js": "84102186c2125beaa6e9f08cffca1e807cadacb1c4d237c0e5a9d67a11312ed5",
-      "dist/app/assets/invite-C4IwtpZf.js": "8ff169820e79cfb17e15151dcf46c4325bcb4e70fb9be55214372533dbf987bb",
-      "dist/app/assets/resource-detail-CRWJVEL8.js": "3566481e229730047d08c9ca3c398560e785774c311122ddc8557cf363a97b8b",
-      "dist/app/assets/resource-form-DulAO-yd.js": "8b8b89fb78e2dcd53471756fbf7a55c6d877e1f93ed46db506f5f6e6f42c48f9",
-      "dist/app/assets/resource-list-wxhtKedG.js": "f5a452d17f88de461d5b29e2db4b0c9e375dcfa8af34fe6d9a4775ee999f9c66",
-      "dist/app/assets/setup-CBpGZMzZ.js": "b80589ba2411dcfe36e69b82b725ce7124e644c64fa48ba5f5acf9cd5afb1202",
-      "dist/app/assets/use-command-CVgCpnG6.js": "e882a35ab8186a3e959c1bda20c6dc5e7a8538b34ba8da1c4d51f3f6118b85cc",
-      "dist/app/assets/work-lists-CKGWNjSC.js": "1258c82ea08da8dcf4b2a585dda65cb07bdde37d10b1a9326708d711a1b7caad",
+      "dist/app/assets/index-CJIaoAxE.js": "e99daee039bd6873e4cf73eea6dce911eb01578926279223f1b538ef3302da74",
+      "dist/app/assets/invite-DtAspOzb.js": "aa238d84ae5c5c16b95337e5056ac1f59d37f87e2645f949ced15b94e892f205",
+      "dist/app/assets/resource-detail-Du1RdgVZ.js": "ebf6435a529b8675c118335900725e2ea91ec5125c52f3dd4c6dc278cf2c2f10",
+      "dist/app/assets/resource-form-EmoEfjrj.js": "1f8826d42e5fa918f0b23754f773a3307b37e178441d3b02885dfba7e5fff08e",
+      "dist/app/assets/resource-list-VLCxpKZl.js": "8b42f06d949b02f28dd30a2511b189b69f564b90ba803984015d348f80078287",
+      "dist/app/assets/setup-BiUpBePR.js": "d45e13f5eced59f064eb86e9dcb78661163f780d22c99770f0b1094fb4619e1b",
+      "dist/app/assets/use-command-CB6a5Dop.js": "de5ed878a74f8086d8db82597f0bae2fcd5181d06123834596bc03ec9600e042",
+      "dist/app/assets/work-lists-C3wqs0gp.js": "4b3a49ed9b62997fe0f9320b26c97b6b5fbb36bd46abb46a40b751b07a513f2d",
       "dist/app/boot.js": "3099141f8935b0c2f15a041f205a673c977a9c8bfc7aa30f23a44b44a69bdb1d",
-      "dist/app/build.json": "4a5afa95433c107b6ab2ffdc0837e45fb6aae06eb79d48593d266010ec1e7a10",
-      "dist/app/index.html": "7cf61261460b8ca9cb9731996b8ceffd74dbe0ec2399d5786c2196a199a3908d",
+      "dist/app/build.json": "ee4c28bdd6ba1b787b8f22d07f962cb81ceedba95e8f034138715b4088e8663c",
+      "dist/app/index.html": "7ede70cce6abcff8c1225ce961885a540206462300c5897a23f3cba80c7ee8db",
       "dist/app/licenses.txt": "7a2bb91cbbc5e4201b72d4d95b2a4d7458f42e80a0d05b01398c9e93f5764f62",
-      "package.json": "ac905bafbb0da5e7d0a8acbd59ac66ee5da567579e7c31be282bfc9c881e25fc",
+      "package.json": "742f602ed4dce5f800505a9e9e9996240ab19462182c1213c96e5e0db54e922f",
       "slots.json": "3252f255e1628537056317d74be5fd2db2fb7e283cd6e8d3f2d49e6dad4b15e5"
     },
     "@kedge/cli": {
       "LICENSE": "5068e060c465b99dee8b5d7ccfecc51f395affd63d6b9651a2d31e71e3a0d9fb",
+      "README.md": "642be70aa940d01572dc5e91482353b3ecb9c24d4558f3014a4b93fb62a909fd",
       "bin/kedge.mjs": "8279a888842a6ee6c0ae9e26fd4380b97892648ca94979fc69d505ff8af6aa9f",
-      "package.json": "bf3232f8449a5417d2fd9e5819a083a7a1ba8d0451712a495a6724c57355aff8",
+      "package.json": "318bca59c7980a066581995a1f4cd22d59fbb652dd6603f7a45bb88453030618",
       "src/cf.ts": "af5a7e281f628f07c46426c819da35b96d2662f275a196073b511966aa1786e6",
-      "src/check.ts": "3199e0e2e1be899f0216580eb8c4bbe0faf4e403da2970e8a060e9751d71dcb5",
+      "src/check.ts": "273ff4b59d717aea33e166e4d88775f190fa826cc3432642a2ccfa2cad12ddd6",
       "src/cli-session.ts": "2e666d1e64f1f3997b5923dc8803e8ddb84cc05c61593d22cbae19b148e69768",
       "src/code-lint.ts": "a696fb8ce00a10da783c1d514a1afa1dd9306a9e04819ae36580c592b651a544",
-      "src/commands.ts": "cd4aeab6821608e17717d08063d9dcbdcd56d6696f3fde10adbe462bbe73ad1d",
+      "src/commands.ts": "3f1d6ba7b1c68aa6125eb409c172b50688c1b77d8306b24c655f37487f008cf6",
       "src/compose.ts": "bc67b22f814e54c0c27db88d776b135d3c7b26b55702f678e1f0253aaf50c943",
-      "src/d1-batch.ts": "45bda667f5c77118d0004dff95516cb242a16456763fa57465ee3cc6895fac35",
+      "src/d1-batch.ts": "dd4dd69778ccf47970e9fc80637b6655ccd94bffa96a6ff7de3dfa92dd668662",
       "src/deploy.ts": "574c4338231bdc1cc7bfd2024e2e37689b2d75b2a3b822889a46a1fb9bba25e8",
       "src/doctor.ts": "17db6b809e9e71ddb10bee6aa009c1f86beff3b5476629ec4ff8626e8c776b9f",
       "src/fork.ts": "f3d9878f58098a563bf2abc76f9e3207514e81779d144831d2e0259c8f455656",
       "src/index.ts": "1f1427679dce8ce228bbce9fcc9290382dd2027c5f2c25bf6a712de74d9793ab",
       "src/invariants.ts": "177446f4144571345c6872f816a076dc88f5dc92dc0503281456f3a2164229ae",
-      "src/keys-save.ts": "bb1fc660f20a0f0d2369e5c79d70723aae191e7c34a9f26a952be3d57f5d48b3",
-      "src/local-state.ts": "abc1b6414bc8a8603ce52acdab3906c4aab84b000f9bf82ee5e722447b0f4dcd",
-      "src/main.ts": "076ce997163de82b929249701eb0019d3f70829eb61d0075cd8ab572554cb03c",
+      "src/keys-save.ts": "682e27974af1e0aba6127e70f73b99a848dae7baf31a6db1584d68d64f027581",
+      "src/local-state.ts": "bcfc69f6eb1b3ca134f428e27fe7dd38340755a0a37565587b5c88dfd99cae83",
+      "src/main.ts": "f0b3e2c4b30f9b1a525f5be092a31c6c6435b6be16c14124e379343e52ccfbbd",
       "src/manifest.ts": "9d52eafd735f9e3d8978588f2b9fb712e17d0e78106170fdb8cd373f39920c87",
       "src/n1.ts": "17b26eb4114dba819282c44c67ef8bf5fbfcc854674133bee5d87bd250ebdc39",
       "src/ops.ts": "9eab0317f1f6b480b07498621f9d6b47fd8a22f24e417b83555b7fe0a4ef5649",
       "src/order.ts": "faba43ade99bd2f966cbc40c3c5d780e6f47a8df06c3e45cc16629ac82d5407e",
-      "src/output.ts": "1f257884d714eb51470697add21e135c418b1466eddd838ebbfb06eeb855cbd4",
+      "src/output.ts": "d599d8752695efc8b56919914f2fb7fc27b5f420d0c5f5d6df03b8416a404184",
       "src/plugin-lint.ts": "b716e02ee5a2ebaac1ef0bee709d5417fa800aa7ab2b1d3ded1607739091584d",
-      "src/preview.ts": "0ebdf3364c9f20097794aec38731dd263f30654e451128eda5ca4c5f3ed7529f",
+      "src/preview.ts": "48e83edc7282053eef9be43644c96d885499605ff5305ac6c0c0adc10a171022",
       "src/schema.ts": "d0b2b8b1bbb7a9ea1a53e092563ac62f0e98c8c1b27a5172d977e2f1c63453d1",
-      "src/smoke.ts": "13c245e4bf54760137ab3997c3b2825caad162aea47e6687fd7897d526af31cd",
+      "src/smoke.ts": "dd722d21d319db8c75a826f799721ae371761497bb3524bf980249a05d94940c",
       "src/sqlite-verify.ts": "1181960dfbbf5b94bd376c024a69d71aaa76bd69c6b92359713acf665e89c3b5",
       "src/store-api.ts": "72a7ee732ba8b531c703df5880d701a305a9c1552a5a3fa631c8ea464d72c8ff",
       "src/store.ts": "fcee4e1838b289c0a5875f63fd83610e46173edd8d189827ce6aa94723b97635",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kedge/cli",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -28,10 +28,10 @@
     "yaml": "2.9.1",
     "@babel/parser": "7.29.9",
     "wrangler": "4.152.0",
-    "@kedge/core": "0.10.0",
-    "@kedge/db": "0.10.0",
-    "@kedge/testing": "0.10.0",
-    "@kedge/runtime-cf": "0.10.0"
+    "@kedge/core": "0.10.1",
+    "@kedge/db": "0.10.1",
+    "@kedge/testing": "0.10.1",
+    "@kedge/runtime-cf": "0.10.1"
   },
   "devDependencies": {
     "@types/node": "24.19.2",

package/src/check.ts

@@ -5,7 +5,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { childStdio } from "./output";
+import { childFailed, childStdio } from "./output";
 
 export interface CheckInput {
   cwd: string;
@@ -22,7 +22,9 @@ const runBin = (bin: string, args: string[], cwd: string): number => {
     console.error(`${bin} isn't installed in this store: run pnpm install`);
     return 1;
   }
-  return spawnSync(path, args, { cwd, stdio: childStdio() }).status ?? 1;
+  const r = spawnSync(path, args, { cwd, stdio: childStdio(), maxBuffer: 1 << 26 });
+  childFailed(r);
+  return r.status ?? 1;
 };
 
 export async function check(input: CheckInput): Promise<number> {

package/src/commands.ts

@@ -6,6 +6,7 @@
 // acting on production.
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
 import { join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { isPermission, type KedgeConfig } from "@kedge/core";
@@ -41,7 +42,7 @@ import { childStdio, emit } from "./output";
 import { needsLive, smoke } from "./smoke";
 import { git, storeNames } from "./store";
 import { storeRequest } from "./store-api";
-import { resolveTarget, type StoreTarget } from "./target";
+import { devPort, resolveTarget, type StoreTarget } from "./target";
 import { compileStoreZone } from "./tz";
 
 export interface CommandDeps {
@@ -302,14 +303,8 @@ function adminUrl(cwd: string, url: string): string | null {
 }
 
 export async function migrateCommand(args: readonly string[], d: CommandDeps): Promise<number> {
-  if (!args.includes("--remote")) {
-    // Local: the dev database, through Wrangler's own bookkeeping.
-    const r = spawnSync(process.execPath, [wranglerBin(), "d1", "migrations", "apply", "DB", "--local"], {
-      cwd: d.cwd,
-      stdio: childStdio(),
-    });
-    return r.status ?? 1;
-  }
+  // Local: the dev database, through Wrangler's own bookkeeping.
+  if (!args.includes("--remote")) return migrateLocal(d);
   return refusals(d, async () => (await deployer(d)).migrateRemote());
 }
 
@@ -743,7 +738,41 @@ export function devArgs(cwd: string): string[] {
   return id ? ["--define", `KEDGE_ADMIN_BUILD:${JSON.stringify(id)}`] : [];
 }
 
-export function devCommand(d: CommandDeps): number {
+/**
+ * The local database's migrations, through Wrangler's own bookkeeping, in one
+ * line: Wrangler prints its whole status table again after each migration,
+ * thousands of lines for a new store (p0.10.1 §1, 8). Its full output is shown
+ * only when it fails.
+ */
+export function migrateLocal(d: Pick<CommandDeps, "cwd" | "log" | "error">): number {
+  const r = spawnSync(process.execPath, [wranglerBin(), "d1", "migrations", "apply", "DB", "--local"], {
+    cwd: d.cwd,
+    encoding: "utf8",
+    env: { ...process.env, WRANGLER_SEND_METRICS: "false" },
+    maxBuffer: 1 << 26,
+  });
+  const out = `${r.stdout ?? ""}${r.stderr ?? ""}`;
+  if (r.status !== 0) {
+    (d.error ?? console.error)(out.trim().split("\n").slice(-40).join("\n"));
+    return r.status ?? 1;
+  }
+  const n = new Set(out.match(/\b\d{4}_[a-z0-9_]+\.sql\b/g) ?? []).size;
+  (d.log ?? console.log)(
+    n ? `applied ${n} migration${n === 1 ? "" : "s"} to the local database` : "the local database is up to date",
+  );
+  return 0;
+}
+
+/** Whether something already listens on the port: Wrangler would otherwise move to another, silently. */
+function portTaken(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", () => resolve(true));
+    server.listen(port, "127.0.0.1", () => server.close(() => resolve(false)));
+  });
+}
+
+export async function devCommand(d: CommandDeps): Promise<number> {
   const vars = join(d.cwd, ".dev.vars");
   if (!existsSync(vars)) {
     const lines = [
@@ -759,11 +788,16 @@ export function devCommand(d: CommandDeps): number {
     });
     (d.log ?? console.log)("wrote .dev.vars with fresh local secrets");
   }
-  const migrated = spawnSync(process.execPath, [wranglerBin(), "d1", "migrations", "apply", "DB", "--local"], {
-    cwd: d.cwd,
-    stdio: "inherit",
-  });
-  if (migrated.status !== 0) return migrated.status ?? 1;
+  // One port for dev, its invite link and the CLI's local target (p0.10.1 §3): taken is a refusal, never a move.
+  const port = devPort(d.cwd);
+  if (await portTaken(port)) {
+    (d.error ?? console.error)(
+      `port ${port} is in use: stop what's on it, or set "dev": { "port": <another> } in wrangler.jsonc`,
+    );
+    return 1;
+  }
+  const migrated = migrateLocal(d);
+  if (migrated !== 0) return migrated;
   let extra: string[];
   try {
     extra = devArgs(d.cwd);
@@ -771,7 +805,20 @@ export function devCommand(d: CommandDeps): number {
     (d.log ?? console.log)((e as Error).message);
     return 1;
   }
-  return spawnSync(process.execPath, [wranglerBin(), "dev", ...extra], { cwd: d.cwd, stdio: "inherit" }).status ?? 0;
+  const origin = `http://localhost:${port}`;
+  // Where the store and its admin are, and how a person signs in to a new store's admin (p0.10.1 §1, 5).
+  (d.log ?? console.log)(
+    [
+      `the store: ${origin}   its admin: ${origin}/app/`,
+      "no one can sign in to the admin until there's an Owner: pnpm kedge staff invite-owner <your email>",
+    ].join("\n"),
+  );
+  return (
+    spawnSync(process.execPath, [wranglerBin(), "dev", "--port", String(port), ...extra], {
+      cwd: d.cwd,
+      stdio: "inherit",
+    }).status ?? 0
+  );
 }
 
 export const removeIfExists = (p: string) => rmSync(p, { recursive: true, force: true });

package/src/d1-batch.ts

@@ -7,7 +7,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { CliBatch } from "@kedge/db";
 import { wranglerBin } from "./cf";
-import { childStdio } from "./output";
+import { childFailed, childStdio } from "./output";
 
 /** Runs one CLI batch against the store's D1; tests replace it. */
 export type Executor = (
@@ -56,8 +56,10 @@ export const wranglerExecute: Executor = (b, opts) => {
         cwd: opts.cwd,
         stdio: childStdio(),
         env: bootstrapEnv(process.env, dir, opts.env),
+        maxBuffer: 1 << 26,
       },
     );
+    childFailed(r);
     return r.status ?? 1;
   } finally {
     // The file holds no secret (only digests), but it needn't outlive the run.

package/src/keys-save.ts

@@ -11,7 +11,7 @@ import type { DatabaseSync } from "node:sqlite";
 import { NeedsPerson } from "./cf";
 import { OLDER_KEDGE, type SessionDeps, withCliSession } from "./cli-session";
 import { DeployRefused } from "./deploy";
-import { type RefRecord, readEnvLocal, saveEnv, stateDb, withStoreLock } from "./local-state";
+import { ENV_FILE, type RefRecord, readEnvLocal, saveEnv, stateDb, withStoreLock } from "./local-state";
 import { storeRequest } from "./store-api";
 import type { StoreTarget } from "./target";
 
@@ -85,7 +85,10 @@ async function save(db: DatabaseSync, target: StoreTarget, wanted: Wanted, d: Sa
   // digest, never by a label beside it: a key with no such ref, or one for another store, would be sent
   // to the wrong store or relabelled as this one's (codex code r11, r13). So any such key, of either
   // kind, is the person's to remove before anything is saved beside it.
-  const env = readEnvLocal(d.cwd);
+  moveLocalBundle(db, d);
+  // Each store's keys in its own file (p0.10.1 §4): kedge dev's apart from Cloudflare's.
+  const envFile = target.kind === "local" ? ENV_FILE.local : ENV_FILE.production;
+  const env = readEnvLocal(d.cwd, envFile);
   const all = db.prepare("SELECT * FROM credential_ref").all() as unknown as RefRecord[];
   const foreign: string[] = [];
   for (const name of [ENV.publishable, ENV.secret]) {
@@ -104,7 +107,7 @@ async function save(db: DatabaseSync, target: StoreTarget, wanted: Wanted, d: Sa
   if (sf && !all.some((r) => r.store === store && r.storefront_id === sf)) foreign.push(ENV.storefront);
   if (foreign.length)
     throw new NeedsPerson(
-      `.env.local holds ${foreign.join(", ")} that this checkout didn't make for this store: remove ${foreign.length === 1 ? "that line" : "those lines"}, or save this store's keys in its own checkout, then run this again`,
+      `${envFile} holds ${foreign.join(", ")} that this checkout didn't make for this store: remove ${foreign.length === 1 ? "that line" : "those lines"}, or save this store's keys in its own checkout, then run this again`,
     );
   const saved = env[envName];
   if (saved && (await works(target, wanted, saved, d))) {
@@ -172,7 +175,7 @@ async function save(db: DatabaseSync, target: StoreTarget, wanted: Wanted, d: Sa
     // 4. Saved before anything else happens, then marked saved.
     const values: Record<string, string> = { [ENV.store]: store, [envName]: made.key };
     if (made.storefront_id) values[ENV.storefront] = made.storefront_id;
-    saveEnv(d.cwd, values);
+    saveEnv(d.cwd, values, envFile);
     set(ref, { state: "saved" });
     d.log(`saved ${Object.keys(values).join(", ")} to .env.local`);
     return values;
@@ -254,6 +257,48 @@ export function badOrigins(origins: readonly string[]): string[] {
   });
 }
 
+/**
+ * A 0.10.0 checkout saved `kedge dev`'s keys in `.env.local`, where they'd block
+ * Cloudflare's (p0.10.1 §4). Under the lock, before anything else, the bundle
+ * proven local moves to `.env.development.local`: each key whose digest matches
+ * a ref recorded for a `local/…` store, the storefront a local ref recorded, and
+ * a `local/…` store marker. Nothing unproven moves. The destination is written
+ * first and read back, then only names it now holds are removed from
+ * `.env.local`; a run stopped between the two finishes the removal next time.
+ * A destination already holding one of those names with another value is a handoff.
+ */
+function moveLocalBundle(db: DatabaseSync, d: SaveDeps): void {
+  const prod = readEnvLocal(d.cwd, ENV_FILE.production);
+  const refs = (db.prepare("SELECT * FROM credential_ref").all() as unknown as RefRecord[]).filter((r) =>
+    r.store.startsWith("local/"),
+  );
+  const moving: Record<string, string> = {};
+  for (const name of [ENV.publishable, ENV.secret]) {
+    const value = prod[name];
+    if (value && refs.some((r) => r.env_name === name && r.key_digest === keyDigest(value))) moving[name] = value;
+  }
+  const sf = prod[ENV.storefront];
+  if (sf && refs.some((r) => r.storefront_id === sf)) moving[ENV.storefront] = sf;
+  if (prod[ENV.store]?.startsWith("local/")) moving[ENV.store] = prod[ENV.store] as string;
+  const names = Object.keys(moving);
+  if (!names.length) return;
+  const dev = readEnvLocal(d.cwd, ENV_FILE.local);
+  const clash = names.filter((n) => dev[n] !== undefined && dev[n] !== moving[n]);
+  if (clash.length)
+    throw new NeedsPerson(
+      `${ENV_FILE.production} holds kedge dev's ${clash.join(", ")}, and ${ENV_FILE.local} holds others: keep one, remove the other line, then run this again`,
+    );
+  saveEnv(d.cwd, moving, ENV_FILE.local);
+  const landed = readEnvLocal(d.cwd, ENV_FILE.local);
+  saveEnv(
+    d.cwd,
+    {},
+    ENV_FILE.production,
+    names.filter((n) => landed[n] === moving[n]),
+  );
+  d.log(`moved kedge dev's ${names.join(", ")} from ${ENV_FILE.production} to ${ENV_FILE.local}`);
+}
+
 /**
  * Whether a saved key still does its job (§6.2): a publishable key passes the
  * storefront gate; a secret key holds its grants. Only a definite answer

package/src/local-state.ts

@@ -77,24 +77,36 @@ export function stateDb(cwd: string): DatabaseSync {
   return db;
 }
 
+/** Where a store's saved keys go (p0.10.1 §4): `kedge dev`'s apart from Cloudflare's, so neither blocks the other. */
+export const ENV_FILE = { production: ".env.local", local: ".env.development.local" } as const;
+
 /**
- * Writes `values` into `.env.local`, keeping every other line: a temporary
+ * Rewrites an env file, keeping every line it doesn't touch: `values` set
+ * (replaced in place, or added at the end) and `remove` dropped. A temporary
  * file in the same directory, mode 0600, renamed over it, so a crash leaves
  * the old file or the new one, never half of either.
  */
-export function saveEnv(cwd: string, values: Record<string, string>): void {
-  const file = join(cwd, ".env.local");
+export function saveEnv(
+  cwd: string,
+  values: Record<string, string>,
+  name: string = ENV_FILE.production,
+  remove: readonly string[] = [],
+): void {
+  const file = join(cwd, name);
   const lines = existsSync(file) ? readFileSync(file, "utf8").split("\n") : [];
   const left = new Set(Object.keys(values));
-  const out = lines.map((line) => {
-    const name = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)?.[1];
-    if (!name || !(name in values)) return line;
-    left.delete(name);
-    return `${name}=${values[name]}`;
+  const drop = new Set(remove);
+  const out = lines.flatMap((line) => {
+    const key = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)?.[1];
+    if (!key) return [line];
+    if (drop.has(key)) return [];
+    if (!(key in values)) return [line];
+    left.delete(key);
+    return [`${key}=${values[key]}`];
   });
   while (out.length && out.at(-1) === "") out.pop();
-  for (const name of left) out.push(`${name}=${values[name]}`);
-  const tmp = join(cwd, `.env.local.${process.pid}.tmp`);
+  for (const key of left) out.push(`${key}=${values[key]}`);
+  const tmp = join(cwd, `${name}.${process.pid}.tmp`);
   try {
     writeFileSync(tmp, `${out.join("\n")}\n`, { mode: 0o600 });
     renameSync(tmp, file);
@@ -103,8 +115,8 @@ export function saveEnv(cwd: string, values: Record<string, string>): void {
   }
 }
 
-/** `.env.local`'s values, as the credential resolver reads them. */
-export function readEnvLocal(cwd: string): Record<string, string> {
-  const file = join(cwd, ".env.local");
+/** An env file's values (`.env.local` by default), as the credential resolver reads them. */
+export function readEnvLocal(cwd: string, name: string = ENV_FILE.production): Record<string, string> {
+  const file = join(cwd, name);
   return existsSync(file) ? (parseEnv(readFileSync(file, "utf8")) as Record<string, string>) : {};
 }

package/src/main.ts

@@ -118,7 +118,15 @@ async function inviteOrigin(
 ): Promise<string | null> {
   const url = flag(args, "--url");
   if (url) return new URL(url).origin;
-  if (!remote) return null;
+  // Local: kedge dev's own origin, the port it binds (p0.10.1 §1, 5; §3).
+  if (!remote) {
+    try {
+      const { devPort } = await import("./target");
+      return `http://localhost:${devPort(cwd)}`;
+    } catch {
+      return null;
+    }
+  }
   try {
     const worker = storeNames(cwd).names.worker;
     return `https://${worker}.${await (cf ?? (await cloudflareFor(env, cwd))).workersSubdomain()}.workers.dev`;
@@ -372,8 +380,17 @@ async function run(argv: string[], cwd: string, deps: RunDeps & { json: boolean
         else results.push(...(await doctorRemote({ cwd, cf, lock, logpushJobs: () => cf.logpushJobs() })));
       }
     }
-    console.log(flags.includes("--json") ? JSON.stringify({ checks: results }, null, 2) : formatReport(results));
     const handoff = results.find((r) => r.handoff)?.handoff;
+    // The same envelope as every --json command (p0.10.1 §1, 7): ok, the checks, and a handoff when there is one.
+    console.log(
+      flags.includes("--json")
+        ? JSON.stringify({
+            ok: !results.some((r) => r.status === "fail"),
+            checks: results,
+            ...(handoff ? { handoff } : {}),
+          })
+        : formatReport(results),
+    );
     if (handoff) {
       console.error(`for you: ${handoff}`);
       return 3;
@@ -463,7 +480,8 @@ export async function main(argv: string[], cwd: string, deps: RunDeps = {}): Pro
       const f = failureOf(e);
       if (!f) throw e;
       console.error(f.line);
-      if (json) (deps.emit ?? emit)(f.result);
+      // doctor keeps its own --json report, and a failure past it is still one object (p0.10.1, codex code r20).
+      if (json || (command === "doctor" && flags.includes("--json"))) (deps.emit ?? emit)(f.result);
       return f.code;
     }
   });

package/src/output.ts

@@ -1,9 +1,11 @@
 // `--json` (p0.10 §5): stdout carries one object when the command ends, and
-// nothing else, so an agent parses it whole. Progress still reaches a person,
-// on stderr: console.log is pointed there for the command's run, and every
-// child the CLI starts (Wrangler, the store's checks and scenarios) writes its
-// stdout there too, since a child's line on stdout would break the object.
-import type { StdioOptions } from "node:child_process";
+// nothing else, so an agent parses it whole. stderr carries only what the
+// agent must read: a refusal, a handoff's `for you:` line, or a child's failure.
+// Progress is dropped, and every child the CLI starts (Wrangler, the store's
+// checks and scenarios) is captured and shown, its last lines on stderr, only
+// when it fails: an agent's tool shows both streams as one, so anything chatty
+// there reads as part of the answer (p0.10.1 §1, 7).
+import type { SpawnSyncReturns, StdioOptions } from "node:child_process";
 
 let reserved = false;
 
@@ -13,8 +15,8 @@ export async function withJsonOutput<T>(on: boolean, work: () => Promise<T>): Pr
   const log = console.log;
   const info = console.info;
   reserved = true;
-  console.log = console.error;
-  console.info = console.error;
+  console.log = () => {};
+  console.info = () => {};
   try {
     return await work();
   } finally {
@@ -29,7 +31,14 @@ export function emit(result: Record<string, unknown>): void {
   process.stdout.write(`${JSON.stringify(result)}\n`);
 }
 
-/** A child's stdio: inherited, except that its stdout goes to stderr while stdout is reserved. */
+/** A child's stdio: inherited, or under `--json` captured, for `childFailed` to show if it fails. */
 export function childStdio(): StdioOptions {
-  return reserved ? ["inherit", 2, "inherit"] : "inherit";
+  return reserved ? ["ignore", "pipe", "pipe"] : "inherit";
+}
+
+/** Under `--json`, a captured child that failed shows its last lines on stderr; inherited output was already seen. */
+export function childFailed(r: Pick<SpawnSyncReturns<string | Buffer>, "status" | "stdout" | "stderr">): void {
+  if (!reserved || r.status === 0) return;
+  const out = `${r.stdout?.toString() ?? ""}${r.stderr?.toString() ?? ""}`.trim();
+  if (out) process.stderr.write(`${out.split("\n").slice(-40).join("\n")}\n`);
 }

package/src/preview.ts

@@ -33,7 +33,7 @@ import type { Lock } from "./compose";
 import { CORE_SECRETS, DeployRefused, openOps, stageAssets } from "./deploy";
 import { assetsShape, declaredClasses, readWrangler } from "./doctor";
 import { LostOwnership, OperationHeld, type OpsStore } from "./ops";
-import { childStdio } from "./output";
+import { childFailed, childStdio } from "./output";
 import { hashTree, type StoreNames, sha256, type WranglerJson } from "./store";
 import { readTar, type TarEntry, TarRefused, writeTar } from "./tar";
 
@@ -1018,7 +1018,9 @@ export function runScenarios(cwd: string, credentials: StoreCredentials, env: No
       cwd,
       stdio: childStdio(),
       env: { ...env, KEDGE_PREVIEW_CREDENTIALS: JSON.stringify(credentials) },
+      maxBuffer: 1 << 26,
     });
+    childFailed(r);
     return r.status ?? 1;
   } finally {
     rmSync(tmp, { recursive: true, force: true });

package/src/smoke.ts

@@ -47,11 +47,25 @@ export interface SmokeResult {
   status: string;
 }
 
-const table = (db: DatabaseSync) =>
-  db.exec(`CREATE TABLE IF NOT EXISTS smoke_run (
-    name TEXT PRIMARY KEY, store TEXT NOT NULL, storefront_id TEXT NOT NULL,
+const COLUMNS = `store TEXT NOT NULL, name TEXT NOT NULL, storefront_id TEXT NOT NULL,
     cart_id TEXT, cart_token TEXT, completion TEXT, order_id TEXT, order_token TEXT, number TEXT, abandoned TEXT,
-    created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL)`);
+    created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL`;
+
+/**
+ * Runs keyed by store and name (p0.10.1 §5): `first` on kedge dev and `first` on
+ * Cloudflare are two runs. A 0.10.0 checkout's `smoke_run`, keyed by name alone,
+ * is copied in whole the first time, every recorded moment with it, so a run it
+ * stopped resumes; the old table is left as it was.
+ */
+function table(db: DatabaseSync) {
+  db.exec(`CREATE TABLE IF NOT EXISTS smoke_runs (${COLUMNS}, PRIMARY KEY (store, name))`);
+  const legacy = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'smoke_run'").get();
+  if (legacy)
+    db.exec(`INSERT OR IGNORE INTO smoke_runs (store, name, storefront_id, cart_id, cart_token, completion, order_id,
+      order_token, number, abandoned, created_at, updated_at)
+      SELECT store, name, storefront_id, cart_id, cart_token, completion, order_id, order_token, number, abandoned,
+      created_at, updated_at FROM smoke_run`);
+}
 
 /** The smoke run `name` on `target`: resumed, or answered again once it has its number. */
 export async function smoke(target: StoreTarget, name: string, d: SmokeDeps): Promise<SmokeResult> {
@@ -69,20 +83,18 @@ export async function smoke(target: StoreTarget, name: string, d: SmokeDeps): Pr
 async function run(db: DatabaseSync, target: StoreTarget, name: string, d: SmokeDeps): Promise<SmokeResult> {
   const now = d.now ?? Date.now;
   const store = identityOf(target);
-  const get = () => db.prepare("SELECT * FROM smoke_run WHERE name = ?").get(name) as unknown as Run | undefined;
+  const get = () =>
+    db.prepare("SELECT * FROM smoke_runs WHERE store = ? AND name = ?").get(store, name) as unknown as Run | undefined;
   const set = (a: Partial<Run>) => {
     const cols = Object.keys(a);
-    db.prepare(`UPDATE smoke_run SET ${cols.map((c) => `${c} = ?`).join(", ")}, updated_at = ? WHERE name = ?`).run(
-      ...cols.map((c) => (a as Record<string, string | null>)[c] ?? null),
-      now(),
-      name,
-    );
+    db.prepare(
+      `UPDATE smoke_runs SET ${cols.map((c) => `${c} = ?`).join(", ")}, updated_at = ? WHERE store = ? AND name = ?`,
+    ).run(...cols.map((c) => (a as Record<string, string | null>)[c] ?? null), now(), store, name);
   };
 
   let r = get();
   // A finished run answers its order again, sending nothing: a retried command can't place a second one.
   if (r?.number && r.order_id) {
-    if (r.store !== store) throw new DeployRefused(`smoke run ${name} belongs to another store (${r.store})`);
     return { run: name, order_id: r.order_id, number: r.number, status: "open" };
   }
   if (r?.abandoned)
@@ -106,19 +118,15 @@ async function run(db: DatabaseSync, target: StoreTarget, name: string, d: Smoke
 
   if (!r) {
     const t = now();
-    db.prepare("INSERT INTO smoke_run (name, store, storefront_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(
-      name,
-      store,
-      storefront,
-      t,
-      t,
-    );
+    db.prepare(
+      "INSERT INTO smoke_runs (store, name, storefront_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+    ).run(store, name, storefront, t, t);
     r = get() as Run;
   }
-  // A cart admits only its own storefront's key: a record for another store or storefront is refused, not reused.
-  if (r.store !== store || r.storefront_id !== storefront)
+  // A cart admits only its own storefront's key: a record for another storefront is refused, not reused.
+  if (r.storefront_id !== storefront)
     throw new DeployRefused(
-      `smoke run ${name} was made for ${r.store === store ? `storefront ${r.storefront_id}` : r.store}: start another with --run <new name>`,
+      `smoke run ${name} was made for storefront ${r.storefront_id}: start another with --run <new name>`,
     );
 
   const shop = { "x-kedge-key": key };