dorfl 0.0.0 → 0.1.0

package/dist/advance.d.ts

@@ -0,0 +1,340 @@
+import { type SlugNamespace } from './slug-namespace.js';
+import { type LedgerReadStrategy } from './ledger-read.js';
+import { type SidecarModel, type SidecarType } from './sidecar.js';
+import { type TickClassification } from './advance-classify.js';
+import { type AcquireAdvancingLockResult, type ReleaseAdvancingLockResult } from './advancing-lock.js';
+import { type DoOptions, type DoResult } from './do.js';
+import { type SurfaceGate } from './surface-gate.js';
+import { type TriageGate } from './triage-gate.js';
+import type { ObservationTriage } from './config.js';
+import { type AutoDispositionOptions, type AutoDispositionResult, type PromoteObservationOptions, type PromoteObservationResult } from './triage-persist.js';
+import { type MintAdrOptions, type MintAdrResult } from './mint-adr.js';
+import { type ApplyDecider } from './apply-decide.js';
+import { type SurfacePersistOptions, type SurfacePersistResult } from './surface-persist.js';
+import { type ApplyAnsweredQuestionsOptions, type ApplyAnsweredQuestionsResult } from './apply-persist.js';
+import { type MergeActionHandler } from './apply-merge-action.js';
+import type { VerifyConfig } from './verify.js';
+import type { NewQuestion } from './sidecar.js';
+/**
+ * The terminal condition of one `advance` tick (mirrors `DoOutcome`'s shape).
+ *
+ * `vanished` (task `observation-identity-is-its-filename-not-a-foreign-slug`):
+ * a BENIGN SKIP when the item's file was enumerated into the lifecycle pool but
+ * has since been moved/triaged/deleted by a sibling leg (the cross-tick window
+ * under parallel CI). It is `exitCode: 0` so the matrix tolerates it, but it is
+ * DISTINGUISHABLE from `no-op` (which is a calm classify result, e.g. a pending
+ * sidecar) so reviewers can grep these out. NOT used for a human-typed bare slug
+ * that names nothing — that is a malformed invocation; today the two are not
+ * distinguished at this seam (a human typo also skips benignly) and the matrix
+ * scale of the calm condition justifies the trade.
+ */
+export type AdvanceOutcome = 'advanced' | 'no-op' | 'vanished' | 'usage-error' | 'lost' | 'contended' | 'not-implemented' | 'invariant-violation';
+/** Maps onto the claim-CAS exit codes (identical semantics). */
+export type AdvanceExitCode = 0 | 1 | 2 | 3;
+/**
+ * The injectable rung-executor SEAM — WHAT happens once the tick has classified a
+ * rung AND won the `advancing` lock. It is the boundary between the skeleton (this
+ * task) and the rung bodies (later tasks): the surface/apply/triage rungs are
+ * filled by their own tasks; the build/task rungs ORCHESTRATE `do`/`do prd:`.
+ *
+ * Production wires {@link defaultRungExecutor}; tests inject a spy to assert the
+ * classify→lock→dispatch ORDER (and that a CAS loser never reaches the executor).
+ */
+export interface RungExecutor {
+    /** A ready task → build it by ORCHESTRATING `do <slug>` (NOT a re-implementation). */
+    buildTask(input: RungExecInput): Promise<RungExecResult>;
+    /** A ready spec → task it by ORCHESTRATING `do spec:<slug>` (NOT a re-implementation). */
+    taskSpec(input: RungExecInput): Promise<RungExecResult>;
+    /** An untriaged observation → triage it (LATER task fills this body). */
+    triageObservation(input: RungExecInput): Promise<RungExecResult>;
+    /** `needsAnswers` but no sidecar → surface the questions (LATER task fills this). */
+    surface(input: RungExecInput): Promise<RungExecResult>;
+    /** Every entry answered → apply the answers + advance (LATER task fills this). */
+    apply(input: RungExecInput): Promise<RungExecResult>;
+}
+/** What a rung executor is handed: the resolved identity + the run context. */
+export interface RungExecInput {
+    /** The canonical namespaced identity (`task:<slug>` / `prd:<slug>` / `observation:<slug>`). */
+    item: string;
+    /** The resolved namespace (`task` / `prd` / `observation`). */
+    namespace: SlugNamespace;
+    /** The bare slug. */
+    slug: string;
+    /** The classification that selected this rung (the two signals are visible). */
+    classification: TickClassification;
+    /** The tick's run context (cwd, arbiter, …) — threaded to `do`/`do prd:`. */
+    context: AdvanceContext;
+}
+/** A rung executor's result (the outcome the tick reports). */
+export interface RungExecResult {
+    exitCode: AdvanceExitCode;
+    outcome: AdvanceOutcome;
+    message: string;
+}
+/** The run context threaded from the CLI into the tick + the rung executor. */
+export interface AdvanceContext {
+    /** The working clone/checkout to run in-place in. */
+    cwd: string;
+    /** Name of the arbiter git remote. Defaults to `origin`. */
+    arbiter?: string;
+    /** The base `do` options the build/task rungs orchestrate `performDo` with. */
+    doOptions?: Omit<DoOptions, 'arg'>;
+    /**
+     * The build/task ORCHESTRATION DRIVER seam (task
+     * `advance-loop-driver-registry-set-job-worktrees`). The build-task / task-spec
+     * rungs ORCHESTRATE `do` by handing the resolved arg + the threaded
+     * {@link doOptions} to THIS driver. `undefined` ⇒ {@link performDo} (the IN-PLACE
+     * substrate — the human-local one-shot `advance` command + today's
+     * single-mirror `run --advance`, which build in the cwd checkout). The
+     * registry-set advance driver injects a PER-MIRROR JOB-WORKTREE driver
+     * ({@link jobWorktreeDoDriver}) so the daemon/CI path builds isolated off each
+     * mirror's arbiter (the SAME isolation `run`'s build tick gives `runOneItem`),
+     * NOT in `process.cwd()`. This is the parameterised isolation strategy the
+     * task's `## Decisions` records: in-place and worktree COEXIST behind one seam,
+     * reusing the EXISTING `selectIsolationStrategy`/`jobWorktreeStrategy` (no second
+     * isolation mechanism). The DEFAULT keeps in-place behaviour byte-for-byte.
+     */
+    doDriver?: (options: DoOptions) => Promise<DoResult>;
+    /**
+     * The SURFACE gate seam — the fresh-context `surface-questions` spawn the
+     * surface rung uses (task `advance-rung-surface`). The skill JUDGES (emits
+     * questions); the engine PERSISTS. Production wires {@link harnessSurfaceGate};
+     * tests inject a stub emit. `undefined` ⇒ the surface rung defaults to
+     * {@link harnessSurfaceGate} (a NullHarness, no real model) so the seam is never
+     * a crash — but the CLI threads the real harness-backed gate.
+     */
+    surfaceGate?: SurfaceGate;
+    /**
+     * The model the SURFACE agent runs on (de-correlated from the builder, like
+     * `reviewModel`). Flows to the gate's launch through `LaunchInput.model`.
+     */
+    surfaceModel?: string;
+    /**
+     * Persist the surfaced questions ATOMICALLY (append-or-create the sidecar + set
+     * `needsAnswers:true` in ONE commit). Tests inject a spy; production uses
+     * {@link persistSurfacedQuestions}. The ENGINE owns ALL persistence — the skill
+     * writes nothing.
+     */
+    surfacePersist?: (options: SurfacePersistOptions) => SurfacePersistResult;
+    /**
+     * Apply the HUMAN's answered sidecar ATOMICALLY (item body + sidecar in ONE
+     * commit, via the sidecar contract's atomic-apply), then resolve / re-pause /
+     * disposition to a terminal. Tests inject a spy; production uses
+     * {@link applyAnsweredQuestions}. The engine applies ONLY human-authored answers
+     * — it NEVER invents one.
+     */
+    applyPersist?: (options: ApplyAnsweredQuestionsOptions) => ApplyAnsweredQuestionsResult;
+    /**
+     * Supply the NEW follow-up questions an apply discovered (so it APPENDS them and
+     * re-pauses rather than resolving). `undefined`/empty ⇒ the apply resolves (or
+     * dispositions) the item. The follow-up GENERATION is the surface skill's job;
+     * this seam lets the apply rung append already-formulated follow-ups (and lets
+     * tests drive the append-re-pause path) WITHOUT inventing an ANSWER.
+     */
+    applyFollowups?: NewQuestion[];
+    /**
+     * The AGENTIC apply DECISION seam (task
+     * `agentic-apply-retire-disposition-vocabulary`): the fresh-context decision
+     * agent the apply rung runs on a fully-answered OBSERVATION to choose what to DO
+     * with the signal (`mint-task | mint-prd | mint-adr | delete-source |
+     * ask-follow-up`),
+     * grounded in the source's full context. It is the injected
+     * {@link ApplyDecider} the shared `decide(input, allowedOutcomes)` engine runs;
+     * tests inject a CANNED verdict (no model). `undefined` ⇒ the apply rung defaults
+     * to {@link harnessApplyDecider} (a NullHarness, no real model) so the seam is
+     * never a crash — but the CLI threads the real harness-backed decider. The
+     * verdict's type SELECTION (task vs prd vs adr) replaces the retired `promote-*`
+     * disposition token; `adr` is now WIRED (task `agentic-apply-mint-adr-route`).
+     */
+    applyDecide?: ApplyDecider;
+    /** The model the apply-DECISION agent runs on (de-correlated, like `surfaceModel`). */
+    applyModel?: string;
+    /**
+     * The 3-state `observationTriage` policy (ADR `ci-config-policy-and-gate-
+     * family` §2) read at the triage rung. It governs the rung-internal
+     * ask-vs-auto distinction (the SELECTION-layer `off` gate is applied EARLIER, in
+     * the driver, by dropping the observation pool — so a rung that runs was either
+     * `ask`/`auto`-selected OR explicitly named, which BYPASSES the selection gate):
+     *   - `'auto'` ⇒ the conservative auto-disposition EXCEPTION is live (ask the
+     *     {@link TriageGate}; auto-dispose ONLY the no-question cases);
+     *   - `'ask'` / `'off'` / `undefined` ⇒ surface the promote/keep/delete question
+     *     and WAIT (the question-gated path). Under `off` + an EXPLICIT `obs:<slug>`
+     *     (which bypasses the selection gate) the rung runs in `ask`-mode — the
+     *     conservative, question-surfacing default (task `## Decisions`). SURFACE +
+     *     APPLY stay ALWAYS allowed; this gate ONLY governs the auto-disposition
+     *     exception, never the always-allowed question loop.
+     */
+    observationTriage?: ObservationTriage;
+    /**
+     * The TRIAGE auto-disposition gate seam — the fresh-context spawn the triage
+     * rung asks (ONLY when `observationTriage` is `'auto'`) whether an observation
+     * is a no-question case. The skill JUDGES; the engine ACTS. Production wires
+     * {@link harnessTriageGate}; tests inject a stub decision. `undefined` ⇒ the
+     * triage rung defaults to {@link harnessTriageGate} (a NullHarness, no real
+     * model) so the seam is never a crash.
+     */
+    triageGate?: TriageGate;
+    /** The model the TRIAGE agent runs on (de-correlated, like `surfaceModel`). */
+    triageModel?: string;
+    /**
+     * Execute the conservative auto-disposition ATOMICALLY (record + marker, one
+     * commit). Tests inject a spy; production uses {@link autoDispositionObservation}.
+     */
+    autoDisposition?: (options: AutoDispositionOptions) => AutoDispositionResult;
+    /**
+     * Promote an answered observation: CAS-create a new backlog stub keyed on the
+     * NEW item's identity, then record + resolve the observation. Tests inject a
+     * spy; production uses {@link promoteObservation}.
+     */
+    promote?: (options: PromoteObservationOptions) => Promise<PromoteObservationResult>;
+    /**
+     * Mint an ADR from an answered observation (the agentic `mint-adr` verdict, task
+     * `agentic-apply-mint-adr-route`): CAS-create `docs/adr/<slug>.md` keyed on the
+     * NEW ADR's identity, with the source + sidecar deleted in the SAME commit. The
+     * SIBLING of {@link promote} for the `docs/adr/` target (an ADR lands OUTSIDE the
+     * work board, so it is a distinct route, not a `promoteObservation` artifact
+     * type). Tests inject a spy; production uses {@link mintAdr}.
+     */
+    mintAdr?: (options: MintAdrOptions) => Promise<MintAdrResult>;
+    /**
+     * The NEW backlog slug an answered promote drafts. `undefined` ⇒ the promote
+     * defaults to the observation's own slug. Lets a test (or a future driver) steer
+     * the promoted item's identity WITHOUT inventing the answer.
+     */
+    promoteSlug?: string;
+    /**
+     * The execution working area (`workspacesDir`, default `~/.dorfl`) the
+     * answered-merge LAND uses to cut a per-job worktree from the hub mirror
+     * (via `workspace.ts` `createJob`). Unset ⇒ no `workspacesDir` is available
+     * to the dispatcher, so an answered `kind: merge` entry is REFUSED (clean
+     * surfacing); the answer stays for a follow-up. The registry-set advance
+     * driver threads the resolved `workspacesDir` here.
+     * (prd `land-time-reverify-and-parallel-merge-ceiling`, task
+     * `apply-rung-merge-disposition`)
+     */
+    workspacesDir?: string;
+    /**
+     * The arbiter URL the answered-merge LAND mirrors from. Optional: when
+     * unset the dispatcher resolves it via `git remote get-url <arbiter>` in the
+     * apply rung's `cwd` (the in-place / one-shot caller). The registry-set
+     * advance driver threads the per-mirror origin URL here directly so the
+     * per-mirror tree-less clone (whose `origin` points at the LOCAL mirror
+     * path, not the real arbiter URL) is bypassed.
+     */
+    arbiterUrl?: string;
+    /**
+     * Per-repo env-prep config (`prepare`) the answered-merge LAND threads into
+     * `performIntegration` so the fresh-worktree gate runs `prepare` then
+     * `verify` on the rebased tip — the SAME config the build path uses.
+     */
+    prepare?: VerifyConfig;
+    /**
+     * Per-repo acceptance gate (`verify`) the answered-merge LAND threads into
+     * `performIntegration` so the fresh-worktree gate re-verifies the rebased
+     * tip before integrating.
+     */
+    verify?: VerifyConfig;
+    /**
+     * Resolved `strictMergeApproval` boolean (sibling task
+     * `strict-merge-approval-gate`). Default OFF ⇒ honour the prior approval +
+     * land on a green re-verify (cheap, the PRD-applied OQ6 default). ON ⇒
+     * re-surface the merge-question when the merge-base moved between the
+     * surfacer's question and this apply (the host-agnostic analogue of
+     * GitHub's "dismiss stale approvals when the base changes").
+     */
+    strictMergeApproval?: boolean;
+    /**
+     * The merge-action dispatch SEAM (task `apply-rung-merge-disposition`):
+     * the deterministic answer-driven runner-action handler the apply rung
+     * invokes BEFORE the agentic decider when an answered `kind: merge` entry
+     * is detected. Production wires {@link performMergeAction} (checks out via
+     * `createJob` + lands via `performIntegration` with `committedRecovery:
+     * true` + `freshWorktreeGate: true`); tests inject a stub so they assert on
+     * the apply-rung's `landed | refused | restale | hold | drop` routing
+     * WITHOUT spinning up a hub mirror or running real verify.
+     */
+    mergeAction?: MergeActionHandler;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+/** The options one `advance` tick consumes. */
+export interface AdvanceOptions extends AdvanceContext {
+    /**
+     * The raw CLI slug argument: bare (= task), `task:<slug>`, `prd:<slug>`, or
+     * `obs:<slug>` / `observation:<slug>`. Omit/empty ⇒ the bare eligible-SET form,
+     * which needs the driver task (a clear error here — see `## Decisions`).
+     */
+    arg?: string;
+    /** The repo working-tree root whose `work/` to read (defaults to `cwd`). */
+    repoPath?: string;
+    /** The read seam for the resolver's cross-namespace existence check. */
+    read?: LedgerReadStrategy;
+    /** The rung executor seam (defaults to {@link defaultRungExecutor}). */
+    executor?: RungExecutor;
+    /** Inject the classify signals (tests); production reads them from disk. */
+    readSignals?: (input: ReadSignalsInput) => ItemSignals;
+    /** Inject the lock acquire (tests); production uses {@link acquireAdvancingLock}. */
+    acquireLock?: (item: string) => Promise<AcquireAdvancingLockResult>;
+    /** Inject the lock release (tests); production uses {@link releaseAdvancingLock}. */
+    releaseLock?: (item: string) => Promise<ReleaseAdvancingLockResult>;
+}
+/** The tick's terminal result. */
+export interface AdvanceResult {
+    exitCode: AdvanceExitCode;
+    outcome: AdvanceOutcome;
+    /** The classified rung kind, when the tick got far enough to classify. */
+    rung?: TickClassification['kind'];
+    /** The resolved bare slug acted on, when one was resolved. */
+    slug?: string;
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+}
+/** The two classify SIGNALS read off the item (the only state the classifier needs). */
+export interface ItemSignals {
+    /** The item-body `needsAnswers` flag. */
+    needsAnswers: boolean | undefined;
+    /** The parsed ACTIVE sidecar, or `undefined` when none exists. */
+    sidecar: SidecarModel | undefined;
+}
+/** What {@link readItemSignals} needs to read an item's two signals off disk. */
+export interface ReadSignalsInput {
+    /** The repo working-tree root. */
+    repoPath: string;
+    /** The item type (task / prd / observation). */
+    type: SidecarType;
+    /** The bare slug. */
+    slug: string;
+    /** The canonical namespaced identity (`<namespace>:<slug>`). */
+    item: string;
+}
+/**
+ * Read an item's two CLASSIFY signals off disk (read-only, NO model, NO lock):
+ *   - `needsAnswers` from the item-body frontmatter (searching the lifecycle
+ *     folders the type may rest in), and
+ *   - the ACTIVE sidecar (`work/questions/<type>-<slug>.md`) parsed when present.
+ *
+ * Identity-keyed: the sidecar path derives PURELY from `<type>-<slug>` (it
+ * survives the item's `git mv`s with no lock-step move). Returns
+ * `needsAnswers:undefined` when no item file is found (the classifier treats it
+ * as "not gated", an ANALYSE rung) — the verb's job here is to wire the two
+ * signals, not to assert the item exists (that is the rung's concern).
+ */
+export declare function readItemSignals(input: ReadSignalsInput): ItemSignals;
+/**
+ * The PRODUCTION rung executor: build/task rungs ORCHESTRATE the existing
+ * `do`/`do prd:` machinery ({@link performDo}); the `surface`/`apply`/
+ * `triage-observation` rung bodies are filled by their own tasks
+ * ({@link surfaceRung} / {@link applyRung} / {@link triageRung}). It NEVER
+ * re-implements the build/task path — it hands the resolved arg to `performDo`,
+ * which spans both namespaces (the task path is the `do prd:` rung the prd's
+ * 2026-06-09 UPDATE confirms routes through `performIntegration`).
+ */
+export declare const defaultRungExecutor: RungExecutor;
+/**
+ * Run ONE `advance` tick over a SINGLE named item: classify → lock → dispatch →
+ * release. The pure tick the drivers (later tasks) wrap. The expensive phase is
+ * ALWAYS post-lock — a CAS loser backs off having done ONLY the free
+ * classification (it never reaches the executor).
+ */
+export declare function performAdvance(options: AdvanceOptions): Promise<AdvanceResult>;
+//# sourceMappingURL=advance.d.ts.map

package/dist/advance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance.d.ts","sourceRoot":"","sources":["../src/advance.ts"],"names":[],"mappings":"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"}