dorfl 0.0.0 → 0.1.0

package/dist/prompt.d.ts

@@ -0,0 +1,360 @@
+/**
+ * Builds the prompt the runner hands to `agentCmd`: a small CONSTANT wrapper
+ * (only the `<slug>` / source-prd path vary) around the claimed task's own
+ * `## Prompt` section. This is dual-use — the SAME assembly the autonomous
+ * runner feeds `agentCmd` and the human `dorfl prompt [<slug>]` command.
+ *
+ * The wrapper is NOT hardcoded here: it is read VERBATIM from the work-contract
+ * (`skills/setup/protocol/CLAIM-PROTOCOL.md` → "The prompt handed to the work agent"),
+ * so the emitted text can never silently diverge from the canonical contract.
+ * We only substitute the per-task placeholders (`<slug>`, `<prd>`).
+ *
+ * The wrapper draws the git boundary IN-BAND — the spawned agent does NO git ops
+ * on the repo (no commit/push, no moving `work/` files); the RUNNER owns every
+ * git-state transition (claim, done-move, work commit, integration). We state
+ * this in the prompt rather than relying on the host's global agent config (an
+ * `AGENTS.md`), because the runner is portable and cannot assume any host rule
+ * exists. See CLAIM-PROTOCOL.md → "The prompt handed to the work agent".
+ */
+import { type Frontmatter } from './frontmatter.js';
+import type { PromptGuidance } from './config.js';
+import { type TaskResolutionFolder } from './work-layout.js';
+/**
+ * Extract the body of the `## Prompt` section from a task's markdown. Returns
+ * the section text with the heading removed, leading `>` blockquote markers
+ * stripped, trimmed; or `undefined` when the task has no `## Prompt` heading.
+ */
+export declare function extractPromptSection(content: string): string | undefined;
+/**
+ * Locate one of the runtime-read protocol docs (`CLAIM-PROTOCOL.md`,
+ * `REVIEW-PROTOCOL.md`, …) the runner reads at RUNTIME. Resolution order,
+ * highest authority first:
+ *
+ *   1. `override` — explicit, for tests / unusual layouts (short-circuits).
+ *   2. `<cwd>/work/protocol/<name>` — the TARGET repo's adopted copy. `setup`
+ *      copies the protocol docs verbatim into every repo's `work/protocol/`
+ *      (ADR `methodology-and-skills.md` §5, the `work/protocol/` propagation),
+ *      so a set-up repo carries the protocol VERSION it adopted; that copy
+ *      wins.
+ *   3. `dist/protocol/<name>` — a copy VENDORED inside this package (by the
+ *      `vendor-protocol` build step). The published-CLI fallback: an installed
+ *      CLI has no sibling `skills/` tree, and the target repo may not be set
+ *      up yet (no `work/protocol/`), so the package ships its own copy of the
+ *      SET of runtime-read protocol docs.
+ *   4. the legacy monorepo-relative `skills/setup/protocol/<name>` walk —
+ *      DEV-only, kept LAST (it only resolves inside this dev monorepo; an
+ *      installed CLI's walks escape into the consumer's filesystem → ENOENT,
+ *      which is why it cannot be the primary source).
+ *
+ * `cwd` is the target repo root (threaded from `renderPrompt`/`do`/`run`/the
+ * `render-prompt` CLI). When omitted, the target-repo step is simply skipped.
+ * `name` is the doc's BASENAME (e.g. `'CLAIM-PROTOCOL.md'`).
+ */
+export declare function resolveProtocolDoc(name: string, cwd?: string, override?: string): string;
+/**
+ * Pull the canonical wrapper TEMPLATE out of CLAIM-PROTOCOL.md: the first fenced
+ * code block following the "The prompt handed to the work agent" heading. The
+ * returned text still contains the `<slug>` / `<prd>` placeholders verbatim — it
+ * is the single source of truth for the wrapper.
+ */
+export declare function extractCanonicalWrapperTemplate(protocol: string): string;
+/**
+ * The single-pass extractor-post-step for the `promptGuidance` NUDGE namespace.
+ * Resolves every `<!-- if promptGuidance.<member> --> … <!-- else --> … <!-- /if -->`
+ * conditional fragment in the canonical wrapper template ("Option A" — single
+ * wrapper, conditional fragments — see the ADR + this task's recorded decision):
+ * when the named nudge member resolves TRUE the IF-branch text is kept and the
+ * markers + ELSE-branch are stripped; when FALSE the ELSE-branch text is kept
+ * and the markers + IF-branch are stripped. The markers' own lines (and the
+ * newlines that terminate them) are consumed too, so the OFF-path output is
+ * BYTE-IDENTICAL to the pre-marker template — the guard the prompt-assembly
+ * byte-identity test pins.
+ *
+ * Pure string transform; runs AFTER `extractCanonicalWrapperTemplate` (a pure
+ * verbatim extractor stays a pure verbatim extractor) and BEFORE the
+ * `<slug>`/`<prd>` substitution.
+ */
+export declare function applyPromptGuidance(template: string, nudges?: {
+    testFirst?: boolean;
+}): string;
+/**
+ * The constant wrapper, parameterised only by the task slug, its source prd
+ * slug, and (optionally) the resolved {@link PromptGuidance} nudges. Read
+ * verbatim from the work-contract and substituted — never a divergent hardcoded
+ * copy. `prd` may be `undefined` when the task has no `prd:` field. When
+ * `promptGuidance` is omitted (or every member resolves false) the output is
+ * BYTE-IDENTICAL to today's wrapper (the ELSE-branch of every conditional is
+ * the historic text).
+ */
+export declare function wrapper(slug: string, prd: string | undefined, options?: {
+    protocolPath?: string;
+    cwd?: string;
+    promptGuidance?: {
+        testFirst?: boolean;
+    };
+}): string;
+/**
+ * The CONTINUE context that turns the fresh-start assembly into a continue-mode
+ * one (the `agent-prompt-continue-context` task). It is OPT-IN state inherited
+ * from a PRIOR attempt: present iff the arbiter holds a `work/<slug>` branch
+ * AHEAD of main (the `requeue` default kept it) — the SAME condition the
+ * `requeue-continue-and-reset` onboarding paths detect via {@link branchAheadOf}.
+ * When absent, the assembly stays byte-identical to the fresh-start wrapper.
+ */
+export interface ContinueContext {
+    /**
+     * The arbiter remote name the prior `work/<type>-<slug>` lives on (e.g.
+     * `origin` / `arbiter`). Used only to point the agent at the right diff base
+     * (`<arbiter>/main`) — the block is prose, not a git op.
+     */
+    arbiter: string;
+    /**
+     * The NAMESPACED work branch the prior attempt's work lives on
+     * (`work/<type>-<slug>`), derived from the resolved `branchRef`. The block
+     * prose names it VERBATIM (the agent's `git diff` pointer must hit the real
+     * branch, not a bare `work/<slug>`).
+     */
+    branch: string;
+    /**
+     * The needs-attention reason (runner-written: WHY the prior attempt stalled),
+     * read from the item BODY. Empty string when none was recorded.
+     */
+    reason: string;
+    /**
+     * The requeue handoff note(s) (human-written via `requeue -m`: what to do
+     * about it), read from the item BODY — the accumulated `## Requeue YYYY-MM-DD`
+     * sections, newest last. Empty array when none were threaded.
+     */
+    requeueNotes: string[];
+}
+/**
+ * Extract the accumulated requeue handoff notes from an item's BODY: the prose
+ * under each `## Requeue YYYY-MM-DD` heading (append-only; written by
+ * `requeue -m "<note>"` in `needs-attention.ts`). Returns one trimmed string per
+ * section in file order (oldest first, newest last); `[]` when none are present.
+ */
+export declare function extractRequeueNotes(content: string): string[];
+/**
+ * Resolve the CONTINUE context for `slug`, runner-side, REUSING the SAME
+ * continue-detection the `requeue-continue-and-reset` claim/start path uses
+ * ({@link branchAheadOf}) — never a parallel re-derivation. Returns a
+ * {@link ContinueContext} iff the arbiter holds a `work/<slug>` ref AHEAD of
+ * main (the prior attempt's kept work); otherwise `undefined` (fresh-start: the
+ * common case, a first attempt or a `requeue --reset` that deleted the branch).
+ *
+ * The reason + handoff note(s) are read from the item BODY (the ledger file the
+ * caller already resolved), so they survive the requeue → tasks-ready (the pool) → claim gap
+ * and cross machines. The ref names match the two onboarding paths:
+ *   - in-place clone:  branchRef=`<arbiter>/work/<slug>`, mainRef=`<arbiter>/main`
+ *   - bare hub mirror: branchRef=`work/<slug>`,           mainRef=`main`
+ */
+export declare function resolveContinueContext(options: {
+    /** The repo/worktree/mirror the branch refs live in. */
+    cwd: string;
+    /** The slug being onboarded. */
+    slug: string;
+    /** The arbiter remote name (for the diff-base pointer in the block). */
+    arbiter: string;
+    /** The `work/<slug>` ref to test (in-place: `<arbiter>/work/<slug>`). */
+    branchRef: string;
+    /** The main ref to compare against (in-place: `<arbiter>/main`). */
+    mainRef: string;
+    /** The resolved task file content (the item body the notes live in). */
+    content: string;
+    /** Environment for the read-only git child. */
+    env?: NodeJS.ProcessEnv;
+}): ContinueContext | undefined;
+/**
+ * Build the CONTINUE block injected ahead of the task prompt in continue-mode.
+ * Pure text: a "you are continuing" framing + a pointer to review the prior diff
+ * vs `<arbiter>/main` + the needs-attention reason + the requeue handoff note(s)
+ * (read from the item body). Never emitted in fresh-start mode.
+ */
+export declare function buildContinueBlock(slug: string, ctx: ContinueContext): string;
+/**
+ * Build the full prompt: the canonical wrapper for `slug` (with its source prd
+ * substituted) followed by the task's own `## Prompt` body, appended verbatim.
+ *
+ * In CONTINUE-mode (a {@link ContinueContext} is supplied), a CONTINUE block is
+ * injected between the wrapper and the task prompt — telling the agent it is
+ * continuing, where to find the prior diff, why it stalled, and the human's
+ * handoff note(s). In FRESH-START mode (no context, the common case) the output
+ * is BYTE-IDENTICAL to the canonical wrapper + task prompt — no CONTINUE block.
+ */
+export declare function buildAgentPrompt(slug: string, prd: string | undefined, taskPrompt: string, options?: {
+    protocolPath?: string;
+    cwd?: string;
+    continueContext?: ContinueContext;
+    promptGuidance?: {
+        testFirst?: boolean;
+    };
+}): string;
+/**
+ * Which work/ folder a task file was resolved from. `done` is reachable ONLY on
+ * a CONTINUE and ONLY when the work-branch tip is STRANDED (committed-but-not-on
+ * the arbiter) — never on a fresh claim, never for a genuinely-COMPLETE task
+ * (see {@link resolveTask} + {@link ContinueResolutionGate}).
+ */
+export type TaskFolder = TaskResolutionFolder;
+export interface ResolvedTask {
+    /** The slug of the resolved task. */
+    slug: string;
+    /** Absolute path to the task file that was read. */
+    path: string;
+    /** The folder the task was resolved from (in-progress wins over tasks-ready). */
+    folder: TaskFolder;
+    /** The task's source prd slug (frontmatter `prd:`), if any. */
+    prd: string | undefined;
+    /** The extracted `## Prompt` body. */
+    taskPrompt: string;
+}
+export interface PromptOptions {
+    /** Slug to render. If omitted, inferred from a `work/<slug>` branch. */
+    slug?: string;
+    /** The repo root (defaults to cwd). */
+    cwd: string;
+    /** Override the path to CLAIM-PROTOCOL.md (tests / unusual layouts). */
+    protocolPath?: string;
+    /** Environment for the branch-inference git child. */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Resolved {@link PromptGuidance} nudges (the prompt-text knobs the
+     * `promptGuidance` namespace carries; e.g. `testFirst`). Omitted (the
+     * common case) ⇒ every member false ⇒ wrapper byte-identical to today.
+     * The CLI's `prompt` action resolves this from the per-repo config; the
+     * autonomous `do`/`run` paths thread it through `buildAgentPrompt`.
+     */
+    promptGuidance?: {
+        testFirst?: boolean;
+    };
+}
+/** Raised for usage/environment problems (no slug, no task file, no prompt). */
+export declare class PromptError extends Error {
+}
+/**
+ * The CONTINUE-only gate that lets {@link resolveTask} reach a task that has
+ * already been done-moved into `work/done/` — story 5 of the `ledger-integrity`
+ * prd (defect 3). A continue/re-claim can legitimately land on a branch whose
+ * task was ALREADY moved to `done/` (the green-but-unpushed STRAND state), and
+ * onboard must find it; but a `done/` task is folder-indistinguishable between
+ * two states and re-onboarding a genuinely-finished one would RE-RUN it. So
+ * `done/` is admitted ONLY behind this gate, which disambiguates by TIP-vs-
+ * ARBITER reachability, NEVER folder name alone:
+ *
+ *   - work-branch tip REACHABLE on `<arbiter>/main` => COMPLETE => NOT admitted
+ *     (onboard must not resurrect a finished task).
+ *   - work-branch tip committed-but-NOT-on-the-arbiter => STRANDED => admitted
+ *     (the continue is legitimate).
+ *
+ * The reachability predicate REUSES {@link isAncestor} (the one provably-merged
+ * primitive in `gc.ts`, the same `merge-base --is-ancestor <tip> <arbiter>/main`
+ * the reaper uses) — no second, divergent reachability implementation. Absent
+ * this gate (a fresh claim — `resolveTask` called with no continue gate) the
+ * resolution is UNCHANGED: `in-progress` then `tasks-ready` (the pool), blind to
+ * `done/`.
+ */
+export interface ContinueResolutionGate {
+    /** The repo/worktree/mirror the work-branch + arbiter refs live in. */
+    cwd: string;
+    /**
+     * The work-branch tip to test for reachability. In-place clone:
+     * `<arbiter>/work/<slug>`; bare hub mirror: `work/<slug>`. The SAME ref the
+     * matching {@link resolveContinueContext} call passes as `branchRef`.
+     */
+    branchRef: string;
+    /**
+     * The arbiter main ref the tip is tested against. In-place clone:
+     * `<arbiter>/main`; bare hub mirror: `main`. The SAME ref the matching
+     * {@link resolveContinueContext} call passes as `mainRef`.
+     */
+    mainRef: string;
+    /** Environment for the read-only reachability git child. */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Extra knobs for {@link resolveTask} beyond the continue gate. Today the only
+ * member is `allowBacklog` (prd
+ * `do-allow-backlog-drive-staged-tasks-without-promotion`): the operator's
+ * EXPLICIT `do … --allow-backlog`, which widens resolution to also search
+ * `tasks-backlog` (staging) at LOWEST priority. Default off (omitted) \u21d2 the
+ * resolution is byte-identical to today; no autonomous path sets it.
+ */
+export interface ResolveTaskOptions {
+    /**
+     * When `true`, append `tasks-backlog` (staging) to the resolution order at
+     * LOWEST priority (after `tasks-ready`), so a human can drive a staged task in
+     * place WITHOUT promoting it. The READY copy wins a same-slug tie. Reachable
+     * ONLY via the explicit `--allow-backlog` flag \u2014 never `run`/auto-pick/advance.
+     */
+    allowBacklog?: boolean;
+}
+/**
+ * Resolve a task's file: prefer `work/in-progress/<slug>.md`, fall back to
+ * `work/tasks/ready/<slug>.md` (the pool). Returns the parsed prd + extracted
+ * `## Prompt` body. Throws {@link PromptError} when neither file exists or it has
+ * no prompt body.
+ *
+ * On a CONTINUE (a {@link ContinueResolutionGate} is supplied), `work/done/` is
+ * added to the resolution AFTER `in-progress`/`tasks-ready` — but ONLY when the
+ * gate proves the work-branch tip is STRANDED (committed-but-not-on-the-arbiter).
+ * A genuinely-COMPLETE `done/` task (tip reachable on `<arbiter>/main`) is NEVER
+ * resolved, so onboard cannot resurrect a finished task (defect 3 / story 5).
+ * The `in-progress`/`tasks-ready` resolution is UNCHANGED in every case; `done/`
+ * is
+ * the only addition, and it is gated. With no gate (a fresh claim) the behaviour
+ * is byte-identical to the original `['in-progress','tasks-ready']`-only resolution.
+ *
+ * `--allow-backlog` (prd `do-allow-backlog-drive-staged-tasks-without-promotion`):
+ * when {@link ResolveTaskOptions.allowBacklog} is set, `tasks-backlog` (the staging
+ * folder) is appended at the LOWEST priority — after `tasks-ready`, so a slug
+ * present in BOTH the pool and staging resolves to the READY copy (the same-slug
+ * precedence the prd's decision 5 fixes). Default off ⇒ byte-identical to today
+ * (no autonomous path sets it; staging stays unreachable to `run`/auto-pick).
+ */
+export declare function resolveTask(cwd: string, slug: string, continueGate?: ContinueResolutionGate, options?: ResolveTaskOptions): ResolvedTask;
+/** If HEAD is a `work/<slug>` branch, return `<slug>`; else `''`. */
+export declare function inferSlugFromBranch(cwd: string, env?: NodeJS.ProcessEnv): string;
+/**
+ * The full `dorfl prompt [<slug>]` rendering: resolve the slug (explicit,
+ * else inferred from a `work/<slug>` branch), resolve its task file
+ * (in-progress over `tasks-ready`, the pool), and assemble the canonical wrapper
+ * + the task's
+ * `## Prompt`. Pure with respect to the repo (read-only) — the caller writes the
+ * result to stdout.
+ */
+/**
+ * Resolve the EFFECTIVE `promptGuidance` for an item by walking the precedence
+ * chain (highest → lowest): the per-task frontmatter override, the per-prd
+ * frontmatter override (only when the task carries a `prd:`), then the
+ * already-resolved repo policy. Each nudge member resolves independently — a
+ * task's `promptGuidance.testFirst` override never bleeds into a sibling
+ * member — mirroring the `humanOnly`/`autoBuild` per-item override shape.
+ *
+ * A task may carry the override even when it has NO `prd:` (a self-contained
+ * chore), by symmetry with `humanOnly` at the item level; `specFrontmatter`
+ * is then simply absent and the chain reads task ⇒ repo.
+ */
+export declare function resolveItemPromptGuidance(repoResolved: PromptGuidance, taskFrontmatter?: Frontmatter, specFrontmatter?: Frontmatter): PromptGuidance;
+/**
+ * Locate a prd's file on disk: prefer `work/prds/ready/<slug>.md` (the
+ * auto-slice pool), then fall back to `work/prds/tasked/<slug>.md` (tasked,
+ * resting). Returns `undefined` when neither exists — the caller treats that
+ * as "no prd-level override available" and the precedence chain falls
+ * through to the repo policy (a missing prd is NOT an error at this seam;
+ * the per-item override is OPTIONAL by design).
+ */
+export declare function findSpecPath(cwd: string, specSlug: string): string | undefined;
+/**
+ * The convenience seam every caller of {@link buildAgentPrompt} reuses to
+ * resolve the per-item override: load the task frontmatter from its file +
+ * (when the task carries `prd:`) the prd frontmatter, then walk
+ * {@link resolveItemPromptGuidance}. Pure-ish (reads at most two files);
+ * returns the repo policy verbatim when neither item layer overrides anything.
+ */
+export declare function resolvePromptGuidanceForItem(options: {
+    cwd: string;
+    repoResolved: PromptGuidance;
+    taskContent: string;
+}): PromptGuidance;
+export declare function renderPrompt(options: PromptOptions): string;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/prompt.d.ts.map

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