dorfl 0.0.0 → 0.1.0

package/dist/github.js

@@ -0,0 +1,343 @@
+import { run } from './git.js';
+import { ghFailureDetail } from './gh-failure.js';
+import { realSleep, retryWithBackoff } from './retry-backoff.js';
+import { NoneProvider, manualRequestText, } from './integrator.js';
+/** The default `gh` CLI binary name (resolved on `PATH`). */
+export const DEFAULT_GH_BIN = 'gh';
+/**
+ * True iff `url` is a GitHub arbiter remote, recognised across the URL shapes
+ * the arbiter can take (scp-like ssh `git@github.com:o/r.git`, `ssh://`,
+ * `https://`/`http://`). We match on the HOST being exactly `github.com` (or a
+ * `github.com` subdomain — GitHub Enterprise installs are out of scope and read
+ * as not-GitHub, the safe `none` default). A mere substring match is rejected so
+ * a lookalike host (`notgithub.com.evil`) never selects the GitHub provider.
+ */
+export function isGitHubArbiterUrl(url) {
+    const host = arbiterHost(url);
+    if (host === undefined) {
+        return false;
+    }
+    return host === 'github.com' || host.endsWith('.github.com');
+}
+/**
+ * Extract the bare host from an arbiter remote URL, or `undefined` for a local
+ * filesystem path (`file://...` / `/abs/path`) which has no host. Mirrors the
+ * `repo-mirror` URL handling (the four shapes the arbiter can take) but only
+ * needs the host for provider detection.
+ */
+function arbiterHost(url) {
+    const trimmed = url.trim();
+    if (!trimmed.includes('://')) {
+        // scp-like ssh: [user@]host:path (no `://`, a `:` before the path, NOT a
+        // plain absolute local path).
+        const scp = /^(?:[^@/]+@)?([^/:]+):(.+)$/;
+        const m = scp.exec(trimmed);
+        if (m && !trimmed.startsWith('/')) {
+            return m[1].toLowerCase();
+        }
+        return undefined; // a plain local path has no host
+    }
+    const rest = trimmed.slice(trimmed.indexOf('://') + 3);
+    const slash = rest.indexOf('/');
+    const authority = slash === -1 ? rest : rest.slice(0, slash);
+    const host = stripUserAndPort(authority).toLowerCase();
+    // `file://` yields an empty authority (file:///abs/path) → no host.
+    return host === '' ? undefined : host;
+}
+/** Drop `user@` and `:port` from an authority, leaving the bare host. */
+function stripUserAndPort(authority) {
+    const afterUser = authority.includes('@')
+        ? authority.slice(authority.lastIndexOf('@') + 1)
+        : authority;
+    const colon = afterUser.indexOf(':');
+    return colon === -1 ? afterUser : afterUser.slice(0, colon);
+}
+/**
+ * Resolve the review-request provider for an integration (ADR §6), PURELY from
+ * the arbiter URL — there is NO override axis:
+ *
+ *   - a `github.com` arbiter URL ⇒ the GitHub provider, else
+ *   - the `none` provider (the safe default for unknown / local `--bare`
+ *     arbiters, which have no review concept).
+ *
+ * The GitHub provider degrades to `none` behaviour at RUNTIME when `gh` is
+ * absent/unauthenticated (so it is safe to select it on URL alone — the work is
+ * already pushed by the seam, ADR §6); this keeps SELECTION a pure, testable
+ * function of the arbiter URL. The orthogonal "do not open a PR" INTENT is the
+ * `noPR` config axis (handled by the caller, layered on top — it does NOT pick a
+ * provider here), and whether `gh` is authed to actually open the PR is the
+ * identity's `providers.github` / ambient `gh` auth.
+ */
+export function selectProvider(options) {
+    if (options.arbiterUrl && isGitHubArbiterUrl(options.arbiterUrl)) {
+        return new GitHubProvider({ ghBin: options.ghBin });
+    }
+    return new NoneProvider();
+}
+/**
+ * The GitHub provider: opens a PR for an already-pushed `work/<slug>` branch via
+ * `gh pr create`. It NEVER hard-fails — a missing/unauthenticated `gh` degrades
+ * to the `none` behaviour (the branch is already pushed; print manual-PR
+ * instructions) — and NEVER `--force`s anything. The created PR URL is parsed
+ * from `gh`'s stdout and returned so the caller can record it.
+ */
+export class GitHubProvider {
+    name = 'github';
+    ghBin;
+    base;
+    constructor(options = {}) {
+        this.ghBin = options.ghBin ?? DEFAULT_GH_BIN;
+        this.base = options.base ?? 'main';
+    }
+    /**
+     * Open a PR for `input.branch` via `gh pr create --base main --head <branch>`,
+     * passing an explicit `--title`/`--body` when the caller supplied them (the
+     * synthesised single-line title + the agent's summary body) and falling back to
+     * `--fill` ONLY when BOTH are absent (today's behaviour — no regression). A
+     * partial set (one present) still drops `--fill`: `--fill` and an explicit
+     * `--title`/`--body` are mutually exclusive to `gh`, so once we override either
+     * field we must supply both explicitly (the other defaults to the slug-derived
+     * title / an empty body rather than re-deriving a run-on subject). The branch
+     * is GUARANTEED to be on the arbiter already (the push is the seam's safety-
+     * bearing step), so any `gh` failure is non-fatal: we fall back to the same
+     * manual-instructions result the `none` provider returns. On success we parse
+     * the PR URL `gh` prints and surface it (recorded by the caller into the job
+     * record / `status`).
+     */
+    async openRequest(input) {
+        const args = [
+            'pr',
+            'create',
+            '--base',
+            this.base,
+            '--head',
+            input.branch,
+            ...prCreateContentArgs(input),
+        ];
+        // First attempt. A non-zero / missing `gh` can mean two VERY different things:
+        //   - DETERMINISTIC: `gh` is missing or unauthenticated — retrying is pointless
+        //     (every attempt fails identically); degrade IMMEDIATELY (today's
+        //     behaviour, no wasted backoff).
+        //   - TRANSIENT (OUTAGE): `gh` is present + authed but the network/API is down
+        //     — RETRY with bounded backoff (the same shared helper the push uses)
+        //     before degrading. This is a LOW-severity mode: the branch is already
+        //     pushed (the seam's safety step), so the work is safe — only the review
+        //     surface is missing. We do NOT gate requeue on it.
+        const first = this.runGh(args, input.cwd, input.env);
+        if (first !== undefined && first.status === 0) {
+            return this.parseOpened(input, first);
+        }
+        // Failed once — distinguish DETERMINISTIC (missing/unauth) from a TRANSIENT
+        // outage by an availability probe. Missing/unauth ⇒ degrade now (no retry).
+        // Thread the FAILED first attempt so the degrade surfaces the REAL `gh` cause
+        // (its stderr / the missing-binary detail), not a hard-coded auth guess.
+        //
+        // NOTE (degrade NARROWED): for a propose-with-PR-intent run (`noPR` unset) the
+        // start-of-run "`gh` unavailable/unauthed" case is now caught UP FRONT by the
+        // pre-flight `gh` auth probe (see `do.ts`'s pre-flight guard / `selectProvider`
+        // docs), so it never reaches this point as a silent degrade. The legitimate
+        // callers that still land here are: `noPR: true` (intended push-only — the
+        // caller does not even pass a GitHub provider, so this is moot), and a `gh`
+        // that went away AFTER a passing up-front probe (a transient mid-run loss).
+        if (!this.available(input.cwd, input.env)) {
+            return this.degrade(input, 'unavailable', first);
+        }
+        // `gh` IS available but the create failed — a transient outage. Retry the
+        // create with bounded backoff before a clean give-up into the OUTAGE degrade.
+        const attempt = await retryWithBackoff(async () => {
+            const r = this.runGh(args, input.cwd, input.env);
+            if (r !== undefined && r.status === 0) {
+                return { ok: true, value: r };
+            }
+            return {
+                ok: false,
+                error: r?.stderr.trim() || 'gh pr create failed',
+            };
+        }, { sleep: input.sleep ?? realSleep, ...input.backoff });
+        if (!attempt.ok) {
+            return this.degrade(input, 'outage');
+        }
+        return this.parseOpened(input, attempt.value);
+    }
+    /** Map a successful `gh pr create` RunResult to an OpenRequestResult. */
+    parseOpened(input, result) {
+        const url = parsePrUrl(result.stdout);
+        if (url === undefined) {
+            // gh succeeded but we could not parse a URL — still treat the PR as
+            // opened (gh exited 0) but fall back to a generic confirmation.
+            return {
+                opened: true,
+                instruction: `Opened a GitHub PR for ${input.branch}.`,
+            };
+        }
+        return {
+            opened: true,
+            url,
+            instruction: `Opened a GitHub PR for ${input.branch}: ${url}`,
+        };
+    }
+    /**
+     * Post a follow-up COMMENT on an already-opened PR via
+     * `gh pr comment <url> --body <text>` (task `review-gate-pr-comment`),
+     * threading the PR by the `url` {@link openRequest} returned. The PR already
+     * exists (this runs AFTER the propose integrate), so any `gh` failure is
+     * non-fatal: a missing/unauthenticated `gh` DEGRADES to the same surface-the-
+     * text result the `none` provider returns — NEVER throws (ADR §6). The comment
+     * is ADVISORY: it changes no gate/verdict/merge logic. NEVER `--force`s.
+     */
+    postPRComment(input) {
+        const result = this.runGh(['pr', 'comment', input.url, '--body', input.body], input.cwd, input.env);
+        // gh missing (spawn failed) OR non-zero exit (e.g. unauthenticated): the PR
+        // already exists and the review is in the run output, so degrade gracefully
+        // — NEVER throw (the comment is advisory; a failure must not lose work).
+        if (result === undefined || result.status !== 0) {
+            // Surface the REAL `gh` cause (its stderr, with the missing-binary special
+            // case) — NOT a hard-coded "unavailable or unauthenticated" guess that sends
+            // the operator chasing a phantom auth problem (mirrors `issue-provider.ts`).
+            const reason = ghFailureDetail(result);
+            return {
+                posted: false,
+                instruction: `${reason} The review was not posted as a comment on ` +
+                    `${input.url}. The review:\n${input.body}`,
+            };
+        }
+        return {
+            posted: true,
+            instruction: `Posted the review as a comment on ${input.url}.`,
+        };
+    }
+    /**
+     * Post the review comment by RESOLVING the PR from the pushed `work/<slug>`
+     * BRANCH (task `review-comment-fallback-on-unparsed-pr-url`), the FALLBACK for
+     * when `gh pr create` opened a PR (exit 0) but its stdout url was unparseable so
+     * {@link openRequest} returned `{opened: true}` with NO `url`. We first RESOLVE
+     * the open PR's url from the branch (`gh pr view <branch> --json url --jq .url`):
+     *
+     *  - a url comes back ⇒ a PR genuinely exists — post the comment on it via the
+     *    url-keyed {@link postPRComment} (the audit trail is preserved);
+     *  - nothing resolvable (no PR for the branch, or `gh` missing/unauthenticated)
+     *    ⇒ an HONEST clean no-op (`posted: false`) — but only AFTER trying. The
+     *    "no PR ⇒ no comment" rule holds; what changes is we no longer drop the
+     *    comment when a PR DID open.
+     *
+     * Resolving the url first (rather than commenting on the branch directly) keeps
+     * the no-PR case a deterministic no-op and reuses the exact same comment
+     * mechanics as the url path. NEVER throws, NEVER `--force`s (ADR §6).
+     */
+    postPRCommentOnBranch(input) {
+        const url = this.resolvePrUrlForBranch(input.branch, input.cwd, input.env);
+        if (url === undefined) {
+            // No PR resolvable from the branch (truly none, or `gh` unavailable): an
+            // honest no-op — but only after trying. Surface the review text so it is
+            // never lost; nothing was posted.
+            return {
+                posted: false,
+                instruction: `No open PR could be resolved for ${input.branch}, so the review ` +
+                    `was not posted as a comment. The review:\n${input.body}`,
+            };
+        }
+        // A PR genuinely exists for the branch — comment on it via the url path.
+        return this.postPRComment({
+            cwd: input.cwd,
+            url,
+            body: input.body,
+            env: input.env,
+        });
+    }
+    /**
+     * Resolve the open PR's url for `branch` via `gh pr view <branch> --json url
+     * --jq .url`, or `undefined` when no PR is found / `gh` is missing or
+     * unauthenticated (a non-zero exit or a spawn failure). Read-only; mutates
+     * nothing. The result is parsed for a PR url (any surrounding chatter ignored)
+     * so a stray warning line never defeats the resolution.
+     */
+    resolvePrUrlForBranch(branch, cwd, env) {
+        const result = this.runGh(['pr', 'view', branch, '--json', 'url', '--jq', '.url'], cwd, env);
+        if (result === undefined || result.status !== 0) {
+            return undefined; // no PR for the branch, or gh missing/unauthenticated
+        }
+        return parsePrUrl(result.stdout);
+    }
+    /**
+     * Is `gh` available AND authenticated (so a PR can actually be opened)?
+     * `gh auth status` exits 0 when authenticated. A missing `gh` (spawn failure)
+     * or a non-zero exit both read as unavailable. Read-only; mutates nothing.
+     */
+    available(cwd, env) {
+        const result = this.runGh(['auth', 'status'], cwd, env);
+        return result !== undefined && result.status === 0;
+    }
+    /**
+     * Run `gh <args>` in `cwd`, returning the result, or `undefined` when `gh`
+     * cannot even be spawned (binary missing). `run` throws on a spawn error; we
+     * catch it here so a missing `gh` degrades rather than crashing the runner.
+     */
+    runGh(args, cwd, env) {
+        try {
+            return run(this.ghBin, args, cwd, { env });
+        }
+        catch {
+            return undefined; // gh binary not found / not executable
+        }
+    }
+    /**
+     * The graceful-degradation result (identical SHAPE to the `none` provider's):
+     * the branch is already pushed (safe), only the PR is missing. The `reason`
+     * distinguishes the two LOW-severity degrade causes so the operator knows what
+     * to do: `unavailable` (`gh` missing/unauth — fix `gh`/auth) vs `outage`
+     * (transient network/API failure that survived the bounded retry — just re-run
+     * / open it manually). Both print the SAME manual `gh pr create` suggestion.
+     */
+    degrade(input, reason, 
+    /**
+     * The FAILED `gh pr create` result that triggered the `unavailable` degrade
+     * (`undefined` = `gh` binary missing). Threaded in so the `unavailable` arm
+     * surfaces the REAL cause rather than a hard-coded auth guess. The `outage`
+     * arm does not need it (its wording is already honest about the retried
+     * transient failure).
+     */
+    result) {
+        // Echo the explicit title/body in the suggested manual command when present,
+        // so a human opening the PR by hand reuses the same content the autonomous
+        // path would have set (else fall back to the bare `--fill` suggestion).
+        const contentArgs = prCreateContentArgs(input);
+        const suggestion = `gh pr create --base ${this.base} --head ${input.branch} ${contentArgs.join(' ')}`.trim();
+        const cause = reason === 'outage'
+            ? '`gh pr create` failed after retries (a transient outage), so no PR ' +
+                'was opened — the branch is pushed and the work is SAFE; re-run or ' +
+                'open one manually, e.g. '
+            : // Surface the REAL `gh` cause (its stderr, with the missing-binary
+                // special case) — NOT a hard-coded "unavailable or unauthenticated"
+                // guess (mirrors `issue-provider.ts`).
+                `${ghFailureDetail(result)} No PR was opened — open one manually, e.g. `;
+        return {
+            opened: false,
+            instruction: `Pushed ${input.branch} to ${input.arbiter}. ${cause}` +
+                `\`${suggestion}\`.` +
+                manualRequestText(input),
+        };
+    }
+}
+/**
+ * The CONTENT args for `gh pr create`: an explicit `--title`/`--body` when the
+ * caller supplied either (a partial set is completed so `--fill` is never mixed
+ * with an explicit field — `gh` forbids that), else the lone `--fill` (today's
+ * behaviour, no regression). Returned as a flat arg array so both the live
+ * invocation and the degraded suggestion build from one source of truth.
+ */
+export function prCreateContentArgs(input) {
+    if (input.title === undefined && input.body === undefined) {
+        return ['--fill'];
+    }
+    return ['--title', input.title ?? '', '--body', input.body ?? ''];
+}
+/**
+ * Parse the PR URL `gh pr create` prints to stdout. `gh` prints the PR URL as a
+ * line (often the only/last line); we pick the first GitHub PR URL we find. Any
+ * surrounding chatter is ignored. Returns `undefined` when no URL is present.
+ */
+function parsePrUrl(stdout) {
+    const match = stdout.match(/https?:\/\/\S+\/pull\/\d+/);
+    return match ? match[0] : undefined;
+}
+//# sourceMappingURL=github.js.map

package/dist/github.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.js","sourceRoot":"","sources":["../src/github.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAiB,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAC,SAAS,EAAE,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EACN,YAAY,EACZ,iBAAiB,GAOjB,MAAM,iBAAiB,CAAC;AA2CzB,6DAA6D;AAC7D,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,CAAC;AAEnC;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAW;IAC7C,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,KAAK,CAAC;IACd,CAAC;IACD,OAAO,IAAI,KAAK,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;GAKG;AACH,SAAS,WAAW,CAAC,GAAW;IAC/B,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAE3B,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,yEAAyE;QACzE,8BAA8B;QAC9B,MAAM,GAAG,GAAG,6BAA6B,CAAC;QAC1C,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;QAC3B,CAAC;QACD,OAAO,SAAS,CAAC,CAAC,iCAAiC;IACpD,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAChC,MAAM,SAAS,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC7D,MAAM,IAAI,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;IACvD,oEAAoE;IACpE,OAAO,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;AACvC,CAAC;AAED,yEAAyE;AACzE,SAAS,gBAAgB,CAAC,SAAiB;IAC1C,MAAM,SAAS,GAAG,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;QACxC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjD,CAAC,CAAC,SAAS,CAAC;IACb,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACrC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAC7D,CAAC;AAYD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,cAAc,CAAC,OAA8B;IAC5D,IAAI,OAAO,CAAC,UAAU,IAAI,kBAAkB,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QAClE,OAAO,IAAI,cAAc,CAAC,EAAC,KAAK,EAAE,OAAO,CAAC,KAAK,EAAC,CAAC,CAAC;IACnD,CAAC;IACD,OAAO,IAAI,YAAY,EAAE,CAAC;AAC3B,CAAC;AAYD;;;;;;GAMG;AACH,MAAM,OAAO,cAAc;IACjB,IAAI,GAAG,QAAQ,CAAC;IACR,KAAK,CAAS;IACd,IAAI,CAAS;IAE9B,YAAY,UAAiC,EAAE;QAC9C,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,cAAc,CAAC;QAC7C,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,MAAM,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,WAAW,CAAC,KAAuB;QACxC,MAAM,IAAI,GAAG;YACZ,IAAI;YACJ,QAAQ;YACR,QAAQ;YACR,IAAI,CAAC,IAAI;YACT,QAAQ;YACR,KAAK,CAAC,MAAM;YACZ,GAAG,mBAAmB,CAAC,KAAK,CAAC;SAC7B,CAAC;QAEF,+EAA+E;QAC/E,gFAAgF;QAChF,sEAAsE;QACtE,qCAAqC;QACrC,+EAA+E;QAC/E,0EAA0E;QAC1E,2EAA2E;QAC3E,6EAA6E;QAC7E,wDAAwD;QACxD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;QACrD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/C,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACvC,CAAC;QAED,4EAA4E;QAC5E,4EAA4E;QAC5E,8EAA8E;QAC9E,yEAAyE;QACzE,EAAE;QACF,+EAA+E;QAC/E,8EAA8E;QAC9E,gFAAgF;QAChF,4EAA4E;QAC5E,2EAA2E;QAC3E,4EAA4E;QAC5E,4EAA4E;QAC5E,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YAC3C,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC;QAED,0EAA0E;QAC1E,8EAA8E;QAC9E,MAAM,OAAO,GAAG,MAAM,gBAAgB,CACrC,KAAK,IAAI,EAAE;YACV,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;YACjD,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACvC,OAAO,EAAC,EAAE,EAAE,IAAa,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;YACtC,CAAC;YACD,OAAO;gBACN,EAAE,EAAE,KAAc;gBAClB,KAAK,EAAE,CAAC,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,qBAAqB;aAChD,CAAC;QACH,CAAC,EACD,EAAC,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,SAAS,EAAE,GAAG,KAAK,CAAC,OAAO,EAAC,CACnD,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED,yEAAyE;IACjE,WAAW,CAClB,KAAuB,EACvB,MAAiB;QAEjB,MAAM,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACtC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACvB,oEAAoE;YACpE,gEAAgE;YAChE,OAAO;gBACN,MAAM,EAAE,IAAI;gBACZ,WAAW,EAAE,0BAA0B,KAAK,CAAC,MAAM,GAAG;aACtD,CAAC;QACH,CAAC;QACD,OAAO;YACN,MAAM,EAAE,IAAI;YACZ,GAAG;YACH,WAAW,EAAE,0BAA0B,KAAK,CAAC,MAAM,KAAK,GAAG,EAAE;SAC7D,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,aAAa,CAAC,KAAyB;QACtC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CACxB,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,EAClD,KAAK,CAAC,GAAG,EACT,KAAK,CAAC,GAAG,CACT,CAAC;QACF,4EAA4E;QAC5E,4EAA4E;QAC5E,yEAAyE;QACzE,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjD,2EAA2E;YAC3E,6EAA6E;YAC7E,6EAA6E;YAC7E,MAAM,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;YACvC,OAAO;gBACN,MAAM,EAAE,KAAK;gBACb,WAAW,EACV,GAAG,MAAM,6CAA6C;oBACtD,GAAG,KAAK,CAAC,GAAG,kBAAkB,KAAK,CAAC,IAAI,EAAE;aAC3C,CAAC;QACH,CAAC;QACD,OAAO;YACN,MAAM,EAAE,IAAI;YACZ,WAAW,EAAE,qCAAqC,KAAK,CAAC,GAAG,GAAG;SAC9D,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,qBAAqB,CACpB,KAAiC;QAEjC,MAAM,GAAG,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3E,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACvB,yEAAyE;YACzE,yEAAyE;YACzE,kCAAkC;YAClC,OAAO;gBACN,MAAM,EAAE,KAAK;gBACb,WAAW,EACV,oCAAoC,KAAK,CAAC,MAAM,kBAAkB;oBAClE,6CAA6C,KAAK,CAAC,IAAI,EAAE;aAC1D,CAAC;QACH,CAAC;QACD,yEAAyE;QACzE,OAAO,IAAI,CAAC,aAAa,CAAC;YACzB,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,GAAG;YACH,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,GAAG,EAAE,KAAK,CAAC,GAAG;SACd,CAAC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACK,qBAAqB,CAC5B,MAAc,EACd,GAAW,EACX,GAAkC;QAElC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CACxB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EACvD,GAAG,EACH,GAAG,CACH,CAAC;QACF,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjD,OAAO,SAAS,CAAC,CAAC,sDAAsD;QACzE,CAAC;QACD,OAAO,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,GAAW,EAAE,GAAuB;QAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QACxD,OAAO,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACK,KAAK,CACZ,IAAc,EACd,GAAW,EACX,GAAkC;QAElC,IAAI,CAAC;YACJ,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,EAAC,GAAG,EAAC,CAAC,CAAC;QAC1C,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,SAAS,CAAC,CAAC,uCAAuC;QAC1D,CAAC;IACF,CAAC;IAED;;;;;;;OAOG;IACK,OAAO,CACd,KAAuB,EACvB,MAAgC;IAChC;;;;;;OAMG;IACH,MAAkB;QAElB,6EAA6E;QAC7E,2EAA2E;QAC3E,wEAAwE;QACxE,MAAM,WAAW,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC/C,MAAM,UAAU,GACf,uBAAuB,IAAI,CAAC,IAAI,WAAW,KAAK,CAAC,MAAM,IAAI,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;QAC3F,MAAM,KAAK,GACV,MAAM,KAAK,QAAQ;YAClB,CAAC,CAAC,qEAAqE;gBACtE,oEAAoE;gBACpE,0BAA0B;YAC3B,CAAC,CAAC,mEAAmE;gBACpE,oEAAoE;gBACpE,uCAAuC;gBACvC,GAAG,eAAe,CAAC,MAAM,CAAC,8CAA8C,CAAC;QAC5E,OAAO;YACN,MAAM,EAAE,KAAK;YACb,WAAW,EACV,UAAU,KAAK,CAAC,MAAM,OAAO,KAAK,CAAC,OAAO,KAAK,KAAK,EAAE;gBACtD,KAAK,UAAU,KAAK;gBACpB,iBAAiB,CAAC,KAAK,CAAC;SACzB,CAAC;IACH,CAAC;CACD;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAGnC;IACA,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC3D,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnB,CAAC;IACD,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,KAAK,IAAI,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;AACnE,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,MAAc;IACjC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC;IACxD,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACrC,CAAC"}

package/dist/harness.d.ts

@@ -0,0 +1,242 @@
+/**
+ * The **harness seam** (ADR §5): how a job's command is launched and how its
+ * liveness is observed is pluggable behind an adapter; the core never hard-codes
+ * a specific tool.
+ *
+ * Crucially, **liveness is reported by the harness, NOT inferred from filesystem
+ * mtime**: a live agent can think for minutes without writing any files, so
+ * mtime would mistake a thinking agent for a dead one. Adapters answer liveness
+ * from the real signal (the PID, a session handle, …) — never mtime.
+ *
+ * This task ships the **null adapter** (records a PID, runs a configured
+ * command) so the substrate is testable standalone. The first real target (the
+ * `pi` adapter: liveness via PID + a pointer to the pi session dir/log,
+ * invocation via the pi CLI) is its own task.
+ */
+/**
+ * The persisted harness block in a job's `.dorfl-job.json` record. It
+ * captures which adapter launched the job + the liveness pointer the adapter
+ * needs to answer `isAlive` later (so `gc`/`status` can re-derive liveness from
+ * a fresh process without re-launching). Adapter-specific fields are optional.
+ */
+export interface HarnessRecord {
+    /** Which harness adapter owns this job (`null`, later `pi`, …). */
+    adapter: string;
+    /** OS process id of the launched command (the liveness anchor). */
+    pid?: number;
+    /** The command the adapter ran (for audit / re-launch). */
+    command?: string;
+    /** Adapter-specific session pointer (e.g. the pi session dir/log path). */
+    session?: string;
+}
+/** What a harness needs to launch one job's command. */
+export interface LaunchInput {
+    /** The job's working directory (the worktree) — the command runs here. */
+    dir: string;
+    /** The slug being processed (for adapters that name/log per slug). */
+    slug: string;
+    /** The command to run (e.g. the configured `agentCmd`). */
+    command: string;
+    /** Optional prompt fed on the command's stdin. */
+    prompt?: string;
+    /**
+     * The model the agent should run on (the harness-agnostic routing intent, ADR
+     * §13). `undefined` ⇒ dorfl forces no model. The ADAPTER decides HOW
+     * this reaches its tool: the pi adapter passes `--model <model>` natively; the
+     * null/shell adapter substitutes a `{model}` placeholder in `command` (see
+     * {@link substituteModel}). auth/keys are NEVER carried here — they stay the
+     * harness's job.
+     */
+    model?: string;
+    /**
+     * The full pi session-FILE path the adapter passes as `--session <path>` (the
+     * caller generates it ONCE — before launch, so the `do --watch` tailer can tail
+     * the KNOWN path — via {@link generateSessionPath} from the resolved
+     * `sessionsDir` + cwd). Adapter-agnostic: the pi adapter uses it verbatim and
+     * records it in `PiHarnessRecord.session`; the null/shell adapter ignores it.
+     * `undefined` ⇒ the pi adapter falls back to a generated default for its cwd.
+     */
+    session?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * What a harness needs to launch one item's harness INTERACTIVELY (task
+ * `agent-interactive-launch`): a FOREGROUND human session in `dir`, inherited
+ * stdio, NO prepared prompt. This is the OPPOSITE shape to {@link LaunchInput}
+ * (which feeds a prompt on stdin and captures output for the autonomous path):
+ * here the human drives the agent, so there is nothing to feed and nothing to
+ * capture. A NEW seam intent, NOT a flag on {@link Harness.launch} (decision #1):
+ * `launch` is fundamentally spawnSync + prompt-on-stdin + capture-output, and a
+ * boolean would make its `LaunchResult` lie.
+ */
+export interface InteractiveLaunchInput {
+    /** The onboarded working tree to start the session in (the command runs here). */
+    dir: string;
+    /** The slug being worked on (for adapters that name/log per slug). */
+    slug: string;
+    /**
+     * The resolved model the human starts pinned to (ADR §13 routing: flag > env
+     * > per-repo > global). `undefined` ⇒ no model forced. The pi adapter passes
+     * `--model <model>`; the human may still switch models inside the session.
+     */
+    model?: string;
+    /**
+     * The full pi session-FILE path passed as `--session <path>` so the human
+     * session is still recorded/visible (audit trail + the pi dashboard, decision
+     * #2). `undefined` ⇒ the pi adapter generates a default for `dir`.
+     */
+    session?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * The result of an interactive launch — there is NOTHING to capture (the human
+ * drove a foreground session; no prepared prompt, no piped output, no PID record
+ * to persist; it is NOT a tracked job, decision #3). The only useful signal is
+ * the harness's exit code, returned here. Callers may ignore it.
+ */
+export interface InteractiveLaunchResult {
+    /** The harness process's exit code (0 = clean exit). */
+    exitCode: number;
+}
+/**
+ * What the human-face verbs (`start`/`work-on`) hand a launcher: just the
+ * onboarded WORKING TREE + the slug + env. The model + the pi `--session` path
+ * are resolved at the CLI boundary (where config lives) and BOUND INTO the
+ * injected closure, so the git-logic modules stay decoupled from `createHarness`
+ * / config resolution. The CLI's closure calls
+ * {@link Harness.launchInteractive} with the resolved model/session.
+ */
+export interface InteractiveLaunchSite {
+    /** The slug being worked on. */
+    slug: string;
+    /** The onboarded working tree to start the foreground session in. */
+    dir: string;
+    /** Environment for the launched harness process. */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * The injectable interactive launcher the human-face verbs call AFTER
+ * onboarding. The CLI binds the resolved harness + model + sessions-dir into it;
+ * tests inject a spy. A thin seam so `start.ts`/`work-on.ts` never import
+ * `createHarness` or resolve config.
+ */
+export type InteractiveLauncher = (site: InteractiveLaunchSite) => void;
+/** The `{model}` placeholder the null/shell adapter substitutes in `agentCmd`. */
+export declare const MODEL_PLACEHOLDER = "{model}";
+/**
+ * Inject the model ROUTING intent (ADR §13) into a shell `command` for the
+ * null/shell adapter, with three degradation rules so model routing is OFFERED,
+ * never FORCED:
+ *
+ *  1. `{model}` present + `model` set ⇒ substitute every occurrence.
+ *  2. `{model}` present + `model` unset ⇒ a clear config error (we never emit a
+ *     literal `{model}` to the shell — that would silently misroute).
+ *  3. `{model}` absent ⇒ return `command` as-is (a user who bakes the model into
+ *     `agentCmd`, or relies on the harness's own default, is untouched).
+ *
+ * dorfl only moves the model INTENT; auth/keys stay the harness's job.
+ */
+export declare function substituteModel(command: string, model: string | undefined): string;
+export interface LaunchResult {
+    /** True iff the launched command completed successfully. */
+    ok: boolean;
+    /** The harness block to persist in the job record (PID, command, …). */
+    record: HarnessRecord;
+    /** Failure detail when `ok` is false (the stderr/failure channel). */
+    detail?: string;
+    /**
+     * The agent's final ANSWER (task `harness-agent-output`): the concatenated
+     * `text` of the LAST assistant turn the invocation produced. This is the
+     * channel for the agent's OUTPUT on success — DISTINCT from {@link detail},
+     * which is the failure/`stderr` channel. `undefined` when the invocation
+     * produced no parseable assistant text.
+     *
+     * Per-adapter EXTRACTION from each tool's native channel (Option C, decided
+     * 2026-06-06): pi reads the last assistant message from the session `.jsonl`
+     * it wrote (via `watch-session.ts`'s shared reader); the null/shell adapter
+     * returns its captured (synchronous) command stdout. The forward-contract for
+     * an opencode adapter (not built yet) is to take the last assistant `text`
+     * part from its `--format json` stream — the SAME `output` field.
+     */
+    output?: string;
+}
+/**
+ * The harness seam. `launch` starts the job's command + returns the record (with
+ * the liveness anchor); `isAlive` answers liveness FROM THE HARNESS (PID/session
+ * — never mtime, ADR §5).
+ */
+export interface Harness {
+    /** A stable adapter name (`null`, `pi`, …) stamped into the record. */
+    readonly adapter: string;
+    /** Launch the job's command; record the PID + liveness pointer. */
+    launch(input: LaunchInput): LaunchResult;
+    /**
+     * Launch the harness INTERACTIVELY (task `agent-interactive-launch`): a
+     * FOREGROUND human session in `input.dir` with INHERITED stdio and NO prepared
+     * prompt — the human drives it, and control returns when they exit. This is
+     * the human-facing counterpart to the autonomous {@link launch}; it is NOT a
+     * tracked job (no `.dorfl-job.json`, no PID/liveness record, no gate,
+     * decision #3), so it returns only an exit code. pi-only: the null adapter
+     * throws a clear pi-only error (decision #2).
+     */
+    launchInteractive(input: InteractiveLaunchInput): InteractiveLaunchResult;
+    /** Is the job still alive? Answered from the record's anchor, NOT mtime. */
+    isAlive(record: HarnessRecord): boolean;
+}
+/**
+ * Is this `spawnSync.error` a BENIGN failure of the prompt write, safe to
+ * ignore? The null/shell adapter feeds `input.prompt` to the child on stdin
+ * (`spawnSync('bash', …, {input})`). When the prompt is EMPTY — the autonomous
+ * review/arbiter launches that just shell out and capture stdout — a child that
+ * closes its stdin before the parent's (zero-byte) write surfaces as `EPIPE`
+ * under concurrent test load. That write failing is harmless: there was nothing
+ * to deliver, and the child's stdout/exit status are still captured normally.
+ * So we treat ONLY `EPIPE` as benign and let every OTHER spawn error (`ENOENT`,
+ * `EACCES`, buffer overflow, …) throw — those are real launch failures.
+ */
+export declare function isBenignPromptWriteError(error: Error): boolean;
+/**
+ * The **null adapter**: runs the configured command synchronously to completion
+ * in the job dir, recording the PID. Liveness is `process.kill(pid, 0)` against
+ * the recorded PID (the OS process table) — explicitly NOT a file mtime. Because
+ * it runs synchronously, the process has already exited by the time `launch`
+ * returns, so a finished job reads as not-alive (which is correct).
+ */
+export declare class NullHarness implements Harness {
+    readonly adapter = "null";
+    launch(input: LaunchInput): LaunchResult;
+    /**
+     * Interactive launch is NOT supported by the null/shell adapter (decision #2):
+     * its `agentCmd` is shaped for the captured, prompt-fed AUTONOMOUS path, so
+     * "interactive" has no clean meaning here. Throw a CLEAR pi-only error
+     * (mirroring `do --watch`'s fail-on-null decision) rather than silently
+     * shelling out the wrong way.
+     */
+    launchInteractive(_input: InteractiveLaunchInput): InteractiveLaunchResult;
+    isAlive(record: HarnessRecord): boolean;
+}
+/**
+ * Resolve the harness adapter that OWNS a given job record, keyed off the
+ * record's `adapter` field. The core (`status`, `watch`, `gc`) reads liveness
+ * for a heterogeneous set of jobs (some null, some pi) from their persisted
+ * records, so it must ask the RIGHT adapter per job — a pi job's liveness is the
+ * pi adapter's responsibility (PID + session pointer), not the null adapter's.
+ *
+ * Adapters register here lazily via {@link registerHarness}; an unknown adapter
+ * falls back to the null adapter (PID-only liveness — never mtime), which is a
+ * safe superset for any PID-anchored record.
+ */
+export declare function resolveHarness(record: HarnessRecord): Harness;
+/**
+ * Register a harness adapter under its `adapter` name so {@link resolveHarness}
+ * can dispatch liveness to it. Idempotent (last registration wins). The pi
+ * adapter registers itself on import; tests may register stubs.
+ */
+export declare function registerHarness(harness: Harness): void;
+/**
+ * Is `pid` a live process? Uses signal 0 (`process.kill(pid, 0)`), which checks
+ * for existence/permission WITHOUT delivering a signal — the OS process table,
+ * never a filesystem mtime. Unknown/undefined PID ⇒ not alive.
+ */
+export declare function pidAlive(pid: number | undefined): boolean;
+//# sourceMappingURL=harness.d.ts.map

package/dist/harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../src/harness.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC7B,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wDAAwD;AACxD,MAAM,WAAW,WAAW;IAC3B,0EAA0E;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,sBAAsB;IACtC,kFAAkF;IAClF,GAAG,EAAE,MAAM,CAAC;IACZ,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACvC,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACrC,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;IACZ,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,CAAC;AAExE,kFAAkF;AAClF,eAAO,MAAM,iBAAiB,YAAY,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GAAG,SAAS,GACvB,MAAM,CAYR;AAED,MAAM,WAAW,YAAY;IAC5B,4DAA4D;IAC5D,EAAE,EAAE,OAAO,CAAC;IACZ,wEAAwE;IACxE,MAAM,EAAE,aAAa,CAAC;IACtB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACvB,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAAC;IACzC;;;;;;;;OAQG;IACH,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,uBAAuB,CAAC;IAC1E,4EAA4E;IAC5E,OAAO,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC;CACxC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAE9D;AAED;;;;;;GAMG;AACH,qBAAa,WAAY,YAAW,OAAO;IAC1C,QAAQ,CAAC,OAAO,UAAU;IAE1B,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY;IAoDxC;;;;;;OAMG;IACH,iBAAiB,CAAC,MAAM,EAAE,sBAAsB,GAAG,uBAAuB;IAO1E,OAAO,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO;CAGvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEtD;AAOD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAWzD"}