monday-cli 0.2.0 → 0.4.0

package/dist/api/dev-conventions.d.ts

@@ -0,0 +1,1038 @@
+/**
+ * Monday Dev convention helpers for the v0.3-M26 `monday dev …`
+ * namespace (`cli-design.md` §2.7 + §5.9 + §11.3 + §13 v0.3 entry;
+ * `v0.3-plan.md` §3 M26).
+ *
+ * **Monday Dev is convention, not API (cli-design §2.7).** No
+ * dedicated GraphQL surface — `dev sprint current`, `dev task done`,
+ * etc. are *workflow shortcuts* that resolve to standard board /
+ * item CRUD operations against per-profile-configured board IDs.
+ * This module owns the convention-to-board-ID resolution, the
+ * per-profile `[profiles.<name>.dev]` reader / writer, and the
+ * board-name-based discovery heuristic that seeds the config from
+ * a Monday Dev template-shaped workspace.
+ *
+ * **What this module owns.**
+ *
+ *   1. The {@link DevMapping} alias over `profiles.ts:profileDevBlockSchema`
+ *      — single source of truth for the per-profile board mapping
+ *      shape. Re-exported here for namespace-clarity at the
+ *      `dev`-command call sites; the schema itself lives next to
+ *      the profile-file reader so v0.3-M21's multi-profile config
+ *      shape stays single-source-of-truth.
+ *   2. The {@link DevDiscoverOutput} + {@link DevConfigureOutput} +
+ *      {@link DevDoctorOutput} output projections — pinned at this
+ *      pre-flight so `monday schema` reads consistent shapes across
+ *      the three setup verbs.
+ *   3. Pure helpers: {@link matchBoardByConvention} (name-based
+ *      heuristic — exact-match-then-substring against the
+ *      Monday Dev template's stock board names) +
+ *      {@link buildDiscoverMappingFromMatches} (collapses the
+ *      heuristic's per-noun matches into a {@link DevMapping}).
+ *      Real implementations — the heuristic is content-addressed
+ *      against board names so it shipped testable at pre-flight
+ *      alongside the runtime fetchers (M26a IMPL `19755e3` landed
+ *      the `boards(state: all, workspace_ids:)` walker with the
+ *      `Board.type === 'board'` filter + per-board metadata
+ *      hydration).
+ *   4. Runtime fetchers: {@link discoverDevBoards} (walks accessible
+ *      boards + applies the heuristic) + {@link runDevDoctor}
+ *      (validates the active profile's mapping against current board
+ *      shape) + {@link loadDevMapping} (reads
+ *      `[profiles.<name>.dev]`) + {@link saveDevMapping} (writes
+ *      `[profiles.<name>.dev]` via atomic TOML round-trip). The
+ *      pre-flight `c8 ignore start/stop` wraps dropped at M26a IMPL
+ *      (`19755e3`) alongside the per-fetcher wire bodies.
+ *
+ * **Empirical-probe findings pinned at M26a IMPL (2026-05-11, against
+ * `api.monday.com`, API version `2026-01`) — `scripts/probe/m26-
+ * dev-discover.ts` + `scripts/probe/m26-board-kind.ts` +
+ * `scripts/probe/m26-board-type.ts`:**
+ *
+ *   - **Stock template names unchanged.** Live Monday Dev workspace
+ *     surfaces `Tasks` / `Epics` / `Bugs Queue` matching the pinned
+ *     {@link DEV_NOUN_PATTERNS} (substring tolerance handles the
+ *     `Queue` suffix on bugs). Decision 1 closure stands; no
+ *     `DEV_NOUN_PATTERNS` amendment needed.
+ *   - **`Board.type === 'board'` filter required.** Monday's
+ *     `boards()` walker returns `sub_items_board` virtual entries
+ *     (auto-generated `Subitems of <BoardName>` boards) that pollute
+ *     the substring heuristic — `Subitems of Tasks` matches the
+ *     `tasks` pattern, creating an ambiguous match that prevents
+ *     auto-mapping. The walker filters to `type === 'board'`,
+ *     silently dropping `sub_items_board` / `custom_object` /
+ *     `document` entries. Behavior-equivalent refinement, NOT a
+ *     contract amendment — {@link DiscoverBoardCandidate} schema
+ *     unchanged.
+ *   - **`state: all` walker filter.** Per the M26 IMPL handoff
+ *     guidance (don't filter by board state at the walker), the
+ *     walker passes `state: all` so the heuristic sees archived /
+ *     deleted boards too; the action body surfaces them on
+ *     {@link DevDiscoverOutput.matches} for agent-side review.
+ *   - **`board_kind`-`public`/`private`/`share` only.** Does NOT
+ *     discriminate subitem boards — `Subitems of Tasks` reports
+ *     `board_kind: 'public'`, identical to the parent `Tasks`
+ *     board. Hence the `Board.type` filter rather than a
+ *     `board_kind` filter.
+ *
+ * **What this module does NOT own.**
+ *
+ *   - The base profile-config schema + read path. Lives in
+ *     `src/config/profiles.ts` per v0.3-M21 (`loadProfilesConfig`,
+ *     `profilesConfigSchema`, `profileDevBlockSchema`). This module
+ *     re-exports the dev-block schema as `devMappingSchema` for
+ *     namespace clarity + owns the dev-block WRITE-back path
+ *     (`saveDevMapping`); the parent profile shape stays under
+ *     `src/config/profiles.ts`.
+ *   - Per-workflow-verb wire calls (sprint/epic/release/task
+ *     reads + writes). Those route through existing api/* modules
+ *     (`items-page-walker`, `item-mutation-execute`, etc.) — the
+ *     dev namespace contributes the *resolver* that maps `current
+ *     sprint` to the right item-search input, not new wire
+ *     primitives.
+ *   - Convention-name overrides for non-template workspaces. The
+ *     heuristic looks for Monday Dev template's stock English
+ *     names; localised workspaces (Spanish "Tareas" etc.) fall
+ *     through to `dev configure` + an explicit per-board override.
+ *     A v0.4+ extension may add `--name-aliases` to discover.
+ *
+ * **Failure-mode routing (no new ERROR_CODES; 29 stays).** Per
+ * cli-design §5.9, the two `dev_*` codes pre-registered in
+ * `src/utils/errors.ts:ERROR_CODES` cover the namespace's failure
+ * modes:
+ *
+ *   - `dev_not_configured` — active profile has no `[profiles.
+ *     <name>.dev]` block AND no overrides via env vars / flags.
+ *     Surface points at `monday dev configure` + `monday dev
+ *     discover`.
+ *   - `dev_board_misconfigured` — mapped board exists but doesn't
+ *     expose the expected column (no status column on the tasks
+ *     board, etc.). Surface points at `monday dev doctor` for
+ *     diagnostics + `monday board describe <bid>` to inspect.
+ *
+ * Other failures (board deleted / access revoked / column-token
+ * collision / etc.) route through the existing 29-code registry
+ * (`not_found`, `column_not_found`, `unauthorized`, etc.) without
+ * widening.
+ */
+import { z } from 'zod';
+import type { Complexity } from '../utils/output/envelope.js';
+import { type ProfilesRootOptions, type ProfileDevBlock } from '../config/profiles.js';
+import type { MondayClient } from './client.js';
+import { type ProjectedItem } from './item-projection.js';
+/**
+ * The per-profile Monday Dev board mapping. Alias over the
+ * `profileDevBlockSchema` defined in `src/config/profiles.ts:49-57`
+ * so the dev-namespace verbs read the same shape v0.3-M21 pinned
+ * for the multi-profile TOML config.
+ *
+ * Field names use snake_case to match the TOML config; the CLI
+ * flag layer (`monday dev configure --tasks-board <bid>`) maps
+ * camelCase argv to snake_case at the parse boundary.
+ */
+export declare const devMappingSchema: z.ZodObject<{
+    tasks_board: z.ZodOptional<z.ZodString>;
+    sprints_board: z.ZodOptional<z.ZodString>;
+    epics_board: z.ZodOptional<z.ZodString>;
+    bugs_board: z.ZodOptional<z.ZodString>;
+    releases_board: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type DevMapping = ProfileDevBlock;
+/**
+ * The Monday Dev template's stock noun → board-name patterns.
+ * The discovery heuristic uses these as the matcher seed; a
+ * workspace whose board names match one of these patterns (case-
+ * insensitive, Unicode NFC) gets auto-mapped to the corresponding
+ * dev-noun slot.
+ *
+ * Pinned in the order the heuristic considers them. Order matters
+ * only for tie-breaking when a single board matches multiple
+ * patterns (rare; e.g. a board named "Tasks & Bugs" matches both
+ * `tasks` and `bugs` — the heuristic surfaces such ambiguity on
+ * the success envelope's `matches[]` array via
+ * `matched.length > 1` rather than auto-mapping).
+ *
+ * Localised workspaces (Spanish "Tareas", French "Sprints" — same
+ * spelling but different language) round-trip the English form
+ * since the heuristic is forward-compat-extensible at v0.4 via a
+ * `--name-aliases` flag on `dev discover`. Today's heuristic ships
+ * English-only by design — Monday Dev templates default to English
+ * board names on new workspaces regardless of UI locale.
+ */
+export declare const DEV_NOUN_PATTERNS: readonly {
+    readonly noun: keyof DevMapping;
+    readonly patterns: readonly string[];
+}[];
+/**
+ * One board candidate the discovery heuristic considers. Carries
+ * the minimum the matcher needs: ID for the mapping, name for the
+ * heuristic itself, optional workspace_id so `dev discover
+ * --workspace <wid>` can scope the search.
+ */
+export interface DiscoverBoardCandidate {
+    readonly id: string;
+    readonly name: string;
+    readonly workspace_id: string | null;
+}
+export declare const discoverBoardCandidateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    workspace_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * One per-noun match result from the heuristic. The `matched`
+ * array carries every board that matched the noun's patterns; the
+ * `dev discover` action layer surfaces ambiguity (`matched.length
+ * > 1`) and zero-match (`matched.length === 0`) cases via the
+ * success envelope's `matches[]` array rather than auto-resolving
+ * silently or emitting a warning code.
+ */
+export interface DevNounMatchResult {
+    readonly noun: keyof DevMapping;
+    readonly matched: readonly DiscoverBoardCandidate[];
+}
+export declare const devNounMatchResultSchema: z.ZodObject<{
+    noun: z.ZodEnum<{
+        tasks_board: "tasks_board";
+        sprints_board: "sprints_board";
+        epics_board: "epics_board";
+        bugs_board: "bugs_board";
+        releases_board: "releases_board";
+    }>;
+    matched: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        workspace_id: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * Returns true when `candidate.name` matches any of `patterns`.
+ * Exact-match wins over substring-match; the matcher returns true
+ * on either form so the caller can rank candidates afterwards if
+ * needed. Pure helper — real implementation at pre-flight so the
+ * Codex review can verify the heuristic shape inline.
+ */
+export declare const matchBoardByConvention: (candidate: DiscoverBoardCandidate, patterns: readonly string[]) => boolean;
+/**
+ * Runs the heuristic across `candidates` and groups by dev-noun.
+ * Returns one {@link DevNounMatchResult} per noun in
+ * {@link DEV_NOUN_PATTERNS} order; nouns with zero matches surface
+ * with empty `matched` arrays (the caller surfaces these on the
+ * `dev discover` success envelope's `matches[]` array via
+ * `matched.length === 0` — no warning code registered at M26
+ * pre-flight). Pure helper — real implementation at pre-flight.
+ */
+export declare const groupCandidatesByDevNoun: (candidates: readonly DiscoverBoardCandidate[]) => readonly DevNounMatchResult[];
+/**
+ * Collapses the per-noun match results into a {@link DevMapping}.
+ * Nouns with exactly one match populate the mapping slot;
+ * zero-match or ambiguous (>1 match) nouns are omitted from the
+ * mapping. The caller — `dev discover` — surfaces both modes
+ * via the same `matches[]` array on the success envelope
+ * (`matched.length === 0` = unmapped; `matched.length > 1` =
+ * ambiguous); no separate warning code is registered at M26
+ * pre-flight (round-1 Codex P2-3 clarification — warning-code
+ * registration is per cli-design §6.1 + the `dev discover`
+ * surface intentionally uses data-shape rather than warnings
+ * for the heuristic's per-noun outcomes). Pure helper — real
+ * implementation at pre-flight.
+ */
+export declare const buildDiscoverMappingFromMatches: (matches: readonly DevNounMatchResult[]) => DevMapping;
+/**
+ * Output shape for `monday dev discover` (cli-design §11.3 +
+ * §4.3 `dev discover [--apply]` row). Surfaces the heuristic's
+ * findings + the would-be-written mapping. Per-noun outcomes
+ * (matched / unmapped / ambiguous) are surfaced via the
+ * `matches[]` array's per-entry `matched.length` rather than
+ * via a separate warning surface.
+ */
+export interface DevDiscoverOutput {
+    readonly profile: string;
+    readonly mapping: DevMapping;
+    readonly matches: readonly DevNounMatchResult[];
+    readonly applied: boolean;
+}
+export declare const devDiscoverOutputSchema: z.ZodObject<{
+    profile: z.ZodString;
+    mapping: z.ZodObject<{
+        tasks_board: z.ZodOptional<z.ZodString>;
+        sprints_board: z.ZodOptional<z.ZodString>;
+        epics_board: z.ZodOptional<z.ZodString>;
+        bugs_board: z.ZodOptional<z.ZodString>;
+        releases_board: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    matches: z.ZodArray<z.ZodObject<{
+        noun: z.ZodEnum<{
+            tasks_board: "tasks_board";
+            sprints_board: "sprints_board";
+            epics_board: "epics_board";
+            bugs_board: "bugs_board";
+            releases_board: "releases_board";
+        }>;
+        matched: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            workspace_id: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    applied: z.ZodBoolean;
+}, z.core.$strict>;
+/**
+ * Output shape for `monday dev configure` (cli-design §4.3 +
+ * §5.9). The verb writes the now-stored mapping to the active
+ * profile's `[profiles.<name>.dev]` block and returns the
+ * canonical mapping (post-write read-back) so an agent can verify
+ * the value landed.
+ */
+export interface DevConfigureOutput {
+    readonly profile: string;
+    readonly mapping: DevMapping;
+}
+export declare const devConfigureOutputSchema: z.ZodObject<{
+    profile: z.ZodString;
+    mapping: z.ZodObject<{
+        tasks_board: z.ZodOptional<z.ZodString>;
+        sprints_board: z.ZodOptional<z.ZodString>;
+        epics_board: z.ZodOptional<z.ZodString>;
+        bugs_board: z.ZodOptional<z.ZodString>;
+        releases_board: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * Pinned check-name vocabulary for `dev doctor` (Decision 2
+ * closure at M26 pre-flight). The runtime body iterates this list
+ * in order and emits one {@link DevDoctorCheckResult} per name.
+ * Names are stable contract surface — agents key off them (an
+ * agent self-correcting after a `dev task` failure can grep the
+ * doctor output for `tasks_status_column_present.status === 'fail'`).
+ *
+ * Adding a check is non-breaking (additive); removing or renaming
+ * is a major bump.
+ *
+ * **Round-1 Codex fix (P1-1).** `sprints_state_column_present`
+ * was the round-0 name but every sprint verb's runtime semantics
+ * are date-range-derived (cli-design §5.9 + the sprint-list verb's
+ * `--state active|past|future` filter), not status-column-derived.
+ * Renamed to `sprints_date_columns_present` to match what the
+ * runtime body will actually inspect — start_date + end_date
+ * columns on the configured sprints board.
+ *
+ * **Round-1 Codex fix (P2-2).** Added `bugs_board_exists` so the
+ * `bugs_board` mapping slot is diagnosed by the doctor like every
+ * other dev-noun slot.
+ *
+ * **Round-2 Codex fix (P2-3).** Replaced `epics_to_releases_relation`
+ * with `tasks_to_epics_relation` — the round-1 list had a relation
+ * check for an epic↔release wiring that no M26 verb consumes
+ * (there's no `dev release items` verb at v0.3), while the
+ * actually-consumed epic↔task relation (`dev epic items <eid>`
+ * walks tasks linked to a given epic) was missing. The release-
+ * to-epic relation can rejoin in a v0.3.x / v0.4 follow-up when /
+ * if a `dev release items` verb lands. Total check count holds at
+ * 10.
+ */
+export declare const DEV_DOCTOR_CHECK_NAMES: readonly ["tasks_board_exists", "tasks_status_column_present", "tasks_status_labels_canonical", "sprints_board_exists", "sprints_date_columns_present", "epics_board_exists", "releases_board_exists", "bugs_board_exists", "tasks_to_sprints_relation", "tasks_to_epics_relation"];
+export type DevDoctorCheckName = (typeof DEV_DOCTOR_CHECK_NAMES)[number];
+/**
+ * One diagnostic check `dev doctor` ran against the active
+ * profile's mapping. `status: 'ok'` = passed; `'warn'` = the
+ * check raised a non-fatal concern (e.g. status column has
+ * non-standard labels); `'fail'` = the check found drift that
+ * blocks the corresponding `dev` verb (e.g. tasks board has no
+ * status column at all — `dev task start` would fail).
+ *
+ * Per-status `details` shape is now STRUCTURALLY pinned at M26a
+ * IMPL round-2 P2-1 via the {@link okCheckDetailsSchema} /
+ * {@link warnCheckDetailsSchema} / {@link failCheckDetailsSchema}
+ * discriminated union below — `monday schema dev.doctor` surfaces
+ * the closed {@link DEV_DOCTOR_REASONS} enum via JSON Schema
+ * export, and `failResult` enforces a required `reason` at
+ * compile time. Extra `details` keys beyond `reason` stay open
+ * per-status (open-ended `Record<string, unknown>` extension via
+ * `.loose()`) so each check emits its own context fields
+ * (`board_id`, `column_id`, etc.) without per-check schema
+ * widening.
+ *
+ * **M26 pre-flight round-1 Codex fix (P2-1).** `name` is typed
+ * as {@link DevDoctorCheckName} (the enum literal union) so
+ * `monday schema` exposes the stable vocabulary + implementation
+ * typos fail output-schema validation rather than silently
+ * passing through.
+ */
+/**
+ * Pinned `details.reason` enum vocabulary surfaced by per-check
+ * failure paths. Closes the Decision 2 deferral (per-check
+ * discriminated-union pinning) at M26a IMPL — `details.reason`
+ * is the agent-keyable discriminator on `status: 'fail'` (and on
+ * `status: 'warn'` when a warn carries a structured reason, e.g.
+ * `settings_unparseable`).
+ *
+ * Codex M26a IMPL round-1 P2-1 fix: previously the schema accepted
+ * any `details: Record<string, unknown>` shape, so `monday schema`
+ * couldn't expose the reason vocabulary + tests couldn't catch
+ * typos. Pinning the enum + the "fail requires reason" refinement
+ * gives agents a stable branchpoint.
+ *
+ * Adding a reason is non-breaking; removing or renaming is major.
+ */
+export declare const DEV_DOCTOR_REASONS: readonly ["not_in_mapping", "not_accessible", "board_deleted", "no_tasks_board", "no_sprints_board", "no_status_column", "no_date_columns", "no_relation_column", "no_matching_relation", "no_target_board", "settings_unparseable"];
+export type DevDoctorReason = (typeof DEV_DOCTOR_REASONS)[number];
+export declare const devDoctorReasonSchema: z.ZodEnum<{
+    not_in_mapping: "not_in_mapping";
+    not_accessible: "not_accessible";
+    board_deleted: "board_deleted";
+    no_tasks_board: "no_tasks_board";
+    no_sprints_board: "no_sprints_board";
+    no_status_column: "no_status_column";
+    no_date_columns: "no_date_columns";
+    no_relation_column: "no_relation_column";
+    no_matching_relation: "no_matching_relation";
+    no_target_board: "no_target_board";
+    settings_unparseable: "settings_unparseable";
+}>;
+/**
+ * Per-status `details` shape. Codex M26a IMPL round-2 P2-1 + P2-2
+ * fix: the round-1 superRefine ran the `reason`-enum check
+ * runtime-only — `monday schema` (which calls `z.toJSONSchema(outputSchema)`)
+ * couldn't surface the enum vocabulary, and ok-status details were
+ * incidentally blocked when an ok carried any non-enum `reason`.
+ * Refactored into a structural discriminated union on `status`:
+ *
+ *   - `ok`: open `details` object (or null) — no `reason` constraint.
+ *   - `warn`: optional `reason: DEV_DOCTOR_REASONS` enum + open
+ *     extras; supports both unstructured warnings (archived board)
+ *     and structured ones (settings_unparseable).
+ *   - `fail`: REQUIRED `reason: DEV_DOCTOR_REASONS` enum + open
+ *     extras; `details` is non-nullable on fail (every failure
+ *     surfaces a structured reason).
+ *
+ * Open-ended extra keys per-status mirror Monday's per-call payload
+ * variability — every check emits its own context fields
+ * (`board_id`, `column_id`, etc.) under the same status family.
+ */
+export declare const okCheckDetailsSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export declare const warnCheckDetailsSchema: z.ZodNullable<z.ZodObject<{
+    reason: z.ZodOptional<z.ZodEnum<{
+        not_in_mapping: "not_in_mapping";
+        not_accessible: "not_accessible";
+        board_deleted: "board_deleted";
+        no_tasks_board: "no_tasks_board";
+        no_sprints_board: "no_sprints_board";
+        no_status_column: "no_status_column";
+        no_date_columns: "no_date_columns";
+        no_relation_column: "no_relation_column";
+        no_matching_relation: "no_matching_relation";
+        no_target_board: "no_target_board";
+        settings_unparseable: "settings_unparseable";
+    }>>;
+}, z.core.$loose>>;
+export declare const failCheckDetailsSchema: z.ZodObject<{
+    reason: z.ZodEnum<{
+        not_in_mapping: "not_in_mapping";
+        not_accessible: "not_accessible";
+        board_deleted: "board_deleted";
+        no_tasks_board: "no_tasks_board";
+        no_sprints_board: "no_sprints_board";
+        no_status_column: "no_status_column";
+        no_date_columns: "no_date_columns";
+        no_relation_column: "no_relation_column";
+        no_matching_relation: "no_matching_relation";
+        no_target_board: "no_target_board";
+        settings_unparseable: "settings_unparseable";
+    }>;
+}, z.core.$loose>;
+export declare const devDoctorCheckResultOkSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        tasks_board_exists: "tasks_board_exists";
+        tasks_status_column_present: "tasks_status_column_present";
+        tasks_status_labels_canonical: "tasks_status_labels_canonical";
+        sprints_board_exists: "sprints_board_exists";
+        sprints_date_columns_present: "sprints_date_columns_present";
+        epics_board_exists: "epics_board_exists";
+        releases_board_exists: "releases_board_exists";
+        bugs_board_exists: "bugs_board_exists";
+        tasks_to_sprints_relation: "tasks_to_sprints_relation";
+        tasks_to_epics_relation: "tasks_to_epics_relation";
+    }>;
+    status: z.ZodLiteral<"ok">;
+    message: z.ZodString;
+    details: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const devDoctorCheckResultWarnSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        tasks_board_exists: "tasks_board_exists";
+        tasks_status_column_present: "tasks_status_column_present";
+        tasks_status_labels_canonical: "tasks_status_labels_canonical";
+        sprints_board_exists: "sprints_board_exists";
+        sprints_date_columns_present: "sprints_date_columns_present";
+        epics_board_exists: "epics_board_exists";
+        releases_board_exists: "releases_board_exists";
+        bugs_board_exists: "bugs_board_exists";
+        tasks_to_sprints_relation: "tasks_to_sprints_relation";
+        tasks_to_epics_relation: "tasks_to_epics_relation";
+    }>;
+    status: z.ZodLiteral<"warn">;
+    message: z.ZodString;
+    details: z.ZodNullable<z.ZodObject<{
+        reason: z.ZodOptional<z.ZodEnum<{
+            not_in_mapping: "not_in_mapping";
+            not_accessible: "not_accessible";
+            board_deleted: "board_deleted";
+            no_tasks_board: "no_tasks_board";
+            no_sprints_board: "no_sprints_board";
+            no_status_column: "no_status_column";
+            no_date_columns: "no_date_columns";
+            no_relation_column: "no_relation_column";
+            no_matching_relation: "no_matching_relation";
+            no_target_board: "no_target_board";
+            settings_unparseable: "settings_unparseable";
+        }>>;
+    }, z.core.$loose>>;
+}, z.core.$strict>;
+export declare const devDoctorCheckResultFailSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        tasks_board_exists: "tasks_board_exists";
+        tasks_status_column_present: "tasks_status_column_present";
+        tasks_status_labels_canonical: "tasks_status_labels_canonical";
+        sprints_board_exists: "sprints_board_exists";
+        sprints_date_columns_present: "sprints_date_columns_present";
+        epics_board_exists: "epics_board_exists";
+        releases_board_exists: "releases_board_exists";
+        bugs_board_exists: "bugs_board_exists";
+        tasks_to_sprints_relation: "tasks_to_sprints_relation";
+        tasks_to_epics_relation: "tasks_to_epics_relation";
+    }>;
+    status: z.ZodLiteral<"fail">;
+    message: z.ZodString;
+    details: z.ZodObject<{
+        reason: z.ZodEnum<{
+            not_in_mapping: "not_in_mapping";
+            not_accessible: "not_accessible";
+            board_deleted: "board_deleted";
+            no_tasks_board: "no_tasks_board";
+            no_sprints_board: "no_sprints_board";
+            no_status_column: "no_status_column";
+            no_date_columns: "no_date_columns";
+            no_relation_column: "no_relation_column";
+            no_matching_relation: "no_matching_relation";
+            no_target_board: "no_target_board";
+            settings_unparseable: "settings_unparseable";
+        }>;
+    }, z.core.$loose>;
+}, z.core.$strict>;
+export declare const devDoctorCheckResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodEnum<{
+        tasks_board_exists: "tasks_board_exists";
+        tasks_status_column_present: "tasks_status_column_present";
+        tasks_status_labels_canonical: "tasks_status_labels_canonical";
+        sprints_board_exists: "sprints_board_exists";
+        sprints_date_columns_present: "sprints_date_columns_present";
+        epics_board_exists: "epics_board_exists";
+        releases_board_exists: "releases_board_exists";
+        bugs_board_exists: "bugs_board_exists";
+        tasks_to_sprints_relation: "tasks_to_sprints_relation";
+        tasks_to_epics_relation: "tasks_to_epics_relation";
+    }>;
+    status: z.ZodLiteral<"ok">;
+    message: z.ZodString;
+    details: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodEnum<{
+        tasks_board_exists: "tasks_board_exists";
+        tasks_status_column_present: "tasks_status_column_present";
+        tasks_status_labels_canonical: "tasks_status_labels_canonical";
+        sprints_board_exists: "sprints_board_exists";
+        sprints_date_columns_present: "sprints_date_columns_present";
+        epics_board_exists: "epics_board_exists";
+        releases_board_exists: "releases_board_exists";
+        bugs_board_exists: "bugs_board_exists";
+        tasks_to_sprints_relation: "tasks_to_sprints_relation";
+        tasks_to_epics_relation: "tasks_to_epics_relation";
+    }>;
+    status: z.ZodLiteral<"warn">;
+    message: z.ZodString;
+    details: z.ZodNullable<z.ZodObject<{
+        reason: z.ZodOptional<z.ZodEnum<{
+            not_in_mapping: "not_in_mapping";
+            not_accessible: "not_accessible";
+            board_deleted: "board_deleted";
+            no_tasks_board: "no_tasks_board";
+            no_sprints_board: "no_sprints_board";
+            no_status_column: "no_status_column";
+            no_date_columns: "no_date_columns";
+            no_relation_column: "no_relation_column";
+            no_matching_relation: "no_matching_relation";
+            no_target_board: "no_target_board";
+            settings_unparseable: "settings_unparseable";
+        }>>;
+    }, z.core.$loose>>;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodEnum<{
+        tasks_board_exists: "tasks_board_exists";
+        tasks_status_column_present: "tasks_status_column_present";
+        tasks_status_labels_canonical: "tasks_status_labels_canonical";
+        sprints_board_exists: "sprints_board_exists";
+        sprints_date_columns_present: "sprints_date_columns_present";
+        epics_board_exists: "epics_board_exists";
+        releases_board_exists: "releases_board_exists";
+        bugs_board_exists: "bugs_board_exists";
+        tasks_to_sprints_relation: "tasks_to_sprints_relation";
+        tasks_to_epics_relation: "tasks_to_epics_relation";
+    }>;
+    status: z.ZodLiteral<"fail">;
+    message: z.ZodString;
+    details: z.ZodObject<{
+        reason: z.ZodEnum<{
+            not_in_mapping: "not_in_mapping";
+            not_accessible: "not_accessible";
+            board_deleted: "board_deleted";
+            no_tasks_board: "no_tasks_board";
+            no_sprints_board: "no_sprints_board";
+            no_status_column: "no_status_column";
+            no_date_columns: "no_date_columns";
+            no_relation_column: "no_relation_column";
+            no_matching_relation: "no_matching_relation";
+            no_target_board: "no_target_board";
+            settings_unparseable: "settings_unparseable";
+        }>;
+    }, z.core.$loose>;
+}, z.core.$strict>], "status">;
+export type DevDoctorCheckResult = z.infer<typeof devDoctorCheckResultSchema>;
+/**
+ * Output shape for `monday dev doctor` (cli-design §11.3). The
+ * verb runs every check against the active profile's mapping +
+ * surfaces both the per-check results and the active mapping
+ * (so an agent diagnosing a misconfiguration sees both in one
+ * envelope).
+ *
+ * **Decision 2 closure (M26 pre-flight + M26a IMPL).** The
+ * pinned check names: see {@link DEV_DOCTOR_CHECK_NAMES} above
+ * (10 entries post-round-1; round-0 had 9 entries before P1-1
+ * / P2-2 fix-ups). Mirror cli-design §11.3 "runs `board doctor`
+ * against each configured dev board plus checks the cross-board
+ * `board_relation` wiring". Per-check `details` shape was
+ * deferred to IMPL at pre-flight + landed at M26a IMPL round-2
+ * P2-1 as a structural `z.discriminatedUnion('status', [...])`
+ * over {@link okCheckDetailsSchema} / {@link warnCheckDetailsSchema}
+ * / {@link failCheckDetailsSchema} (the `reason` enum from
+ * {@link DEV_DOCTOR_REASONS} is required on fail + optional on
+ * warn; extra keys per check stay open).
+ */
+export interface DevDoctorOutput {
+    readonly profile: string;
+    readonly mapping: DevMapping;
+    readonly checks: readonly DevDoctorCheckResult[];
+    readonly summary: {
+        readonly ok_count: number;
+        readonly warn_count: number;
+        readonly fail_count: number;
+    };
+}
+export declare const devDoctorOutputSchema: z.ZodObject<{
+    profile: z.ZodString;
+    mapping: z.ZodObject<{
+        tasks_board: z.ZodOptional<z.ZodString>;
+        sprints_board: z.ZodOptional<z.ZodString>;
+        epics_board: z.ZodOptional<z.ZodString>;
+        bugs_board: z.ZodOptional<z.ZodString>;
+        releases_board: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    checks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodEnum<{
+            tasks_board_exists: "tasks_board_exists";
+            tasks_status_column_present: "tasks_status_column_present";
+            tasks_status_labels_canonical: "tasks_status_labels_canonical";
+            sprints_board_exists: "sprints_board_exists";
+            sprints_date_columns_present: "sprints_date_columns_present";
+            epics_board_exists: "epics_board_exists";
+            releases_board_exists: "releases_board_exists";
+            bugs_board_exists: "bugs_board_exists";
+            tasks_to_sprints_relation: "tasks_to_sprints_relation";
+            tasks_to_epics_relation: "tasks_to_epics_relation";
+        }>;
+        status: z.ZodLiteral<"ok">;
+        message: z.ZodString;
+        details: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodEnum<{
+            tasks_board_exists: "tasks_board_exists";
+            tasks_status_column_present: "tasks_status_column_present";
+            tasks_status_labels_canonical: "tasks_status_labels_canonical";
+            sprints_board_exists: "sprints_board_exists";
+            sprints_date_columns_present: "sprints_date_columns_present";
+            epics_board_exists: "epics_board_exists";
+            releases_board_exists: "releases_board_exists";
+            bugs_board_exists: "bugs_board_exists";
+            tasks_to_sprints_relation: "tasks_to_sprints_relation";
+            tasks_to_epics_relation: "tasks_to_epics_relation";
+        }>;
+        status: z.ZodLiteral<"warn">;
+        message: z.ZodString;
+        details: z.ZodNullable<z.ZodObject<{
+            reason: z.ZodOptional<z.ZodEnum<{
+                not_in_mapping: "not_in_mapping";
+                not_accessible: "not_accessible";
+                board_deleted: "board_deleted";
+                no_tasks_board: "no_tasks_board";
+                no_sprints_board: "no_sprints_board";
+                no_status_column: "no_status_column";
+                no_date_columns: "no_date_columns";
+                no_relation_column: "no_relation_column";
+                no_matching_relation: "no_matching_relation";
+                no_target_board: "no_target_board";
+                settings_unparseable: "settings_unparseable";
+            }>>;
+        }, z.core.$loose>>;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodEnum<{
+            tasks_board_exists: "tasks_board_exists";
+            tasks_status_column_present: "tasks_status_column_present";
+            tasks_status_labels_canonical: "tasks_status_labels_canonical";
+            sprints_board_exists: "sprints_board_exists";
+            sprints_date_columns_present: "sprints_date_columns_present";
+            epics_board_exists: "epics_board_exists";
+            releases_board_exists: "releases_board_exists";
+            bugs_board_exists: "bugs_board_exists";
+            tasks_to_sprints_relation: "tasks_to_sprints_relation";
+            tasks_to_epics_relation: "tasks_to_epics_relation";
+        }>;
+        status: z.ZodLiteral<"fail">;
+        message: z.ZodString;
+        details: z.ZodObject<{
+            reason: z.ZodEnum<{
+                not_in_mapping: "not_in_mapping";
+                not_accessible: "not_accessible";
+                board_deleted: "board_deleted";
+                no_tasks_board: "no_tasks_board";
+                no_sprints_board: "no_sprints_board";
+                no_status_column: "no_status_column";
+                no_date_columns: "no_date_columns";
+                no_relation_column: "no_relation_column";
+                no_matching_relation: "no_matching_relation";
+                no_target_board: "no_target_board";
+                settings_unparseable: "settings_unparseable";
+            }>;
+        }, z.core.$loose>;
+    }, z.core.$strict>], "status">>;
+    summary: z.ZodObject<{
+        ok_count: z.ZodNumber;
+        warn_count: z.ZodNumber;
+        fail_count: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * Inputs to {@link discoverDevBoards}.
+ *
+ * `workspaceId` is optional — when set, the discovery walker scopes
+ * to that workspace via Monday's `boards(workspace_ids: [...])`
+ * arg; when unset, it walks every board the user has access to.
+ * M26a IMPL pinned the walker cadence at `DISCOVER_PAGE_LIMIT` 200
+ * entries per page with a hard `DISCOVER_PAGE_CAP` of 50 pages
+ * (10000 boards max — comfortably above any realistic dev
+ * workspace).
+ */
+export interface DiscoverDevBoardsInputs {
+    readonly client: MondayClient;
+    readonly workspaceId?: string;
+}
+/**
+ * Result of {@link discoverDevBoards}. Carries the candidate list
+ * + the grouped per-noun match results so the `dev discover`
+ * action can emit the {@link DevDiscoverOutput} envelope after
+ * deciding whether `--apply` writes the mapping to the active
+ * profile.
+ *
+ * `source` / `cacheAgeSeconds` / `complexity` mirror the M23
+ * {@link FetchBoardFavoritesResult} envelope-meta pin — discover
+ * is a pure live read with no per-call cache; `complexity` is the
+ * LAST page's complexity slot (under `--verbose`).
+ */
+export interface DiscoverDevBoardsResult {
+    readonly candidates: readonly DiscoverBoardCandidate[];
+    readonly matches: readonly DevNounMatchResult[];
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Walks the user's accessible boards (optionally scoped to
+ * `workspaceId`) and groups them by dev-noun via the heuristic.
+ *
+ * **Walker contract.** Pages through `boards(limit:, page:, state:
+ * all[, workspace_ids:])` until a short page indicates the end of
+ * results OR the page cap is reached. Per the M26a IMPL handoff,
+ * `state: all` is passed so archived / deleted boards surface to the
+ * heuristic too — the action body surfaces them on
+ * {@link DevDiscoverOutput.matches} for agent-side review. The
+ * walker silently drops `Board.type !== 'board'` rows
+ * (`sub_items_board` virtual boards, `custom_object` entries,
+ * `document` entries) since those aren't valid dev-noun mapping
+ * targets — see the module docstring for the empirical-probe
+ * rationale.
+ */
+export declare const discoverDevBoards: (inputs: DiscoverDevBoardsInputs) => Promise<DiscoverDevBoardsResult>;
+/**
+ * Inputs to {@link runDevDoctor}.
+ */
+export interface RunDevDoctorInputs {
+    readonly client: MondayClient;
+    readonly profile: string;
+    readonly mapping: DevMapping;
+}
+/**
+ * Result of {@link runDevDoctor}. Mirrors the {@link DevDoctorOutput}
+ * envelope minus the action-owned `profile` + `mapping` echo (the
+ * action body re-echoes these from its own inputs so the doctor
+ * resolver stays narrow). `source` / `cacheAgeSeconds` /
+ * `complexity` mirror the M23 envelope-meta pin.
+ */
+export interface RunDevDoctorResult {
+    readonly checks: readonly DevDoctorCheckResult[];
+    readonly summary: DevDoctorOutput['summary'];
+    readonly source: 'live';
+    readonly cacheAgeSeconds: null;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Internal wire-row shape for the doctor's per-board hydration call.
+ * Carries the columns + state needed for the 10 pinned checks.
+ */
+declare const rawDoctorColumnSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodString;
+    settings_str: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+type RawDoctorColumn = z.infer<typeof rawDoctorColumnSchema>;
+/**
+ * Runs every {@link DEV_DOCTOR_CHECK_NAMES} check against the
+ * `inputs.mapping`. Returns a per-check result list + a summary
+ * count. One `boards(ids:)` call hydrates every configured board's
+ * metadata; the 10 checks operate over the hydrated data.
+ *
+ * The verb's exit code stays 0 regardless of per-check `fail`
+ * counts — `dev doctor`'s success is "diagnostics completed";
+ * agents inspect `data.summary.fail_count` for drift.
+ * `dev_board_misconfigured` is reserved for the case where the
+ * doctor itself can't complete (no boards hydrated at all, etc.) —
+ * not surfaced here at this milestone (no configured boards = empty
+ * mapping = every `<noun>_board_exists` check fails, which is the
+ * correct diagnostic signal).
+ */
+export declare const runDevDoctor: (inputs: RunDevDoctorInputs) => Promise<RunDevDoctorResult>;
+/**
+ * Reads the active profile's `[profiles.<name>.dev]` block. Throws
+ * `dev_not_configured` when:
+ *   - no `config.toml` exists at all (`details.reason:
+ *     "no_config_file"`),
+ *   - the named profile is absent from the config
+ *     (`details.reason: "profile_absent"`), OR
+ *   - the named profile exists but has no `dev` sub-block
+ *     (`details.reason: "no_dev_block"`).
+ *
+ * Each surface points the agent at `monday dev configure` /
+ * `monday dev discover --apply` via `details.hint`.
+ */
+export declare const loadDevMapping: (profile: string, options?: ProfilesRootOptions) => Promise<DevMapping>;
+/**
+ * Atomically writes the supplied `mapping` into
+ * `profiles[profile].dev` in `~/.monday-cli/config.toml`. Creates
+ * the file (and the named profile entry) if absent.
+ *
+ * **TOML round-trip behavior.** `smol-toml`'s `stringify` produces
+ * canonical TOML output — comments and bespoke formatting from the
+ * original file are NOT preserved. This is a contract correction
+ * vs the M26 pre-flight docstring claim (to be flagged in the
+ * M26a close-docs sweep's post-mortem). Mitigation: most config.toml
+ * files are CLI-managed (`monday auth login` populates the
+ * credentials side; this helper populates the dev side), so the
+ * comment-preservation concern is narrow. A future v0.4 string-
+ * surgery write path could preserve comments outside the dev block
+ * if user demand surfaces.
+ *
+ * **Disk discipline (mirrors `src/config/credentials.ts`):**
+ *   1. `mkdir({ recursive: true, mode: 0o700 })` + explicit `chmod
+ *      0o700` on the parent dir.
+ *   2. `writeFile(tmpPath, payload, { mode: 0o600 })`.
+ *   3. `chmod(tmpPath, 0o600)` (re-applied since `writeFile`'s
+ *      `mode` is advisory under umask).
+ *   4. `rename(tmpPath, finalPath)` (atomic on the same filesystem).
+ *
+ * **Idempotent:** re-writing the same mapping produces the same
+ * bytes (modulo formatting). When `mapping` carries every existing
+ * slot at the same value, the write is functionally a no-op.
+ */
+export declare const saveDevMapping: (profile: string, mapping: DevMapping, options?: ProfilesRootOptions) => Promise<void>;
+/**
+ * Sprint date-range state literal — `active` (today within range),
+ * `past` (range ended before today), `future` (range starts after
+ * today). Surfaced as the argv shape for `dev sprint list --state`
+ * + the classification output of {@link classifySprint}.
+ *
+ * R-NEW-38 lift (post-M26b drift sweep): hoisted from
+ * `commands/dev/sprint/list.ts:_internals` after the 3-consumer
+ * threshold fired across `sprint/list.ts` + `sprint/current.ts` +
+ * `task/list.ts` (the verb-file-to-verb-file cross-import via
+ * `_internals` was the anti-pattern that surfaced the lift).
+ */
+export declare const SPRINT_STATE_LITERALS: readonly ["active", "past", "future"];
+export type SprintState = (typeof SPRINT_STATE_LITERALS)[number];
+/**
+ * Parses a YYYY-MM-DD string into an epoch-ms day boundary (UTC).
+ * NaN-guards per the M24 round-2 P3-1 precedent (`4c83860`) —
+ * returns `null` on an unparseable / malformed date so the caller
+ * falls through to the `past` default rather than emitting NaN-
+ * shaped state buckets.
+ */
+export declare const dayEpoch: (raw: string | null | undefined) => number | null;
+export interface SprintDateRange {
+    readonly start: number;
+    readonly end: number;
+}
+/**
+ * Extracts a sprint's date range from its projected columns. Prefers
+ * a `timeline` column (parses `value.from` / `value.to`); falls back
+ * to the first two `date` columns sorted by id (single date column
+ * = single-day range; reversed start/end auto-normalised by epoch).
+ * Returns `null` when no usable date columns are present.
+ */
+export declare const extractDateRange: (item: ProjectedItem) => SprintDateRange | null;
+/**
+ * Classifies a sprint's state from its date range + the current
+ * day's epoch. Sprints without a resolvable date range default to
+ * `past` so a `--state past` filter catches misconfigured rows
+ * (the structural drift is diagnosed via `dev doctor`'s
+ * `sprints_date_columns_present` check; no warning code).
+ */
+export declare const classifySprint: (range: SprintDateRange | null, todayEpoch: number) => SprintState;
+/**
+ * Walks every page of `items_page` on the supplied board and projects
+ * the rows through the M4 {@link projectItem} contract. Used by the
+ * read-side dev workflow verbs (`dev sprint list/items/current`,
+ * `dev epic list/items`, `dev release list`, `dev task list`).
+ *
+ * Skips board-metadata cache loading — dev verbs don't expose
+ * `--columns` selection, and the items_page rows include
+ * `column { title }` per the {@link ITEM_FIELDS_FRAGMENT}, so the
+ * fallback title path on {@link projectItem} is sufficient. Returns
+ * the `complexity` from the *last* response so the verb's success
+ * envelope reflects the freshest budget snapshot per `cli-design.md`
+ * §6.1 — mirrors the {@link paginate} walker's idiom.
+ */
+export declare const walkDevBoardItems: (inputs: {
+    readonly client: MondayClient;
+    readonly boardId: string;
+    readonly operationName: string;
+    readonly queryParams?: Readonly<Record<string, unknown>>;
+    readonly now: () => Date;
+}) => Promise<{
+    readonly items: readonly ProjectedItem[];
+    readonly complexity: Complexity | null;
+}>;
+/**
+ * Hydrates one board's `columns { id title type settings_str }` slot
+ * via a single `boards(ids:)` call. Used by mutation verbs
+ * (`dev task start/done/block`) to resolve the status column ID +
+ * label vocabulary, and by the relation-filter verbs
+ * (`dev sprint items`, `dev epic items`) to find the board_relation
+ * column linking the tasks board to a target.
+ */
+export declare const hydrateDevBoardColumns: (client: MondayClient, boardId: string, operationName: string) => Promise<{
+    readonly columns: readonly RawDoctorColumn[];
+    readonly complexity: Complexity | null;
+}>;
+/**
+ * Walks `columns` looking for a `board_relation` column whose
+ * `settings_str.boardIds` (or `board_ids`) array includes
+ * `targetBoardId`. Returns the first match or `undefined`.
+ *
+ * Same `settings_str` parse as the doctor's
+ * `checkBoardRelation` — pinned at M26a IMPL. Lifted here for
+ * reuse by `dev sprint items` and `dev epic items`.
+ */
+export declare const findRelationColumnIdToBoard: (columns: readonly {
+    readonly id: string;
+    readonly type: string;
+    readonly settings_str: string | null;
+}[], targetBoardId: string) => string | undefined;
+/**
+ * Extracts linked item IDs (as decimal strings) from a board_relation
+ * column's parsed `value` JSON. Monday's wire shape is one of:
+ *   - `{linkedPulseIds: [{linkedPulseId: 123 | "123"}, ...]}`
+ *   - `{item_ids: [123 | "123", ...]}` (newer 2026-01 shape)
+ * Returns an empty array on null / malformed / unrecognised shape.
+ */
+export declare const extractLinkedItemIds: (value: unknown) => readonly string[];
+/**
+ * Finds the status (or color) column on a board. Returns the column
+ * + the parsed labels (id → label text). Throws
+ * `dev_board_misconfigured` with `reason: 'no_status_column'` when
+ * no status column is present (mirrors the doctor's
+ * `tasks_status_column_present` fail surface; if doctor passes, this
+ * lookup also passes).
+ */
+export declare const resolveStatusColumn: (boardId: string, columns: readonly RawDoctorColumn[]) => {
+    readonly columnId: string;
+    readonly labels: ReadonlyMap<string, string>;
+};
+/**
+ * Canonical status labels Monday Dev's stock Tasks template surfaces.
+ * The three task mutation verbs (`dev task start/done/block`) flip
+ * the status column to one of these. Exported for the
+ * {@link flipTaskStatus} helper + the verbs that import the literal
+ * union for argv shapes.
+ */
+export type DevTaskCanonicalLabel = 'Working on it' | 'Done' | 'Stuck';
+/**
+ * Resolves a canonical Monday Dev status label ("Working on it" /
+ * "Done" / "Stuck") to the actual label text written on the
+ * configured status column — case-insensitive match. Returns the
+ * exact stored form so the subsequent
+ * `change_simple_column_value` flips against bytes Monday accepts
+ * (the wire is case-sensitive on the value).
+ *
+ * Throws `dev_board_misconfigured` with
+ * `reason: 'no_status_column'` when the canonical label isn't
+ * present on the column — points at `monday dev doctor` for
+ * diagnostics. (Mirrors the doctor's
+ * `tasks_status_labels_canonical` warn surface; the doctor's warn
+ * doesn't block a workflow verb at the doctor layer, but the
+ * workflow verb itself can't proceed without a matching label.)
+ */
+export declare const resolveCanonicalLabel: (boardId: string, columnId: string, labels: ReadonlyMap<string, string>, canonical: DevTaskCanonicalLabel) => string;
+export interface DevCreateUpdateResult {
+    readonly updateId: string;
+    readonly complexity: Complexity | null;
+}
+/**
+ * Fires the `create_update` mutation for a dev task side-effect
+ * (`task done --message` / `task block --reason`) and returns the
+ * created update's ID + the wire complexity. Shared by both verbs
+ * (3-consumer threshold not yet reached, but the parse-boundary
+ * discipline matters at every site).
+ *
+ * Throws `internal_error` when Monday's response carries
+ * `create_update: null` (the documented null-payload escape hatch
+ * for failed update creation; mirrors M5b's `internal_error` shape
+ * per `item-mutation-result.ts`'s `caller_handles` semantics).
+ */
+export declare const fireDevCreateUpdate: (inputs: {
+    readonly client: MondayClient;
+    readonly itemId: string;
+    readonly body: string;
+    readonly operationName: string;
+}) => Promise<DevCreateUpdateResult>;
+export declare const flipTaskStatus: (inputs: {
+    readonly client: MondayClient;
+    readonly tasksBoard: string;
+    readonly itemId: string;
+    readonly canonical: DevTaskCanonicalLabel;
+    readonly hydrateOperation: string;
+}) => Promise<{
+    readonly projected: ProjectedItem;
+    readonly columnId: string;
+    readonly label: string;
+    readonly complexity: Complexity | null;
+}>;
+export {};
+//# sourceMappingURL=dev-conventions.d.ts.map