@nikovirtala/adr 0.0.0 → 0.1.0

package/dist/types/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/config.d.ts

@@ -0,0 +1,25 @@
+import { type Severity, type ToolConfig } from "@nikovirtala/ledger";
+/** adr's settings from `adr.toml` (design §5.3); every key is optional. */
+export interface AdrConfig {
+    /** `[log] default_template`: the template `adr new` uses without `--template`. */
+    readonly defaultTemplate: string;
+    /** `[log] main_branch`: the ref numbers come from; `null` resolves it automatically. */
+    readonly mainBranch: string | null;
+    /** `[log] index`: validated now, used in phase 2. */
+    readonly index: "committed" | "none";
+    /** `[policy] accept_requires_human`. */
+    readonly acceptRequiresHuman: boolean;
+    /** `[policy] auto_commit`: commit writes without `--commit`. */
+    readonly autoCommit: boolean;
+    /** `[policy] mcp_can_decide`: validated now, used in phase 3. */
+    readonly mcpCanDecide: boolean;
+    /** `[verify] fail_on`. */
+    readonly failOn: Severity;
+}
+export declare const DEFAULT_ADR_CONFIG: AdrConfig;
+/**
+ * Validates `adr.toml` (ledger's parsed `ToolConfig`; `null` when there is none). A wrong type or
+ * value throws `ConfigError` naming the file and key. Unknown keys are ignored, so newer files
+ * still load. `[log] root` is ledger's (`openToolLog` already checked it).
+ */
+export declare function parseAdrConfig(config: ToolConfig | null, file: string | null): AdrConfig;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export { type AdrConfig, DEFAULT_ADR_CONFIG, parseAdrConfig } from "./config.js";
+export { type AdrOptions, adrKind, DECISION_STATUSES, type DecisionEvents, type DecisionState, type DecisionStatus, type DecisionView, formatDecisionNumber, type LinkRel, parseDecisionNumber, REF, } from "./kind.js";
+export { type DecisionLog, type DecisionsRead, openDecisionLog, readDecisions, readDecisionsFrom, resolveDecision, } from "./log.js";
+export { adrChecks, verifyDecisions } from "./verify.js";
+export { type DecisionListJson, type DecisionShowJson, listDecisions, type NumberingJson, showDecision, stateHeader, } from "./views.js";
+export { acceptDecision, type ProposeInput, proposeDecision, supersedeDecision, type WriteResultJson, } from "./write.js";

package/dist/types/kind/project.d.ts

@@ -0,0 +1,50 @@
+import type { FoldedSubject, ProjectContext } from "@nikovirtala/ledger";
+import type { DecisionState } from "./reduce.js";
+import type { DecisionEvents, DecisionStatus } from "./schemas.js";
+/** One decision as the CLI, the library and MCP show it (01:173–192, plus the added fields). */
+export interface DecisionView {
+    readonly id: string;
+    readonly number: number | null;
+    /** `ADR-0007`, or the id when unnumbered. */
+    readonly display: string;
+    readonly title: string;
+    readonly status: DecisionStatus;
+    readonly superseded_by: string | null;
+    /** Ids whose applied `superseded.by` is this id, sorted. */
+    readonly supersedes: readonly string[];
+    /** The proposal's intent (01:164). */
+    readonly declared_supersedes: readonly string[];
+    /** Head of the `superseded_by` chain; `null` only on a cycle. */
+    readonly effective: string | null;
+    /** `[id, …, effective]`, following `superseded_by` forward. */
+    readonly chain: readonly string[];
+    readonly template: {
+        readonly name: string;
+        readonly version: number;
+    };
+    readonly body_path: string | null;
+    /** Recorded at acceptance. */
+    readonly body_sha256: string | null;
+    /** `null` until accepted; whether the current body hash equals the recorded one. */
+    readonly body_intact: boolean | null;
+    readonly links: readonly {
+        readonly to: string;
+        readonly rel: string;
+    }[];
+    readonly applies_to: readonly string[];
+    readonly notes: number;
+    readonly proposed_at: string;
+    readonly decided_at: string | null;
+    readonly status_at: string;
+    /** `proposed 2026-03-12`: state-changing events, in fold order. */
+    readonly history: readonly string[];
+}
+type Subject = FoldedSubject<DecisionStatus, DecisionState, DecisionEvents>;
+type Context = ProjectContext<DecisionStatus, DecisionState, DecisionEvents>;
+/** `ADR-0007`: at least 4 digits, growing past 9999. */
+export declare function formatDecisionNumber(n: number): string;
+/** `7`, `0007`, `ADR-7`, `adr-0007` → 7; `null` for anything else. */
+export declare function parseDecisionNumber(s: string): number | null;
+/** Pure: the view of one folded decision. */
+export declare function project(subject: Subject, ctx: Context): DecisionView;
+export {};

package/dist/types/kind/reduce.d.ts

@@ -0,0 +1,35 @@
+import type { Actor, FoldEvent } from "@nikovirtala/ledger";
+import type { DecisionEvents } from "./schemas.js";
+/** A decision's own state, maintained by `reduce` over its applied events. */
+export interface DecisionState {
+    readonly title: string;
+    readonly template: {
+        readonly name: string;
+        readonly version: number;
+    };
+    readonly declaredSupersedes: readonly string[];
+    /** From the applied `accepted` event. */
+    readonly bodySha256: string | null;
+    readonly acceptedBy: Actor | null;
+    readonly supersededBy: string | null;
+    /** In fold order, duplicates kept once. */
+    readonly links: readonly {
+        readonly to: string;
+        readonly rel: string;
+    }[];
+    /** The latest `scoped` set (latest wins). */
+    readonly appliesTo: readonly string[];
+    readonly notes: number;
+    /** State-changing events only, in fold order. */
+    readonly history: readonly {
+        readonly type: string;
+        readonly at: string;
+    }[];
+    readonly proposedAt: string;
+    /** `at` of `accepted`, `rejected` or `withdrawn`. */
+    readonly decidedAt: string | null;
+    /** `at` of the latest state-changing event. */
+    readonly statusAt: string;
+}
+/** Pure: the state after one applied event. The fold only passes events the machine allows. */
+export declare function reduce(state: DecisionState | null, e: FoldEvent<DecisionEvents>): DecisionState;

package/dist/types/kind/rules.d.ts

@@ -0,0 +1,20 @@
+import type { FoldedLog, FoldedSubject, KindFinding } from "@nikovirtala/ledger";
+import type { DecisionState } from "./reduce.js";
+import type { DecisionEvents, DecisionStatus } from "./schemas.js";
+/** Options of the decision kind's `invariants` and `relate`. */
+export interface AdrOptions {
+    /** Default `true`: an agent may propose, but only a human may accept (01:98). */
+    readonly acceptRequiresHuman: boolean;
+}
+type Subject = FoldedSubject<DecisionStatus, DecisionState, DecisionEvents>;
+type Log = FoldedLog<DecisionStatus, DecisionState, DecisionEvents>;
+/** `decision/agent-accepted`: an applied `accepted` event written by an agent under the human policy. */
+export declare function invariants(subject: Subject, options: AdrOptions): readonly KindFinding[];
+/**
+ * Cross-subject rules: `decision/reference-missing` for a local `supersedes`, `superseded.by` or
+ * `linked.to` naming no subject in the log; `decision/superseded-by-unaccepted` when the target of
+ * an applied `superseded.by` has no applied `accepted` event in this tree; and
+ * `decision/supersession-cycle`, once per cycle on its smallest id.
+ */
+export declare function relate(log: Log): readonly KindFinding[];
+export {};

package/dist/types/kind/schemas.d.ts

@@ -0,0 +1,37 @@
+/** A decision's computed status. */
+export type DecisionStatus = "proposed" | "accepted" | "rejected" | "withdrawn" | "deprecated" | "superseded";
+/** Every status, in lifecycle order. */
+export declare const DECISION_STATUSES: readonly DecisionStatus[];
+/** A local subject id, or a qualified `<source>:<id>` one. */
+export declare const REF = "^(?:[a-z][a-z0-9-]*:)?[0-9a-hjkmnp-tv-z]{8}$";
+/** How a `linked` decision relates to its target. */
+export type LinkRel = "relates-to" | "refines" | "depends-on";
+/** The decision kind's event types (01:128–136): data schemas, allowed states and targets. */
+export declare const decisionEvents: {
+    readonly proposed: import("@nikovirtala/ledger").EventTypeDef<"proposed", {
+        title: string;
+        template: string;
+        template_version: number;
+        supersedes?: string[];
+    }>;
+    readonly accepted: import("@nikovirtala/ledger").EventTypeDef<"accepted" | "proposed", {
+        body_sha256: string;
+    }>;
+    readonly rejected: import("@nikovirtala/ledger").EventTypeDef<"proposed" | "rejected", Record<string, never>>;
+    readonly withdrawn: import("@nikovirtala/ledger").EventTypeDef<"proposed" | "withdrawn", Record<string, never>>;
+    readonly deprecated: import("@nikovirtala/ledger").EventTypeDef<"accepted" | "deprecated", Record<string, never>>;
+    readonly superseded: import("@nikovirtala/ledger").EventTypeDef<"accepted" | "deprecated" | "superseded", {
+        by: string;
+    }>;
+    readonly noted: import("@nikovirtala/ledger").EventTypeDef<never, {
+        text: string;
+    }>;
+    readonly linked: import("@nikovirtala/ledger").EventTypeDef<never, {
+        to: string;
+        rel: LinkRel;
+    }>;
+    readonly scoped: import("@nikovirtala/ledger").EventTypeDef<"accepted" | "deprecated" | "proposed", {
+        set: string[];
+    }>;
+};
+export type DecisionEvents = typeof decisionEvents;

package/dist/types/kind.d.ts

@@ -0,0 +1,18 @@
+import { type Kind } from "@nikovirtala/ledger";
+import { type DecisionView } from "./kind/project.js";
+import { type DecisionState } from "./kind/reduce.js";
+import { type AdrOptions } from "./kind/rules.js";
+import { type DecisionEvents, type DecisionStatus } from "./kind/schemas.js";
+export type { DecisionView } from "./kind/project.js";
+export { formatDecisionNumber, parseDecisionNumber } from "./kind/project.js";
+export type { DecisionState } from "./kind/reduce.js";
+export type { AdrOptions } from "./kind/rules.js";
+export { DECISION_STATUSES, type DecisionEvents, type DecisionStatus, type LinkRel, REF, } from "./kind/schemas.js";
+/**
+ * The decision kind (01:128–194), as imported by other tools through `@nikovirtala/adr/kind`.
+ *
+ * Decisions are proposed, then accepted (which freezes the body and earns a number on main),
+ * rejected or withdrawn; accepted ones can be deprecated or superseded. This module imports only
+ * `@nikovirtala/ledger` and `./kind/*`, so importing the kind never loads CLI or MCP code.
+ */
+export declare const adrKind: Kind<DecisionStatus, DecisionEvents, DecisionState, DecisionView, AdrOptions>;

package/dist/types/log.d.ts

@@ -0,0 +1,53 @@
+import { type Finding, type FoldedLogOf, type GitOptions, type LogLayout, type Numbering, type Projection, type ToolLog, type TreeReader } from "@nikovirtala/ledger";
+import { type AdrConfig } from "./config.js";
+import { adrKind, type DecisionView } from "./kind.js";
+/** A decision log opened for the CLI or MCP: ledger's tool log plus adr's config. */
+export interface DecisionLog extends ToolLog {
+    readonly adr: AdrConfig;
+}
+/**
+ * Opens the decision log (design D3): `--root`, else `adr.toml`'s `[log] root`, else `docs/adr`;
+ * read from the `ref` tree, the index or the work tree.
+ */
+export declare function openDecisionLog(o: {
+    readonly cwd: string;
+    readonly root?: string | null;
+    readonly ref?: string | null;
+    readonly reader?: "worktree" | "index";
+    readonly gitOptions?: GitOptions;
+}): Promise<DecisionLog>;
+/** One read of a decision log: everything list, show and the write plans need. */
+export interface DecisionsRead {
+    /** The tree that was read, its layout and config; no `Git`, so plans can run on a MemoryTree. */
+    readonly tree: TreeReader;
+    readonly layout: LogLayout;
+    readonly adr: AdrConfig;
+    readonly root: string;
+    readonly ref: string | null;
+    readonly commit: string | null;
+    readonly folded: FoldedLogOf<typeof adrKind>;
+    readonly projection: Projection<DecisionView>;
+    readonly numbering: Numbering;
+    /** Load, transition, invariant and relate findings; no diff-based checks. */
+    readonly findings: readonly Finding[];
+    /** How the log was located (`ToolLog.notes`); `[]` for a MemoryTree read. */
+    readonly notes: readonly string[];
+}
+/** `numberLog` on the repository, then `readDecisionsFrom(log.tree, …)`. */
+export declare function readDecisions(log: DecisionLog): Promise<DecisionsRead>;
+/** The git-free core of `readDecisions`; tests pass a MemoryTree and a hand-made `Numbering`. */
+export declare function readDecisionsFrom(tree: TreeReader, o: {
+    readonly layout: LogLayout;
+    readonly adr: AdrConfig;
+    readonly numbering: Numbering;
+    readonly ref?: string | null;
+    readonly commit?: string | null;
+    readonly notes?: readonly string[];
+}): Promise<DecisionsRead>;
+/** Why numbers are unavailable, in words: `shallow clone` or `no main branch`. */
+export declare function unavailableReason(n: Numbering): string;
+/**
+ * The id a decision argument names: an id, or a number in any form `parseDecisionNumber` takes.
+ * Throws `UsageError` (exit 2) naming the reason when it names nothing.
+ */
+export declare function resolveDecision(read: DecisionsRead, input: string): string;

package/dist/types/templates/builtin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The built-in decision templates, version 1 (design §5.7). `adr new` copies the one it uses into
+ * `<root>/templates/<name>.md` on first use, so the team owns it and its versions live in git
+ * (D4). Every section is required unless marked optional, and each has a required Scope section
+ * (01:311).
+ */
+/** The built-in templates by name: the file text `adr new` materializes. */
+export declare const BUILTIN_TEMPLATES: Readonly<Record<string, string>>;

package/dist/types/verify.d.ts

@@ -0,0 +1,10 @@
+import { type Check, type Finding, type VerifyMode } from "@nikovirtala/ledger";
+import type { DecisionLog } from "./log.js";
+/**
+ * Every phase-1 check for the log: ledger's mechanical and fold checks with adr's actor policy,
+ * and template lint against the templates in the head tree and, for older versions, the history
+ * of `historyRef`.
+ */
+export declare function adrChecks(log: DecisionLog, historyRef: string | null): readonly Check[];
+/** Verifies the decision log in `mode` (staged, range or full) with `adrChecks`. */
+export declare function verifyDecisions(log: DecisionLog, mode: VerifyMode): Promise<Finding[]>;

package/dist/types/views.d.ts

@@ -0,0 +1,63 @@
+import { type EventEnvelope, type Finding, type StateHeader } from "@nikovirtala/ledger";
+import type { DecisionStatus, DecisionView } from "./kind.js";
+import type { DecisionsRead } from "./log.js";
+/** The `numbering` key of the read documents. */
+export interface NumberingJson {
+    readonly available: boolean;
+    readonly reason: "shallow" | "no-main-ref" | null;
+    readonly ref: string | null;
+}
+/** `adr list --json` (design §5.5). */
+export interface DecisionListJson {
+    readonly format: "adr-list/v1";
+    readonly root: string;
+    readonly ref: string | null;
+    readonly commit: string | null;
+    readonly numbering: NumberingJson;
+    readonly decisions: readonly DecisionView[];
+    /** Newer envelope or schema versions; upgrade adr. */
+    readonly unreadable: readonly string[];
+    /** First event not `proposed`, or a body with no events; run adr verify. */
+    readonly unfoldable: readonly string[];
+    readonly findings: readonly Finding[];
+    readonly notes: readonly string[];
+}
+/** `adr show <decision> --json` (design §5.5). */
+export interface DecisionShowJson {
+    readonly format: "adr-show/v1";
+    readonly root: string;
+    readonly ref: string | null;
+    readonly commit: string | null;
+    readonly numbering: NumberingJson;
+    readonly header: StateHeader;
+    readonly decision: DecisionView;
+    readonly body: string | null;
+    /** Every valid event in fold order with `history`, else `null`. */
+    readonly events: readonly EventEnvelope[] | null;
+    readonly findings: readonly Finding[];
+    readonly notes: readonly string[];
+}
+/**
+ * The `adr-list/v1` document: decisions in list order, filtered by `status` and truncated to
+ * `limit` after ordering. `findings` are those of the listed decisions and of the log as a whole.
+ */
+export declare function listDecisions(read: DecisionsRead, o?: {
+    readonly status?: readonly DecisionStatus[];
+    readonly limit?: number;
+}): DecisionListJson;
+/**
+ * The `adr-show/v1` document of the decision `id` (resolve it with `resolveDecision` first).
+ * Throws `UsageError` for an unknown, unreadable or unfoldable decision.
+ */
+export declare function showDecision(read: DecisionsRead, id: string, o?: {
+    readonly history?: boolean;
+}): Promise<DecisionShowJson>;
+/**
+ * The state header (01:258–259): `<display> (<id>) · <status>`, and for a decision that isn't in
+ * force a warning saying what to read instead. `refer` names where to read another decision. CLI
+ * default: `display(id)`. Phase 3 MCP passes `id => "adr://decision/" + display(id)`, e.g.
+ * `adr://decision/ADR-0012`, or the id when unnumbered.
+ */
+export declare function stateHeader(view: DecisionView, read: DecisionsRead, o?: {
+    readonly refer?: (id: string) => string;
+}): StateHeader;

package/dist/types/write.d.ts

@@ -0,0 +1,171 @@
+import { type Actor, type EventEnvelope, type Finding, type Template, type TemplateSource, type Trailer } from "@nikovirtala/ledger";
+import { type DecisionView } from "./kind.js";
+import { type DecisionLog, type DecisionsRead } from "./log.js";
+/** `adr new|accept|supersede --json` (design §5.5). */
+export interface WriteResultJson {
+    readonly format: "adr-write/v1";
+    readonly command: "new" | "accept" | "supersede";
+    readonly ok: boolean;
+    /**
+     * The decision after the write; before it when `ok` is false (`null` for a refused `new`).
+     * After a commit it is read again from the log, so an acceptance committed on the main ref
+     * carries its number; otherwise `number` is `null` until the acceptance lands on main.
+     */
+    readonly decision: DecisionView | null;
+    /** Each decision superseded by this write, after it (read again after a commit, like `decision`). */
+    readonly affected: readonly DecisionView[];
+    /** Repo-relative paths this command wrote, in write order. */
+    readonly written: readonly string[];
+    readonly commit: string | null;
+    /** Refusal findings when `ok` is false; the draft's template lint for `new` (informational). */
+    readonly findings: readonly Finding[];
+    /** How the log was located (`ToolLog.notes`). */
+    readonly notes: readonly string[];
+}
+export interface ProposeInput {
+    readonly title: string;
+    /** Default `[log] default_template`. */
+    readonly template?: string;
+    /** Section id → markdown. */
+    readonly sections?: Readonly<Record<string, string>>;
+    /** Decisions this one is meant to replace, as ids or numbers. */
+    readonly supersedes?: readonly string[];
+    readonly actor: Actor;
+}
+/** What a plan needs besides the read: a clock, randomness and templates. */
+export interface PlanContext {
+    /** Clock for `nextEventIdentity`. */
+    readonly now: () => number;
+    /** ULID and subject-id randomness. */
+    readonly random?: (buf: Uint8Array) => void;
+    /** Drafts' recorded template versions. */
+    readonly templates: TemplateSource;
+    /** Built-in template texts by name (§5.7), for `new`. */
+    readonly builtins: Readonly<Record<string, string>>;
+}
+/** Everything one write command does, computed without touching git or the disk. */
+export interface WritePlan {
+    readonly command: "new" | "accept" | "supersede" | "event";
+    readonly subject: string;
+    /** New files, repo-relative path → bytes, in write order: body, materialized template, events. */
+    readonly files: Readonly<Record<string, Uint8Array>>;
+    readonly events: readonly EventEnvelope[];
+    /** Paths to stage: every new file, plus the existing body for accept. */
+    readonly stage: readonly string[];
+    /** Subject ids involved (D6): the subject, every superseded target, and `by` for supersede. Sorted. */
+    readonly involved: readonly string[];
+    /** Per involved subject: its body, its events dir and its recorded template. Sorted, deduplicated. */
+    readonly commitScope: readonly string[];
+    /** The events directories in `commitScope`, sorted; the rest of `commitScope` are file paths. */
+    readonly eventDirs: readonly string[];
+    /** For new: the body path, the rendered bytes and the template, for the editor step. */
+    readonly draft: {
+        readonly path: string;
+        readonly rendered: Uint8Array;
+        readonly template: Template;
+    } | null;
+    /** The D6 commit message. */
+    readonly message: string;
+    /** One `ADR`/`ADR-Event` pair per plan event, in write order. */
+    readonly trailers: readonly Trailer[];
+    /** Views after the write, computed on `overlayTree(read.tree, files)`. */
+    readonly decision: DecisionView;
+    readonly affected: readonly DecisionView[];
+    /** Informational (new: the draft's template lint). */
+    readonly findings: readonly Finding[];
+}
+export type PlanResult = {
+    readonly ok: true;
+    readonly plan: WritePlan;
+} | {
+    readonly ok: false;
+    readonly decision: DecisionView | null;
+    readonly findings: readonly Finding[];
+};
+/** Plans `adr new`: a rendered body, a materialized template if needed, and `proposed`. */
+export declare function planPropose(read: DecisionsRead, input: ProposeInput, c: PlanContext): Promise<PlanResult>;
+/** Plans `adr accept`: `accepted` with the body hash, and `superseded` on each declared target. */
+export declare function planAccept(read: DecisionsRead, input: {
+    readonly id: string;
+    readonly actor: Actor;
+}, c: PlanContext): Promise<PlanResult>;
+/** Plans `adr supersede <id> --by <by>`: one `superseded` event on `id`. */
+export declare function planSupersede(read: DecisionsRead, input: {
+    readonly id: string;
+    readonly by: string;
+    readonly reason?: string | null;
+    readonly actor: Actor;
+}, c: PlanContext): Promise<PlanResult>;
+/**
+ * Plans any one event on an existing decision: the state machine and the event's validation
+ * decide, then the precheck. Phase 2's reject, withdraw, deprecate, note, link and scope wrap it.
+ */
+export declare function planEvent(read: DecisionsRead, input: {
+    readonly subject: string;
+    readonly type: string;
+    readonly data: Record<string, unknown>;
+    readonly reason?: string | null;
+    readonly actor: Actor;
+}, c: PlanContext): Promise<PlanResult>;
+/** What the editor step decided (§5.4 step 4a). */
+export interface AfterStage {
+    /** Draft lint findings to report instead of `plan.findings`; `null` keeps `plan.findings`. */
+    readonly findings: readonly Finding[] | null;
+    /** `false` skips the commit: the files stay written and staged, and `commit` is `null`. */
+    readonly commit: boolean;
+}
+/**
+ * Applies a plan (§5.4): refuses a commit whose scope has unstaged or needed untracked paths,
+ * writes the files (removing them again if a write fails), stages them, runs `afterStage`, and
+ * commits `plan.stage` plus the involved subjects' already-staged files with exact trailers.
+ */
+export declare function applyPlan(log: DecisionLog, plan: WritePlan, o: {
+    readonly commit: boolean;
+    readonly afterStage?: () => Promise<AfterStage>;
+}): Promise<{
+    written: string[];
+    commit: string | null;
+    findings: readonly Finding[];
+}>;
+/**
+ * The clock, the randomness and `applyPlan` the write functions use. Only tests pass their own
+ * (for example an `apply` that fails once); the default is the real ones.
+ */
+export interface WriteDeps {
+    readonly now: () => number;
+    readonly random?: (buf: Uint8Array) => void;
+    readonly apply: typeof applyPlan;
+}
+/**
+ * `adr new`: renders a draft, writes the body, any materialized template and the `proposed`
+ * event, stages them, and commits with `commit` (default `[policy] auto_commit`).
+ *
+ * `edit` (CLI only; MCP never passes it) runs between staging and committing, on the absolute
+ * body path. It resolves to `null` when the editor exited 0, else to a note for the user (spawn
+ * error, exit status). `onNote` receives the notes about a skipped commit or a removed body,
+ * without the "not committed: " prefix the CLI adds when a commit was requested.
+ */
+export declare function proposeDecision(log: DecisionLog, input: ProposeInput, o?: {
+    readonly commit?: boolean;
+    readonly edit?: (absBodyPath: string) => Promise<string | null>;
+    readonly onNote?: (note: string) => void;
+}, deps?: WriteDeps): Promise<WriteResultJson>;
+/**
+ * `adr accept`: lints the draft, hashes the body, writes `accepted` and a `superseded` event on
+ * each declared target, stages them with the body, and commits with `commit`.
+ */
+export declare function acceptDecision(log: DecisionLog, input: {
+    readonly id: string;
+    readonly actor: Actor;
+}, o?: {
+    readonly commit?: boolean;
+}, deps?: WriteDeps): Promise<WriteResultJson>;
+/** `adr supersede <id> --by <by>`: writes `superseded`, stages it, and commits with `commit`. */
+export declare function supersedeDecision(log: DecisionLog, input: {
+    readonly id: string;
+    readonly by: string;
+    readonly reason?: string | null;
+    readonly actor: Actor;
+}, o?: {
+    readonly commit?: boolean;
+}, deps?: WriteDeps): Promise<WriteResultJson>;