sandcastle-drain 0.1.0

package/dist/content/principles/language-and-types.md

@@ -0,0 +1,85 @@
+# Language and types
+
+TypeScript, run on Node, with strict-mode flags maxed and Zod parsing every external boundary.
+
+## Why TS strict + Zod, not Effect-ts
+
+Effect-ts is a stronger guarantee — its type system can refuse to compile code that violates architectural invariants the way TS+Zod cannot. We chose against it for this project because:
+
+- The user is not yet familiar with Effect's `Layer` / `Schema` / `Effect` idioms; learning them alongside building a complex agent + experimenting with memory architectures would compound learning curves.
+- For a single-operator personal project, "the lint rules + pre-commit hook + ADR review enforces the architecture" is good enough — _if_ the lint rules and pre-commit hook are taken seriously.
+
+The trade-off: with Effect, the _compiler_ refuses to let you violate the architecture. With TS strict + Zod + ESLint, the _project_ refuses, but only because we wired up the rules to enforce it. If you `// @ts-expect-error` your way past a problem or skip a lint rule, the system rots. **Effect makes that rot impossible; we make it visible.**
+
+Re-examine this choice in an ADR if Effect-ts familiarity grows or if architectural drift becomes painful.
+
+## tsconfig strictness
+
+The project's `tsconfig.json` sets _every_ strictness flag worth setting:
+
+```jsonc
+{
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "useUnknownInCatchVariables": true,
+  },
+}
+```
+
+These catch whole classes of agent-introduced bugs. Expect lint failures often early on. **Soften specific rules only if a real false positive shows up — never globally relax for convenience.**
+
+## Branded types for every domain identifier and value object
+
+```ts
+// in packages/domain/aggregates/order/order-id.ts
+export type OrderId = string & { readonly _brand: 'OrderId' };
+
+export const OrderId = (raw: string): Result<OrderId, ParseError> => {
+  // validation here
+};
+```
+
+- No raw `string` IDs cross a function boundary, ever.
+- The factory in `packages/domain` is the _only_ place a brand is minted; consumers receive it pre-validated.
+- Branded value objects (e.g. `EmailAddress`, `MoneyUSD`, `Url`) follow the same pattern.
+
+## Zod at every boundary
+
+Anything entering the system from outside our type-checked code gets Zod-parsed. **Parse, don't validate** — the schema generates the type via `z.infer`, so the runtime check and the static type can never disagree.
+
+Boundaries that require Zod parsing:
+
+- LLM output (every structured agent response)
+- Database row (every read from a persistent store)
+- Web fetch (LLM tool-use results, HTTP responses, JSON APIs)
+- HTTP request body / query / params
+- Config files / environment variables at startup
+- File reads where shape matters
+
+The schemas live next to the code that uses them, in the layer that owns the boundary (External adapters own the persistence schemas; the API owns the HTTP schemas; etc.).
+
+## Tagged unions for fallible operations in the domain layer
+
+`throw` is reserved for _bug, kill the process_ — not for control flow. Domain functions that can fail return:
+
+```ts
+type Result<T, E> = { tag: 'ok'; value: T } | { tag: 'err'; error: E };
+```
+
+A custom ESLint rule (`local/no-throw-in-domain`, see [linting-and-tooling.md](linting-and-tooling.md)) bans `throw` inside `packages/domain/`. The `application` layer can lift `Result` into thrown errors at the API edge if it wants — but the domain itself stays totally exception-free.
+
+Match on `tag` exhaustively (TS strict + `noFallthroughCasesInSwitch` + `@typescript-eslint/switch-exhaustiveness-check` covers this). A new `tag` variant that isn't handled is a compile error.
+
+## What this enables
+
+- Every dataflow has a `Schema` parse at its boundary — untyped or string-typed agent outputs are a recipe for silent wrong answers.
+- Branded IDs prevent accidental cross-aggregate mixing (an `OrderId` cannot be silently passed where a `CustomerId` is expected).
+- Tagged-union results force callers to handle both success and failure paths at compile time.
+
+The rest of the architecture (see [architecture.md](architecture.md), [domain-modeling.md](domain-modeling.md)) is built on top of these primitives.

package/dist/content/principles/linting-and-tooling.md

@@ -0,0 +1,122 @@
+# Linting and tooling
+
+ESLint + typescript-eslint + Prettier + custom local rules. Pre-commit hook via Husky + lint-staged. No `--no-verify` ever.
+
+## Why ESLint, not Biome
+
+Three reasons we picked ESLint:
+
+1. **`eslint-plugin-boundaries` is non-negotiable.** Our entire onion architecture (see [architecture.md](architecture.md)) relies on a real boundary-enforcement plugin. Biome does not have an equivalent. Without lint-enforced boundaries, the layers become honor-system, and we already decided we cannot afford honor-system on architecture rules in autonomous sandcastle-drain runs.
+2. **Custom rules are easier in ESLint.** We need three (`no-throw-in-domain`, `no-anemic-aggregate`, `domain-names-match-context-md`). In ESLint these are 50–150 lines of TypeScript each; in Biome they require GritQL or Rust.
+3. **Speed isn't the bottleneck on a personal project.** Biome's main pitch is speed at scale. With ~50–100 source files, ESLint's 10–30s runs are fine. `oxlint` can be added as a fast pre-pass later if it becomes annoying.
+
+Re-examine in an ADR if Biome's plugin ecosystem catches up or our project size grows past ESLint's comfort zone.
+
+## Plugin set
+
+```jsonc
+{
+  "plugins": [
+    "@typescript-eslint",
+    "boundaries", // onion-direction
+    "functional", // immutability, no let, readonly fields
+    "unicorn", // sane defaults beyond ESLint core
+    "vitest", // test-file rules
+  ],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/strict-type-checked",
+    "plugin:@typescript-eslint/stylistic-type-checked",
+  ],
+}
+```
+
+## Specific rules to enable
+
+```jsonc
+{
+  "@typescript-eslint/no-floating-promises": "error",
+  "@typescript-eslint/no-misused-promises": "error",
+  "@typescript-eslint/strict-boolean-expressions": "error",
+  "@typescript-eslint/switch-exhaustiveness-check": "error",
+  "@typescript-eslint/consistent-type-imports": "error",
+  "@typescript-eslint/no-unnecessary-condition": "error",
+  "@typescript-eslint/no-throw-literal": "error",
+
+  "max-depth": ["error", 3],
+  "complexity": ["error", 10],
+  "max-lines-per-function": ["error", { "max": 50, "skipBlankLines": true, "skipComments": true }],
+  "max-params": ["error", 4],
+}
+```
+
+The four `max-*` / `complexity` rules are the structural enforcement of the small-functions rule in [clean-code.md](clean-code.md). Thresholds are intentionally tight; loosen one rule for one function with a `// eslint-disable-next-line` comment that explains why, never globally.
+
+## Boundary enforcement
+
+```jsonc
+"boundaries/element-types": ["error", {
+  "default": "disallow",
+  "rules": [
+    { "from": "domain",       "allow": ["domain"] },
+    { "from": "application",  "allow": ["domain", "application"] },
+    { "from": "external",     "allow": ["domain", "application", "external"] },
+    { "from": "presentation", "allow": ["*"] }
+  ]
+}]
+```
+
+`boundaries/elements` maps folders to ring labels. Any inner-from-outer import is a hard error. No exemptions, no `// eslint-disable`. If a violation feels necessary, the right move is to define a port in `packages/application/`.
+
+## Three custom local rules
+
+Live in `tools/eslint-rules/` (TypeScript, simple AST walks). Loaded via `eslint-plugin-local-rules` or equivalent.
+
+### `local/no-throw-in-domain`
+
+Bans `throw` (statement and expression) inside `packages/domain/**`. Domain functions return `Result<T, E>` per [language-and-types.md](language-and-types.md). `throw` is reserved for "bug, kill the process" and only appears at the application boundary or above.
+
+### `local/no-anemic-aggregate`
+
+Fails any class exported from `packages/domain/aggregates/**` whose body has only a constructor and getters with no behavioral methods. Aggregates carry their invariants in their behavior; a data-only class belongs in `packages/domain/dtos/` instead. DTOs are explicitly exempt.
+
+### `local/domain-names-match-context-md`
+
+Parses `CONTEXT.md` headings and fails any export from `packages/domain/aggregates/` or `packages/domain/value-objects/` whose name does not appear there. Silent until `CONTEXT.md` is populated — the template ships with a stub.
+
+## Prettier
+
+Formatting only. `eslint-config-prettier` disables the stylistic rules that overlap with Prettier so the two never argue. Run via the same pre-commit hook.
+
+```jsonc
+// .prettierrc
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "printWidth": 100,
+  "tabWidth": 2,
+}
+```
+
+## Pre-commit hook (Husky + lint-staged)
+
+`.husky/pre-commit` runs:
+
+1. `pnpm tsc --noEmit` (or `npm run typecheck`) — full project typecheck
+2. `lint-staged` — ESLint + Prettier on changed files
+3. `vitest related --run` on changed test files
+4. **In `packages/domain/`**: coverage check (90% gate, 95% target — line + branch)
+
+**Never `--no-verify`.** If a hook fails, fix the underlying issue. The global CLAUDE.md already records this rule; it stays here too because it's load-bearing for autonomous sandcastle-drain runs where there's no human reviewer to catch a skipped hook.
+
+If a hook is genuinely too slow (e.g. > 30s on small commits), the right move is to make the hook faster (cache TS server, scope ESLint to staged files, reduce Vitest's "related" scope) — _not_ to skip it.
+
+## Strictness expectation
+
+`@typescript-eslint/strict-type-checked` is genuinely strict — it catches `if (someString)` ambiguity, requires explicit `boolean` checks, etc. **Strict from day one. Soften specific rules only if a real false positive shows up — never globally relax for convenience.** Expect lint failures often early on; treat each as feedback, not friction.
+
+## What lives outside this doc
+
+- The actual `.eslintrc.*` and `tsconfig.json` files don't exist yet — they're queued as follow-up sandcastle-drain issues. This doc is the spec the issue implements.
+- The custom rule implementations live in `tools/eslint-rules/`, also queued as follow-up issues.
+- `pg_dump` / backup scheduling lives in [personal-use-tradeoffs.md](personal-use-tradeoffs.md), not here.

package/dist/content/principles/personal-use-tradeoffs.md

@@ -0,0 +1,55 @@
+# Personal-use trade-offs
+
+This is a personal-use, single-operator, attended product. Some standards relax; others stay tight. The dividing line:
+
+> **Standards relax where mistakes cost only your time.**
+> **Standards stay tight where mistakes corrupt your data or your decisions.**
+
+A lazy "personal use means skip everything" reading is wrong. Domain bugs corrupt your data. Type drift produces silent wrong answers from the agent. None of those are negotiable just because there's only one user.
+
+## Relaxed
+
+| Area                                       | What that means concretely                                                                                                                                                                                                  |
+| ------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **UI design polish**                       | Functional > beautiful. No design system, no theme tokens. Tailwind utilities directly. Desktop-only — no responsive layouts. No animations.                                                                                |
+| **UI a11y**                                | Not enforced. Use semantic HTML by default but no audit, no a11y tests.                                                                                                                                                     |
+| **Auth**                                   | **Localhost-only by default.** API binds to `127.0.0.1`. No user accounts, passwords, OAuth, JWT. If you ever need access from another device, tunnel via Tailscale or SSH port-forward — don't add auth code to this repo. |
+| **Onboarding / settings / preferences UI** | Skip. Edit a config file.                                                                                                                                                                                                   |
+| **i18n / l10n**                            | Skip. English only.                                                                                                                                                                                                         |
+| **Performance budgets**                    | "Fast enough not to annoy you." No SLOs. No premature caching. LLM calls taking 10s is fine.                                                                                                                                |
+| **Observability**                          | Plain `console.log` + Sandcastle's own log files. No structured logging service, no tracing, no metrics dashboards.                                                                                                         |
+| **Multi-tenancy / RBAC**                   | The system has one user. Database role is single-user; no row-level security policies, no per-tenant scoping.                                                                                                               |
+| **CI/CD pipeline**                         | None. Tests run via the pre-commit hook locally. Deploy is manual (`git pull && pnpm install && systemd restart`, or whatever you actually use).                                                                            |
+| **Marketing / docs site**                  | None.                                                                                                                                                                                                                       |
+| **End-user error messages**                | Stack traces are fine. You are the user.                                                                                                                                                                                    |
+
+## NOT relaxed
+
+| Area                            | Why it stays tight                                                                                                                                                                                                                                                                |
+| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Domain correctness**          | A bug in your core state transitions or derived calculations means you make a real decision on wrong data. Domain layer 90% coverage gate / 95% target (line + branch); property-based tests on state machines and math; branded types; no anemic models. See [testing.md](testing.md), [domain-modeling.md](domain-modeling.md). |
+| **Type safety**                 | TS strict + Zod at every boundary, fully enforced. Personal use does not mean `any` is OK.                                                                                                                                                                                        |
+| **Architecture boundaries**     | Onion enforced via `eslint-plugin-boundaries`. No "I'll skip the layer this once" exemptions.                                                                                                                                                                                     |
+| **Token budget**                | 100k target / 150k ceiling, mechanically measured per-run. Oversized issues labeled. See [context-budget.md](context-budget.md).                                                                                                                                                  |
+| **Secrets handling**            | API keys in `.env`, `.env` gitignored, no keys in logs. The personal project still talks to external APIs — keys do not leak.                                                                                                                                                     |
+| **Backups of persistent state** | **Required.** The persistent data store is the irreplaceable artifact of this system. `pg_dump` cron + versioned snapshots; any wiki-style or filesystem-projected state is git-versioned. _This is the strongest "not relaxed" — losing your data undoes the project._           |
+| **Pre-commit hooks**            | Run on every commit, no `--no-verify`. The agent will try to skip them in tight loops; the hook is a hard block.                                                                                                                                                                  |
+
+## Tech-selection rule
+
+> **Default to free / open-source for libraries, runtimes, databases, and self-hostable services.** Pay for managed cloud / proprietary services only when **(a)** the open alternative would burn a meaningful fraction of build time on operating it, or **(b)** the proprietary option is meaningfully better at the specific job.
+>
+> **Each paid service requires a one-page ADR** in `docs/adr/` justifying the exception against an OSS alternative.
+
+The ADR requirement keeps the rule from being silent. Every paid dependency has a written "why this over the OSS alternative" that future-you can re-examine when costs shift.
+
+## Backups: this is operational, but it's also a principle
+
+Treating backups as an _operational concern_ would mean the agent can deprioritize them. Treating them as a _principle_ keeps them in the active rule set the agent reads. Given that losing the persistent data store undoes the project, this belongs in principles.
+
+Concretely:
+
+- `pg_dump` (or equivalent) runs on a host cron, output to a versioned snapshot dir (e.g. `~/backup/<dbname>/YYYY-MM-DD.sql.gz`).
+- Retention: at minimum, daily for 14 days + monthly for 12 months.
+- A restore drill quarterly: pick a snapshot, restore into a scratch container, verify it loads. If you've never restored, you don't have a backup.
+- Specific cron timing, retention details, and offsite mirror policy live in an ADR (queued as a follow-up issue once the database is actually running).

package/dist/content/principles/testing.md

@@ -0,0 +1,89 @@
+# Testing
+
+Vitest for unit + integration. Playwright for the chat-UI E2E flow. `fast-check` for property-based tests on the domain layer. Coverage targets and enforcement vary per layer — flat targets produce ritual tests where they don't matter and miss coverage where they do.
+
+## Runner choices
+
+- **Vitest** for unit + integration. TS+ESM-native, fast, watch mode, parallel workers, integrates with `fast-check`.
+- **Playwright Test** for the chat-UI E2E flow. Already implied by the sandcastle-drain Dockerfile baking in Playwright + Chromium.
+- **`node:test`** is available but not used; Vitest's DX (built-in expect, watch UI, snapshot) wins for the costs of one extra dep.
+
+## Per-layer coverage policy
+
+| Layer                  | Coverage target                            | Test type                                                | Enforcement                                 |
+| ---------------------- | ------------------------------------------ | -------------------------------------------------------- | ------------------------------------------- |
+| `packages/domain`      | **≥ 90% gate, 95% target (line + branch)** | Pure unit; property-based for state machines and math    | **Gated** — pre-commit / CI fails below 90% |
+| `packages/application` | **≥ 85% line**                             | Use-case tests with in-memory port stubs                 | **Report-only** — printed, not gated        |
+| `packages/external/*`  | **No coverage target**                     | Integration tests against real services where reasonable | Tests gated to pass; coverage not enforced  |
+| `apps/api`             | Smoke + Zod contract tests                 | Endpoint smoke, schema round-trips                       | Tests gated to pass                         |
+| `apps/ui`              | **No coverage target**                     | A few Playwright smoke tests on the golden chat flow     | Smoke tests gated to pass                   |
+| `apps/agent`           | Composition root, mostly untested          | Wiring integration test only                             | —                                           |
+
+The 90%-gated / 95%-target rule on `packages/domain` is the load-bearing one. The domain layer is where bugs cause silent wrong answers, and where the agent is most likely to skip tests without something forcing them. The 5% gap between gate and target is deliberate: 95% as a hard gate forces ritual tests on trivial getters and coverage-of-coverage games that corrupt the discipline; 90% as a hard gate stays tight on real behavior. Aim for 95%; the commit fails below 90%.
+
+## Property-based testing on the domain
+
+Required for state machines and pure math in `packages/domain`; encouraged elsewhere; optional in adapters.
+
+Use `fast-check` to express invariants like:
+
+```ts
+import fc from 'fast-check';
+import { test } from 'vitest';
+
+test('transition to shipped preserves prior status as snapshot', () => {
+  fc.assert(
+    fc.property(arbOrder(), arbShipmentEvent(), (order, event) => {
+      const before = order.status;
+      order.ship(event);
+      expect(before).toMatchInlineSnapshot(/* ... */);
+    }),
+  );
+});
+```
+
+The cost is real (property tests take longer to write than examples) but for state machines, derived math, and aggregations — the parts of the domain where bugs cause silent wrong answers — property tests pay back many times over.
+
+## Integration tests: real services or recorded fixtures
+
+| Service                                                 | Strategy                                           | Why                                                                                                                                                                                                           |
+| ------------------------------------------------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Postgres / databases**                                | **Testcontainers**                                 | Real schema, real migrations, real query plans. Cheap and fast in a container.                                                                                                                                |
+| **LLM APIs (Anthropic, OpenAI, etc.)**                  | **Recorded fixtures** with explicit re-record flag | Calls cost money and take seconds. Replay deterministically; re-record when the agent's prompt changes.                                                                                                       |
+| **Other paid APIs (embeddings, web search, etc.)**      | **Recorded fixtures** with explicit re-record flag | Same reasoning.                                                                                                                                                                                               |
+| **HTTP GET against arbitrary URLs**                     | **Recorded fixtures** keyed by URL                 | Real fetches are non-deterministic (paywalls, redirects, content drift); fixtures pin the bytes for stable test behavior.                                                                                     |
+| **Filesystem**                                          | Real, in a tmp directory                           | No reason to mock; filesystem is fast.                                                                                                                                                                        |
+
+**No mocking the database.** A recurring failure mode: mocked DB tests pass while a real production migration breaks. Integration tests for your persistence adapters hit a real database in testcontainers.
+
+## Behavior-required test rule
+
+Tests are required when introducing testable _behavior_:
+
+- A new domain function
+- A new invariant
+- A new state-machine transition
+- A new use-case orchestration
+- A new parser, schema, or math routine
+
+Tests are **not** required for:
+
+- Type-only changes
+- Dependency bumps
+- Comment / doc edits
+- Config tweaks
+- UI cosmetic changes
+- Log-message changes
+
+This inherits verbatim from `src/prompts/implementer.md.tpl`'s existing rule. The rationale: forcing tests on type-only changes produces theater tests that pass for the wrong reason and rot when the type changes.
+
+## Test file layout
+
+- Tests colocated with code: `foo.ts` + `foo.test.ts` in the same folder.
+- Integration tests in `*.integration.test.ts` (separate suite, slower, can be `--exclude`'d in dev loop).
+- E2E tests in `apps/ui/e2e/*.spec.ts` (Playwright's convention).
+- `vitest.config.ts` at the workspace root configures per-package projects with the right thresholds.
+
+## What to do when a test would be obviously theater
+
+Don't write it. Instead, add a one-line note in the PR / commit explaining the work has no testable behavior. The pre-commit hook does not require _every_ change to add tests — it requires the test suite to _pass_ and (in the domain) coverage thresholds to hold. If you remove a tested behavior, remove the test in the same commit.

package/dist/orchestrator/blocked-by.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Parses the `## Blocked by` section of a GitHub issue body and returns the
+ * referenced issue numbers. The wrapper uses this to skip dependents of an
+ * issue that failed to land in the current drain run.
+ *
+ * Convention (from src/content/agent-docs/issue-tracker.md and existing issue bodies):
+ *
+ *   ## Blocked by
+ *
+ *   - #33 (short reference)
+ *   - [#34](https://github.com/owner/repo/issues/34) (markdown link form)
+ *
+ * The section ends at the next markdown heading or EOF. References anywhere
+ * else in the body are ignored.
+ */
+export declare function parseBlockedBy(body: string): number[];
+//# sourceMappingURL=blocked-by.d.ts.map

package/dist/orchestrator/blocked-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocked-by.d.ts","sourceRoot":"","sources":["../../src/orchestrator/blocked-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CA4BrD"}

package/dist/orchestrator/blocked-by.js

@@ -0,0 +1,48 @@
+/**
+ * Parses the `## Blocked by` section of a GitHub issue body and returns the
+ * referenced issue numbers. The wrapper uses this to skip dependents of an
+ * issue that failed to land in the current drain run.
+ *
+ * Convention (from src/content/agent-docs/issue-tracker.md and existing issue bodies):
+ *
+ *   ## Blocked by
+ *
+ *   - #33 (short reference)
+ *   - [#34](https://github.com/owner/repo/issues/34) (markdown link form)
+ *
+ * The section ends at the next markdown heading or EOF. References anywhere
+ * else in the body are ignored.
+ */
+const HEADING_RE = /^##\s+blocked\s+by\b/i;
+const ANY_HEADING_RE = /^#{1,6}\s/;
+const REF_RE = /#(\d+)/g;
+export function parseBlockedBy(body) {
+    if (!body)
+        return [];
+    const lines = body.split(/\r?\n/);
+    let start = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (HEADING_RE.test(lines[i])) {
+            start = i + 1;
+            break;
+        }
+    }
+    if (start === -1)
+        return [];
+    let end = lines.length;
+    for (let i = start; i < lines.length; i++) {
+        if (ANY_HEADING_RE.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    const section = lines.slice(start, end).join('\n');
+    const numbers = new Set();
+    for (const m of section.matchAll(REF_RE)) {
+        const n = Number(m[1]);
+        if (Number.isFinite(n) && n > 0)
+            numbers.add(n);
+    }
+    return [...numbers].sort((a, b) => a - b);
+}
+//# sourceMappingURL=blocked-by.js.map

package/dist/orchestrator/blocked-by.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocked-by.js","sourceRoot":"","sources":["../../src/orchestrator/blocked-by.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,UAAU,GAAG,uBAAuB,CAAC;AAC3C,MAAM,cAAc,GAAG,WAAW,CAAC;AACnC,MAAM,MAAM,GAAG,SAAS,CAAC;AAEzB,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,CAAC;IACrB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAElC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC;IACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9B,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;YACd,MAAM;QACR,CAAC;IACH,CAAC;IACD,IAAI,KAAK,KAAK,CAAC,CAAC;QAAE,OAAO,EAAE,CAAC;IAE5B,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;IACvB,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC1C,IAAI,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAClC,GAAG,GAAG,CAAC,CAAC;YACR,MAAM;QACR,CAAC;IACH,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;IAClC,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACzC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACvB,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;YAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IACD,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAC5C,CAAC"}

package/dist/orchestrator/ci-gate.d.ts

@@ -0,0 +1,28 @@
+export type PackageManager = 'npm' | 'pnpm' | 'yarn';
+export type CiCheck = 'install' | 'typecheck' | 'lint' | 'test';
+export interface CiCheckRun {
+    check: CiCheck;
+    exitCode: number;
+    output: string;
+}
+export interface CiGateResult {
+    ok: boolean;
+    failedCheck?: CiCheck;
+    runs: CiCheckRun[];
+    logPath: string;
+    packageManager: PackageManager;
+}
+export declare function determineCiOk(runs: readonly CiCheckRun[]): {
+    ok: boolean;
+    failedCheck?: CiCheck;
+};
+export declare function needsInstall(dir: string, pm: PackageManager): boolean;
+export declare function detectPackageManager(repoRoot: string): PackageManager;
+export declare function formatCiSection(result: CiGateResult): string;
+export declare function runCiGate(args: {
+    issue: number;
+    branch: string;
+    repoRoot: string;
+    worktreePath: string;
+}): Promise<CiGateResult>;
+//# sourceMappingURL=ci-gate.d.ts.map

package/dist/orchestrator/ci-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci-gate.d.ts","sourceRoot":"","sources":["../../src/orchestrator/ci-gate.ts"],"names":[],"mappings":"AAwBA,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAErD,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAEhE,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,cAAc,CAAC;CAChC;AAID,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,GAAG;IAC1D,EAAE,EAAE,OAAO,CAAC;IACZ,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAKA;AAQD,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,cAAc,GAAG,OAAO,CAKrE;AAOD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAkBrE;AAsBD,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAsB5D;AA4DD,wBAAsB,SAAS,CAAC,IAAI,EAAE;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,YAAY,CAAC,CA6CxB"}