@lchase/kiln 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,228 @@
-# Temporary Holding Version
+# Kiln
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Kiln runs a workflow against a git checkout. Register any repo, add a job from a markdown spec, a prompt, a directory of tickets, or a Jira Cloud issue, and tick. Tick launches ready jobs in yak worktrees. Status shows each job. Approve or reject answers a human gate.
+
+A ready spec is the input. Kiln does not build or iterate requirements.
+
+This repository is public. Checkout paths and jobs stay in gitignored `.kiln/` or `~/.kiln/`. Do not commit them.
+
+## Install
+
+```bash
+npm i -g @lchase/kiln
+kiln repo add web /absolute/path/to/web --test "npm test"
+kiln repo list
+```
+
+`kiln` is the command. The subcommands in the rest of this file are the same ones. Examples that say `npm run kiln --` are the in-checkout form.
+
+## Develop from a checkout
+
+```bash
+npm install
+npm run build
+npm link
+kiln repo list
+```
+
+`npm link` puts this checkout's `kiln` on your PATH. The bin is `dist/cli.js`, so build before linking, and rebuild after source changes. `npm run kiln --` builds and runs without a global link.
+
+Workflows (`workflows/*.yaml`) and prompts (`prompts/`) are read from the package that contains the running file, next to its `package.json`. A global install and `npm link` both resolve them from that package, not from the directory you ran `kiln` in.
+
+## Prerequisites
+
+- Node.js >= 22 (the `engines` field in `package.json`)
+- git
+- Claude Code, installed and logged in, for a real run. `adapter: "mock"` does not call a model.
+- `gh`, installed and logged in, only when a repo uses `deliver: "pr"`.
+
+Each checkout is a git repo with a commit at `HEAD`. `tick` adds a worktree and leaves uncommitted files in the checkout as they are. The job edits the worktree, on branch `yak/<run-id>`. With the default `deliver: "local"`, Kiln does not push. `deliver: "pr"` pushes that branch and opens a draft pull request. See [Delivery and dependencies](#delivery-and-dependencies).
+
+## Register repos
+
+```bash
+npm install
+npm run kiln -- repo add web /absolute/path/to/web --test "npm test"
+npm run kiln -- repo add api /absolute/path/to/api --test "npm test"
+npm run kiln -- repo list
+```
+
+`npm run kiln` builds first. `npm run kiln -- repo add` writes `./.kiln/kiln.config.json` (or updates `~/.kiln/kiln.config.json` when that file already exists). A relative path is stored relative to the config file's directory. `~` is expanded from the home directory. `test` is optional on the entry and required before tick can launch a job in that repo.
+
+```json
+{
+  "repos": {
+    "web": { "path": "../web", "test": "npm test" },
+    "api": { "path": "~/src/api", "test": "npm test" }
+  },
+  "maxConcurrent": 2,
+  "adapter": "claude-code"
+}
+```
+
+`repos` is an open map. Any name is allowed. `maxConcurrent` caps how many jobs may be in flight (default 2). `adapter` is `claude-code` (default) or `mock`.
+
+## Add a job
+
+A job is one workflow run. The workflow name is a file `workflows/<name>.yaml`. `feature` is the factory loop. Bug, investigation, and security workflows are next. A later `pr-review` workflow is not in this repo yet.
+
+```bash
+npm run kiln -- add feature --repo web --spec spec.md --title "Show a Sunday summary"
+npm run kiln -- add feature --repo api --spec api-spec.md --after <job-id>
+npm run kiln -- add feature --repo web --jira PROJ-123
+```
+
+`--title` defaults to the first `#` heading in the spec, then the file name. `--after` may be repeated. Those jobs must already exist. Kiln copies the spec to `.kiln/specs/<id>.md` and writes `.kiln/jobs/<id>.json`:
+
+```json
+{
+  "id": "j20261025020600ab12",
+  "repo": "web",
+  "workflow": "feature",
+  "spec": "specs/j20261025020600ab12.md",
+  "title": "Show a Sunday summary",
+  "dependsOn": ["j20261025020500cd34"],
+  "source": { "kind": "file", "ref": "/home/dev/specs/sunday.md" },
+  "createdAt": "2026-10-25T02:06:00.000Z"
+}
+```
+
+`dependsOn` is omitted when the job has no `--after`. `stack: true` is set by `--stack` and is omitted otherwise. `source` records which intake created the job. Jobs written before intake omit `source` and still run. State is not stored. The pull request url is not stored on the job; Kiln writes it under `.kiln/deliveries/`.
+
+## Intake
+
+Every intake writes the same job: `id`, `repo`, `workflow`, `spec`, `title`, optional `dependsOn`, and `source`. `source` is `{ "kind": "file" | "prompt" | "tickets" | "jira", "ref": "..." }`. Status prints `source <kind> <ref>` when the job has one. Tick, reconcile, and status do not special-case an intake. The adapters are `src/intake/file.ts`, `src/intake/prompt.ts`, `src/intake/tickets.ts`, and `src/intake/jira.ts`.
+
+### File
+
+```bash
+npm run kiln -- add feature --repo web --spec spec.md --title "Show a Sunday summary"
+```
+
+This copies the markdown file into the kiln directory. `source.kind` is `file`. `source.ref` is the absolute path of the file that was copied. `--title` defaults to the first `#` heading, then the file name. `--after` may be repeated, and those jobs must already exist.
+
+### Prompt
+
+```bash
+npm run kiln -- add feature --repo web --prompt "Show a quiet empty state"
+npm run kiln -- add feature --repo api --prompt - < notes.md
+```
+
+`--prompt -` reads stdin. The text is stored as that job's spec. The title defaults to the first non-empty line, truncated to 80 characters. `source.kind` is `prompt`. `source.ref` is `inline` for an argument and `stdin` when the prompt is read from stdin. `--title` and `--after` work the same way as file intake. Pass one of `--spec`, `--prompt`, or `--jira`.
+
+### Tickets
+
+```bash
+npm run kiln -- import ./tickets --repo web
+npm run kiln -- import ./tickets --repo web --workflow feature --context spec.md --dry-run
+```
+
+`import` reads a directory of `NN-slug.md` files, the shape a Matt Pocock-style `/to-tickets` pass writes. Each file starts with `# NN: Title`, a `**What to build:**` paragraph, and a `**Blocked by:**` line. That line is followed by `None…` or by bullets such as `- 01: Probe the unconfirmed platform facts`. Kiln matches the `NN` number to a filename in the same directory (`01` and `1` are the same number). YAML front matter is also accepted, with `title`, `type`, and `blocked-by` (`blocked-by:` as a list, a flow list, or a single number).
+
+One file becomes one job. Blocked-by becomes `dependsOn` on the imported job ids. An unknown number is an error that names the ticket file, and no new job is written.
+
+`--workflow` defaults to `feature`. Kiln switches a ticket to `investigation` only when `workflows/investigation.yaml` exists and the ticket is a spike: front matter `type` is `spike`, `investigation`, or `research` (the word after a colon counts, as in `wayfinder:research`), the title contains spike or probe, or the text says "no product code". A body that only mentions an upstream spike stays on the requested workflow. `investigation` is not in this repo, so a spike ticket stays on the requested workflow and Kiln prints a warning.
+
+`--context` defaults to `spec.md` in the parent of the ticket directory when that file is present. The text is appended to every job spec as a `## Background` section. A context file larger than 40KB is not copied in. The spec names its path instead.
+
+Import is idempotent. The key is the ticket directory plus the filename, stored as `source.ref` (an absolute path) with `source.kind` `tickets`. Running import again on the same directory does not create a second job for a file already imported. The report says how many jobs are new and how many are unchanged. `--dry-run` prints each ticket, its workflow, and its dependencies, and writes nothing.
+
+### Jira
+
+```bash
+npm run kiln -- add feature --repo web --jira PROJ-123
+npm run kiln -- add feature --repo web --jira PROJ-123 --after <job-id> --dry-run
+```
+
+`--jira` reads one Jira Cloud issue over REST API v3 and writes the same job as the other intakes. `source.kind` is `jira`. `source.ref` is the issue key (`PROJ-123`). The title is `PROJ-123: <summary>`. The spec is that heading, a `Source:` line with the issue's browse URL, then the description converted from Atlassian document format to markdown.
+
+Set `JIRA_BASE_URL` (for example `https://acme.atlassian.net`), `JIRA_EMAIL`, and `JIRA_API_TOKEN`. Each value falls back to the optional `jira` block in the gitignored kiln config (`./.kiln/kiln.config.json`, or `~/.kiln/kiln.config.json` when the working directory has no config):
+
+```json
+"jira": {
+  "baseUrl": "https://acme.atlassian.net",
+  "email": "dev@example.com",
+  "apiToken": "<token>"
+}
+```
+
+Create a token at <https://id.atlassian.com/manage-profile/security/api-tokens>. Kiln sends it as Basic auth and does not write it into the job, the spec, or error text. A missing value is an error that names `JIRA_BASE_URL`, `JIRA_EMAIL`, or `JIRA_API_TOKEN`.
+
+A Blocks link where this issue is blocked by another key becomes `dependsOn` when a kiln job with `source` `jira` and that key already exists. Otherwise Kiln prints a warning naming the key and still creates the job. `--after` is merged with those ids. Issue type Spike or Research uses the same rule as a spike ticket: `investigation` when `workflows/investigation.yaml` exists, and a warning on the requested workflow when it does not. Running add again for the same key prints the existing job id and creates nothing. `--dry-run` prints the job and writes nothing.
+
+`examples/spec.md` is a fictional spec you can copy.
+
+## Tick, status, approve
+
+```bash
+npm run kiln -- tick
+npm run kiln -- status
+npm run kiln -- approve <job-id>
+npm run kiln -- reject <job-id>
+```
+
+`tick` launches at most one ready job and returns. Run it again until nothing is left to launch:
+
+```bash
+while true; do npm run kiln -- tick; sleep 30; done
+```
+
+A job is ready when its dependencies are met and the number of jobs in flight is under `maxConcurrent`. The default is after merged: every job in `dependsOn` is `done`. `--stack` is met when that one upstream has landed. A rejected gate does not unblock the next job. An ok run with no readable approval does not either.
+
+`npm run kiln -- status` lists jobs across repos. When a job has `source`, status prints `source <kind> <ref>`. For `needs-human` it prints `approve: kiln approve <id>` and `reject: kiln reject <id>`. Run those as `npm run kiln -- approve <id>` and `npm run kiln -- reject <id>`. For `done` and `in-review` it prints `branch yak/<run-id>`. For `deliver=pr` it also prints the pull request url once one exists. For `blocked` on a dependency id that has no job file, it prints `blocked on missing job <id>`. While an upstream pull request is open, it prints `waiting for PR #N to merge`.
+
+State is derived from the yak journal, the gate files, and (for `deliver=pr`) `gh pr view`:
+
+| State | Meaning |
+| --- | --- |
+| `queued` | Dependencies are met, and the job has not started |
+| `blocked` | An after-merged dependency is not `done`, or a stacked dependency has not landed. A missing job id is named |
+| `running` | Yak is alive, or the launch process is alive and has not written a journal |
+| `needs-human` | The run is suspended on an open gate |
+| `approved` | The gate says approve and the run has not finished. This still holds a slot |
+| `rejected` | The run finished ok and the gate says reject |
+| `failed` | The run failed, the launch died before a journal, the run finished ok with no readable approval, or a pull request could not be opened |
+| `dead` | The journal's process is gone. Status prints the cancel command |
+| `in-review` | `deliver=pr` and the run has landed. The pull request is open, or the next tick still has to open it |
+| `done` | `deliver=local`: the run finished ok and the gate says approve. `deliver=pr`: that pull request has merged |
+
+## What a feature job runs
+
+`npm run kiln -- tick` starts `yak run --isolation worktree --from <sha>` in the repo, tagged `kiln:<jobId>`, with logs in `<kiln-dir>/logs/<jobId>.log`. Kiln passes `title`, the spec text as `description` and `acceptance`, `baseRef` (the commit the worktree is cut from), and `runNonce`. For `deliver=local` that commit is checkout `HEAD`. For `deliver=pr` it is `origin/<base>` after `git fetch`, or the upstream branch tip when the job is stacked. The test command is `KILN_TEST`. `--from` is that same commit. Yak cuts the worktree from it and leaves the checkout's `HEAD` and files where they are.
+
+The job runs the factory loop from Lawrence Chase's factory plugin v0.7.0 (MIT), copied from commit `4c84a2ce7fbde5ac298c0de9f0b90141eac4ed98`: spec, then up to two rounds of build, verify, and the security, ux, ui, and code reviewers, then the approver, a human gate, and a commit. The prompts in `prompts/factory/` are those agent files, copied verbatim. `prompts/kiln/` maps the factory's job-folder files onto the artifacts yak passes in. `npm run kiln -- tick` writes a per-run copy of the workflow under the kiln directory, with absolute prompt paths, before it starts yak.
+
+Verify runs the repo's `test` command with `failOn: never`. Stdout and stderr stored from verify are cut to the last 200 lines or 20KB. One round is build, then verify, then the four reviewers. `concurrency: 4` starts security, ux, ui, and code together after verify. Build stays first. The approver runs after the loop. Each reviewer needs `spec`, `build`, and `verify`, and inherits `input` so the preamble can still read `baseRef`. Yak warns that those four Bash steps share one working tree and may race. That warning is expected: the reviewer preambles say to use the verify output and not re-run tests, builds, or anything else that writes. Git diff and file reads stay allowed. A `CHANGES` verdict, a `BLOCKED` build, or a non-zero verify starts another build, at most twice. The loop then continues to the approver. After an approved gate, the run commits on `yak/<run-id>` with message `kiln: <title>`. A reject skips that commit. `adapter: "mock"` reads fixtures at `test/fixtures/kiln-feature/<step>.json` and does not call a model.
+
+The first launch adds `.runs/` and `.yak/` to that checkout's `.git/info/exclude`.
+
+## Delivery and dependencies
+
+`deliver` is set on the repo. The default is `local`: the job is `done` when the run lands on `yak/<run-id>`, and Kiln does not push. Existing repos and tests stay on that path.
+
+```bash
+npm run kiln -- repo add web /absolute/path/to/web --test "npm test" --deliver pr --base main
+```
+
+`deliver` is `local` or `pr`. `base` is the pull request base branch. When `base` is omitted, Kiln uses origin's default branch, from `refs/remotes/origin/HEAD` after `git fetch`.
+
+With `deliver=pr`, the tick after an approved land pushes `yak/<run-id>` and runs `gh pr create --draft`. The title is the job title. The body is the spec's first paragraph, the line `Kiln job: <id>`, and the security, ux, ui, code, and approver verdicts. The branch, pull request number, and url are written to `.kiln/deliveries/<job-id>.json`, not the job file. A later tick looks up an existing pull request for that branch and does not push when origin already has the same commit. Kiln does not merge, and it does not push the base branch.
+
+If `gh` is missing or not authenticated, that job becomes `failed` and status prints what to run (`gh auth login`, then `kiln tick`). The rest of the tick still runs. The next tick tries again.
+
+`done` for `deliver=pr` is `gh pr view --json state,mergedAt`. A squash merge counts. Kiln does not ask git whether the landed commit is an ancestor of the base.
+
+### After merged and stacked
+
+The default is after merged. A job stays `blocked` until every upstream is `done`. Status says `waiting for PR #N to merge` while an upstream pull request is open. A `deliver=pr` worktree is cut from `origin/<base>` after `git fetch`, not from checkout `HEAD`.
+
+`--stack` on `kiln add` or `kiln import` waits for one upstream to be approved and landed, then cuts the worktree from that upstream branch (`yak/<run-id>`). The pull request targets that branch. `stack` with any count other than one dependency is an error at add time, and the upstream job has to be in the same repo. Stacked work does not wait for the upstream pull request to merge.
+
+```bash
+npm run kiln -- add feature --repo web --spec spec.md --after <job-id> --stack
+npm run kiln -- import ./tickets --repo web --stack
+```
+
+## Not included
+
+No requirement refinement. Bug, investigation, security, and pr-review workflows are not in this repo yet. Kiln does not merge pull requests and does not push the base branch.

package/dist/cli.js

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+import { addRepo, renderRepoList, resolveKilnConfig } from "./config.js";
+import { answerJob, runStatus, runTick } from "./driver.js";
+import { addFromFile } from "./intake/file.js";
+import { addFromJira } from "./intake/jira.js";
+import { addFromPrompt } from "./intake/prompt.js";
+import { importTickets } from "./intake/tickets.js";
+import { renderAddedJob } from "./jobs.js";
+function usage() {
+    console.error([
+        "Usage: kiln repo add <name> <path> [--test <cmd>] [--deliver local|pr] [--base <branch>] [--config <file>]",
+        "       kiln repo list [--config <file>]",
+        "       kiln add <workflow> --repo <name> (--spec <file.md> | --prompt <text> | --jira <KEY>) [--title <text>] [--after <jobId>]... [--stack] [--dry-run] [--config <file>]",
+        "       kiln import <dir> --repo <name> [--workflow <name>] [--context <file.md>] [--stack] [--dry-run] [--config <file>]",
+        "       kiln tick [--config <file>]",
+        "       kiln status [jobId] [--config <file>]",
+        "       kiln approve <jobId> [--config <file>]",
+        "       kiln reject <jobId> [--config <file>]",
+        "",
+        "repo add registers a checkout. Relative paths are stored relative to the",
+        "config directory. ~ is expanded from the home directory.",
+        "",
+        "add writes one job from a spec file, from --prompt text (--prompt - reads stdin),",
+        "or from a Jira Cloud issue (--jira PROJ-123). Pass one of those, not more.",
+        "The repo and the workflow (workflows/<name>.yaml) must already exist.",
+        "--after names jobs that must be done before this one launches. --stack waits",
+        "for one upstream to land and opens the pull request against that branch.",
+        "A Jira Blocks link where this issue is blocked by another key is included",
+        "when a kiln job for that key already exists.",
+        "--dry-run with --jira prints the job and writes nothing. Running add again",
+        "for the same Jira key prints the existing job id and creates nothing.",
+        "",
+        "import reads a directory of NN-slug.md tickets and writes one job per file.",
+        "Blocked-by becomes dependsOn. Re-running the same directory does not duplicate jobs.",
+        "--dry-run prints the jobs and writes nothing.",
+        "",
+        "tick launches at most one ready job. After merged, dependencies must be done.",
+        "Stacked jobs launch once the upstream has landed. deliver=pr then pushes",
+        "yak/<run-id> and opens a draft pull request. status prints the derived state.",
+        "approve and reject answer the human gate.",
+    ].join("\n"));
+    process.exit(2);
+}
+function parseFlags(argv) {
+    const bag = { positionals: [], after: [], dryRun: false, stack: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const flag = argv[i];
+        const next = argv[i + 1];
+        if (flag === "--config") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.configPath = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--test") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.test = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--repo") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.repo = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--spec") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.spec = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--prompt") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.prompt = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--jira") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.jira = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--workflow") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.workflow = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--context") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.context = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--dry-run") {
+            bag.dryRun = true;
+            continue;
+        }
+        if (flag === "--title") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.title = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--after") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.after.push(next);
+            i += 1;
+            continue;
+        }
+        if (flag === "--stack") {
+            bag.stack = true;
+            continue;
+        }
+        if (flag === "--deliver") {
+            if (next !== "local" && next !== "pr")
+                usage();
+            bag.deliver = next;
+            i += 1;
+            continue;
+        }
+        if (flag === "--base") {
+            if (!next || next.startsWith("--"))
+                usage();
+            bag.base = next;
+            i += 1;
+            continue;
+        }
+        if (flag?.startsWith("--"))
+            usage();
+        if (flag !== undefined)
+            bag.positionals.push(flag);
+    }
+    return bag;
+}
+function repoCommand(argv) {
+    const sub = argv[0];
+    const flags = parseFlags(argv.slice(1));
+    if (sub === "list") {
+        if (flags.positionals.length !== 0 || hasIntakeFlags(flags) || flags.test || flags.deliver || flags.base)
+            usage();
+        const config = resolveKilnConfig({ configPath: flags.configPath });
+        process.stdout.write(renderRepoList(config));
+        return;
+    }
+    if (sub === "add") {
+        const name = flags.positionals[0];
+        const repoPath = flags.positionals[1];
+        if (!name || !repoPath || flags.positionals.length !== 2 || hasIntakeFlags(flags))
+            usage();
+        process.stdout.write(addRepo({
+            configPath: flags.configPath,
+            name,
+            repoPath,
+            ...(flags.test !== undefined ? { test: flags.test } : {}),
+            ...(flags.deliver !== undefined ? { deliver: flags.deliver } : {}),
+            ...(flags.base !== undefined ? { base: flags.base } : {}),
+        }));
+        return;
+    }
+    usage();
+}
+async function addCommand(argv) {
+    const flags = parseFlags(argv);
+    const workflow = flags.positionals[0];
+    const selected = [flags.spec !== undefined, flags.prompt !== undefined, flags.jira !== undefined].filter(Boolean).length;
+    if (!workflow ||
+        flags.positionals.length !== 1 ||
+        !flags.repo ||
+        selected !== 1 ||
+        flags.test ||
+        flags.workflow ||
+        flags.context ||
+        flags.deliver ||
+        flags.base ||
+        (flags.dryRun && flags.jira === undefined)) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    if (flags.jira !== undefined) {
+        const result = await addFromJira(config, {
+            workflow,
+            repo: flags.repo,
+            key: flags.jira,
+            ...(flags.title !== undefined ? { title: flags.title } : {}),
+            dependsOn: flags.after,
+            ...(flags.stack ? { stack: true } : {}),
+            dryRun: flags.dryRun,
+        });
+        process.stdout.write(result.report);
+        if (result.warnings.length > 0)
+            process.stderr.write(`${result.warnings.join("\n")}\n`);
+        return;
+    }
+    const { job, jsonPath } = flags.spec !== undefined
+        ? addFromFile(config, {
+            workflow,
+            repo: flags.repo,
+            specPath: flags.spec,
+            ...(flags.title !== undefined ? { title: flags.title } : {}),
+            dependsOn: flags.after,
+            ...(flags.stack ? { stack: true } : {}),
+            cwd: process.cwd(),
+        })
+        : addFromPrompt(config, {
+            workflow,
+            repo: flags.repo,
+            prompt: flags.prompt ?? "",
+            ...(flags.title !== undefined ? { title: flags.title } : {}),
+            dependsOn: flags.after,
+            ...(flags.stack ? { stack: true } : {}),
+        });
+    process.stdout.write(renderAddedJob(job, jsonPath));
+}
+function importCommand(argv) {
+    const flags = parseFlags(argv);
+    const dir = flags.positionals[0];
+    if (!dir ||
+        flags.positionals.length !== 1 ||
+        !flags.repo ||
+        flags.spec ||
+        flags.prompt ||
+        flags.title ||
+        flags.after.length > 0 ||
+        flags.test ||
+        flags.deliver ||
+        flags.base) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    const result = importTickets(config, {
+        dir,
+        repo: flags.repo,
+        ...(flags.workflow !== undefined ? { workflow: flags.workflow } : {}),
+        ...(flags.context !== undefined ? { contextPath: flags.context } : {}),
+        dryRun: flags.dryRun,
+        ...(flags.stack ? { stack: true } : {}),
+        cwd: process.cwd(),
+    });
+    process.stdout.write(result.report);
+    if (result.warnings.length > 0)
+        process.stderr.write(`${result.warnings.join("\n")}\n`);
+}
+function tickCommand(argv) {
+    const flags = parseFlags(argv);
+    if (flags.positionals.length !== 0 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    process.stdout.write(runTick(config));
+}
+function statusCommand(argv) {
+    const flags = parseFlags(argv);
+    if (flags.positionals.length > 1 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    process.stdout.write(runStatus(config, flags.positionals[0]));
+}
+function gateCommand(choice, argv) {
+    const flags = parseFlags(argv);
+    const jobId = flags.positionals[0];
+    if (!jobId || flags.positionals.length !== 1 || flags.test || hasIntakeFlags(flags) || flags.deliver || flags.base || flags.stack) {
+        usage();
+    }
+    const config = resolveKilnConfig({ configPath: flags.configPath });
+    process.stdout.write(answerJob(config, jobId, choice));
+}
+function hasIntakeFlags(flags) {
+    return Boolean(flags.repo ||
+        flags.spec ||
+        flags.prompt ||
+        flags.jira ||
+        flags.title ||
+        flags.workflow ||
+        flags.context ||
+        flags.dryRun ||
+        flags.stack ||
+        flags.after.length > 0);
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const command = argv[0];
+    if (!command || command === "--help" || command === "-h" || command === "help")
+        usage();
+    if (command === "repo") {
+        repoCommand(argv.slice(1));
+        return;
+    }
+    if (command === "add") {
+        await addCommand(argv.slice(1));
+        return;
+    }
+    if (command === "import") {
+        importCommand(argv.slice(1));
+        return;
+    }
+    if (command === "tick") {
+        tickCommand(argv.slice(1));
+        return;
+    }
+    if (command === "status") {
+        statusCommand(argv.slice(1));
+        return;
+    }
+    if (command === "approve") {
+        gateCommand("approve", argv.slice(1));
+        return;
+    }
+    if (command === "reject") {
+        gateCommand("reject", argv.slice(1));
+        return;
+    }
+    usage();
+}
+try {
+    await main();
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+}