dorfl 0.0.0 → 0.1.0

package/dist/do.d.ts

@@ -0,0 +1,621 @@
+import type { TaskReviewGate } from './tasker-review-loop.js';
+import { type Harness } from './harness.js';
+import { type LedgerReadStrategy } from './ledger-read.js';
+import type { ReviewProvider } from './integrator.js';
+import type { IntegrationMode, PromptGuidance } from './config.js';
+import type { VerifyConfig } from './verify.js';
+import type { ReviewGate } from './review-gate.js';
+import { type Identity } from './identity.js';
+/**
+ * `dorfl do <slug>` (in-place form) — the per-repo, in-place WORKER that
+ * claims + builds + gates + integrates in ONE checkout, then EXITS (ADR §3).
+ * **This is the CI command** (CI has a checkout, is one repo, is one triggered
+ * invocation, exits) and it ABSORBS the manual `ar-run.sh` test-driver.
+ *
+ * In-place `do` is on the ISOLATION SEAM (`do-run-share-isolation-seam`): it is
+ * the FIRST production consumer of `selectIsolationStrategy`/`inPlaceStrategy`,
+ * so all THREE `do`/`run` forms (in-place `do`, `do --remote`, `run`) share the
+ * ONE `IsolatedTree`-handle post-claim shape. The composition mirrors
+ * `do --remote`/`run` exactly: keep the two in-place GUARDS (dirty-tree refusal
+ * + pre-flight diverged-main guard) in this driver BEFORE onboarding, CLAIM
+ * explicitly via the CAS (`performClaim`), then let
+ * `selectIsolationStrategy({checkout}).prepare()` do the ONBOARDING half (fetch +
+ * continue-detection + fresh-main `work/<slug>` switch, incl. the §14
+ * continue/rebase + §10 conflict path) WITHOUT re-claiming. The agent run is the
+ * ONLY new middle step (the one `ar-run.sh` shelled out for, `prompt | pi`). The
+ * runner owns EVERY git-state transition (claim, done-move, completion commit,
+ * integration); the agent only edits code.
+ *
+ * The in-place ISOLATION (ADR §3): the current checkout / CI container IS the
+ * isolation — no hub mirror, no external worktree. `inPlaceStrategy.prepare()`
+ * puts the checkout on `work/<slug>` cut from the freshly-fetched
+ * `<arbiter>/main`; its handle's `teardown` is a NO-OP (the checkout is left in a
+ * defined state on `work/<slug>`, NEVER reaped). `do --remote` (the job-worktree
+ * strategy) is the SEPARATE `do-remote` task; auto-pick / multi-arg / `-n` is
+ * `do-autopick`.
+ *
+ * CLAIM SEMANTICS (autonomous, same as `do --remote`/`run`): the claim is
+ * explicit and claim-or-lose. An item that is NOT in the pool (`tasks-ready`) on
+ * the arbiter (already in-progress / done / absent) is not claimable, so the CAS
+ * returns
+ * `lost` (exit 2) and the run skips cleanly — `do`, the unattended CI worker,
+ * never re-claims an item someone else holds and never silently picks up a
+ * needs-attention item (a human does that through the human face).
+ *
+ * **CRITICAL — `do` is AUTONOMOUS, so its failure path is `run`'s, NOT
+ * `complete`'s.** On a red gate / rebase conflict, `performComplete` routes the
+ * item to needs-attention via the SAME seam call as `run`'s `runOneItem`, but
+ * `complete` calls it WITHOUT an arbiter (the human path: a human is right
+ * there). `do` runs UNATTENDED, so it MUST get the autonomous, arbiter-passed
+ * surfacing like `run` (the on-`main` cherry-pick that makes a stuck CI run
+ * visible to `scan`/`status`/another machine). We achieve this by passing
+ * `surfaceArbiter` into `performComplete` (resolution (a) from the task): the
+ * success path reuses `complete`'s machinery; only the NEEDS-ATTENTION routing
+ * becomes the autonomous variant.
+ *
+ * `--propose` (default) / `--merge` is resolved at integrate-time exactly like
+ * `complete` (the caller threads the resolved mode in as `integration`).
+ */
+/** The terminal status of one in-place `do` run. */
+export type DoOutcome = 'completed' | 'lost' | 'contended' | 'needs-attention' | 'surface-unmoved' | 'agent-failed' | 'transient-infra' | 'config-error' | 'agent-stopped' | 'refused' | 'usage-error' | 'tasked' | 'gate-refused' | 'stale';
+export interface DoResult {
+    exitCode: 0 | 1 | 2 | 3;
+    outcome: DoOutcome;
+    /** The resolved bare slug acted on (task or prd), when one was resolved. */
+    slug?: string;
+    /** The work branch the run operated on, when one was created/switched-to. */
+    branch?: string;
+    /**
+     * True iff a FAILURE (agent-failed) SAVED + surfaced the partial work via the
+     * needs-attention mechanism (committed the agent's work, pushed the
+     * `work/<slug>` branch, surfaced on the arbiter's main) rather than dropping it.
+     * Undefined/false on the success, lost/contended/refused, and usage-error paths.
+     */
+    routedToNeedsAttention?: boolean;
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+}
+/** The agent invocation: edits code in `cwd` to satisfy the prompt. */
+export type DoDorfl = (input: {
+    cwd: string;
+    prompt: string;
+    slug: string;
+    env?: NodeJS.ProcessEnv;
+}) => {
+    ok: boolean;
+    detail?: string;
+    /**
+     * The agent's FINAL SUMMARY (the harness seam's `LaunchResult.output`): the
+     * channel the propose-mode PR BODY is built from. Optional so a test agent may
+     * supply a body; production surfaces the build agent's last assistant message.
+     * Absent ⇒ no body ⇒ the provider degrades to `--fill` (no regression).
+     */
+    output?: string;
+};
+export interface DoOptions {
+    /** The raw CLI slug argument: bare (= task), `task:<slug>`, or `prd:<slug>`. */
+    arg: string;
+    /** The working clone/checkout to run in-place in. */
+    cwd: string;
+    /** Name of the arbiter git remote. Defaults to `origin`. */
+    arbiter?: string;
+    /**
+     * The optional runner IDENTITY (a bot), threaded from host-only
+     * `config.identity`. Scopes the runner's GIT/provider ops (claim, push,
+     * integrate, `gh`) — NEVER the agent launch (the agent stays ambient; it must
+     * not commit as the identity). Absent ⇒ ambient. See {@link identityEnv}.
+     */
+    identity?: Identity;
+    /**
+     * Per-repo `autoTask` policy (resolved by `autoslice-gate`: flag > env >
+     * per-repo > global > default false). It gates the AUTO-PICK / pool path only
+     * (`do-autopick.ts`'s taskable-prd pool): "may an agent auto-task an
+     * UNDECLARED prd in this repo?". An EXPLICITLY-named `do prd:<slug>` tasks
+     * REGARDLESS of this policy (the dispatch passes `explicit: true` to
+     * `performTask` — naming the prd IS the authorization, exactly as `do <task>`
+     * builds regardless of `autoBuild`). Ignored by the task-build path.
+     */
+    autoTask?: boolean;
+    /**
+     * The resolved {@link PromptGuidance} NUDGE namespace (e.g. `testFirst`),
+     * threaded from the per-repo config by the CLI and forwarded INTO
+     * {@link buildAgentPrompt} so the autonomous in-place `do` worker prompt
+     * actually carries the nudge. Absent ⇒ every member false ⇒ byte-identical to
+     * today. (Without this the per-repo `promptGuidance.testFirst` was a silent
+     * no-op on the build path — only `dorfl prompt` honoured it.)
+     */
+    promptGuidance?: PromptGuidance;
+    /**
+     * **The tasker review→edit→converge LOOP seam** (`slicer-review-edit-loop`):
+     * consumed ONLY by the `do prd:<slug>` tasking path — after the agent produces
+     * candidate tasks, run the `review` SKILL as a review→edit→re-review loop that
+     * improves them, routing the verdict through the needsAnswers / needs-attention
+     * sink. Ignored by the task-build path. Omitted ⇒ no loop (candidate tasks land
+     * as-is). Production wires {@link harnessTaskReviewGate}; tests inject a canned
+     * verdict+edits.
+     */
+    reviewLoop?: TaskReviewGate;
+    /** The tasker improver loop's `taskerLoopMax` cap (flag > env > per-repo > global > default). Loop only. */
+    taskerLoopMax?: number;
+    /** The tasker improver loop's de-correlated review model (`--tasker-loop-model`). Loop only. */
+    taskerLoopModel?: string;
+    /** How many fresh-context (M) executions of the tasker loop to run. Default 1. Loop only. */
+    reviewExecutions?: number;
+    /** Integration mode resolved at integrate-time (flag > per-repo > global > default). */
+    integration?: IntegrationMode;
+    /**
+     * **The explicit `--merge` override** for the untrusted-origin build-propose rule
+     * (task `untrusted-origin-forces-build-propose`). `true` iff the operator
+     * EXPLICITLY typed `--merge` (vs `merge` resolved from config). Forwarded to the
+     * task-BUILD `performComplete` → `performIntegration` so an explicit `--merge`
+     * OVERRIDES the untrusted-origin build-propose rule. The autonomous/CI path (a bare
+     * `advance`/`do` auto-pick) passes no flag ⇒ unset ⇒ an untrusted-origin task
+     * reliably forces `propose`. (Build transition only; the tasking transition is
+     * unaffected — a task FILE landing on main is inert.)
+     */
+    explicitMerge?: boolean;
+    /**
+     * **Per-TRANSITION override for the TASKING transition only** (config
+     * `taskingIntegration`). Consumed ONLY by the `do prd:<slug>` tasking path: the
+     * value threaded into {@link performTask} is `taskingIntegration ?? integration`,
+     * so an unset override is byte-for-byte today's behaviour (tasking uses
+     * `integration`). The task-BUILD path ALWAYS threads `integration` (never this
+     * key). An explicit `--merge`/`--propose` flag wins over BOTH (the flag-override
+     * layer sets `integration` AND `taskingIntegration` to the typed mode — see
+     * `do-config.ts`). DISTINCT from intake's per-EMITTED-TYPE `{task, prd}` resolver.
+     */
+    taskingIntegration?: IntegrationMode;
+    /**
+     * **The per-repo TASK-PLACEMENT default** (prd
+     * `staging-pool-position-gate-and-trust-model` US #5, task
+     * `runner-deterministic-slice-placement-policy-and-precedence`). Consumed by
+     * the `do prd:<slug>` tasking path: the value is fed as the
+     * CONFIGURED-DEFAULT rung into the runner-deterministic placement resolver
+     * (`src/placement.ts`). Resolved per-repo through the SAME chain as
+     * `taskingIntegration` (flag > env > per-repo > global > built-in
+     * `pre-backlog`). The task-BUILD path ignores it (placement is a TASKING
+     * lifecycle concern).
+     */
+    tasksLandIn?: 'pre-backlog' | 'ready';
+    /**
+     * **The OPERATOR's EXPLICIT task-placement override** (the TOP precedence
+     * rung in the placement resolver). Set ONLY when the operator typed
+     * `--tasks-land-in <where>` on this invocation; never when the value came
+     * from config. Wins over `originTrust: untrusted` (the operator is present;
+     * CLI always wins, no special force-key) — the positional analogue of
+     * `explicitMerge` overriding the untrusted-origin build-propose rule.
+     */
+    explicitTasksLandIn?: 'pre-backlog' | 'ready';
+    /**
+     * Override the pre-flight DIVERGENCE guard (`--ignore-diverged-main`, mirroring
+     * `--ignore-not-ready`): proceed even when local `main` is ahead of
+     * `<arbiter>/main` (has unpushed commits). When overridden and the divergence
+     * persists, `complete`'s now-NON-FATAL local-main sync handles the outcome
+     * honestly (the work lands on the arbiter; local `main` is left for the operator
+     * to rebase). Loud, never the default.
+     */
+    ignoreDivergedMain?: boolean;
+    /**
+     * **`--allow-backlog`** (prd
+     * `do-allow-backlog-drive-staged-tasks-without-promotion`): let this `do task:`
+     * invocation FIND, CLAIM, and COMPLETE a task that lives in `tasks/backlog/`
+     * (staging) IN PLACE, WITHOUT first promoting it to the pool — so no `advance`
+     * leg / `run` daemon can claim it out from under the operator. It widens ONLY
+     * resolution (`resolveTask` also searches `tasks-backlog`, lowest priority) +
+     * the claimable predicate (`performClaim` accepts a staged body); claim/lock/
+     * build/gate are identical, and the done-move goes `tasks/backlog/ → tasks/done/`
+     * directly (the explicit drive IS the promotion). EXPLICIT-INVOCATION-ONLY:
+     * default off, never set by `run`/auto-pick/`advance` (the leak-fence). The
+     * task-build path only; the `do prd:` path is unaffected.
+     */
+    allowBacklog?: boolean;
+    /** The declared per-repo ENV-PREP step (string | list), run ONCE before the
+     * first `verify` on a fresh worktree. Unset ⇒ a no-op (NO default install). */
+    prepare?: VerifyConfig;
+    /** The declared per-repo acceptance gate (string | list). */
+    verify?: VerifyConfig;
+    /**
+     * Run the acceptance gate against the REBASED tip in a clean throwaway worktree
+     * (the tree that integrates) when `true` (the default), else in the build
+     * worktree (the pre-rebase tree). `do` is a SINGLE-JOB path, so the resolved
+     * flag is passed UNCONDITIONALLY (no `run`-fleet downgrade).
+     */
+    freshWorktreeGate?: boolean;
+    /**
+     * **The cross-job merge-serialiser CAS-retry cap** (config `mergeRetries`, prd
+     * `land-time-reverify-and-parallel-merge-ceiling` Story 5 / Applied Answer q1
+     * (a)). Threaded VERBATIM into `performComplete` → `performIntegration` so a
+     * wide-matrix CI's raised cap actually reaches the cross-job land queue (the
+     * CAS loop IS the queue across separate jobs). Resolved per-repo through the
+     * gate-family precedence chain (flag > env > per-repo > global > default).
+     */
+    mergeRetries?: number;
+    /**
+     * **The PR-INTENT axis** (config `noPR`, ADR §6): when `true`, propose pushes
+     * the branch but deliberately skips the PR (the explicit suppress-PR intent).
+     * NOT a provider choice — the provider is purely arbiter-derived. Threaded
+     * verbatim into `performComplete`. Unset/false ⇒ propose opens the PR normally.
+     */
+    noPR?: boolean;
+    /**
+     * The `gh` AUTH/AVAILABILITY PROBE the PR-INTENT pre-flight guard runs UP FRONT
+     * (propose + GitHub arbiter + `noPR` unset): `true` ⇒ `gh` CAN open a PR. The
+     * probe is the signal (mirroring `GitHubProvider.available`), NOT a config check
+     * — an absent identity falls back to ambient `gh` auth and the probe reports it
+     * available. Injectable so tests stub `gh` without a real binary; production
+     * defaults to `new GitHubProvider().available(cwd, env)`. Side-effecting (it
+     * shells `gh`), a deliberate pre-flight cost justified by saving a wasted build.
+     */
+    ghCanOpenPr?: (cwd: string, env: NodeJS.ProcessEnv | undefined) => boolean;
+    /**
+     * Optional FULLY-FORMED review provider INSTANCE used VERBATIM (the SAME seam
+     * `run` exposes via `RunOptions.provider`; threaded to `performComplete` →
+     * `performIntegration` as `providerInstance`). Tests/embeddings inject a stubbed
+     * `GitHubProvider` (a custom `gh` path) to drive the full propose pipeline
+     * OFFLINE without a real GitHub arbiter. The resolved provider OBJECT, NOT a
+     * config override (there is none). Unset ⇒ the core selects from the arbiter URL.
+     */
+    providerInstance?: ReviewProvider;
+    /**
+     * **Gate 2 — the PR/code review gate** (GATES prd `work/prds/tasked/review.md`):
+     * threaded VERBATIM into `performComplete` (the gate rides inside the shared
+     * `do`/`complete` pipeline, so CI inherits it for free). When `review` is on,
+     * the `review` SKILL runs as a fresh-context agent AFTER the green `verify` and
+     * BEFORE the done-move; a `block` maps to the `needs-attention` outcome the same
+     * way `gate-failed` does (exit 1). `reviewModel`/`reviewMaxRounds`
+     * tune it; `reviewGate` is the injectable seam (production: harness-backed).
+     */
+    review?: boolean;
+    reviewModel?: string;
+    reviewMaxRounds?: number;
+    reviewGate?: ReviewGate;
+    /**
+     * **The task-SET ACCEPTANCE GATE seam** (task `slice-acceptance-gate`):
+     * consumed ONLY by the `do prd:<slug>` tasking path. When `review` resolves on,
+     * a fresh-context review of the produced task SET runs BEFORE the tasks
+     * integrate (riding `performIntegration`'s review block); `block` routes the set
+     * to needs-attention, `approve` lets it integrate. It rides the SAME BUILD
+     * `--review`/`--no-review`/`--review-model` family as Gate-2 (one gate-config
+     * story) and is ONE-SHOT (no rounds; it does NOT inherit `reviewMaxRounds`). It
+     * is DISTINCT from the build {@link reviewGate} (a task-SET prompt, not a code
+     * diff) and from the tasker improver loop ({@link reviewLoop}). Production wires
+     * `harnessTaskAcceptanceGate`; tests inject a canned verdict. Omitted ⇒ no gate.
+     */
+    taskReviewGate?: ReviewGate;
+    /**
+     * The autonomous agent invocation. Tests inject this to edit files directly;
+     * production wires the harness seam (the prompt-fed, run-to-completion launch
+     * `run` uses). When omitted, {@link harness} is used.
+     */
+    dorfl?: DoDorfl;
+    /** The harness seam used when `dorfl` is omitted; defaults to the null adapter. */
+    harness?: Harness;
+    /**
+     * `do --watch`: stream the agent's high-signal events live by tailing the pi
+     * session `.jsonl` (task `do-watch`, option (a)). A READ-ONLY observer — it
+     * NEVER changes the run's outcome, gate, integration, git, or exit code; only a
+     * concurrent log-tail is added. REQUIRES the pi harness (the null adapter has
+     * no session log to tail) — passing it with a non-pi harness is a usage error.
+     */
+    watch?: boolean;
+    /** The configured agent command the harness shells out to (null adapter). */
+    agentCmd?: string;
+    /** The model routing intent forwarded to the harness (ADR §13). */
+    model?: string;
+    /**
+     * The HOST-ONLY root folder under which this run's pi session FILE is generated
+     * (resolved `config.sessionsDir`; flag > env > global > default). `undefined`
+     * ⇒ pi's default per-cwd folder. Mapped from `Config` in `cli.ts`'s `do`
+     * action (the bridge from resolved config to the launch — without it the key
+     * resolves but never reaches pi).
+     */
+    sessionsDir?: string;
+    /** Override the read seam (slug resolution); defaults to {@link ledgerRead}. */
+    read?: LedgerReadStrategy;
+    /** Override the resolver's repo path (slug-namespace existence reads). Defaults to `cwd`. */
+    repoPath?: string;
+    /** Environment for child git/agent processes. */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+    /**
+     * Sink for a pre-formatted block printed VERBATIM (forwarded to `complete`'s
+     * propose-mode next-step block). Defaults to `note`.
+     */
+    noteBlock?: (message: string) => void;
+    /** Emit ANSI color in `complete`'s (cosmetic) propose next-step block. */
+    color?: boolean;
+    /**
+     * Where `--watch`'s tailed events are written (defaults to stderr). Tests inject
+     * a sink to assert the surfaced lines without a real terminal.
+     */
+    watchSink?: (line: string) => void;
+}
+/**
+ * The agent-launch fields {@link runDoAgent} reads, shared by the in-place
+ * {@link DoOptions} and the remote {@link DoRemoteOptions} (so one launch helper
+ * serves both forms). A structural subset — both option shapes satisfy it.
+ */
+interface DoAgentLaunchOptions {
+    dorfl?: DoDorfl;
+    harness?: Harness;
+    agentCmd?: string;
+    model?: string;
+    sessionsDir?: string;
+    /**
+     * The resolved {@link PromptGuidance} NUDGE namespace (e.g. `testFirst`),
+     * threaded from the per-repo config by the CLI and forwarded INTO
+     * {@link buildAgentPrompt} so the autonomous worker prompt actually carries the
+     * nudge. Absent ⇒ every member false ⇒ the wrapper is byte-identical to today.
+     * (Without this the per-repo `promptGuidance.testFirst` was a silent no-op on
+     * the build path — only `dorfl prompt` honoured it.)
+     */
+    promptGuidance?: PromptGuidance;
+    watch?: boolean;
+    watchSink?: (line: string) => void;
+    color?: boolean;
+    env?: NodeJS.ProcessEnv;
+    /**
+     * The optional runner IDENTITY (a bot). Threaded from the host-only
+     * `config.identity`. It scopes the runner's GIT + provider operations (claim,
+     * push, integration, `gh`) via process-scoped env overrides — NEVER the AGENT
+     * launch (the agent keeps the plain ambient `env`; the agent must not commit as
+     * the identity, only the runner's own git transitions do). Absent ⇒ ambient
+     * (today's behaviour, byte-for-byte).
+     */
+    identity?: Identity;
+}
+/**
+ * Options for {@link performDoRemote} — `do --remote <r> <arg>`. It carries the
+ * SAME pipeline knobs as {@link DoOptions} (integration / verify / review /
+ * agent-launch), but selects a REGISTERED repo by `remote` (auto-mirrored) +
+ * `workspacesDir` (the agents' execution area) INSTEAD of an in-place `cwd`:
+ * there is no checkout, so the worktree is materialised under `workspacesDir`.
+ */
+export interface DoRemoteOptions extends DoAgentLaunchOptions {
+    /** The raw CLI slug argument: bare (= task), `task:<slug>`, or `prd:<slug>`. */
+    arg: string;
+    /**
+     * The registered remote spec/URL to run against (`do --remote <r>`). Resolved
+     * to a hub mirror via `ensureMirror` (auto-created when unregistered).
+     */
+    remote: string;
+    /**
+     * The execution working area (config `workspacesDir`) — the AGENTS' area where
+     * the hub mirror + job worktree live. NEVER the human area.
+     */
+    workspacesDir: string;
+    /**
+     * Name of the arbiter remote, used ONLY for human-readable surfacing messages
+     * (the actual rebase/integrate/push target inside the worktree is `origin`, the
+     * bare mirror's clone remote). Defaults to `origin`.
+     */
+    arbiter?: string;
+    /**
+     * Per-repo `autoTask` policy — gates the AUTO-PICK / pool path only. An
+     * EXPLICITLY-named `do --remote prd:<slug>` tasks regardless of it (the
+     * dispatch passes `explicit: true`), mirroring `do <task>` vs `autoBuild`.
+     * Ignored by the task-build path.
+     */
+    autoTask?: boolean;
+    /** The tasker review→edit→converge loop seam — `do --remote prd:<slug>` path only (see {@link DoOptions.reviewLoop}). */
+    reviewLoop?: TaskReviewGate;
+    /** The tasker improver loop's `taskerLoopMax` cap. Loop only. */
+    taskerLoopMax?: number;
+    /** The tasker improver loop's de-correlated review model (`--tasker-loop-model`). Loop only. */
+    taskerLoopModel?: string;
+    /** How many fresh-context (M) executions of the tasker loop to run. Default 1. Loop only. */
+    reviewExecutions?: number;
+    /** Integration mode resolved at integrate-time (flag > per-repo > global > default). */
+    integration?: IntegrationMode;
+    /**
+     * The explicit `--merge` override for the untrusted-origin build-propose rule on the
+     * `do --remote` task-BUILD path. See {@link DoOptions.explicitMerge}.
+     */
+    explicitMerge?: boolean;
+    /**
+     * **Per-TRANSITION override for the TASKING transition only** (config
+     * `taskingIntegration`) on the `do --remote prd:<slug>` path: threaded into
+     * {@link performTask} as `taskingIntegration ?? integration`. Unset ⇒ tasking
+     * uses `integration` (today's behaviour); the task-BUILD path always threads
+     * `integration`. See {@link DoOptions.taskingIntegration}.
+     */
+    taskingIntegration?: IntegrationMode;
+    /**
+     * **The per-repo TASK-PLACEMENT default** (prd
+     * `staging-pool-position-gate-and-trust-model` US #5) on the `do --remote
+     * prd:<slug>` path: threaded into {@link performTask} as the
+     * configured-default rung. See {@link DoOptions.tasksLandIn}.
+     */
+    tasksLandIn?: 'pre-backlog' | 'ready';
+    /**
+     * **The OPERATOR's EXPLICIT task-placement override** on the `do --remote
+     * prd:` path. See {@link DoOptions.explicitTasksLandIn}.
+     */
+    explicitTasksLandIn?: 'pre-backlog' | 'ready';
+    /** The declared per-repo ENV-PREP step (string | list), run ONCE before the
+     * first `verify` on a fresh worktree. Unset ⇒ a no-op (NO default install). */
+    prepare?: VerifyConfig;
+    /** The declared per-repo acceptance gate (string | list). */
+    verify?: VerifyConfig;
+    /**
+     * Run the acceptance gate against the REBASED tip in a clean throwaway worktree
+     * (the tree that integrates) when `true` (the default), else in the build
+     * worktree. `do --remote`/`--isolated` is a SINGLE-JOB path, so the resolved
+     * flag is passed UNCONDITIONALLY (no `run`-fleet downgrade).
+     */
+    freshWorktreeGate?: boolean;
+    /**
+     * **The cross-job merge-serialiser CAS-retry cap** (config `mergeRetries`, prd
+     * `land-time-reverify-and-parallel-merge-ceiling` Story 5 / Applied Answer q1
+     * (a)). Threaded VERBATIM into `performComplete` → `performIntegration` so the
+     * resolved cap reaches the cross-job land queue (the CAS loop IS the queue
+     * across separate jobs). Mirrors {@link DoOptions.mergeRetries} so the in-place
+     * and no-checkout `do` paths share ONE knob.
+     */
+    mergeRetries?: number;
+    /**
+     * **The PR-INTENT axis** (config `noPR`, ADR §6): when `true`, propose pushes
+     * the branch but skips the PR (the explicit suppress-PR intent). NOT a provider
+     * choice — the provider is purely arbiter-derived. Unset/false ⇒ PR opens.
+     */
+    noPR?: boolean;
+    /**
+     * The `gh` AUTH/AVAILABILITY PROBE the PR-INTENT pre-flight guard runs UP FRONT
+     * on the AUTONOMOUS path too (propose + GitHub arbiter + `noPR` unset): `true` ⇒
+     * `gh` CAN open a PR. Mirrors {@link DoOptions.ghCanOpenPr} so the in-place and
+     * no-checkout `do` paths share ONE signal. The probe (not a config check) is the
+     * signal — an absent `providers.github` identity falls back to ambient `gh` auth,
+     * which the probe reports available, so a working ambient setup still PROCEEDS.
+     * Injectable so tests stub `gh` without a real binary; production defaults to
+     * `new GitHubProvider().available(probeDir, env)`, run in the claim clone (which
+     * carries the arbiter remote), NOT a bare cwd.
+     */
+    ghCanOpenPr?: (cwd: string, env: NodeJS.ProcessEnv | undefined) => boolean;
+    /**
+     * Optional FULLY-FORMED review provider INSTANCE (tests/embeddings inject a
+     * stubbed `GitHubProvider` to drive the propose pipeline offline). The resolved
+     * provider OBJECT, NOT a config override. Unset ⇒ the core selects from the
+     * arbiter URL.
+     */
+    providerInstance?: ReviewProvider;
+    /** Gate 2 (PR/code review) toggle — threaded verbatim into `performComplete`. */
+    review?: boolean;
+    reviewModel?: string;
+    reviewMaxRounds?: number;
+    reviewGate?: ReviewGate;
+    /** The task-SET ACCEPTANCE GATE seam — `do --remote prd:<slug>` path only (see {@link DoOptions.taskReviewGate}). */
+    taskReviewGate?: ReviewGate;
+    /**
+     * **`--allow-backlog`** on the no-checkout `do --remote`/`--isolated` path (see
+     * {@link DoOptions.allowBacklog}): widen resolution + the claimable predicate to
+     * ALSO accept a `tasks/backlog/`-resident task, so the human-driven `drive-tasks`
+     * opt-in backlog mode can build a STAGED task in place. The done-move goes
+     * `tasks/backlog/ → tasks/done/` directly. Default off; never set by an
+     * autonomous path. The task-build path only.
+     */
+    allowBacklog?: boolean;
+    /** Override the read seam (slug resolution); defaults to {@link ledgerRead}. */
+    read?: LedgerReadStrategy;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+    /** Sink for a pre-formatted block (forwarded to `complete`'s next-step block). */
+    noteBlock?: (message: string) => void;
+}
+/**
+ * Run the in-place `do` ritual end-to-end. Never throws for the expected
+ * lost/contended/refused/needs-attention cases — those are returned with the
+ * appropriate exit code and outcome. The runner owns all git; the agent only
+ * edits code.
+ */
+export declare function performDo(options: DoOptions): Promise<DoResult>;
+/**
+ * The EXACT recovery one-liner handed to the operator when an isolated/remote `do`
+ * integration fails terminally AFTER the work was committed + done-moved (the
+ * stale-lease-strand class surfaced by Part B #97), leaving the job worktree
+ * RETAINED. It points them straight at the recover-already-committed path
+ * (`complete --isolated <slug>`) so they need not reverse-engineer the encoded
+ * worktree path \u2014 the FINISH half of try-to-finish / else-surface. Detection is
+ * unspoofable (an already-integrated task is a clean no-op), so re-running it is
+ * always safe.
+ *
+ * `complete --isolated` recovers the retained WORKTREE, so it ONLY works ON THE
+ * MACHINE that ran the job (the worktree is local + reaped when that runner ends).
+ * From a DIFFERENT checkout (e.g. a CI-stranded job finished on your laptop),
+ * `--isolated` finds no local worktree and silently no-ops; there, check out the
+ * already-pushed work branch off the arbiter and run plain `complete`. Both named.
+ */
+export declare function recoverIsolatedOneLiner(slug: string): string;
+/**
+ * `dorfl do --remote <r> <arg>` — the per-repo `do` WORKER run against a
+ * REGISTERED repo with NO checkout (`docs/adr/command-surface-and-journeys.md`
+ * §3). Where the in-place {@link performDo} uses the CURRENT checkout AS its
+ * isolation, this form materialises a **hub mirror + job worktree in the AGENTS'
+ * area** (`workspacesDir`, the SAME isolation `run` uses — NEVER the human area),
+ * runs the existing `do` pipeline against that worktree, then tears it down per
+ * the §4 provably-safe deletion predicate.
+ *
+ * **Option A — materialise-then-reuse** (the drift correction; the full
+ * IsolatedTree-seam unification is the SEPARATE `do-run-share-isolation-seam`
+ * task). `performDo` composes the human verbs against a literal `cwd`; this
+ * function does the same — it just points that `cwd` at a freshly-cut job
+ * worktree instead of a checkout. It reuses (does NOT reimplement) the pipeline:
+ * `performStart` (resume) → agent → `performComplete`.
+ *
+ * **The claim ↔ worktree ↔ start composition.** Both `createJob` (cuts the
+ * `work/<slug>` branch off the mirror's fresh main) and `performStart` (claims +
+ * switches to `work/<slug>`) overlap. To compose without double-claiming or
+ * fighting over the branch we order them as the task mandates:
+ *
+ *   1. **CLAIM FIRST** — the CAS push to the arbiter, run in a throwaway clone of
+ *      the mirror (the CAS needs a non-bare checkout with an `origin/main`
+ *      tracking ref + a worktree to commit in, which a bare mirror does not
+ *      provide — exactly `work-on`'s remote-form claim context).
+ *   2. **MATERIALISE the worktree** off the POST-CLAIM fresh main via the EXISTING
+ *      job-worktree machinery (`jobWorktreeStrategy`/`createJob`): `createJob`
+ *      re-`ensureMirror`s (fetching the claim move) then cuts `work/<slug>` off
+ *      the freshly-fetched mirror main.
+ *   3. **RUN start/agent/complete** against the worktree dir as `cwd`. `start` is
+ *      driven with `resume: true` so it PLAIN-SWITCHES the branch `createJob`
+ *      already created (the item is in-progress on the arbiter after the claim;
+ *      `performStart`'s resume path switches without re-claiming) — no
+ *      double-claim, no branch fight. The worktree's arbiter remote is `origin`
+ *      (the bare mirror's clone remote), so both `start` and `complete` use
+ *      `origin`.
+ *
+ * **Teardown** re-applies the §4 predicate via the strategy handle's `teardown`
+ * (`reapJob`): reap the worktree iff clean AND on the arbiter, retain otherwise
+ * (the never-lose-work signal). NEVER `--force`.
+ *
+ * **Recovery contract.** The worktree is disposable; the durable artifact is the
+ * `work/<slug>` BRANCH (pushed by the autonomous needs-attention surfacing on a
+ * stuck/failed run). A human recovers via the human face (`requeue` + re-claim,
+ * or `work-on`), NEVER by editing the agents'-area worktree.
+ */
+/**
+ * Resolve the URL of a CHECKOUT's arbiter remote — the primitive `do --isolated`
+ * needs to point the job-worktree pipeline ({@link performDoRemote}) at MY OWN
+ * arbiter (`git -C <cwd> remote get-url <arbiter>`). Returns the URL, or
+ * `undefined` when the cwd is not a git repo or has no such remote (the
+ * "isolated against what?" case the CLI turns into a clear error naming
+ * `--remote <url>`). Does NOT fork the isolation/integrate path — it only feeds
+ * the EXISTING `performDoRemote` its `remote` URL.
+ */
+export declare function resolveArbiterUrlFromCheckout(cwd: string, arbiter: string, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function performDoRemote(options: DoRemoteOptions): Promise<DoResult>;
+/**
+ * Adapt the IN-PLACE {@link DoOptions} build/task driver onto the WORKTREE-
+ * ISOLATED {@link performDoRemote} pipeline (task
+ * `advance-loop-driver-registry-set-job-worktrees`) — the per-mirror job-worktree
+ * `doDriver` the registry-set advance driver threads into the advance tick.
+ *
+ * The advance tick's build/task rung ORCHESTRATES `do` by calling the
+ * {@link AdvanceContext.doDriver} seam with a resolved {@link DoOptions} (whose
+ * `cwd` is the per-mirror in-place checkout). The DEFAULT driver is
+ * {@link performDo} (in-place, the cwd checkout IS the isolation — the human-local
+ * one-shot `advance` + today's `run --advance`). The DAEMON/CI registry-set path
+ * wants the SAME per-job-worktree isolation `run`'s build tick gives `runOneItem`,
+ * so it injects THIS driver instead: it re-routes the orchestration onto
+ * {@link performDoRemote}, which materialises a hub mirror + job worktree off the
+ * mirror's arbiter via the EXISTING `jobWorktreeStrategy` (no second isolation
+ * mechanism), runs the SAME `do` pipeline there, and reaps per the §4 predicate.
+ * The cwd checkout is NEVER touched (the equivalence the task asserts vs plain
+ * `run`).
+ *
+ * The pipeline knobs (verify / integration / review family / agent launch /
+ * identity) ride VERBATIM from the threaded `DoOptions` onto the structurally-
+ * matching {@link DoRemoteOptions} fields; `cwd` is DROPPED (the worktree replaces
+ * it) and `remote` + `workspacesDir` are supplied from this driver's closure (the
+ * mirror's arbiter URL + the agents' execution area). A `prd:` arg flows through
+ * unchanged — `performDoRemote` tasks it against the claim clone with NO build
+ * worktree (the tasking/surface/triage/apply rungs are tree-less ledger moves, the
+ * substrate the task's criterion 4 preserves).
+ */
+export declare function jobWorktreeDoDriver(closure: {
+    /** The mirror's arbiter URL (`git -C <mirror> remote get-url origin`) — `performDoRemote`'s `remote`. */
+    remote: string;
+    /** The agents' execution area (config `workspacesDir`) where the hub mirror + worktree live. */
+    workspacesDir: string;
+}): (options: DoOptions) => Promise<DoResult>;
+export {};
+//# sourceMappingURL=do.d.ts.map

package/dist/do.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"do.d.ts","sourceRoot":"","sources":["../src/do.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAQ5D,OAAO,EAAc,KAAK,OAAO,EAAC,MAAM,cAAc,CAAC;AAGvD,OAAO,EAAa,KAAK,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AAerE,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,iBAAiB,CAAC;AAWpD,OAAO,KAAK,EAAC,eAAe,EAAE,cAAc,EAAC,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAGN,KAAK,QAAQ,EACb,MAAM,eAAe,CAAC;AAYvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,oDAAoD;AACpD,MAAM,MAAM,SAAS,GAClB,WAAW,GACX,MAAM,GACN,WAAW,GACX,iBAAiB,GACjB,iBAAiB,GACjB,cAAc,GACd,iBAAiB,GACjB,cAAc,GACd,eAAe,GACf,SAAS,GACT,aAAa,GACb,QAAQ,GACR,cAAc,GACd,OAAO,CAAC;AAEX,MAAM,WAAW,QAAQ;IACxB,QAAQ,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxB,OAAO,EAAE,SAAS,CAAC;IACnB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,uEAAuE;AACvE,MAAM,MAAM,OAAO,GAAG,CAAC,KAAK,EAAE;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB,KAAK;IACL,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,WAAW,SAAS;IACzB,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAC;IACZ,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAC;IACZ,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,4GAA4G;IAC5G,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gGAAgG;IAChG,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wFAAwF;IACxF,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;OASG;IACH,kBAAkB,CAAC,EAAE,eAAe,CAAC;IACrC;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC;IACtC;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC;IAC9C;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;mFAC+E;IAC/E,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,KAAK,OAAO,CAAC;IAC3E;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAClC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mFAAmF;IACnF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED;;;;GAIG;AACH,UAAU,oBAAoB;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAgB,SAAQ,oBAAoB;IAC5D,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yHAAyH;IACzH,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gGAAgG;IAChG,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wFAAwF;IACxF,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,eAAe,CAAC;IACrC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC;IACtC;;;OAGG;IACH,mBAAmB,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC;IAC9C;mFAC+E;IAC/E,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,KAAK,OAAO,CAAC;IAC3E;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,cAAc,CAAC;IAClC,iFAAiF;IACjF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,qHAAqH;IACrH,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gFAAgF;IAChF,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,8CAA8C;IAC9C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,kFAAkF;IAClF,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAuDD;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,CAqqBrE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAS5D;AAqUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC5C,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GACrB,MAAM,GAAG,SAAS,CAOpB;AAED,wBAAsB,eAAe,CACpC,OAAO,EAAE,eAAe,GACtB,OAAO,CAAC,QAAQ,CAAC,CA0RnB;AA0gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC5C,yGAAyG;IACzG,MAAM,EAAE,MAAM,CAAC;IACf,gGAAgG;IAChG,aAAa,EAAE,MAAM,CAAC;CACtB,GAAG,CAAC,OAAO,EAAE,SAAS,KAAK,OAAO,CAAC,QAAQ,CAAC,CA0C5C"}