jackherd 1.23.3 → 1.25.0

package/dist/config.js

@@ -1,17 +1,61 @@
 import {
   PLAN_LANGUAGE,
   RESPONSE_ADDRESS
-} from "./chunk-JDO6O3UO.js";
+} from "./chunk-O365KHHP.js";
 
 // src/config/json-schema.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/config/schema.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
-// src/check/schema.ts
+// src/backend/schema.ts
 import { z } from "zod";
 
+// src/version/release.ts
+var CLI_NAME = "jh";
+
+// src/lane/port.ts
+var DEFAULT_BASE_PORT = 3100;
+var MAX_PORT = 65535;
+var BOARD = "--board";
+var LANE_PORT_USAGE = `usage: ${CLI_NAME} lane port [${BOARD} <board.md>]
+
+Prints the dev-server port for a new lane: the lowest port from lanes.basePort of the config (default ${DEFAULT_BASE_PORT})
+that nothing listens on and no lane still running holds in the port column of the board. Rows of cleaned-up lanes
+reserve nothing. Exit 1 and one line when no port up to ${MAX_PORT} is free.`;
+
+// src/shared/shell-word.ts
+var SHELL_WORD = /^(?!-)[\w@./:-]+$/;
+
+// src/backend/schema.ts
+var SERVICES_PLACEHOLDER = "{services}";
+var DEFAULT_BACKEND_LABEL = "backend";
+var BACKEND_LABEL = /^(?!-)[\w.-]+$/;
+var duplicateIn = (values) => new Set(values).size !== values.length;
+var serviceSchema = z.strictObject({
+  /** The name the command's tool takes, e.g. a package name. */
+  name: z.string().regex(SHELL_WORD, "must be one shell word of letters, digits and @ . / : _ -, not starting with -"),
+  /** The port the service listens on; checked before a start and named when the service is handed to a lane. */
+  port: z.number().int().min(1).max(MAX_PORT)
+});
+var backendSchema = z.strictObject({
+  /** The command that runs the services in the main checkout; `{services}` becomes the names of the services not handed to a lane. */
+  command: z.string().min(1).refine((command3) => command3.includes(SERVICES_PLACEHOLDER), `must contain ${SERVICES_PLACEHOLDER}`),
+  services: z.array(serviceSchema).min(1),
+  /** The label of the backend pane; `backend` when left out. */
+  label: z.string().regex(BACKEND_LABEL, "letters, digits and . _ -, not starting with -").default(DEFAULT_BACKEND_LABEL)
+}).refine(({ services }) => !duplicateIn(services.map(({ name }) => name)), {
+  message: "service names must be unique",
+  path: ["services"]
+}).refine(({ services }) => !duplicateIn(services.map(({ port }) => port)), {
+  message: "service ports must be unique",
+  path: ["services"]
+});
+
+// src/check/schema.ts
+import { z as z2 } from "zod";
+
 // src/check/command-line.ts
 var TOKEN = /(?:"[^"]*"|'[^']*'|\S)+/g;
 var QUOTED = /"([^"]*)"|'([^']*)'/g;
@@ -24,7 +68,7 @@ var tokenize = (command3) => (command3.match(TOKEN) ?? []).map((token) => {
 var CHECK_KIND = { lint: "lint", project: "project", types: "types", tests: "tests" };
 
 // src/check/schema.ts
-var nonEmpty = z.string().min(1);
+var nonEmpty = z2.string().min(1);
 var isTokenizable = (command3) => {
   try {
     tokenize(command3);
@@ -35,7 +79,7 @@ var isTokenizable = (command3) => {
 };
 var command = nonEmpty.refine(isTokenizable, "Unterminated quote in command");
 var glob = nonEmpty.refine((value) => !/[{}[\]]/.test(value), "Braces and brackets are not supported in globs");
-var globs = z.array(glob).min(1);
+var globs = z2.array(glob).min(1);
 var directory = nonEmpty.transform((value) => value.replace(/^(\.\/)+/, "").replace(/\/+$/, "") || ".");
 var DEFAULT_BUILD_ARTIFACT_GLOBS = [
   "**/tsup.config.bundled_*",
@@ -44,12 +88,12 @@ var DEFAULT_BUILD_ARTIFACT_GLOBS = [
   "**/node_modules/**",
   "**/*.tsbuildinfo"
 ];
-var reviewerRoute = z.strictObject({
+var reviewerRoute = z2.strictObject({
   reviewer: nonEmpty,
   globs,
   why: nonEmpty
 });
-var projectCheck = z.strictObject({
+var projectCheck = z2.strictObject({
   name: nonEmpty,
   command,
   /** Without globs the check runs on every change; with them, only when a changed path matches. */
@@ -58,41 +102,41 @@ var projectCheck = z.strictObject({
    * `tests` for a check that runs the project's tests, `types` for its type check; without one, a plain project check.
    * A test run counts towards "no green without a test", and both run with the slow checks.
    */
-  kind: z.enum([CHECK_KIND.tests, CHECK_KIND.types]).optional()
+  kind: z2.enum([CHECK_KIND.tests, CHECK_KIND.types]).optional()
 });
-var generatorOwned = z.strictObject({
+var generatorOwned = z2.strictObject({
   glob,
   generator: nonEmpty
 });
-var publicContent = z.strictObject({
+var publicContent = z2.strictObject({
   /** The published files: a change here gets the reviewer and the scan for names of neighbouring projects. */
   globs,
   /** Files among them that never ship, such as tests. */
-  exclude: z.array(glob).default([]),
+  exclude: z2.array(glob).default([]),
   /** The agent that judges such a change; a global install names it with its prefix. */
   reviewer: nonEmpty.default("public-content")
 });
-var skillBudgets = z.record(glob, z.number().int().positive());
+var skillBudgets = z2.record(glob, z2.number().int().positive());
 var OPEN_BOXES_LEVEL = { fail: "fail", warn: "warn", off: "off" };
 var LINT_POINTERS_LEVEL = { warn: "warn", fail: "fail", off: "off" };
-var lintPointers = z.strictObject({
+var lintPointers = z2.strictObject({
   /** `warn` reports a block and lets the commit through; `fail` stops it; `off` skips the check. */
-  level: z.enum([LINT_POINTERS_LEVEL.warn, LINT_POINTERS_LEVEL.fail, LINT_POINTERS_LEVEL.off]).default(LINT_POINTERS_LEVEL.warn),
+  level: z2.enum([LINT_POINTERS_LEVEL.warn, LINT_POINTERS_LEVEL.fail, LINT_POINTERS_LEVEL.off]).default(LINT_POINTERS_LEVEL.warn),
   /** Rule files left unread, as globs from the project root; the kit copies in the lock file are always left out. */
-  exclude: z.array(glob).default([])
+  exclude: z2.array(glob).default([])
 });
 var DEFAULT_LINT_POINTERS = { level: LINT_POINTERS_LEVEL.warn, exclude: [] };
-var checkConfigSchema = z.strictObject({
+var checkConfigSchema = z2.strictObject({
   /**
    * Run once over the changed files, which are appended as arguments. Separate from `commands.lint`,
    * which lints the whole project. Detected from the repository when left out; without one, no lint runs.
    */
   lintFilesCommand: command.optional(),
   /** Project checks, run alongside lint; add repository-specific scripts here. */
-  checks: z.array(projectCheck).default([]),
-  generatorOwned: z.array(generatorOwned).default([]),
-  buildArtifacts: z.array(glob).default([...DEFAULT_BUILD_ARTIFACT_GLOBS]),
-  reviewerRoutes: z.array(reviewerRoute).default([]),
+  checks: z2.array(projectCheck).default([]),
+  generatorOwned: z2.array(generatorOwned).default([]),
+  buildArtifacts: z2.array(glob).default([...DEFAULT_BUILD_ARTIFACT_GLOBS]),
+  reviewerRoutes: z2.array(reviewerRoute).default([]),
   publicContent: publicContent.optional(),
   /**
    * Word budgets for the files an agent loads again and again. An entry replaces the kit's budget for the same
@@ -104,19 +148,19 @@ var checkConfigSchema = z.strictObject({
    * default) stops the commit, `warn` reports, `off` skips. A row carrying the `partialPhase` word (`(Teil)` in German) builds part of the phase and is
    * left alone; a branch whose directory is no lane's is not checked.
    */
-  openBoxes: z.enum([OPEN_BOXES_LEVEL.fail, OPEN_BOXES_LEVEL.warn, OPEN_BOXES_LEVEL.off]).default(OPEN_BOXES_LEVEL.fail),
+  openBoxes: z2.enum([OPEN_BOXES_LEVEL.fail, OPEN_BOXES_LEVEL.warn, OPEN_BOXES_LEVEL.off]).default(OPEN_BOXES_LEVEL.fail),
   /**
    * Whether a new or changed block of a rule file (or `CLAUDE.md`, `AGENTS.md`) that a linter could check, such
    * as a forbidden import path or call, must name its lint rule with `` `lint:<rule id>` `` (or `` `lint:none` `` and a reason).
    */
   lintPointers: lintPointers.optional(),
   /** Also run tests in directories that hold test files but belong to no package. */
-  looseTests: z.boolean().default(false),
+  looseTests: z2.boolean().default(false),
   /**
    * Package roots, as directories from the repository root, read only where no stack is detected: a changed file
    * belongs to the nearest one above it, else to the repository root `.`.
    */
-  roots: z.array(directory).min(1).optional(),
+  roots: z2.array(directory).min(1).optional(),
   /** The files a test covers; replaces the stack's pattern, or the rule of thumb where no stack is detected. */
   sourceFiles: globs.optional(),
   /** The test files; replaces the stack's pattern, or the rule of thumb where no stack is detected. */
@@ -132,9 +176,6 @@ var SKILL_PATH = new RegExp(`^${SKILLS_DIRECTORY}/([^/]+)/(.+)$`);
 var AGENT_PATH = new RegExp(`^${AGENTS_DIRECTORY}/([^/]+)\\.md$`);
 var claudePath = (...segments) => [CLAUDE_DIRECTORY, ...segments].join("/");
 
-// src/version/release.ts
-var CLI_NAME = "jh";
-
 // src/secrets/options.ts
 var SECRET_NAME = /^[A-Z][A-Z0-9_]*$/;
 var SECRET_USAGE = `Usage: ${CLI_NAME} secret set <NAME>     store a value in the keychain, typed hidden in a terminal
@@ -348,14 +389,14 @@ var DEFAULT_SKILL_PREFIX = "jh-";
 var KIT_CORE = ["orchestrate", "start"];
 var KIT_ENTRY_NAME = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var FULL_MODEL_ID = /^claude-[a-z0-9][a-z0-9.-]*$/;
-var language = z2.enum(Object.values(PLAN_LANGUAGE));
-var modelId = z2.string().regex(FULL_MODEL_ID, "Use a full model ID such as claude-opus-5-5, not an alias like opus or sonnet");
-var command2 = z2.string().min(1);
-var excludedKitEntry = z2.string().regex(KIT_ENTRY_NAME, "a kit skill or agent name as the kit names it, e.g. devops").refine((name) => !KIT_CORE.includes(name), {
+var language = z3.enum(Object.values(PLAN_LANGUAGE));
+var modelId = z3.string().regex(FULL_MODEL_ID, "Use a full model ID such as claude-opus-5-5, not an alias like opus or sonnet");
+var command2 = z3.string().min(1);
+var excludedKitEntry = z3.string().regex(KIT_ENTRY_NAME, "a kit skill or agent name as the kit names it, e.g. devops").refine((name) => !KIT_CORE.includes(name), {
   error: (issue) => `${issue.input} is the kit's core and cannot be excluded`
 });
-var tokenCount = z2.number().int().positive();
-var commandsSchema = z2.strictObject({
+var tokenCount = z3.number().int().positive();
+var commandsSchema = z3.strictObject({
   test: command2.optional(),
   typecheck: command2.optional(),
   lint: command2.optional(),
@@ -367,65 +408,65 @@ var commandsSchema = z2.strictObject({
 });
 var COMMAND_KEYS = Object.keys(commandsSchema.shape);
 var DEFAULT_CONTEXT_WINDOW = 2e5;
-var laneCopyPath = z2.string().regex(
+var laneCopyPath = z3.string().regex(
   // biome-ignore lint/suspicious/noControlCharactersInRegex: the class exists to refuse control characters
   /^(?![/-])(?!(?:.*\/)?\.\.(?:\/|$))[^'\x00-\x1f\x7f]+$/,
   "a relative path inside the checkout: no leading / or -, no .. segment, no quote or control character"
 );
 var warnBelowAlert = ({ warnTokens, alertTokens }) => warnTokens < alertTokens;
 var WARN_BELOW_ALERT = { message: "warnTokens must be below alertTokens", path: ["warnTokens"] };
-var lockFilePath = z2.string().regex(/^(?![/-])(?!(?:.*\/)?\.\.(?:\/|$))[A-Za-z0-9._/-]+$/, "a plain relative file name such as yarn.lock");
-var branchName = z2.string().regex(
+var lockFilePath = z3.string().regex(/^(?![/-])(?!(?:.*\/)?\.\.(?:\/|$))[A-Za-z0-9._/-]+$/, "a plain relative file name such as yarn.lock");
+var branchName = z3.string().regex(
   /^(?!HEAD$)(?![-/.])(?!.*(?:\.\.|\/\/|@\{|\.lock(?:\/|$)))[A-Za-z0-9._/-]+(?<![./])$/,
   "a branch name such as main: not HEAD, no leading - / or ., no .. and no spaces"
 );
-var workflowFile = z2.string().regex(/^(?![-.])[A-Za-z0-9._-]+\.ya?ml$/, "a workflow file name such as deploy.yml");
-var boardPattern = z2.string().regex(/^(?![-.])[A-Za-z0-9._*?-]+$/, "one directory name such as board-*: no / and no leading - or .");
-var boardFile = z2.string().regex(/^(?![-.])[A-Za-z0-9._-]+\.md$/, "one markdown file name such as board.md: no / and no leading - or .");
-var boardSchema = z2.strictObject({
+var workflowFile = z3.string().regex(/^(?![-.])[A-Za-z0-9._-]+\.ya?ml$/, "a workflow file name such as deploy.yml");
+var boardPattern = z3.string().regex(/^(?![-.])[A-Za-z0-9._*?-]+$/, "one directory name such as board-*: no / and no leading - or .");
+var boardFile = z3.string().regex(/^(?![-.])[A-Za-z0-9._-]+\.md$/, "one markdown file name such as board.md: no / and no leading - or .");
+var boardSchema = z3.strictObject({
   /** The directories under `planDirectory` that hold a board; the newest board is the default of `plans` and `watch`. */
   pattern: boardPattern.default("board-*"),
   /** The board document inside each of those directories. */
   file: boardFile.default("board.md"),
   /** What the project calls a board: the herd, its page and the watcher print it as written. */
-  term: z2.string().min(1).default("board")
+  term: z3.string().min(1).default("board")
 });
-var deploySchema = z2.strictObject({
+var deploySchema = z3.strictObject({
   /** The workflow whose runs on the base branch the watcher reports as `deploy`. */
   workflow: workflowFile,
   /** The deployment environments the watcher names as a run's target; any other reads `unknown`. */
-  environments: z2.array(z2.string().min(1)).min(1)
+  environments: z3.array(z3.string().min(1)).min(1)
 });
-var feedbackSchema = z2.strictObject({
+var feedbackSchema = z3.strictObject({
   /** GitHub logins whose feedback does not wake the coordinator, such as a status bot; case is ignored. */
-  ignore: z2.array(z2.string().min(1)).default([]),
+  ignore: z3.array(z3.string().min(1)).default([]),
   /**
    * Texts of a bot's pull request comment that report no finding: such a comment (login ending `[bot]`, no inline
    * comment by the same author within five minutes of it) is no feedback. Compared with whitespace collapsed; the
    * default is the CI code review's comment for a clean run. An empty list counts every bot comment.
    */
-  noFindingTemplates: z2.array(z2.string().min(1)).default([CLEAN_REVIEW_TEXT])
+  noFindingTemplates: z3.array(z3.string().min(1)).default([CLEAN_REVIEW_TEXT])
 });
 var DEFAULT_PARALLEL_TASKS_MAX_TOKENS = 1e5;
-var parallelTasksSchema = z2.strictObject({
+var parallelTasksSchema = z3.strictObject({
   /**
    * The most the extra agents of a parallel proposal may cost before they do anything: the token baseline of a fresh
    * agent times the agents to add. Above it the watcher does not propose parallel tasks. The baseline is the context
    * the first answer of a lane's session carried.
    */
-  maxTokens: z2.number().int().positive().default(DEFAULT_PARALLEL_TASKS_MAX_TOKENS),
+  maxTokens: z3.number().int().positive().default(DEFAULT_PARALLEL_TASKS_MAX_TOKENS),
   /**
    * The days, both included, on which a proposal that keeps every limit is marked `auto` and the coordinator starts it
    * without asking: subagents beside running work in a lane, at most two extra agents, no path that always asks.
    * `since` is the day it was switched on, `until` at most seven days later; outside the window it is off. Unset by
    * default, so every proposal asks.
    */
-  auto: z2.strictObject({ since: z2.iso.date(), until: z2.iso.date() }).refine(({ since, until }) => until >= since, "until must not be before since").refine(
+  auto: z3.strictObject({ since: z3.iso.date(), until: z3.iso.date() }).refine(({ since, until }) => until >= since, "until must not be before since").refine(
     ({ since, until }) => windowDays(since, until) <= MAX_AUTO_WINDOW_DAYS,
     `until must be at most ${MAX_AUTO_WINDOW_DAYS} days after since`
   ).optional()
 });
-var checksSchema = z2.strictObject({
+var checksSchema = z3.strictObject({
   /**
    * Finds a failed test in a line of a red run's log (`gh run view --log-failed`) after its job, step and timestamp
    * prefix: the first group is the name, else the match. The default is Bun's `(fail) <name> [<duration>]`. The
@@ -433,22 +474,22 @@ var checksSchema = z2.strictObject({
    * itself (`(a+)+`, `(\w*)*`, and with alternation `(a|aa)+`) is refused: a best-effort scan of the source against
    * catastrophic backtracking, not a proof.
    */
-  failedTestPattern: z2.string().min(1).refine(isRegularExpression, "not a valid regular expression").refine((pattern) => !hasNestedQuantifier(pattern), "a quantified group that holds a quantifier backtracks badly").default(BUN_FAILED_TEST_PATTERN)
+  failedTestPattern: z3.string().min(1).refine(isRegularExpression, "not a valid regular expression").refine((pattern) => !hasNestedQuantifier(pattern), "a quantified group that holds a quantifier backtracks badly").default(BUN_FAILED_TEST_PATTERN)
 });
-var previewsSchema = z2.strictObject({
+var previewsSchema = z3.strictObject({
   /** Reads the GitHub deployments of each head commit; a successful one outside production and `deploy.environments` names its `environment_url`. */
-  deployments: z2.boolean().default(false),
+  deployments: z3.boolean().default(false),
   /**
    * GitHub logins whose pull request comments link a preview; nothing they write counts as feedback, so name a bot that
    * only posts previews, not one that also reviews. Case is ignored.
    */
-  authors: z2.array(z2.string().min(1)).default([]),
+  authors: z3.array(z3.string().min(1)).default([]),
   /** Finds the URL in such a comment: its first group, else its match; without it the first https link. */
-  urlPattern: z2.string().min(1).refine(isRegularExpression, "not a valid regular expression").optional()
+  urlPattern: z3.string().min(1).refine(isRegularExpression, "not a valid regular expression").optional()
 });
-var sourcePath = z2.string().refine(isSourcePath, "not a source path: `.`, or `.key`, `[n]` and `[-n]` in a chain");
+var sourcePath = z3.string().refine(isSourcePath, "not a source path: `.`, or `.key`, `[n]` and `[-n]` in a chain");
 var SOURCE_FIELD_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
-var sourceMapSchema = z2.object({
+var sourceMapSchema = z3.object({
   [SOURCE_FIELD.id]: sourcePath,
   /**
    * Changes whenever the entry changes; compared as text, so any stable form of a time or version works. Needed
@@ -469,49 +510,49 @@ var sourceMapSchema = z2.object({
   message: "a map field is a letter, then letters, digits and `_`"
 });
 var canChange = ({ map, reportOn }) => map.updatedAt !== void 0 || CONTENT_FIELDS.some((field) => map[field] !== void 0) || reportOn !== void 0;
-var toneName = z2.enum(TONE_NAMES);
-var sourceSchema = z2.strictObject({
+var toneName = z3.enum(TONE_NAMES);
+var sourceSchema = z3.strictObject({
   /** Printed in every report of the source and the key of its saved state. */
-  name: z2.string().regex(/^[A-Za-z0-9][\w.-]*$/, "letters, digits, `_`, `.` and `-`"),
+  name: z3.string().regex(/^[A-Za-z0-9][\w.-]*$/, "letters, digits, `_`, `.` and `-`"),
   /** Program and arguments, run without a shell in the main checkout; it prints JSON on stdout and only reads. */
-  command: z2.array(z2.string().min(1)).min(1),
+  command: z3.array(z3.string().min(1)).min(1),
   /** Minutes between two runs, at least 1. */
-  every: z2.number().int().min(1).default(5),
+  every: z3.number().int().min(1).default(5),
   /** The path of the list in the output; without it the output is the list. */
   items: sourcePath.optional(),
   map: sourceMapSchema,
   /** Values of `map.author` whose changes wake nobody, such as the account the command runs as; case is ignored. */
-  ignoreAuthors: z2.array(z2.string().min(1)).default([]),
+  ignoreAuthors: z3.array(z3.string().min(1)).default([]),
   /** The most new or changed entries one report shows of this source; the rest is one line `+<n> more`. */
-  reportLimit: z2.number().int().min(1).default(5),
+  reportLimit: z3.number().int().min(1).default(5),
   /** Shown before a row of "Your turn" that came from this source (`Error log · Checkout: …`); without it the source's name. */
-  label: z2.string().min(1).max(40).regex(/^[^\r\n]+$/, "one line").optional(),
+  label: z3.string().min(1).max(40).regex(/^[^\r\n]+$/, "one line").optional(),
   /** The lane the source's reports name. */
-  lane: z2.string().min(1).optional(),
+  lane: z3.string().min(1).optional(),
   /**
    * Marks the entries as tickets: the herd shows each as a badge beside the plan of the lane it belongs to,
    * the lane above or the lane whose board row or plan names its id.
    */
-  ticket: z2.boolean().optional(),
+  ticket: z3.boolean().optional(),
   /** The tone of the source's mark in the herd's `Sources` block while its newest report is new; without it the tone of the role `new`. */
   tone: toneName.optional(),
   /**
    * The mapped fields whose change reports, with the old and the new value, in place of the content of `title`,
    * `author`, `body` and `url`; without it a change of that content reports.
    */
-  reportOn: z2.array(z2.string().min(1)).min(1).max(10).optional(),
+  reportOn: z3.array(z3.string().min(1)).min(1).max(10).optional(),
   /**
    * Names of secrets the command needs, handed to it as environment variables of the same name; each is looked up
    * in the keychain, then in the watcher's environment.
    */
-  secrets: z2.array(z2.string().regex(SECRET_NAME, "capital letters, digits and `_`, starting with a letter")).max(10).refine((names) => new Set(names).size === names.length, "secret names must be unique").optional(),
+  secrets: z3.array(z3.string().regex(SECRET_NAME, "capital letters, digits and `_`, starting with a letter")).max(10).refine((names) => new Set(names).size === names.length, "secret names must be unique").optional(),
   /** `entries` shows the source's entries open, in a herd block of its own; not for a ticket source, whose entries are badges. */
-  show: z2.literal(SOURCE_SHOW.entries).optional(),
+  show: z3.literal(SOURCE_SHOW.entries).optional(),
   /**
    * `owner/name` of the repositories a personal source runs in (matched without regard to case); without it every
    * repository. Only in the personal sources file: the repository's own config is for that repository already.
    */
-  repos: z2.array(z2.string().regex(REPOSITORY_NAME, "owner/name, such as acme/tool")).min(1).max(20).refine((repos) => new Set(repos.map((repo) => repo.toLowerCase())).size === repos.length, "repos must be unique").optional()
+  repos: z3.array(z3.string().regex(REPOSITORY_NAME, "owner/name, such as acme/tool")).min(1).max(20).refine((repos) => new Set(repos.map((repo) => repo.toLowerCase())).size === repos.length, "repos must be unique").optional()
 }).refine(canChange, {
   message: "map needs updatedAt, a content field (title, author, body, url) or reportOn",
   path: ["map"]
@@ -529,7 +570,7 @@ var sourceSchema = z2.strictObject({
   path: ["reportOn"]
 });
 var hasUniqueNames = (sources) => new Set(sources.map(({ name }) => name)).size === sources.length;
-var repositorySources = z2.array(sourceSchema).refine(hasUniqueNames, "source names must be unique").superRefine((sources, context) => {
+var repositorySources = z3.array(sourceSchema).refine(hasUniqueNames, "source names must be unique").superRefine((sources, context) => {
   sources.forEach((source, index) => {
     if (source.repos === void 0) return;
     context.addIssue({
@@ -540,7 +581,7 @@ var repositorySources = z2.array(sourceSchema).refine(hasUniqueNames, "source na
   });
 });
 var DEFAULT_CLEAR_TOKENS = 25e4;
-var coordinatorSchema = z2.strictObject({
+var coordinatorSchema = z3.strictObject({
   /** Tokens in the coordinator's context from which the watcher reports `coordinator warn`. */
   warnTokens: tokenCount.default(35e4),
   /** Tokens in the coordinator's context from which the watcher reports `coordinator alert`. */
@@ -562,62 +603,62 @@ var coordinatorSchema = z2.strictObject({
   ...thresholds,
   clearTokens: clearTokens ?? Math.min(DEFAULT_CLEAR_TOKENS, thresholds.warnTokens - 1)
 }));
-var standingTool = z2.string().regex(
+var standingTool = z3.string().regex(
   /^mcp__[A-Za-z0-9_-]+__execute_sql$/,
   "a full MCP tool name ending in execute_sql, such as mcp__<server>__execute_sql"
 ).refine((name) => !/prod/i.test(name), "a tool whose name says prod never runs under a standing approval");
-var guardedCommand = z2.string().regex(/^[a-z][a-z0-9-]*( [a-z][a-z0-9-]*){1,3}$/, "a program and one to three plain words, such as gh pr merge");
-var checkFreePattern = z2.string().regex(/^[A-Za-z0-9_.*/-]+$/, "path words with * and ** only, such as docs/**/*.md").refine(
+var guardedCommand = z3.string().regex(/^[a-z][a-z0-9-]*( [a-z][a-z0-9-]*){1,3}$/, "a program and one to three plain words, such as gh pr merge");
+var checkFreePattern = z3.string().regex(/^[A-Za-z0-9_.*/-]+$/, "path words with * and ** only, such as docs/**/*.md").refine(
   (pattern) => !pattern.startsWith("/") && !pattern.split("/").includes(".."),
   "a relative path that stays inside the repository"
 ).refine(
   (pattern) => pattern.split("/").some((segment) => /^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(segment)),
   "a pattern with a whole path segment that is no wildcard, such as docs/**/*.md"
 );
-var alwaysAskPattern = z2.string().regex(/^[A-Za-z0-9_.*/-]+$/, "path words with * and ** only, such as .github/** or apps/*/src/**").refine(
+var alwaysAskPattern = z3.string().regex(/^[A-Za-z0-9_.*/-]+$/, "path words with * and ** only, such as .github/** or apps/*/src/**").refine(
   (pattern) => pattern.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".."),
   "a relative path that stays inside the repository, without an empty or . segment"
 );
-var checkName = z2.string().max(200).refine(
+var checkName = z3.string().max(200).refine(
   (name) => name.trim() !== "" && ![...name].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127),
   "a check name as GitHub lists it, such as test"
 );
-var mergeSchema = z2.strictObject({
+var mergeSchema = z3.strictObject({
   /**
    * Paths of pull requests that are merged without waiting for checks: when every file of the pull request matches one
    * of them, `/orchestrate` merges at once and the merge guard does not ask, for a merge bound to the head commit with
    * `--match-head-commit`. Empty means every merge waits for checks.
    */
-  withoutChecks: z2.array(checkFreePattern).default([]),
+  withoutChecks: z3.array(checkFreePattern).default([]),
   /**
    * Whether a lane opens every pull request as a draft (`gh pr create --draft`), so pushes while it is worked on start
    * no workflow that skips drafts. `/orchestrate` runs `gh pr ready` before the merge and waits for the checks that
    * start then; the merge guard never lets a draft through. Off opens pull requests ready, as before.
    */
-  openAsDraft: z2.boolean().default(false)
+  openAsDraft: z3.boolean().default(false)
 });
-var guardFields = z2.strictObject({
+var guardFields = z3.strictObject({
   /**
    * The commands the merge guard hook asks the user about before they run, where they stand at a program position, also
    * behind options before the verb, a chain, a wrapper or `sh -c`. `gh api`, when listed, asks only for a write to a
    * merge, a file, a dispatch, a rerun or a ref. An empty list switches the guard off.
    */
-  commands: z2.array(guardedCommand).default(["gh pr merge", "gh workflow run"]),
-  selfMerge: z2.strictObject({
+  commands: z3.array(guardedCommand).default(["gh pr merge", "gh workflow run"]),
+  selfMerge: z3.strictObject({
     /** Whether `/orchestrate` offers "merge it yourself after green checks" in the pull request question; off also stops the hook honouring such an answer. */
-    offer: z2.boolean().default(true),
+    offer: z3.boolean().default(true),
     /** How long an answer to that question lets `gh pr merge <number>` pass without asking, counted from the answer. */
-    approvalMinutes: z2.number().int().min(1).max(1440).default(180)
+    approvalMinutes: z3.number().int().min(1).max(1440).default(180)
   }).prefault({}),
-  approvals: z2.strictObject({
+  approvals: z3.strictObject({
     /** How long the approval gate hook holds a lane's call for the coordinator's dialog before it denies it; below the hook's 10 minutes. */
-    waitMinutes: z2.number().int().min(1).max(9).default(8),
+    waitMinutes: z3.number().int().min(1).max(9).default(8),
     /**
      * The calls a standing approval of the user may let through once the coordinator marked them checked: each tool
      * by its full name and the environment it writes to, only `stage`. A tool whose name says `prod` is refused, as the
      * hook refuses it under a broken config; which project a server reaches is the project's start script's to say.
      */
-    standing: z2.strictObject({ tools: z2.record(standingTool, z2.enum(Object.values(STANDING_ENVIRONMENT))) }).optional()
+    standing: z3.strictObject({ tools: z3.record(standingTool, z3.enum(Object.values(STANDING_ENVIRONMENT))) }).optional()
   }).prefault({}),
   /**
    * Paths that always ask, on top of the ones jackherd brings (`.github/**`, `**\/migrations/**`, `**\/.env*`,
@@ -626,15 +667,15 @@ var guardFields = z2.strictObject({
    * `merge.withoutChecks` pattern never opens them, and the watcher never starts parallel work on them by itself. They
    * add to that list, never replace it. A standing approval covers them; only workflows, migrations and env files ask.
    */
-  alwaysAsk: z2.array(alwaysAskPattern).default([]),
+  alwaysAsk: z3.array(alwaysAskPattern).default([]),
   /**
    * Checks that must be among the head commit's and green before a standing approval lets a merge pass, by their names
    * on GitHub. Unset, the merge needs at least one check and every one green; set, also each of these. Either way
    * GitHub must be able to merge it.
    */
-  requiredChecks: z2.array(checkName).optional(),
+  requiredChecks: z3.array(checkName).optional(),
   /** Read until 2.0.0 as `alwaysAsk` (`exceptPaths`) and `requiredChecks`; the plan approval it was for is gone. */
-  planApproval: z2.strictObject({ exceptPaths: z2.array(alwaysAskPattern).optional(), requiredChecks: z2.array(checkName).optional() }).optional().meta({ deprecated: true })
+  planApproval: z3.strictObject({ exceptPaths: z3.array(alwaysAskPattern).optional(), requiredChecks: z3.array(checkName).optional() }).optional().meta({ deprecated: true })
 });
 var guardWithoutPlanApproval = ({ planApproval, ...guard }) => {
   const requiredChecks = guard.requiredChecks ?? planApproval?.requiredChecks;
@@ -645,21 +686,21 @@ var guardWithoutPlanApproval = ({ planApproval, ...guard }) => {
   };
 };
 var guardSchema = guardFields.transform(guardWithoutPlanApproval);
-var hintsSchema = z2.strictObject({
+var hintsSchema = z3.strictObject({
   /** Whether the `ask-hint` hook points out a last message that ends in a question while the turn used no `AskUserQuestion`; a lane session is never hinted. */
-  askUserQuestion: z2.boolean().default(true),
+  askUserQuestion: z3.boolean().default(true),
   /** Whether the `task-hint` hook points a lane that edits a file without an open task signal to `jh task start`, once per task. */
-  taskSignal: z2.boolean().default(true)
+  taskSignal: z3.boolean().default(true)
 });
 var DEFAULT_TASK_SIGNAL_MINUTES = 10;
-var tonesSchema = z2.strictObject({
+var tonesSchema = z3.strictObject({
   waiting: toneName.default(DEFAULT_TONES.waiting),
   planned: toneName.default(DEFAULT_TONES.planned),
   new: toneName.default(DEFAULT_TONES.new),
   running: toneName.default(DEFAULT_TONES.running),
   resting: toneName.default(DEFAULT_TONES.resting)
 });
-var contextSchema = z2.strictObject({
+var contextSchema = z3.strictObject({
   /** Tokens in a lane's context from which its fill shows yellow and `/implement` offers a new chat. */
   warnTokens: tokenCount.default(25e4),
   /** Tokens in a lane's context from which its fill shows red and the lane hands over at the next phase boundary. */
@@ -668,70 +709,75 @@ var contextSchema = z2.strictObject({
    * Context window in tokens by full model ID, only the upper bound of the share a view shows (the thresholds are
    * tokens); the log does not say which window a session ran with.
    */
-  windows: z2.record(modelId, tokenCount).default({}),
+  windows: z3.record(modelId, tokenCount).default({}),
   /** The window assumed for a model not listed in `windows`. */
   defaultWindow: tokenCount.default(DEFAULT_CONTEXT_WINDOW),
   /** The coordinator's own thresholds, used by `jh context --coordinator`; the lanes keep `warnTokens` and `alertTokens`. */
   coordinator: coordinatorSchema.prefault({})
 }).refine(warnBelowAlert, WARN_BELOW_ALERT);
-var jackherdConfigSchema = z2.strictObject({
-  $schema: z2.string().optional(),
+var jackherdConfigSchema = z3.strictObject({
+  $schema: z3.string().optional(),
   responseLanguage: language.default(PLAN_LANGUAGE.en),
   /** Whether replies address the user with the familiar or the polite form where the language has both (German: du or Sie). */
-  responseAddress: z2.enum(Object.values(RESPONSE_ADDRESS)).default(RESPONSE_ADDRESS.informal),
+  responseAddress: z3.enum(Object.values(RESPONSE_ADDRESS)).default(RESPONSE_ADDRESS.informal),
+  /** The language new plans and the plan templates are written in. Boards and plans are read in every known language whatever this says. */
   planLanguage: language.default(PLAN_LANGUAGE.en),
-  planDirectory: z2.string().min(1).default("docs/plans"),
+  /** The language jh writes the board in (history lines, lane rows, waiting rows); `planLanguage` when left out. */
+  boardLanguage: language.optional(),
+  planDirectory: z3.string().min(1).default("docs/plans"),
   /** Where the boards live and what the project calls them. */
   board: boardSchema.prefault({}),
   /** Replaced by `board.pattern` in 0.13.0; named here only so an old config is refused with that hint. */
-  sprintPattern: z2.never({ error: "sprintPattern was replaced by board.pattern (with board.file and board.term)" }).optional(),
-  worktreeDirectory: z2.string().min(1).refine(isRepositoryDirectory, "must lie below the repository root: relative, not `.`, without `..`").default(claudePath(WORKTREES_DIRECTORY)),
+  sprintPattern: z3.never({ error: "sprintPattern was replaced by board.pattern (with board.file and board.term)" }).optional(),
+  worktreeDirectory: z3.string().min(1).refine(isRepositoryDirectory, "must lie below the repository root: relative, not `.`, without `..`").default(claudePath(WORKTREES_DIRECTORY)),
   baseBranch: branchName.default(DEFAULT_BASE_BRANCH),
   /**
    * Put before every skill and agent name. `jh sync --global` refuses to run without one: a personal skill
    * shadows a project skill of the same name. In a project it is optional and keeps the project's own skills of a
    * kit name (`implement`, `plan`, …) apart from the kit's.
    */
-  skillPrefix: z2.union([z2.literal(""), z2.string().regex(SKILL_PREFIX, "lower-case letters and digits ending in a dash, e.g. kit-")]).default(""),
+  skillPrefix: z3.union([z3.literal(""), z3.string().regex(SKILL_PREFIX, "lower-case letters and digits ending in a dash, e.g. kit-")]).default(""),
   commands: commandsSchema.prefault({}),
   /**
    * Kit skills and agents `jh sync` leaves out, by the kit's name without `skillPrefix`; a name takes its skill and
    * its agent alike. An unchanged copy already installed is removed, a changed one stays untracked.
    */
-  kit: z2.strictObject({ exclude: z2.array(excludedKitEntry).default([]) }).prefault({}),
+  kit: z3.strictObject({ exclude: z3.array(excludedKitEntry).default([]) }).prefault({}),
   /** How `/orchestrate` sets up a lane's worktree. */
-  lanes: z2.strictObject({
+  lanes: z3.strictObject({
     /** Untracked files copied into every new worktree; empty means the files `.worktreeinclude` lists. */
-    copy: z2.array(laneCopyPath).default([]),
+    copy: z3.array(laneCopyPath).default([]),
     /** The dependency lock file a rebase takes from the base branch and regenerates, never merges by hand; detected from the repository when left out. */
     lockFile: lockFilePath.optional(),
     /** Free gigabytes the disk must hold before `jh lane space` lets a new lane install its dependencies; 5 when left out. */
-    minFreeGb: z2.number().positive().optional(),
+    minFreeGb: z3.number().positive().optional(),
     /** The port `jh lane port` starts counting from when it picks a lane's dev-server port; 3100 when left out. */
-    basePort: z2.number().int().min(1).max(65535).optional(),
+    basePort: z3.number().int().min(1).max(65535).optional(),
     /** The command `jh lane dev` runs as `PORT=<port> <command>` in a pane beside the lane's agent; `{port}` and `{filter}` (`--filter <package>`) are filled in. Without it `jh lane dev` refuses. */
-    devCommand: z2.string().min(1).optional()
+    devCommand: z3.string().min(1).optional(),
+    /** The services every lane's app talks to, run in one pane of the main checkout that the watcher starts and keeps; without it `jh backend` has nothing to run. */
+    backend: backendSchema.optional()
   }).prefault({}),
-  models: z2.record(z2.enum(Object.values(MODEL_ROLE)), modelId).default(DEFAULT_MODELS),
-  terminal: z2.strictObject({ adapter: z2.enum(Object.values(TERMINAL_ADAPTER)).default(TERMINAL_ADAPTER.none) }).prefault({}),
+  models: z3.record(z3.enum(Object.values(MODEL_ROLE)), modelId).default(DEFAULT_MODELS),
+  terminal: z3.strictObject({ adapter: z3.enum(Object.values(TERMINAL_ADAPTER)).default(TERMINAL_ADAPTER.none) }).prefault({}),
   /** How the coordinator shows a draft for review (`orchestrate` § 4). */
-  preview: z2.strictObject({
+  preview: z3.strictObject({
     /** Publish the draft as a private Artifact when the session has the tool; `false` sends a file card or `jh preview --open` instead. */
-    publish: z2.boolean().default(true)
+    publish: z3.boolean().default(true)
   }).prefault({}),
-  plans: z2.strictObject({
+  plans: z3.strictObject({
     /** Minutes between background fetches of the base branch while `jh herd` runs; 0 turns them off. */
-    fetchIntervalMinutes: z2.number().min(0).default(5),
+    fetchIntervalMinutes: z3.number().min(0).default(5),
     /** The running task of a folded lane shimmers in `jh herd`; `false` keeps it still. `NO_COLOR` keeps it still too. */
-    shimmer: z2.boolean().default(true),
+    shimmer: z3.boolean().default(true),
     /** Minutes without a prompt after which the `return-brief` hook asks the coordinator to show `jh brief` first; 0 turns it off. */
-    briefAfterMinutes: z2.number().min(0).default(60),
+    briefAfterMinutes: z3.number().min(0).default(60),
     /** Links in a plan that the sprint page shows as chips; the list replaces the built-in kinds. */
-    linkKinds: z2.array(
-      z2.strictObject({
-        pattern: z2.string().min(1).refine(isRegularExpression, "not a valid regular expression"),
-        label: z2.string().min(1),
-        icon: z2.string().min(1)
+    linkKinds: z3.array(
+      z3.strictObject({
+        pattern: z3.string().min(1).refine(isRegularExpression, "not a valid regular expression"),
+        label: z3.string().min(1),
+        icon: z3.string().min(1)
       })
     ).default(DEFAULT_LINK_KINDS.map((kind) => ({ ...kind }))),
     context: contextSchema.prefault({}),
@@ -747,12 +793,12 @@ var jackherdConfigSchema = z2.strictObject({
    * Without `previews` it reads no deploy preview; with it, one `preview` per new head commit. Each of `sources` is a
    * command whose JSON output reports `source` for a new or changed entry.
    */
-  watch: z2.strictObject({
+  watch: z3.strictObject({
     deploy: deploySchema.optional(),
-    feedback: z2.union([z2.literal(false), feedbackSchema]).prefault({}),
+    feedback: z3.union([z3.literal(false), feedbackSchema]).prefault({}),
     checks: checksSchema.prefault({}),
     parallelTasks: parallelTasksSchema.prefault({}),
-    taskSignalMinutes: z2.number().int().positive().default(DEFAULT_TASK_SIGNAL_MINUTES),
+    taskSignalMinutes: z3.number().int().positive().default(DEFAULT_TASK_SIGNAL_MINUTES),
     previews: previewsSchema.optional(),
     sources: repositorySources.default([])
   }).prefault({}),
@@ -769,19 +815,19 @@ var parseJackherdConfig = (raw) => jackherdConfigSchema.parse(raw);
 var parseLabelled = (schema, raw, label) => {
   const parsed = schema.safeParse(raw);
   if (!parsed.success) throw new Error(`${label} is invalid:
-${z2.prettifyError(parsed.error)}`);
+${z3.prettifyError(parsed.error)}`);
   return parsed.data;
 };
 var parseConfigFile = (raw, label) => parseLabelled(jackherdConfigSchema, raw, label);
-var personalSourcesSchema = z2.strictObject({
-  $schema: z2.string().optional(),
-  sources: z2.array(sourceSchema).refine(hasUniqueNames, "source names must be unique").default([])
+var personalSourcesSchema = z3.strictObject({
+  $schema: z3.string().optional(),
+  sources: z3.array(sourceSchema).refine(hasUniqueNames, "source names must be unique").default([])
 });
 var parsePersonalSourcesFile = (raw, label) => parseLabelled(personalSourcesSchema, raw, label);
 var parseSourceDraft = (raw, label) => parseLabelled(sourceSchema, raw, label);
 
 // src/config/json-schema.ts
-var renderJsonSchema = (schema) => `${JSON.stringify(z3.toJSONSchema(schema, { io: "input" }), null, 2)}
+var renderJsonSchema = (schema) => `${JSON.stringify(z4.toJSONSchema(schema, { io: "input" }), null, 2)}
 `;
 var renderConfigJsonSchema = () => renderJsonSchema(jackherdConfigSchema);
 var renderSourcesJsonSchema = () => renderJsonSchema(personalSourcesSchema);