jackherd 0.0.1 → 1.0.1

package/dist/config.d.ts

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+
+declare const renderConfigJsonSchema: () => string;
+
+declare const TERMINAL_ADAPTER: {
+    readonly none: "none";
+    readonly herdr: "herdr";
+};
+type TerminalAdapter = (typeof TERMINAL_ADAPTER)[keyof typeof TERMINAL_ADAPTER];
+declare const MODEL_ROLE: {
+    readonly plan: "plan";
+    readonly implement: "implement";
+    readonly review: "review";
+    readonly explore: "explore";
+    readonly orchestrate: "orchestrate";
+};
+type ModelRole = (typeof MODEL_ROLE)[keyof typeof MODEL_ROLE];
+declare const isTerminalAdapter: (value: string) => value is TerminalAdapter;
+declare const isModelRole: (value: string) => value is ModelRole;
+/** Lower-case letters and digits ending in a dash, so a prefixed name stays one plain path segment. */
+declare const SKILL_PREFIX: RegExp;
+declare const sourceSchema: z.ZodObject<{
+    name: z.ZodString;
+    command: z.ZodArray<z.ZodString>;
+    every: z.ZodDefault<z.ZodNumber>;
+    items: z.ZodOptional<z.ZodString>;
+    map: z.ZodObject<{
+        id: z.ZodString;
+        updatedAt: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodString>>;
+    ignoreAuthors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    reportLimit: z.ZodDefault<z.ZodNumber>;
+    lane: z.ZodOptional<z.ZodString>;
+    reportOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const jackherdConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    responseLanguage: z.ZodDefault<z.ZodEnum<{
+        de: "de";
+        en: "en";
+    }>>;
+    planLanguage: z.ZodDefault<z.ZodEnum<{
+        de: "de";
+        en: "en";
+    }>>;
+    planDirectory: z.ZodDefault<z.ZodString>;
+    board: z.ZodPrefault<z.ZodObject<{
+        pattern: z.ZodDefault<z.ZodString>;
+        file: z.ZodDefault<z.ZodString>;
+        term: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    sprintPattern: z.ZodOptional<z.ZodNever>;
+    worktreeDirectory: z.ZodDefault<z.ZodString>;
+    baseBranch: z.ZodDefault<z.ZodString>;
+    skillPrefix: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+    commands: z.ZodPrefault<z.ZodObject<{
+        test: z.ZodDefault<z.ZodString>;
+        typecheck: z.ZodDefault<z.ZodString>;
+        lint: z.ZodDefault<z.ZodString>;
+        format: z.ZodDefault<z.ZodString>;
+        install: z.ZodDefault<z.ZodString>;
+        dev: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    lanes: z.ZodPrefault<z.ZodObject<{
+        copy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        lockFile: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    models: z.ZodRecord<z.ZodEnum<{
+        plan: "plan";
+        implement: "implement";
+        review: "review";
+        explore: "explore";
+        orchestrate: "orchestrate";
+    }>, z.ZodString>;
+    terminal: z.ZodPrefault<z.ZodObject<{
+        adapter: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            herdr: "herdr";
+        }>>;
+    }, z.core.$strict>>;
+    plans: z.ZodPrefault<z.ZodObject<{
+        fetchIntervalMinutes: z.ZodDefault<z.ZodNumber>;
+        linkKinds: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            pattern: z.ZodString;
+            label: z.ZodString;
+            icon: z.ZodString;
+        }, z.core.$strict>>>;
+        context: z.ZodPrefault<z.ZodObject<{
+            warnAt: z.ZodDefault<z.ZodNumber>;
+            alertAt: z.ZodDefault<z.ZodNumber>;
+            windows: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            defaultWindow: z.ZodDefault<z.ZodNumber>;
+            coordinator: z.ZodPrefault<z.ZodObject<{
+                warnAt: z.ZodDefault<z.ZodNumber>;
+                alertAt: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    watch: z.ZodPrefault<z.ZodObject<{
+        deploy: z.ZodOptional<z.ZodObject<{
+            workflow: z.ZodString;
+            environments: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        feedback: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+            ignore: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>]>>;
+        previews: z.ZodOptional<z.ZodObject<{
+            deployments: z.ZodDefault<z.ZodBoolean>;
+            authors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            urlPattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodArray<z.ZodString>;
+            every: z.ZodDefault<z.ZodNumber>;
+            items: z.ZodOptional<z.ZodString>;
+            map: z.ZodObject<{
+                id: z.ZodString;
+                updatedAt: z.ZodString;
+                title: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                body: z.ZodOptional<z.ZodString>;
+                author: z.ZodOptional<z.ZodString>;
+            }, z.core.$catchall<z.ZodString>>;
+            ignoreAuthors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            reportLimit: z.ZodDefault<z.ZodNumber>;
+            lane: z.ZodOptional<z.ZodString>;
+            reportOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    check: z.ZodOptional<z.ZodObject<{
+        lintFilesCommand: z.ZodDefault<z.ZodString>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodString;
+            globs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+        generatorOwned: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            glob: z.ZodString;
+            generator: z.ZodString;
+        }, z.core.$strict>>>;
+        buildArtifacts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        reviewerRoutes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            reviewer: z.ZodString;
+            globs: z.ZodArray<z.ZodString>;
+            why: z.ZodString;
+        }, z.core.$strict>>>;
+        publicContent: z.ZodOptional<z.ZodObject<{
+            globs: z.ZodArray<z.ZodString>;
+            exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            reviewer: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>>;
+        looseTests: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type JackherdConfig = z.infer<typeof jackherdConfigSchema>;
+declare const parseJackherdConfig: (raw: unknown) => JackherdConfig;
+/** `parseJackherdConfig` for a file: an invalid one throws with `label` (its path) and the issues in words. */
+declare const parseConfigFile: (raw: unknown, label: string) => JackherdConfig;
+/** One `watch.sources` entry outside the config, such as a draft to try; invalid throws with `label` and the issues. */
+declare const parseSourceDraft: (raw: unknown, label: string) => z.infer<typeof sourceSchema>;
+
+export { type JackherdConfig, MODEL_ROLE, type ModelRole, SKILL_PREFIX, TERMINAL_ADAPTER, type TerminalAdapter, isModelRole, isTerminalAdapter, jackherdConfigSchema, parseConfigFile, parseJackherdConfig, parseSourceDraft, renderConfigJsonSchema };

package/dist/config.js

@@ -0,0 +1,401 @@
+import {
+  PLAN_LANGUAGE
+} from "./chunk-R6MGHCD7.js";
+
+// src/config/json-schema.ts
+import { z as z3 } from "zod";
+
+// src/config/schema.ts
+import { z as z2 } from "zod";
+
+// src/check/schema.ts
+import { z } from "zod";
+
+// src/version/release.ts
+var PACKAGE_NAME = "jackherd";
+
+// src/config/location.ts
+import { dirname, join, resolve } from "path";
+var TOOL_DIRECTORY = ".jackherd";
+var CONFIG_FILE = "config.json";
+var CONFIG_SCHEMA_REFERENCE = `../node_modules/${PACKAGE_NAME}/schemas/${PACKAGE_NAME}.schema.json`;
+var PROJECT_CONFIG_PATH = `${TOOL_DIRECTORY}/${CONFIG_FILE}`;
+
+// src/config/detect.ts
+var PACKAGE_MANAGER = { bun: "bun", yarn: "yarn", pnpm: "pnpm", npm: "npm" };
+var LOCK_FILES = {
+  "bun.lock": PACKAGE_MANAGER.bun,
+  "bun.lockb": PACKAGE_MANAGER.bun,
+  "yarn.lock": PACKAGE_MANAGER.yarn,
+  "pnpm-lock.yaml": PACKAGE_MANAGER.pnpm,
+  "package-lock.json": PACKAGE_MANAGER.npm
+};
+var DEFAULT_BASE_BRANCH = "main";
+var DERIVED_COMMANDS = {
+  bun: {
+    test: "bun test",
+    typecheck: "bunx -p typescript tsc --noEmit",
+    lint: "bunx @biomejs/biome check .",
+    format: "bunx @biomejs/biome format --write .",
+    install: "bun install",
+    dev: "bun run dev",
+    lintFiles: "bunx @biomejs/biome check --no-errors-on-unmatched"
+  },
+  yarn: {
+    test: "yarn test",
+    typecheck: "yarn tsc --noEmit",
+    lint: "yarn biome check .",
+    format: "yarn biome format --write .",
+    install: "yarn install",
+    dev: "yarn dev",
+    lintFiles: "yarn biome check --no-errors-on-unmatched"
+  },
+  pnpm: {
+    test: "pnpm test",
+    typecheck: "pnpm exec tsc --noEmit",
+    lint: "pnpm exec biome check .",
+    format: "pnpm exec biome format --write .",
+    install: "pnpm install",
+    dev: "pnpm dev",
+    lintFiles: "pnpm exec biome check --no-errors-on-unmatched"
+  },
+  npm: {
+    test: "npm test",
+    typecheck: "npx tsc --noEmit",
+    lint: "npx @biomejs/biome check .",
+    format: "npx @biomejs/biome format --write .",
+    install: "npm install",
+    dev: "npm run dev",
+    lintFiles: "npx @biomejs/biome check --no-errors-on-unmatched"
+  }
+};
+var BUN_COMMANDS = DERIVED_COMMANDS.bun;
+
+// src/check/command-line.ts
+var TOKEN = /(?:"[^"]*"|'[^']*'|\S)+/g;
+var QUOTED = /"([^"]*)"|'([^']*)'/g;
+var tokenize = (command3) => (command3.match(TOKEN) ?? []).map((token) => {
+  if (/["']/.test(token.replace(QUOTED, ""))) throw new Error(`Unterminated quote in command: ${command3}`);
+  return token.replace(QUOTED, "$1$2");
+});
+
+// src/check/schema.ts
+var nonEmpty = z.string().min(1);
+var isTokenizable = (command3) => {
+  try {
+    tokenize(command3);
+    return true;
+  } catch {
+    return false;
+  }
+};
+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 DEFAULT_BUILD_ARTIFACT_GLOBS = [
+  "**/tsup.config.bundled_*",
+  "**/dist/**",
+  "**/.turbo/**",
+  "**/node_modules/**",
+  "**/*.tsbuildinfo"
+];
+var reviewerRoute = z.strictObject({
+  reviewer: nonEmpty,
+  globs,
+  why: nonEmpty
+});
+var projectCheck = z.strictObject({
+  name: nonEmpty,
+  command,
+  /** Without globs the check runs on every change; with them, only when a changed path matches. */
+  globs: globs.optional()
+});
+var generatorOwned = z.strictObject({
+  glob,
+  generator: nonEmpty
+});
+var publicContent = z.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([]),
+  /** The agent that judges such a change; a global install names it with its prefix. */
+  reviewer: nonEmpty.default("public-content")
+});
+var checkConfigSchema = z.strictObject({
+  /**
+   * Run once over the changed files, which are appended as arguments. Separate from `commands.lint`,
+   * which lints the whole project.
+   */
+  lintFilesCommand: command.default(BUN_COMMANDS.lintFiles),
+  /** 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([]),
+  publicContent: publicContent.optional(),
+  /** Also run tests in directories that hold test files but belong to no package. */
+  looseTests: z.boolean().default(false)
+});
+
+// src/claude/paths.ts
+var CLAUDE_DIRECTORY = ".claude";
+var WORKTREES_DIRECTORY = "worktrees";
+var claudePath = (...segments) => [CLAUDE_DIRECTORY, ...segments].join("/");
+
+// src/watch/source-fields.ts
+var SOURCE_FIELD = {
+  id: "id",
+  updatedAt: "updatedAt",
+  title: "title",
+  url: "url",
+  body: "body",
+  author: "author"
+};
+
+// src/watch/source-path.ts
+var ROOT_PATH = ".";
+var PATH_STEP = /\.([^\s.[\]|]+)|\[(-?\d+)\]/y;
+var pathSteps = (path) => {
+  if (path === ROOT_PATH) return [];
+  const steps = [];
+  PATH_STEP.lastIndex = 0;
+  while (PATH_STEP.lastIndex < path.length) {
+    const match = PATH_STEP.exec(path);
+    if (!match) return null;
+    steps.push(match[1] === void 0 ? { index: Number(match[2]) } : { key: match[1] });
+  }
+  return steps.length > 0 ? steps : null;
+};
+var isSourcePath = (path) => pathSteps(path) !== null;
+
+// src/config/link-kinds.ts
+var DEFAULT_LINK_KINDS = [
+  { pattern: "^https://github\\.com/[^/]+/[^/]+/(pull|issues)/\\d+", label: "GitHub", icon: "\u2442" },
+  { pattern: "^https://(www\\.)?figma\\.com/", label: "Figma", icon: "\u25C8" },
+  { pattern: "^https://claude\\.ai/(code/)?artifact/", label: "Artifact", icon: "\u2726" }
+];
+var isRegularExpression = (source) => {
+  try {
+    new RegExp(source);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/config/schema.ts
+var TERMINAL_ADAPTER = { none: "none", herdr: "herdr" };
+var MODEL_ROLE = {
+  plan: "plan",
+  implement: "implement",
+  review: "review",
+  explore: "explore",
+  orchestrate: "orchestrate"
+};
+var isTerminalAdapter = (value) => Object.values(TERMINAL_ADAPTER).includes(value);
+var isModelRole = (value) => Object.values(MODEL_ROLE).includes(value);
+var SKILL_PREFIX = /^[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 share = z2.number().gt(0).lt(1);
+var laneCopyPath = z2.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 = ({ warnAt, alertAt }) => warnAt < alertAt;
+var WARN_BELOW_ALERT = { message: "warnAt must be below alertAt", path: ["warnAt"] };
+var lockFilePath = z2.string().regex(/^(?![/-])(?!(?:.*\/)?\.\.(?:\/|$))[A-Za-z0-9._/-]+$/, "a plain relative file name such as yarn.lock");
+var branchName = z2.string().regex(
+  /^(?![-/.])(?!.*(?:\.\.|\/\/|@\{|\.lock(?:\/|$)))[A-Za-z0-9._/-]+(?<![./])$/,
+  "a branch name such as main: 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({
+  /** 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 plans view, its page and the watcher print it as written. */
+  term: z2.string().min(1).default("board")
+});
+var deploySchema = z2.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)
+});
+var feedbackSchema = z2.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([])
+});
+var previewsSchema = z2.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),
+  /**
+   * 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([]),
+  /** 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()
+});
+var sourcePath = z2.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({
+  [SOURCE_FIELD.id]: sourcePath,
+  /** Changes whenever the entry changes; compared as text, so any stable form of a time or version works. */
+  [SOURCE_FIELD.updatedAt]: sourcePath,
+  [SOURCE_FIELD.title]: sourcePath.optional(),
+  /** Shown only as an `https:` URL without user name or password. */
+  [SOURCE_FIELD.url]: sourcePath.optional(),
+  /** The first line with text is shown. */
+  [SOURCE_FIELD.body]: sourcePath.optional(),
+  [SOURCE_FIELD.author]: sourcePath.optional()
+}).catchall(sourcePath).refine((map) => Object.keys(map).every((field) => SOURCE_FIELD_NAME.test(field)), {
+  message: "a map field is a letter, then letters, digits and `_`"
+});
+var sourceSchema = z2.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 `-`"),
+  /** 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),
+  /** Minutes between two runs, at least 1. */
+  every: z2.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([]),
+  /** 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),
+  /** The lane the source's reports name. */
+  lane: z2.string().min(1).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()
+}).refine((source) => source.ignoreAuthors.length === 0 || source.map.author !== void 0, {
+  message: "ignoreAuthors needs map.author",
+  path: ["ignoreAuthors"]
+}).refine((source) => !source.reportOn?.includes(SOURCE_FIELD.id), {
+  message: "reportOn cannot name id",
+  path: ["reportOn"]
+}).refine((source) => (source.reportOn ?? []).every((field) => Object.hasOwn(source.map, field)), {
+  message: "reportOn names a field map does not have",
+  path: ["reportOn"]
+});
+var hasUniqueNames = (sources) => new Set(sources.map(({ name }) => name)).size === sources.length;
+var coordinatorSchema = z2.strictObject({
+  /** Share of the coordinator's context window from which the watcher reports `coordinator warn`. */
+  warnAt: share.default(0.5),
+  /** Share of the coordinator's context window from which the watcher reports `coordinator alert`. */
+  alertAt: share.default(0.7)
+}).refine(warnBelowAlert, WARN_BELOW_ALERT);
+var contextSchema = z2.strictObject({
+  /** Share of the context window from which a lane's fill shows yellow and `/implement` offers a new chat. */
+  warnAt: share.default(0.6),
+  /** Share of the context window from which a lane's fill shows red. */
+  alertAt: share.default(0.8),
+  /** Context window in tokens by full model ID; the log does not say which window a session ran with. */
+  windows: z2.record(modelId, z2.number().int().positive()).default({}),
+  /** The window assumed for a model not listed in `windows`. */
+  defaultWindow: z2.number().int().positive().default(2e5),
+  /** The coordinator's own thresholds, used by `jh context --coordinator`; the lanes keep `warnAt` and `alertAt`. */
+  coordinator: coordinatorSchema.prefault({})
+}).refine(warnBelowAlert, WARN_BELOW_ALERT);
+var jackherdConfigSchema = z2.strictObject({
+  $schema: z2.string().optional(),
+  responseLanguage: language.default(PLAN_LANGUAGE.en),
+  planLanguage: language.default(PLAN_LANGUAGE.en),
+  planDirectory: z2.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).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(""),
+  commands: z2.strictObject({
+    test: command2.default(BUN_COMMANDS.test),
+    typecheck: command2.default(BUN_COMMANDS.typecheck),
+    lint: command2.default(BUN_COMMANDS.lint),
+    format: command2.default(BUN_COMMANDS.format),
+    /** Installs a new lane's dependencies. */
+    install: command2.default(BUN_COMMANDS.install),
+    /** Starts a lane's dev server, run as `PORT=<port> <dev>`; a project supplement may name another. */
+    dev: command2.default(BUN_COMMANDS.dev)
+  }).prefault({}),
+  /** How `/orchestrate` sets up a lane's worktree. */
+  lanes: z2.strictObject({
+    /** Untracked files copied into every new worktree; empty means the files `.worktreeinclude` lists. */
+    copy: z2.array(laneCopyPath).default([]),
+    /** The dependency lock file a rebase takes from the base branch and regenerates, never merges by hand. */
+    lockFile: lockFilePath.default("bun.lock")
+  }).prefault({}),
+  models: z2.record(z2.enum(Object.values(MODEL_ROLE)), modelId),
+  terminal: z2.strictObject({ adapter: z2.enum(Object.values(TERMINAL_ADAPTER)).default(TERMINAL_ADAPTER.none) }).prefault({}),
+  plans: z2.strictObject({
+    /** Minutes between background fetches of the base branch while `jh plans` runs; 0 turns them off. */
+    fetchIntervalMinutes: z2.number().min(0).default(5),
+    /** 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)
+      })
+    ).default(DEFAULT_LINK_KINDS.map((kind) => ({ ...kind }))),
+    context: contextSchema.prefault({})
+  }).prefault({}),
+  /**
+   * Read by `jh watch`; without `deploy` it reports no deploy runs. `feedback` is on unless set to `false`:
+   * it reports new feedback on the lanes' pull requests except from the account the watcher runs as and `ignore`.
+   * 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({
+    deploy: deploySchema.optional(),
+    feedback: z2.union([z2.literal(false), feedbackSchema]).default({ ignore: [] }),
+    previews: previewsSchema.optional(),
+    sources: z2.array(sourceSchema).refine(hasUniqueNames, "source names must be unique").default([])
+  }).prefault({}),
+  /** Read by `jh check`; validated here too, so a typo fails every command alike. */
+  check: checkConfigSchema.optional()
+});
+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)}`);
+  return parsed.data;
+};
+var parseConfigFile = (raw, label) => parseLabelled(jackherdConfigSchema, raw, label);
+var parseSourceDraft = (raw, label) => parseLabelled(sourceSchema, raw, label);
+
+// src/config/json-schema.ts
+var renderConfigJsonSchema = () => `${JSON.stringify(z3.toJSONSchema(jackherdConfigSchema, { io: "input" }), null, 2)}
+`;
+export {
+  MODEL_ROLE,
+  SKILL_PREFIX,
+  TERMINAL_ADAPTER,
+  isModelRole,
+  isTerminalAdapter,
+  jackherdConfigSchema,
+  parseConfigFile,
+  parseJackherdConfig,
+  parseSourceDraft,
+  renderConfigJsonSchema
+};