@haus-tech/haus-workflow 6.1.0 → 6.3.0

package/library/global/skills/haus-workflow/references/clone.md

@@ -202,6 +202,142 @@ seeds: # optional: data sources NOT owned by a manifest repo (e.g. a shared Word
         login: 'Add your SSH key to the host (ssh-add …) / request access — or skip the pull.'
 ```
 
+**Workspace, format v2: the `instance:` section (per-worktree environments, ADR-0163).**
+A workspace that runs features in parallel worktrees adds `version: 2` and an `instance:`
+section, and sets `worktree.env: true` in `haus.workspace.yaml`. Unlike the rest of this
+file, `instance:` is parsed and validated strictly by the CLI (`haus doctor`; schema
+`library/schemas/localdev.v2.schema.json`); unknown keys are errors. A v1 file simply has
+no instance support.
+
+```yaml
+version: 2
+instance:
+  ports: # name -> main-checkout port; a worktree gets <leased block> + offset, in this order
+    vendure: 3000
+    admin-ui: 4200
+  datastores: # shared engines; a worktree is isolated INSIDE them, never by its own container
+    mariadb: { engine: mariadb, compose: { project: shop-workspace, service: mariadb }, port: 3318 }
+    # compose.file: the compose file (workspace-relative) when its name is not a default one,
+    # e.g. compose: { project: shop-workspace, service: pg, file: docker-compose.local.yml }
+    redis: { engine: redis, compose: { project: shop-workspace, service: redis }, port: 6381 } # needs --databases 64
+    search:
+      {
+        engine: elasticsearch,
+        compose: { project: shop-workspace, service: es },
+        port: 9201,
+        prefix: 'vendure-',
+      }
+  databases: # one database per worktree: <name>_wt_<slug>, cloned from <name>_tpl (or <name>)
+    ecom: { on: mariadb, name: shop_ecom, perWorktree: clone } # or perWorktree: empty
+  sites: # one Herd site per worktree on a copy-on-write docroot clone
+    wordpress:
+      kind: herd
+      root: shop.se # workspace-relative docroot
+      host: '{{slug}}.shop.se' # served at http://<slug>.shop.se.test
+      share: [wp-content/uploads] # symlinked to the main docroot, not copied
+      plugins: { ecom-widgets: shop-ecom-widgets } # plugin dir -> member repo in this worktree
+      config:
+        {
+          kind: wp-config-override,
+          defines: { DB_NAME: '{{db.wp}}', WP_HOME: '{{site.wordpress.url}}' },
+        }
+      after: ['wp search-replace http://shop.se.test {{site.wordpress.url}} --skip-columns=guid']
+  processes: # what `env start <name>` runs, from that member repo, on its leased port
+    vendure: { repo: shop-ecom, start: 'yarn dev', port: vendure, health: '/health' }
+  copyLocal: # extra machine-local files copied from the main checkout (mode 600)
+    - { repo: shop-ecom, path: auth.json }
+  teardown: # shell commands `env down --destroy` / `env gc --write` run before dropping databases
+    - 'docker compose -p shop-ecom-e2e-{{slug}} down -v --remove-orphans'
+env: # the same map as v1; values may now use templates
+  - value: '{{port.vendure}}'
+    sinks: [{ repo: shop-ecom, key: API_PORT }]
+  - value: '{{db.ecom}}'
+    sinks: [{ repo: shop-ecom, key: DB_NAME }]
+  - value: '{{redis.redis.db}}'
+    sinks: [{ repo: shop-ecom, key: REDIS_DB }]
+```
+
+Templates: `{{slug}}`, `{{port.<name>}}`, `{{db.<name>}}`, `{{redis.<name>.db}}`,
+`{{search.<name>.prefix}}`, `{{site.<name>.url|host|root}}`. In the main checkout they
+resolve to today's values (the main ports and database names, Redis DB 0, the main
+prefix), so one manifest serves both; only a worktree gets new ones. Only keys fed by a
+templated entry are instance-owned; every other key in a repo's `.env` is copied as it is.
+`teardown` (workspace file only) cleans up per-worktree resources the CLI does not track,
+such as a compose project an app's own test harness starts; keep each command idempotent.
+`after` (workspace file only) is its counterpart for `env up`: commands that run once per
+environment in the worktree root, after the `.env` files and `.haus-env.json` exist, such as
+copying the main bucket into a per-worktree one (`mc mirror local/assets
+local/assets-wt-{{slug}}`); a failed one is retried by the next `env up`.
+
+**Single-repo projects** (a plain repo with Claude Code worktrees, ADR-0167): the repo's own
+`.haus-workflow/localdev.yml` takes the whole `instance:` section, the flag is
+`"worktree": { "env": true }` in `.haus-workflow/haus.config.json`, and `repo:` in sinks,
+processes and `copyLocal` names a folder inside the repo (`.` for the root, `apps/server`
+for an app).
+
+**Other engines and site kinds.** The same section covers the other client stacks:
+
+```yaml
+instance:
+  datastores:
+    # An engine on the host (DBngin, Homebrew), not in Docker: haus never starts it and
+    # connects with the host's mysql/mariadb client. Credentials: export MYSQL_USER and
+    # MYSQL_PWD, or use ~/.my.cnf. `port` defaults to native.port. Supported for mariadb,
+    # mysql, elasticsearch and opensearch.
+    mysql: { engine: mysql, native: { host: 127.0.0.1, port: 3306 } }
+    #   native: { host: 127.0.0.1, port: 3306, client: /Users/Shared/DBngin/mysql/8.0.33/bin/mysql }
+    # SQL Server: database isolation (BACKUP / RESTORE WITH MOVE into <name>_wt_<slug>).
+    # azure-sql-edge has no sqlcmd; haus then runs mcr.microsoft.com/mssql-tools (amd64) on
+    # the engine's network. The SA password stays in the engine container's env.
+    mssql: { engine: mssql, compose: { project: vafab-workspace, service: mssql }, port: 49760 }
+  sites:
+    cms: # Bedrock: the root is a member repo, its .env gets the defines (copy: none is the default)
+      kind: herd
+      root: bad-varme.se
+      host: '{{slug}}.bad-varme.se'
+      php: '8.2'
+      share: [web/app/uploads]
+      config:
+        kind: bedrock-env
+        defines:
+          DB_NAME: '{{db.wp}}'
+          WP_HOME: '{{site.cms.url}}'
+          WP_SITEURL: '{{site.cms.url}}/wp'
+    app: # Laravel on Herd: same, with Laravel's keys
+      kind: herd
+      root: app.example.se
+      host: '{{slug}}.app.example.se'
+      secure: true
+      config:
+        kind: laravel-env
+        defines: { APP_URL: '{{site.app.url}}', DB_DATABASE: '{{db.api}}' }
+```
+
+`bedrock-env` and `laravel-env` write no PHP file and need no `patch-wp-config`: the
+defines become instance-owned keys of the member's `.env`, next to any `env:` sinks for
+that repo, and the rest of the main checkout's `.env` is copied as it is. Teardown unlinks
+the Herd site and never deletes the member repo.
+
+**How this relates to the clone flow.** This procedure sets up the **main checkout**: it
+brings the shared engines up, seeds the main databases and writes each repo's `.env`. It
+never touches `instance:`. A worktree then gets its own environment from that main
+checkout with one command, run inside the worktree:
+
+```bash
+haus workspace worktree env snapshot ecom   # once, and whenever fresh data is wanted: <name>_tpl from the main DB
+haus workspace worktree env up              # lease ports, clone DBs, Redis index, prefix, site, .env files
+haus workspace worktree env start vendure   # runs on the worktree's own port
+haus workspace worktree env status          # ports, URLs, databases
+haus workspace worktree env down --destroy  # or just `worktree remove`, which runs it first
+```
+
+`env up` copies each repo's `.env` from the main checkout (secrets included, never printed)
+and replaces only the instance-owned keys, so the main checkout's `.env` must exist first:
+that is exactly what this clone flow produces. Agents never read a `.env`; they use
+`haus workspace worktree env get <key>` or `.haus-env.json`. For a WordPress site with
+`config.kind: wp-config-override`, run `haus workspace worktree env patch-wp-config <site>`
+once in the main checkout (it backs the file up and never prints it).
+
 #### Run order
 
 1. **Discover** `.haus-workflow/localdev.yml` in the workspace root and each repo.

package/library/global/skills/request/SKILL.md

@@ -744,15 +744,14 @@ dispatches no agent and runs no check in this leg. `--repo-rot` is the checkout
 code the assessor reads (the session's cwd; a worktree is fine) and `--arkiv` is
 `ARKIVROT:` from `rot`. The starter writes the running receipt (`archive.mjs korning-start`,
 `state.korning`) before the process starts and clears it after
-(`korning-slut`), skips an item whose receipt carries a living pid (`pågår`), and stops
-starting items when the batch's cost reaches `max_usd_per_batch` in
-`.haus-workflow/request.json` (default 100 USD; `--max-usd` overrides one run), counting an
-item in flight at the average of the finished ones. Read its
+(`korning-slut`), and skips an item whose receipt carries a living pid (`pågår`). There is
+no spend cap: every item that passes the gate starts, and the cost shows instead, as the
+USD per item in the table and the total spent on the line under it (ADR-0162). Read its
 final table (`| post | status | poäng | utfall | wall | USD |`), paste it under the BLUF
 in step 8, and route every row by its status: `priced` goes on to step 8, `stopp` and
 `väntar på dom` take the stop and OLIKA routing below, `ofärdig` shows the reason from
-the table and `<post>/korningar/<körning>/stderr.log`, `grind` and `tak nått` show the
-reason and stop, and a `pågår` row is left alone.
+the table and `<post>/korningar/<körning>/stderr.log`, `grind` shows the
+reason and stops, and a `pågår` row is left alone.
 `bedom.mjs` passes the board's design mode on to `korning.mjs` as `--design-mode`
 (`design_mode` in `.haus-workflow/request.json`; `interview` and an absent key read as
 `intervju`; the flag overrides one run). In draft mode the process drafts a missing design
@@ -2015,22 +2014,20 @@ reference files whose rules it mirrors and WARNS when a catalog bump has changed
   and skipped. `--arkiv` is the archive root; omitted, it is derived from
   `--repo-rot`'s git common dir (ADR-0154). Exit 0 when no run became
   `ofärdig`, 1 otherwise, 2 on a usage error.
-- `scripts/bedom.mjs --repo-rot <abs> [--arkiv <abs>] --post <gid|gid/del-N>... [--parallellt 2] [--max-usd <n>] [--claude <kommando>] [--om] [--sprak <svenska|engelska>]`:
+- `scripts/bedom.mjs --repo-rot <abs> [--arkiv <abs>] --post <gid|gid/del-N>... [--parallellt 2] [--claude <kommando>] [--om] [--sprak <svenska|engelska>]`:
   production's starter (see `bedöm`), one `korning.mjs --post` process per item, two at a
   time. `--post` is relative to the archive root (`--arkiv`, or derived from `--repo-rot`'s
   git common dir as in `svep.mjs`); an absolute `--post` is a usage error. Per item: the
   receipt via `archive.mjs korning-start`/`korning-slut` (the latter always, also when the
   run fails), the run directory `<post>/korningar/<stämpel>/` with `stderr.log`,
-  `matning.json` and the raw replies under `steg/`, the cap from `request.json`
-  (`max_usd_per_batch`, default 100 USD, `--max-usd` overrides; once the finished items'
-  USD, plus each item in flight at the average of the finished ones, reaches it no further
-  item starts, `tak nått`, and a running item is never killed), `--startare <its own pid>` on
+  `matning.json` and the raw replies under `steg/`, no spend cap (every item that passes
+  the gate starts, ADR-0162), `--startare <its own pid>` on
   every `korning.mjs` it starts, SIGINT and SIGTERM both killing the running items and
   clearing their receipts (exit 130),
   and the final table `| post | status | poäng | utfall | wall | USD |` in argument order
-  with the line `tak: <n> USD, använt: <m> USD`. Exit 0 when every item ended in a result
-  (`priced`, `stopp`, `väntar på dom`), 1 on `ofärdig`, `pågår`, `grind` or `tak nått`, 2
-  on a usage error (ADR-0155).
+  with the line `använt: <m> USD`. Exit 0 when every item ended in a result
+  (`priced`, `stopp`, `väntar på dom`), 1 on `ofärdig`, `pågår` or `grind`, 2
+  on a usage error (ADR-0155, ADR-0162).
   `bedom.mjs` takes `--design-mode draft|intervju` and passes it to every `korning.mjs` it
   starts; without the flag the value is `request.json`'s `design_mode` (`interview` is read
   as `intervju`), and without that key `intervju` (ADR-0156).

package/library/global/skills/request/scripts/bedom.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 /**
- * Startaren för produktionens prisning (ADR-0155 beslut 1, 3, 4 och 5):
+ * Startaren för produktionens prisning (ADR-0155 beslut 1, 3 och 5; beslut 4
+ * ersatt av ADR-0162):
  * `bedöm`:s steg 3 till 7 körs som EN `korning.mjs`-process per post i
  * produktionsläget (`--post`), startad härifrån, så huvudkonversationen
  * dispatchar ingen agent för prisbenet. Huvudkonversationen behåller grinden,
@@ -9,7 +10,7 @@
  *
  * Användning:
  *   node bedom.mjs --repo-rot <abs> [--arkiv <abs>] --post <gid|gid/del-N> [--post ...]...
- *                  [--parallellt 2] [--max-usd <n>] [--claude <kommando>] [--om]
+ *                  [--parallellt 2] [--claude <kommando>] [--om]
  *                  [--sprak <svenska|engelska>] [--design-mode <draft|intervju>]
  *
  * `--post` är relativ arkivroten: `--arkiv` när den ges (ARKIVROT: från
@@ -20,7 +21,7 @@
  * Per post, i ordning: förkontroll (state.json läsbar, ingen experimentkatalog,
  * ingen splitrot med `del-N/` under sig, `approval` satt, inget stående
  * `stopp`, inte redan `priced`/`guard_run` utan `--om`; annars raden `grind`
- * och inget startas), taket, körningskatalogen
+ * och inget startas), körningskatalogen
  * `<post>/korningar/<YYYYMMDDTHHMMSS>/`, kvittot `archive.mjs korning-start`
  * (en levande pid ger raden `pågår` och den tomma katalogen tas bort),
  * `korning.mjs` med `stderr.log` och `matning.json` i körningskatalogen och
@@ -28,22 +29,17 @@
  * `korning.json`:s `total_cost_usd`, `archive.mjs sparr` och statusen. Kvittot
  * rensas alltid med `archive.mjs korning-slut` i en finally.
  *
- * Taket (beslut 4): `max_usd_per_batch` i `.haus-workflow/request.json`
- * (`<arkiv>/../request.json`), 100 USD när nyckeln saknas, `--max-usd` vinner
- * för en körning. Före varje poststart jämförs summan mot taket: de klara
- * posterna med sin USD plus varje post i flykt till de klaras snittkostnad
- * (0 så länge ingen är klar). När summan nått taket startas inga fler poster
- * (raden `tak nått`), och ingen pågående körning dödas. Två poster som startar
- * samtidigt innan någon är klar passerar båda kontrollen: det är accepterat,
- * taket stoppar nästa start och aldrig en körning som pågår.
+ * Inget tak (ADR-0162 ersätter ADR-0155 beslut 4): varje post som klarar
+ * förkontrollen startas, oavsett vad batchen kostat. Kostnaden syns i stället:
+ * USD per post i tabellen och summan på sista raden.
  *
  * stdout under körningen: `START <post>`, `KLAR <post> <status>`,
- * `GRIND <post>: <orsak>`, `PÅGÅR <post> (pid N)`, `TAK <post>`; till sist
+ * `GRIND <post>: <orsak>`, `PÅGÅR <post> (pid N)`; till sist
  * tabellen `| post | status | poäng | utfall | wall | USD |` och raden
- * `tak: <n> USD, använt: <m.mm> USD`.
+ * `använt: <m.mm> USD`.
  *
  * Exit 0 = varje rad är `priced`, `stopp` eller `väntar på dom`; 1 = minst en
- * rad är `ofärdig`, `pågår`, `grind` eller `tak nått`; 2 = användningsfel.
+ * rad är `ofärdig`, `pågår` eller `grind`; 2 = användningsfel.
  * SIGINT och SIGTERM skickar SIGTERM till varje pågående körning, skriver
  * matning.json med signalen, rensar varje kvitto med korning-slut och avslutar
  * med 130. Ett oväntat kast i huvudloopen skrivs på stderr och ger exit 2.
@@ -58,30 +54,20 @@ const HAR = path.dirname(fileURLToPath(import.meta.url))
 const ARCHIVE = path.join(HAR, 'archive.mjs')
 const KORNING = path.join(HAR, 'korning.mjs')
 
-export const STANDARD_TAK_USD = 100
 const STANDARD_PARALLELLT = 2
 const SIGNAL_EXIT = 130
 /** Signalerna som avbryter batchen; samma hanterare för båda. */
 export const AVBROTTSSIGNALER = ['SIGINT', 'SIGTERM']
 const SPRAKEN = ['svenska', 'engelska']
 const DESIGNLAGEN = ['draft', 'intervju']
-const VARDEFLAGGOR = [
-  'repo-rot',
-  'arkiv',
-  'post',
-  'parallellt',
-  'max-usd',
-  'claude',
-  'sprak',
-  'design-mode',
-]
+const VARDEFLAGGOR = ['repo-rot', 'arkiv', 'post', 'parallellt', 'claude', 'sprak', 'design-mode']
 const BOOLFLAGGOR = ['om']
 /** Statusar som är ett resultat: exit 0 när varje rad bär en av dem. */
 const RESULTAT = ['priced', 'stopp', 'väntar på dom']
 
 export const ANVANDNING = [
   'användning: bedom.mjs --repo-rot <abs> [--arkiv <abs>] --post <gid|gid/del-N> [--post ...]...',
-  `                      [--parallellt ${STANDARD_PARALLELLT}] [--max-usd <n>] [--claude <kommando>] [--om]`,
+  `                      [--parallellt ${STANDARD_PARALLELLT}] [--claude <kommando>] [--om]`,
   `                      [--sprak <${SPRAKEN.join('|')}>] [--design-mode <${DESIGNLAGEN.join('|')}>]`,
 ].join('\n')
 
@@ -127,12 +113,6 @@ export function tolkaArgv(argv) {
   const parText = enkla.parallellt ?? String(STANDARD_PARALLELLT)
   if (!/^\d+$/.test(parText) || Number(parText) < 1)
     return { fel: `--parallellt måste vara ett heltal >= 1 (fick "${parText}")` }
-  let maxUsd = null
-  if (enkla['max-usd'] !== undefined) {
-    maxUsd = Number(enkla['max-usd'])
-    if (enkla['max-usd'].trim() === '' || !Number.isFinite(maxUsd) || maxUsd < 0)
-      return { fel: `--max-usd måste vara ett tal >= 0 (fick "${enkla['max-usd']}")` }
-  }
   if (enkla.sprak !== undefined && !SPRAKEN.includes(enkla.sprak))
     return { fel: `--sprak måste vara ${SPRAKEN.join(' eller ')} (fick "${enkla.sprak}")` }
   if (enkla['design-mode'] !== undefined && !DESIGNLAGEN.includes(enkla['design-mode']))
@@ -144,7 +124,6 @@ export function tolkaArgv(argv) {
     arkiv: enkla.arkiv ?? null,
     poster: normerade,
     parallellt: Number(parText),
-    maxUsd,
     claude: enkla.claude ?? 'claude',
     om,
     sprak: enkla.sprak ?? null,
@@ -164,16 +143,6 @@ export function losPost(post, arkiv) {
   return { dir }
 }
 
-/** Taket för körningen: flaggan vinner, sedan `max_usd_per_batch` i
- *  `<arkiv>/../request.json` (`.haus-workflow/request.json`), sedan 100. En
- *  saknad eller trasig fil är defaulten, aldrig ett fel. */
-export function lasTak({ arkiv, maxUsd = null }) {
-  if (maxUsd !== null && maxUsd !== undefined) return maxUsd
-  const v = lasRequestJson(arkiv)?.max_usd_per_batch
-  if (typeof v === 'number' && Number.isFinite(v) && v >= 0) return v
-  return STANDARD_TAK_USD
-}
-
 /** `<arkiv>/../request.json` som objekt, eller null när den saknas eller är
  *  trasig (defaulten gäller då, aldrig ett fel). */
 function lasRequestJson(arkiv) {
@@ -294,9 +263,6 @@ export function avgorStatus({ exitCode, signal = null, state, sparrExit }) {
   return { status: 'ofärdig', orsak: `status ${state?.status ?? 'okänd'} utan stopp eller spärr` }
 }
 
-/** Har summan (de klara posterna plus de i flykt till snittet) nått taket? */
-export const kapNatt = (summaUsd, tak) => summaUsd >= tak
-
 /** Standardlöparen för archive.mjs: synkron, cwd i posten. */
 export const arkivStandard = (args, cwd) =>
   spawnSync(process.execPath, [ARCHIVE, ...args], { cwd, encoding: 'utf8' })
@@ -421,7 +387,7 @@ const lasUsd = (runDir) => {
 /** En post, hela ordningen ur ADR-0155. Kastar aldrig medvetet; ett kast
  *  blir en `ofärdig`-rad i korBatch. */
 async function korPost(post, ctx) {
-  const { ut, arkivKor, korKorning, kvitton, summa, tak, konto } = ctx
+  const { ut, arkivKor, korKorning, kvitton, konto } = ctx
   const rad = (status, extra = {}) => ({ post, status, ...extra })
   const los = losPost(post, ctx.arkiv)
   if (los.fel) {
@@ -439,10 +405,6 @@ async function korPost(post, ctx) {
     ut(`GRIND ${post}: ${grind}`)
     return rad('grind', { orsak: grind, ...lasPoang(dir) })
   }
-  if (kapNatt(summa(), tak)) {
-    ut(`TAK ${post}`)
-    return rad('tak nått')
-  }
   const runDir = korningsKatalog(dir, ctx.now ? ctx.now() : new Date())
   const start = startaKorning(dir, ctx.pid ?? process.pid, runDir, { arkivKor })
   if (start.pagar) {
@@ -457,7 +419,6 @@ async function korPost(post, ctx) {
   }
   if (start.varning) console.error(`${post}: ${start.varning}`)
   kvitton.add(dir)
-  konto.iFlykt++
   let belopp = null
   try {
     ut(`START ${post}`)
@@ -488,10 +449,7 @@ async function korPost(post, ctx) {
       usd: belopp,
     })
   } finally {
-    // Posten är klar för taket: ur flykten, in bland de klara med sin USD
-    // (en post utan korning.json räknas som 0).
-    konto.iFlykt--
-    konto.klara++
+    // Postens USD in i summan (en post utan korning.json räknas som 0).
     if (Number.isFinite(belopp)) konto.anvant += belopp
     const slut = avslutaKorning(dir, { arkivKor })
     if (!slut.ok) console.error(`VARNING ${post}: ${slut.fel}`)
@@ -499,20 +457,14 @@ async function korPost(post, ctx) {
   }
 }
 
-/** Summan taket prövas mot: de klara posternas USD plus varje post i flykt
- *  till de klaras snittkostnad (0 så länge ingen är klar). */
-export const taksumma = ({ anvant, klara, iFlykt }) =>
-  anvant + (klara > 0 ? iFlykt * (anvant / klara) : 0)
-
-/** Kör posterna med högst `parallellt` i flykt. Taket prövas vid varje
- *  poststart mot `taksumma` (en post utan korning.json räknas som 0).
- *  Returnerar raderna i argv-ordning och de klara posternas summa. */
+/** Kör posterna med högst `parallellt` i flykt. Returnerar raderna i
+ *  argv-ordning och de klara posternas summa (en post utan korning.json
+ *  räknas som 0). */
 export async function korBatch({
   poster,
   arkiv,
   repoRot,
   parallellt,
-  tak,
   om,
   claude,
   sprak,
@@ -525,7 +477,7 @@ export async function korBatch({
   pid = process.pid,
   now,
 }) {
-  const konto = { anvant: 0, klara: 0, iFlykt: 0 }
+  const konto = { anvant: 0 }
   const ctx = {
     arkiv,
     repoRot,
@@ -533,7 +485,6 @@ export async function korBatch({
     claude,
     sprak,
     designMode,
-    tak,
     ut,
     arkivKor,
     korKorning,
@@ -542,7 +493,6 @@ export async function korBatch({
     pid,
     now,
     konto,
-    summa: () => taksumma(konto),
   }
   const resultat = await schemalagg(poster, parallellt, (post) => korPost(post, ctx))
   const rader = resultat.map((r, i) =>
@@ -604,7 +554,6 @@ async function main(argv) {
     console.error(ANVANDNING)
     return 2
   }
-  const tak = lasTak({ arkiv, maxUsd: val.maxUsd })
   const designMode = lasDesignlage({ arkiv, designMode: val.designMode })
   const ut = (rad) => process.stdout.write(rad + '\n')
   const pagaende = new Map()
@@ -617,7 +566,6 @@ async function main(argv) {
     arkiv,
     repoRot: val.repoRot,
     parallellt: val.parallellt,
-    tak,
     om: val.om,
     claude: val.claude,
     sprak: val.sprak,
@@ -628,7 +576,7 @@ async function main(argv) {
   })
   ut('')
   ut(renderaTabell(rader))
-  ut(`tak: ${tak} USD, använt: ${anvant.toFixed(2)} USD`)
+  ut(`använt: ${anvant.toFixed(2)} USD`)
   return rader.every((r) => RESULTAT.includes(r.status)) ? 0 : 1
 }