@kitman-sh/loops 0.0.0-stage → 0.6.0

package/types/packages/loops/src/build.d.ts

@@ -0,0 +1,33 @@
+import * as Schema from 'effect/Schema';
+declare const BuildTargetMissing_base: Schema.Class<BuildTargetMissing, Schema.TaggedStruct<"BuildTargetMissing", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class BuildTargetMissing extends BuildTargetMissing_base {
+}
+/**
+ * Implements a Task or words, reviews and fixes until the rally stops, gates on the evidence for the head, and opens
+ * the Run's ChangeRequest with the evidence, the claims and whatever it could not settle (ADR-0051). It writes the
+ * Run's milestones to its Task: started, ChangeRequest opened, and failed.
+ */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly words?: string | undefined;
+    readonly taskId?: string | undefined;
+    readonly repoBindingId?: string | undefined;
+    readonly branch?: string | undefined;
+    readonly revision?: string | undefined;
+    readonly outcome?: "bug" | "docs" | "feature" | "investigation" | "migration" | "refactor" | undefined;
+    readonly maxRounds?: number | undefined;
+}, {
+    readonly changeRequest: {
+        readonly id: string;
+        readonly number: string;
+        readonly url: string;
+    };
+    readonly revision: string;
+    readonly tree: string;
+    readonly settled: boolean;
+    readonly unsettled: readonly string[];
+    readonly rounds: number;
+    readonly stopped: "dispute_stands" | "findings_returned" | "round_cap" | "settled";
+}, BuildTargetMissing | import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").ChildFailed | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/loops/src/change-request-body.d.ts

@@ -0,0 +1,14 @@
+import type { RallyDecision, SettledRound, VerifyResult } from '@kitman-sh/sdk/loop';
+/** Why each item the rally could not settle is still open. */
+export declare const unsettledItems: (settled: SettledRound, decision: RallyDecision & {
+    readonly stop: true;
+}) => string[];
+/** A ChangeRequest's description: the summary, the head's evidence, the claims and what was left unsettled. */
+export declare const changeRequestBody: (build: {
+    readonly summary: string;
+    readonly head: VerifyResult;
+    readonly claims: readonly string[];
+    readonly unsettled: readonly string[];
+    readonly rounds: number;
+    readonly stopped: string;
+}) => string;

package/types/packages/loops/src/code-quality-pass.d.ts

@@ -0,0 +1,50 @@
+import * as Schema from 'effect/Schema';
+export declare const CodeQualityPasses: readonly ['architecture', 'simplification'];
+export declare const PassInput: Schema.Struct<{
+    readonly pass: Schema.Literals<readonly ["architecture", "simplification"]>;
+    /** The revision to improve; the head of `branch` when left out. */
+    readonly revision: Schema.optional<Schema.String>;
+    /** The branch the ChangeRequest targets; the repository's default branch when left out. */
+    readonly branch: Schema.optional<Schema.String>;
+    readonly repoBindingId: Schema.optional<Schema.String>;
+    /** Where to look, in a few words. */
+    readonly words: Schema.optional<Schema.String>;
+}>;
+export declare const PassOutput: Schema.Struct<{
+    readonly pass: Schema.Literals<readonly ["architecture", "simplification"]>;
+    readonly improved: Schema.Boolean;
+    readonly changeRequest: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly number: Schema.String;
+        readonly url: Schema.String;
+    }>>;
+    readonly revision: Schema.optional<Schema.String>;
+    readonly tree: Schema.optional<Schema.String>;
+    readonly settled: Schema.optional<Schema.Boolean>;
+    readonly unsettled: Schema.optional<Schema.$Array<Schema.String>>;
+}>;
+/**
+ * One Code Quality pass: the agent makes one improvement, the approved verifications run on the starting revision and
+ * on the result, the Review Loop reviews it once, and it ships as its own ChangeRequest with whatever is unsettled.
+ * Nothing changes code after the review, so the reviewed diff is the diff that ships.
+ */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly pass: "architecture" | "simplification";
+    readonly revision?: string | undefined;
+    readonly branch?: string | undefined;
+    readonly repoBindingId?: string | undefined;
+    readonly words?: string | undefined;
+}, {
+    readonly pass: "architecture" | "simplification";
+    readonly improved: boolean;
+    readonly changeRequest?: {
+        readonly id: string;
+        readonly number: string;
+        readonly url: string;
+    } | undefined;
+    readonly revision?: string | undefined;
+    readonly tree?: string | undefined;
+    readonly settled?: boolean | undefined;
+    readonly unsettled?: readonly string[] | undefined;
+}, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").ChildFailed | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/loops/src/code-quality.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Runs an architecture pass and a simplification pass on a revision or the default branch. Each is a Child Run on a
+ * branch of its own, so each improvement is reviewed, gated and delivered as its own ChangeRequest (ADR-0051).
+ * Build never runs these passes; a person chooses Code Quality from a Build's offer, the CLI or a Schedule.
+ */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly revision?: string | undefined;
+    readonly branch?: string | undefined;
+    readonly repoBindingId?: string | undefined;
+    readonly words?: string | undefined;
+}, {
+    readonly improvements: readonly {
+        readonly pass: "architecture" | "simplification";
+        readonly improved: boolean;
+        readonly changeRequest?: {
+            readonly id: string;
+            readonly number: string;
+            readonly url: string;
+        } | undefined;
+        readonly revision?: string | undefined;
+        readonly tree?: string | undefined;
+        readonly settled?: boolean | undefined;
+        readonly unsettled?: readonly string[] | undefined;
+    }[];
+}, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").ChildFailed | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/loops/src/hello.d.ts

@@ -0,0 +1,9 @@
+/** The smallest program Loop: an Activity of its own, a Question and a durable sleep. */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly name: string;
+    readonly napSeconds?: number | undefined;
+}, {
+    readonly greeting: string;
+    readonly mood: string;
+}, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").QuestionRefused | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/loops/src/incident.d.ts

@@ -0,0 +1,13 @@
+import * as Schema from 'effect/Schema';
+/** Investigates an alert to a supported conclusion, then offers to start a Build that fixes it as a bug. */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly alert: {
+        readonly [x: string]: Schema.Json;
+    };
+    readonly repoBindingId?: string | undefined;
+}, {
+    readonly conclusionArtifactId: string;
+    readonly fix: "declined" | "none" | "started";
+    readonly changeRequestUrl?: string | undefined;
+}, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").ChildFailed | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").QuestionRefused | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/loops/src/index.d.ts

@@ -0,0 +1,172 @@
+import build from './build';
+import codeQuality from './code-quality';
+import codeQualityPass from './code-quality-pass';
+import hello from './hello';
+import incident from './incident';
+import plan from './plan';
+import release from './release';
+import research from './research';
+import review from './review';
+/** Kitman's shipped Loops, by id; a fork spreads the one it replaces. */
+export declare const shippedLoops: {
+    readonly build: import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly words?: string | undefined;
+        readonly taskId?: string | undefined;
+        readonly repoBindingId?: string | undefined;
+        readonly branch?: string | undefined;
+        readonly revision?: string | undefined;
+        readonly outcome?: "bug" | "docs" | "feature" | "investigation" | "migration" | "refactor" | undefined;
+        readonly maxRounds?: number | undefined;
+    }, {
+        readonly changeRequest: {
+            readonly id: string;
+            readonly number: string;
+            readonly url: string;
+        };
+        readonly revision: string;
+        readonly tree: string;
+        readonly settled: boolean;
+        readonly unsettled: readonly string[];
+        readonly rounds: number;
+        readonly stopped: "dispute_stands" | "findings_returned" | "round_cap" | "settled";
+    }, import("./build").BuildTargetMissing | import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").ChildFailed | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").StepFailed>;
+    readonly 'code-quality': import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly revision?: string | undefined;
+        readonly branch?: string | undefined;
+        readonly repoBindingId?: string | undefined;
+        readonly words?: string | undefined;
+    }, {
+        readonly improvements: readonly {
+            readonly pass: "architecture" | "simplification";
+            readonly improved: boolean;
+            readonly changeRequest?: {
+                readonly id: string;
+                readonly number: string;
+                readonly url: string;
+            } | undefined;
+            readonly revision?: string | undefined;
+            readonly tree?: string | undefined;
+            readonly settled?: boolean | undefined;
+            readonly unsettled?: readonly string[] | undefined;
+        }[];
+    }, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").ChildFailed | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").StepFailed>;
+    readonly 'code-quality-pass': import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly pass: "architecture" | "simplification";
+        readonly revision?: string | undefined;
+        readonly branch?: string | undefined;
+        readonly repoBindingId?: string | undefined;
+        readonly words?: string | undefined;
+    }, {
+        readonly pass: "architecture" | "simplification";
+        readonly improved: boolean;
+        readonly changeRequest?: {
+            readonly id: string;
+            readonly number: string;
+            readonly url: string;
+        } | undefined;
+        readonly revision?: string | undefined;
+        readonly tree?: string | undefined;
+        readonly settled?: boolean | undefined;
+        readonly unsettled?: readonly string[] | undefined;
+    }, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").ChildFailed | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").StepFailed>;
+    readonly hello: import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly name: string;
+        readonly napSeconds?: number | undefined;
+    }, {
+        readonly greeting: string;
+        readonly mood: string;
+    }, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").QuestionRefused | import("@kitman-sh/sdk/loop").StepFailed>;
+    readonly incident: import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly alert: {
+            readonly [x: string]: import("effect/Schema").Json;
+        };
+        readonly repoBindingId?: string | undefined;
+    }, {
+        readonly conclusionArtifactId: string;
+        readonly fix: "declined" | "none" | "started";
+        readonly changeRequestUrl?: string | undefined;
+    }, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").ChildFailed | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").QuestionRefused | import("@kitman-sh/sdk/loop").StepFailed>;
+    readonly plan: import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly words: string;
+        readonly repoBindingId?: string | undefined;
+        readonly branch?: string | undefined;
+    }, {
+        readonly title: string;
+        readonly outOfScope: readonly string[];
+        readonly implemented: boolean;
+        readonly tickets: readonly {
+            readonly key: string;
+            readonly title: string;
+            readonly status: "failed" | "merged" | "skipped";
+            readonly repoBindingId?: string | undefined;
+            readonly changeRequest?: {
+                readonly id: string;
+                readonly number: string;
+                readonly url: string;
+            } | undefined;
+            readonly reason?: string | undefined;
+        }[];
+        readonly deliveries: readonly {
+            readonly id: string;
+            readonly number: string;
+            readonly url: string;
+        }[];
+        readonly tasks?: readonly {
+            readonly key: string;
+            readonly taskId: string;
+        }[] | undefined;
+    }, import("@kitman-sh/sdk/loop").BlockingCycle | import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").QuestionRefused | import("@kitman-sh/sdk/loop").StepFailed>;
+    readonly release: import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly tag?: string | undefined;
+        readonly revision?: string | undefined;
+        readonly deployEvent?: string | undefined;
+        readonly deployTimeoutMinutes?: number | undefined;
+    }, {
+        readonly status: "rejected";
+        readonly tag: string;
+        readonly notesArtifactId: string;
+    } | {
+        readonly status: "deploy_failed" | "deployed" | "timed_out";
+        readonly tag: string;
+        readonly notesArtifactId: string;
+        readonly revision: string;
+        readonly url: string;
+    }, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").QuestionRefused | import("@kitman-sh/sdk/loop").StepFailed>;
+    readonly research: import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly taskId: string;
+        readonly repoBindingId?: string | undefined;
+    }, {
+        readonly reportArtifactId: string;
+    }, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").StepFailed>;
+    readonly review: import("@kitman-sh/sdk/loop").LoopDefinition<{
+        readonly changeRequestId?: string | undefined;
+        readonly base?: string | undefined;
+        readonly head?: string | undefined;
+        readonly rebuttals?: readonly {
+            readonly findingId: string;
+            readonly reason: string;
+        }[] | undefined;
+        readonly outcome?: "bug" | "docs" | "feature" | "investigation" | "migration" | "refactor" | undefined;
+        readonly claims?: readonly string[] | undefined;
+    }, {
+        readonly findings: readonly {
+            readonly severity: "blocker" | "major" | "minor";
+            readonly file: string;
+            readonly line: number;
+            readonly detail: string;
+            readonly id: string;
+            readonly seats: readonly string[];
+        }[];
+        readonly verdicts: readonly {
+            readonly findingId: string;
+            readonly accepted: boolean;
+        }[];
+        readonly blocking: boolean;
+        readonly artifactId: string;
+        readonly scope?: {
+            readonly met: boolean;
+            readonly unmet: readonly string[];
+        } | undefined;
+    }, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("./review").ReviewTargetMissing | import("@kitman-sh/sdk/loop").StepFailed>;
+};
+export { build, codeQuality, codeQualityPass, hello, incident, plan, release, research, review };

package/types/packages/loops/src/plan.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Interviews the user through Questions, stores a spec and tickets as Run artifacts, and then asks what next:
+ * build the tickets, file them as Tasks to build later, ask another Agent's opinion, refine the plan from the user's
+ * words, or finish (ADR-0051).
+ * Nothing is written to a repository or a Runner but what the Builds deliver.
+ */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly words: string;
+    readonly repoBindingId?: string | undefined;
+    readonly branch?: string | undefined;
+}, {
+    readonly title: string;
+    readonly outOfScope: readonly string[];
+    readonly implemented: boolean;
+    readonly tickets: readonly {
+        readonly key: string;
+        readonly title: string;
+        readonly status: "failed" | "merged" | "skipped";
+        readonly repoBindingId?: string | undefined;
+        readonly changeRequest?: {
+            readonly id: string;
+            readonly number: string;
+            readonly url: string;
+        } | undefined;
+        readonly reason?: string | undefined;
+    }[];
+    readonly deliveries: readonly {
+        readonly id: string;
+        readonly number: string;
+        readonly url: string;
+    }[];
+    readonly tasks?: readonly {
+        readonly key: string;
+        readonly taskId: string;
+    }[] | undefined;
+}, import("@kitman-sh/sdk/loop").BlockingCycle | import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").QuestionRefused | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/loops/src/release.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Drafts notes from the ChangeRequests merged since the last release and asks for approval, then tags and publishes
+ * the release once and waits for its deploy Event.
+ */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly tag?: string | undefined;
+    readonly revision?: string | undefined;
+    readonly deployEvent?: string | undefined;
+    readonly deployTimeoutMinutes?: number | undefined;
+}, {
+    readonly status: "rejected";
+    readonly tag: string;
+    readonly notesArtifactId: string;
+} | {
+    readonly status: "deploy_failed" | "deployed" | "timed_out";
+    readonly tag: string;
+    readonly notesArtifactId: string;
+    readonly revision: string;
+    readonly url: string;
+}, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").QuestionRefused | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/loops/src/research.d.ts

@@ -0,0 +1,8 @@
+/** Researches the question a Task asks against primary sources, and attaches a report that cites them. */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly taskId: string;
+    readonly repoBindingId?: string | undefined;
+}, {
+    readonly reportArtifactId: string;
+}, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/loops/src/review.d.ts

@@ -0,0 +1,38 @@
+import * as Schema from 'effect/Schema';
+declare const ReviewTargetMissing_base: Schema.Class<ReviewTargetMissing, Schema.TaggedStruct<"ReviewTargetMissing", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ReviewTargetMissing extends ReviewTargetMissing_base {
+}
+/** Reviews a ChangeRequest or a revision range with a panel of reviewer Agents, and merges their findings. */
+declare const _default: import("@kitman-sh/sdk/loop").LoopDefinition<{
+    readonly changeRequestId?: string | undefined;
+    readonly base?: string | undefined;
+    readonly head?: string | undefined;
+    readonly rebuttals?: readonly {
+        readonly findingId: string;
+        readonly reason: string;
+    }[] | undefined;
+    readonly outcome?: "bug" | "docs" | "feature" | "investigation" | "migration" | "refactor" | undefined;
+    readonly claims?: readonly string[] | undefined;
+}, {
+    readonly findings: readonly {
+        readonly severity: "blocker" | "major" | "minor";
+        readonly file: string;
+        readonly line: number;
+        readonly detail: string;
+        readonly id: string;
+        readonly seats: readonly string[];
+    }[];
+    readonly verdicts: readonly {
+        readonly findingId: string;
+        readonly accepted: boolean;
+    }[];
+    readonly blocking: boolean;
+    readonly artifactId: string;
+    readonly scope?: {
+        readonly met: boolean;
+        readonly unmet: readonly string[];
+    } | undefined;
+}, import("@kitman-sh/sdk/loop").CapabilityDenied | import("@kitman-sh/sdk/loop").DuplicateStep | import("@kitman-sh/sdk/loop").OutputInvalid | ReviewTargetMissing | import("@kitman-sh/sdk/loop").StepFailed>;
+export default _default;

package/types/packages/sdk/src/loop/activities.d.ts

@@ -0,0 +1,187 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import { StepFailed } from './steps';
+/** The Run's ChangeRequest, from its branch to its base branch. */
+export declare const ChangeRequestRequest: Schema.Struct<{
+    readonly title: Schema.String;
+    readonly body: Schema.String;
+    /** A RepoBinding: opens from the Run's integration branch on it, into its base branch, instead. */
+    readonly integration: Schema.optional<Schema.String>;
+}>;
+export declare const ChangeRequestResult: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly number: Schema.String;
+    readonly url: Schema.String;
+}>;
+export type ChangeRequestResult = typeof ChangeRequestResult.Type;
+export declare const WriteBackMilestones: readonly ['started', 'change_request_opened', 'merged', 'failed'];
+/** A Run milestone for the Run's Task, which moves it to the state its Team maps the milestone to. */
+export declare const WriteBackRequest: Schema.Struct<{
+    readonly milestone: Schema.optional<Schema.Literals<readonly ["started", "change_request_opened", "merged", "failed"]>>;
+    readonly changeRequestUrl: Schema.optional<Schema.String>;
+}>;
+/** A document stored in Kitman with the Run, such as a plan, findings or a conclusion; later Runs retrieve it. */
+export declare const ArtifactRequest: Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly title: Schema.String;
+    readonly text: Schema.String;
+    readonly data: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+export declare const ArtifactResult: Schema.Struct<{
+    readonly artifactId: Schema.String;
+}>;
+/** A thread entry on the Run's Task; given an artifact, it links to it. */
+export declare const NoteRequest: Schema.Struct<{
+    readonly text: Schema.String;
+    readonly artifactId: Schema.optional<Schema.String>;
+}>;
+export declare const CreateTasksRequest: Schema.Struct<{
+    readonly tickets: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly title: Schema.String;
+        readonly body: Schema.String;
+        readonly acceptanceCriteria: Schema.$Array<Schema.String>;
+        readonly repoBindingId: Schema.optional<Schema.String>;
+        readonly blockedBy: Schema.$Array<Schema.String>;
+        readonly outcome: Schema.optional<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration"]>>;
+    }>>;
+}>;
+/** The Task made for each ticket, by ticket key. */
+export declare const CreateTasksResult: Schema.Struct<{
+    readonly tasks: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly taskId: Schema.String;
+    }>>;
+}>;
+/** The Project's default RepoBinding when left out. */
+export declare const IntegrationBranchRequest: Schema.Struct<{
+    readonly repoBindingId: Schema.optional<Schema.String>;
+}>;
+export declare const IntegrationBranch: Schema.Struct<{
+    readonly repoBindingId: Schema.String;
+    readonly branch: Schema.String;
+    /** The branch head now. */
+    readonly revision: Schema.String;
+}>;
+export type IntegrationBranch = typeof IntegrationBranch.Type;
+export declare const MergeChangeRequestRequest: Schema.Struct<{
+    readonly changeRequestId: Schema.String;
+}>;
+export declare const MergeResult: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"merged">;
+    readonly revision: Schema.String;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"conflict">;
+}>]>;
+export type MergeResult = typeof MergeResult.Type;
+/** A comment on a ChangeRequest, which need not be the Run's own. */
+export declare const CommentRequest: Schema.Struct<{
+    readonly changeRequestId: Schema.String;
+    readonly body: Schema.String;
+}>;
+/** Tags `revision`, the Run's base branch head when left out, and publishes the release with its notes. */
+export declare const ReleaseRequest: Schema.Struct<{
+    readonly tag: Schema.String;
+    readonly revision: Schema.optional<Schema.String>;
+    readonly title: Schema.String;
+    readonly notes: Schema.String;
+}>;
+export declare const ReleaseResult: Schema.Struct<{
+    readonly tag: Schema.String;
+    readonly revision: Schema.String;
+    readonly url: Schema.String;
+}>;
+export type ReleaseResult = typeof ReleaseResult.Type;
+declare const ChangeRequestActivity_base: Context.ServiceClass<ChangeRequestActivity, "@kitman-sh/sdk/loop/ChangeRequestActivity", {
+    /** A Run has one ChangeRequest: it opens once, and a later Step updates it. */
+    readonly run: (request: typeof ChangeRequestRequest.Type, step: string) => Effect.Effect<ChangeRequestResult, StepFailed>;
+}>;
+/** Opens or updates the Run's ChangeRequest. */
+export declare class ChangeRequestActivity extends ChangeRequestActivity_base {
+}
+declare const WriteBackActivity_base: Context.ServiceClass<WriteBackActivity, "@kitman-sh/sdk/loop/WriteBackActivity", {
+    readonly run: (request: typeof WriteBackRequest.Type, step: string) => Effect.Effect<void, StepFailed>;
+}>;
+/** Gives the Run's Task a milestone of the Run's. */
+export declare class WriteBackActivity extends WriteBackActivity_base {
+}
+declare const ArtifactActivity_base: Context.ServiceClass<ArtifactActivity, "@kitman-sh/sdk/loop/ArtifactActivity", {
+    /** `step` names the Step storing it; a Step stores one artifact, however often it runs. */
+    readonly run: (request: typeof ArtifactRequest.Type, step: string) => Effect.Effect<typeof ArtifactResult.Type, StepFailed>;
+}>;
+/** Stores a Run artifact in Kitman, indexed for later Runs' ContextPacks and search. */
+export declare class ArtifactActivity extends ArtifactActivity_base {
+}
+declare const NoteActivity_base: Context.ServiceClass<NoteActivity, "@kitman-sh/sdk/loop/NoteActivity", {
+    readonly run: (request: typeof NoteRequest.Type, step: string) => Effect.Effect<void, StepFailed>;
+}>;
+/** Adds an entry to the thread of the Run's Task. */
+export declare class NoteActivity extends NoteActivity_base {
+}
+declare const CommentActivity_base: Context.ServiceClass<CommentActivity, "@kitman-sh/sdk/loop/CommentActivity", {
+    readonly run: (request: typeof CommentRequest.Type, step: string) => Effect.Effect<void, StepFailed>;
+}>;
+/** Posts a comment on a ChangeRequest through Kitman's external-effect ledger; a Step posts once. */
+export declare class CommentActivity extends CommentActivity_base {
+}
+declare const CreateTasksActivity_base: Context.ServiceClass<CreateTasksActivity, "@kitman-sh/sdk/loop/CreateTasksActivity", {
+    /** A Step makes each ticket's Task once. */
+    readonly run: (request: typeof CreateTasksRequest.Type, step: string) => Effect.Effect<typeof CreateTasksResult.Type, StepFailed>;
+}>;
+/** Makes a Task for each plan ticket, with the plan ticket as its origin and its blockers as TaskDependencies. */
+export declare class CreateTasksActivity extends CreateTasksActivity_base {
+}
+declare const IntegrationBranchActivity_base: Context.ServiceClass<IntegrationBranchActivity, "@kitman-sh/sdk/loop/IntegrationBranchActivity", {
+    readonly run: (request: typeof IntegrationBranchRequest.Type, step: string) => Effect.Effect<IntegrationBranch, StepFailed>;
+}>;
+/** The Run's integration branch on a repository, made from its base branch the first time. */
+export declare class IntegrationBranchActivity extends IntegrationBranchActivity_base {
+}
+declare const MergeChangeRequestActivity_base: Context.ServiceClass<MergeChangeRequestActivity, "@kitman-sh/sdk/loop/MergeChangeRequestActivity", {
+    readonly run: (request: typeof MergeChangeRequestRequest.Type, step: string) => Effect.Effect<MergeResult, StepFailed>;
+}>;
+/** Merges a ChangeRequest into its target branch through the external-effect ledger; a Step merges once. */
+export declare class MergeChangeRequestActivity extends MergeChangeRequestActivity_base {
+}
+declare const ReleaseActivity_base: Context.ServiceClass<ReleaseActivity, "@kitman-sh/sdk/loop/ReleaseActivity", {
+    readonly run: (request: typeof ReleaseRequest.Type, step: string) => Effect.Effect<ReleaseResult, StepFailed>;
+}>;
+/** Tags and publishes a release on the Run's repository through the external-effect ledger; a Step releases once. */
+export declare class ReleaseActivity extends ReleaseActivity_base {
+}
+export declare const changeRequest: (name: string, request: typeof ChangeRequestRequest.Type) => Effect.Effect<{
+    readonly id: string;
+    readonly number: string;
+    readonly url: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, ChangeRequestActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const writeBack: (name: string, request: typeof WriteBackRequest.Type) => Effect.Effect<void, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance | WriteBackActivity>;
+export declare const artifact: (name: string, request: typeof ArtifactRequest.Type) => Effect.Effect<{
+    readonly artifactId: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, ArtifactActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const note: (name: string, request: typeof NoteRequest.Type) => Effect.Effect<void, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | NoteActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const comment: (name: string, request: typeof CommentRequest.Type) => Effect.Effect<void, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, CommentActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const createTasks: (name: string, request: typeof CreateTasksRequest.Type) => Effect.Effect<{
+    readonly tasks: readonly {
+        readonly key: string;
+        readonly taskId: string;
+    }[];
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, CreateTasksActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/** Its head is read when the Step runs, so a later Step with another name sees what was merged since. */
+export declare const integrationBranch: (name: string, request: typeof IntegrationBranchRequest.Type) => Effect.Effect<{
+    readonly repoBindingId: string;
+    readonly branch: string;
+    readonly revision: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, IntegrationBranchActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const mergeChangeRequest: (name: string, request: typeof MergeChangeRequestRequest.Type) => Effect.Effect<{
+    readonly status: "merged";
+    readonly revision: string;
+} | {
+    readonly status: "conflict";
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | MergeChangeRequestActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export declare const release: (name: string, request: typeof ReleaseRequest.Type) => Effect.Effect<{
+    readonly tag: string;
+    readonly revision: string;
+    readonly url: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | ReleaseActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+export {};