@kitman-sh/sdk 0.9.0 → 0.10.53

package/types/packages/sdk/src/build/index.d.ts

@@ -1,4 +1,5 @@
-import { PackageDeclarations } from '../../../core/src/package-declarations';
+import { KitDeclarations } from '../../../core/src/kit-declarations';
+import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as FileSystem from 'effect/FileSystem';
 import * as Path from 'effect/Path';
@@ -24,22 +25,57 @@ declare const DeclarationsInvalid_base: Schema.Class<DeclarationsInvalid, Schema
 export declare class DeclarationsInvalid extends DeclarationsInvalid_base {
     get message(): string;
 }
-export type PackageBuildError = DependencyInstallFailed | BundleFailed | DeclarationsInvalid | ManifestInvalid | LoopCheckError;
-export type PackageProvenance = {
+declare const SourceFetchFailed_base: Schema.Class<SourceFetchFailed, Schema.TaggedStruct<"SourceFetchFailed", {
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SourceFetchFailed extends SourceFetchFailed_base {
+    get message(): string;
+}
+export type KitBuildError = DependencyInstallFailed | BundleFailed | DeclarationsInvalid | SourceFetchFailed | ManifestInvalid | LoopCheckError;
+export type KitProvenance = {
     readonly repository?: string;
     readonly commit?: string;
     readonly clean: boolean;
 };
-export type PackageBuild = {
+export type KitBuild = {
     /** From `package.json`. */
     readonly name: string;
-    /** One module that runs with nothing but `bun`: the program host, the config, the SDK, Effect and every dependency. */
+    readonly version: string;
+    /** One module that runs with nothing but `bun`: the program host, every carried Kit's config, the SDK and Effect. */
     readonly bundle: Uint8Array;
     readonly digest: string;
-    readonly declarations: PackageDeclarations;
+    readonly declarations: KitDeclarations;
+    /** One per carried Kit, as `declarations.carried` names them. */
+    readonly setupArchives: readonly {
+        readonly digest: string;
+        readonly archive: Uint8Array;
+    }[];
     readonly protocolVersion: number;
-    readonly provenance: PackageProvenance;
+    readonly provenance: KitProvenance;
+    /** Each named entry a higher-priority Kit replaced, in priority order. */
+    readonly overrides: readonly KitOverride[];
+};
+export type KitOverride = {
+    readonly what: 'Loop' | 'Agent' | 'skill' | 'plugin' | 'MCP server';
+    readonly name: string;
+    readonly winner: string;
+    readonly replaced: string;
+};
+type GitLocation = {
+    readonly url: string;
+    readonly ref: string | undefined;
 };
-/** Builds the Package in `directory` into one bundle and its declarations; dependencies install with lifecycle scripts off. */
-export declare const buildPackage: (directory: string) => Effect.Effect<PackageBuild, PackageBuildError, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+/** Where a build fetches a git source; a test replaces it to stay off the network. */
+export declare const GitSourceLocation: Context.Reference<(declared: GitLocation) => GitLocation>;
+/**
+ * Builds the Kit in `directory` into one bundle carrying it and every Kit it extends, one setup archive per carried
+ * Kit in priority order, and the declarations of the winning Loops and Agents; dependencies install with lifecycle
+ * scripts off.
+ */
+export declare const buildKit: (directory: string, options?: {
+    /** The version the Kit is published at, in place of its `package.json` one. */
+    readonly version?: string;
+}) => Effect.Effect<KitBuild, KitBuildError, FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner>;
+/** Writes a built Kit into `out` and names its files in `directory`'s package.json `kitman` field, for `npm publish`. */
+export declare const writeKit: (directory: string, built: KitBuild, out: string) => Effect.Effect<void, import("effect/PlatformError").PlatformError | Schema.SchemaError, FileSystem.FileSystem | Path.Path>;
 export {};

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

@@ -1,6 +1,7 @@
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
+import type * as Duration from 'effect/Duration';
 import { StepFailed } from './steps';
 /** The Run's ChangeRequest, from its branch to its base branch. */
 export declare const ChangeRequestRequest: Schema.Struct<{
@@ -62,8 +63,10 @@ export declare const CreateTasksRequest: Schema.Struct<{
         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"]>>;
+        readonly outcome: Schema.optional<Schema.Literals<readonly ["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"]>>;
     }>>;
+    /** The Project the Tasks land in. */
+    readonly projectId: Schema.optionalKey<Schema.String>;
 }>;
 /** The Task made for each ticket, by ticket key. */
 export declare const CreateTasksResult: Schema.Struct<{
@@ -72,6 +75,33 @@ export declare const CreateTasksResult: Schema.Struct<{
         readonly taskId: Schema.String;
     }>>;
 }>;
+/** An alert's Bug Task, found by fingerprint or made. */
+export declare const AlertTaskRequest: Schema.Struct<{
+    /** Names the alert across repeats: its fingerprint, else its title. */
+    readonly fingerprint: Schema.String;
+    readonly title: Schema.String;
+    /** How long a conclusion counts as recent: a repeat within it joins instead of investigating again. */
+    readonly windowHours: Schema.Int;
+    /** The alert reports it resolved: it is folded in as such, lowers its Task to low, and makes no Task when there is none. */
+    readonly resolved: Schema.optionalKey<Schema.Boolean>;
+    /** The alert's priority: its Task takes it when made and when the alert fires again. */
+    readonly priority: Schema.optionalKey<Schema.Literals<readonly ["urgent", "high", "medium", "low"]>>;
+}>;
+/**
+ * The Bug Task the Run now works on; none for a resolve with no Task. `joined` names the open Run of the same alert,
+ * or the Run whose conclusion is recent, that this alert was folded into as another occurrence. `resolved` says a
+ * resolve of the alert was folded into the Run since it took the Task.
+ */
+export declare const AlertTaskResult: Schema.Struct<{
+    readonly taskId: Schema.optionalKey<Schema.String>;
+    readonly created: Schema.Boolean;
+    readonly resolved: Schema.optionalKey<Schema.Boolean>;
+    readonly joined: Schema.optionalKey<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["run", "recent"]>;
+        readonly runId: Schema.String;
+    }>>;
+}>;
+export type AlertTaskResult = typeof AlertTaskResult.Type;
 /** The Team's default RepoBinding when left out. */
 export declare const IntegrationBranchRequest: Schema.Struct<{
     readonly repoBindingId: Schema.optional<Schema.String>;
@@ -85,18 +115,104 @@ export declare const IntegrationBranch: Schema.Struct<{
 export type IntegrationBranch = typeof IntegrationBranch.Type;
 export declare const MergeChangeRequestRequest: Schema.Struct<{
     readonly changeRequestId: Schema.String;
+    /** The head that was checked; the merge is refused as `moved` when the ChangeRequest's head is another by then. */
+    readonly head: Schema.optionalKey<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">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"moved">;
+    readonly head: Schema.String;
 }>]>;
 export type MergeResult = typeof MergeResult.Type;
+export declare const ApproveChangeRequestRequest: Schema.Struct<{
+    readonly changeRequestId: Schema.String;
+    /** The full head revision that was reviewed; the approval approves only this commit. */
+    readonly head: Schema.String;
+    readonly summary: Schema.String;
+    /**
+     * The Step of a Review Child Run of this Run whose passing review of `head` is the approval, as Build's last round
+     * is; the Run approves as itself when left out.
+     */
+    readonly review: Schema.optionalKey<Schema.String>;
+    /**
+     * The Step of a base sync of this Run that merged with no conflict and left the branch's own diff as it was: the
+     * approval of the head it merged from is carried to `head`, the head it pushed. With a `review` of only the files
+     * that sync settled or rewrote, it is what covers the rest of `head`.
+     */
+    readonly carries: Schema.optionalKey<Schema.String>;
+}>;
+/** Refused, with the reason, when the approving Run opened the ChangeRequest or pushed to its branch. */
+export declare const ApproveChangeRequestResult: Schema.Union<readonly [Schema.Struct<{
+    readonly approved: Schema.Literal<true>;
+    readonly reviewId: Schema.String;
+}>, Schema.Struct<{
+    readonly approved: Schema.Literal<false>;
+    readonly reason: Schema.String;
+}>]>;
+/**
+ * Closes an open ChangeRequest on the Run's repository by its number, with one note saying why, while its head is still
+ * the `head` the Run checked.
+ */
+export declare const CloseChangeRequestRequest: Schema.Struct<{
+    readonly number: Schema.String;
+    readonly head: Schema.String;
+    readonly note: Schema.String;
+}>;
+export declare const CloseChangeRequestResult: Schema.Struct<{
+    readonly closed: Schema.Boolean;
+    /** The head it has now, when it was left open because that is not the head asked for. */
+    readonly head: Schema.optionalKey<Schema.String>;
+}>;
+/**
+ * The pipeline of a ChangeRequest's head, or of a ref such as a release tag on the Run's repository. With `all`, the
+ * ref's newest pipeline runs again in full, as a rollback redeploys an earlier tag; otherwise only its failed jobs do.
+ */
+export declare const RerunPipelineRequest: Schema.Union<readonly [Schema.Struct<{
+    readonly changeRequestId: Schema.String;
+}>, Schema.Struct<{
+    readonly ref: Schema.String;
+    readonly all: Schema.optionalKey<Schema.Boolean>;
+}>]>;
+/** The head whose failed jobs were run again, and how many pipelines that was; none when nothing had failed. */
+export declare const RerunPipelineResult: Schema.Struct<{
+    readonly head: Schema.String;
+    readonly pipelines: Schema.Int;
+}>;
+/** A ChangeRequest whose pipeline the Run's completed `verify` Step `verification` ran on a Runner. */
+export declare const ReportPipelineRequest: Schema.Struct<{
+    readonly changeRequestId: Schema.String;
+    readonly verification: Schema.String;
+}>;
+/** The commit the verification checked, which the report is for, and the pipeline's result there. */
+export declare const ReportPipelineResult: Schema.Struct<{
+    readonly head: Schema.String;
+    readonly status: Schema.Literals<readonly ["success", "failed"]>;
+}>;
+export type ReportPipelineResult = typeof ReportPipelineResult.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;
+    /** Replies on this open review thread instead of commenting on the ChangeRequest. */
+    readonly threadId: Schema.optionalKey<Schema.String>;
+    /**
+     * Keeps one comment per `summary` key on the ChangeRequest: a later post with the same key, from any Run, edits that
+     * comment instead of adding another.
+     */
+    readonly summary: Schema.optionalKey<Schema.String>;
+    /**
+     * Comments on these lines of the ChangeRequest's head instead, each on the new side of the diff, once per Step; `body`
+     * is not posted. A line outside the diff fails the Step.
+     */
+    readonly anchors: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly file: Schema.String;
+        readonly line: Schema.Int;
+        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<{
@@ -111,6 +227,118 @@ export declare const ReleaseResult: Schema.Struct<{
     readonly url: Schema.String;
 }>;
 export type ReleaseResult = typeof ReleaseResult.Type;
+/** A ChangeRequest in the Run's Team, which need not be the Run's own. */
+export declare const ChangeRequestReadRequest: Schema.Struct<{
+    readonly changeRequestId: Schema.String;
+}>;
+export declare const PipelineJob: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
+    readonly url: Schema.optional<Schema.String>;
+    /** The redacted end of a failed job's log, at most 4000 characters, where the forge serves job logs. */
+    readonly logTail: Schema.optional<Schema.String>;
+}>;
+/**
+ * The pipeline at the ChangeRequest's head: the forge's, or else the latest one reported through the API for a
+ * pipeline run elsewhere. `none` while neither has a result for the head.
+ */
+export declare const PipelineStatus: Schema.Struct<{
+    readonly head: Schema.String;
+    readonly status: Schema.Literals<readonly ["none", "running", "success", "failed", "canceled"]>;
+    readonly source: Schema.Literals<readonly ["forge", "reported"]>;
+    readonly jobs: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "success", "failed", "skipped"]>;
+        readonly url: Schema.optional<Schema.String>;
+        /** The redacted end of a failed job's log, at most 4000 characters, where the forge serves job logs. */
+        readonly logTail: Schema.optional<Schema.String>;
+    }>>;
+    /** When Kitman read it; a `waitFor` `since` this time ignores the state Events the read already superseded. */
+    readonly readAt: Schema.optionalKey<Schema.String>;
+    /**
+     * The checks approved as the repository's pipeline, where the forge runs none: while it is `none`, a Loop runs these
+     * with `verify` on the head and posts the result with `reportPipeline`, and may do so again for a failure it doubts.
+     */
+    readonly runnerChecks: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+export type PipelineStatus = typeof PipelineStatus.Type;
+/** A review conversation not yet resolved, with its comments oldest first. */
+export declare const ReviewThread: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly path: Schema.optional<Schema.String>;
+    readonly line: Schema.optional<Schema.Int>;
+    /** The code under it has changed since, where the forge says. */
+    readonly outdated: Schema.optional<Schema.Boolean>;
+    readonly comments: Schema.$Array<Schema.Struct<{
+        readonly author: Schema.optional<Schema.String>;
+        readonly body: Schema.String;
+    }>>;
+}>;
+export declare const ReviewThreads: Schema.Struct<{
+    readonly threads: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly path: Schema.optional<Schema.String>;
+        readonly line: Schema.optional<Schema.Int>;
+        /** The code under it has changed since, where the forge says. */
+        readonly outdated: Schema.optional<Schema.Boolean>;
+        readonly comments: Schema.$Array<Schema.Struct<{
+            readonly author: Schema.optional<Schema.String>;
+            readonly body: Schema.String;
+        }>>;
+    }>>;
+}>;
+export type ReviewThreads = typeof ReviewThreads.Type;
+/** The open ChangeRequests on the Run's repository that any of `authors` opened, such as a dependency bot's. */
+export declare const OpenChangeRequestsRequest: Schema.Struct<{
+    readonly authors: Schema.NonEmptyArray<Schema.String>;
+}>;
+export declare const OpenChangeRequest: Schema.Struct<{
+    readonly number: Schema.String;
+    readonly title: Schema.String;
+    /** The description, at most 4000 characters. */
+    readonly body: Schema.String;
+    readonly url: Schema.String;
+    readonly author: Schema.String;
+    readonly sourceBranch: Schema.String;
+    /** The head revision when it was read; a bot can push again before the Run builds on it. */
+    readonly head: Schema.String;
+}>;
+export declare const OpenChangeRequests: Schema.Struct<{
+    readonly changeRequests: Schema.$Array<Schema.Struct<{
+        readonly number: Schema.String;
+        readonly title: Schema.String;
+        /** The description, at most 4000 characters. */
+        readonly body: Schema.String;
+        readonly url: Schema.String;
+        readonly author: Schema.String;
+        readonly sourceBranch: Schema.String;
+        /** The head revision when it was read; a bot can push again before the Run builds on it. */
+        readonly head: Schema.String;
+    }>>;
+}>;
+export type OpenChangeRequests = typeof OpenChangeRequests.Type;
+/** An open ChangeRequest a Run of this Loop opened; `id` is Kitman's, for `call`ing a Loop on it. */
+export declare const OwnChangeRequest: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly number: Schema.String;
+    readonly url: Schema.String;
+    readonly title: Schema.String;
+    readonly sourceBranch: Schema.String;
+    /** Its description on the forge now, such as the list of what a batch supersedes. */
+    readonly body: Schema.String;
+}>;
+export declare const OwnChangeRequests: Schema.Struct<{
+    readonly changeRequests: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly number: Schema.String;
+        readonly url: Schema.String;
+        readonly title: Schema.String;
+        readonly sourceBranch: Schema.String;
+        /** Its description on the forge now, such as the list of what a batch supersedes. */
+        readonly body: Schema.String;
+    }>>;
+}>;
+export type OwnChangeRequests = typeof OwnChangeRequests.Type;
 /** An entry of a Run's Transcript. */
 export declare const TranscriptPoint: Schema.Struct<{
     readonly runId: Schema.String;
@@ -121,13 +349,18 @@ export type TranscriptPoint = typeof TranscriptPoint.Type;
 export declare const TranscriptsRequest: Schema.Struct<{
     readonly days: Schema.Int;
 }>;
-/** The Workspace's failed Runs of the window that the person the Run acts for may read, with their Transcripts. */
+/**
+ * The Workspace's Runs that settled in the window, which the person the Run acts for may read, with their Transcripts:
+ * each with its `status`, a failed one with its `failure`, and one with a retried Step marked `retried`.
+ */
 export declare const TranscriptsResult: Schema.Struct<{
     readonly runs: Schema.$Array<Schema.Struct<{
         readonly runId: Schema.String;
         readonly loopId: Schema.String;
+        readonly status: Schema.optional<Schema.Literals<readonly ["completed", "failed", "canceled", "expired"]>>;
         readonly teamId: Schema.optional<Schema.String>;
         readonly failure: Schema.optional<Schema.String>;
+        readonly retried: Schema.optional<Schema.Boolean>;
         readonly entries: Schema.$Array<Schema.Struct<{
             readonly stepAttemptId: Schema.String;
             readonly sequence: Schema.Int;
@@ -153,6 +386,11 @@ export declare const ProposeRequest: Schema.Union<readonly [Schema.Struct<{
     readonly description: Schema.String;
     /** The Team the approver is offered first. */
     readonly teamId: Schema.optional<Schema.String>;
+    /**
+     * A stable kebab-case name for what it is about. While a proposal with this key waits for a decision it is cited
+     * again instead, and while the Task it filed is open the new Runs are commented on that Task.
+     */
+    readonly key: Schema.optionalKey<Schema.String>;
     readonly citations: Schema.NonEmptyArray<Schema.Struct<{
         readonly runId: Schema.String;
         readonly stepAttemptId: Schema.String;
@@ -163,6 +401,8 @@ export type ProposeRequest = typeof ProposeRequest.Type;
 export declare const ProposeResult: Schema.Struct<{
     readonly kind: Schema.Literals<readonly ["memory", "task"]>;
     readonly id: Schema.String;
+    /** Its key matched an earlier proposal or open Task, which it added to instead. */
+    readonly matched: Schema.optionalKey<Schema.Boolean>;
 }>;
 export declare const ProjectActivityRequest: Schema.Struct<{
     readonly projectId: Schema.String;
@@ -262,6 +502,12 @@ declare const CreateTasksActivity_base: Context.ServiceClass<CreateTasksActivity
 /** 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 AlertTaskActivity_base: Context.ServiceClass<AlertTaskActivity, "@kitman-sh/sdk/loop/AlertTaskActivity", {
+    readonly run: (request: typeof AlertTaskRequest.Type, step: string) => Effect.Effect<AlertTaskResult, StepFailed>;
+}>;
+/** Finds or makes an alert's Bug Task, puts the Run on it, and folds a repeat into earlier work. */
+export declare class AlertTaskActivity extends AlertTaskActivity_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>;
 }>;
@@ -270,6 +516,10 @@ export declare class IntegrationBranchActivity extends IntegrationBranchActivity
 }
 declare const MergeChangeRequestActivity_base: Context.ServiceClass<MergeChangeRequestActivity, "@kitman-sh/sdk/loop/MergeChangeRequestActivity", {
     readonly run: (request: typeof MergeChangeRequestRequest.Type, step: string) => Effect.Effect<MergeResult, StepFailed>;
+    readonly close: (request: typeof CloseChangeRequestRequest.Type, step: string) => Effect.Effect<typeof CloseChangeRequestResult.Type, StepFailed>;
+    readonly rerun: (request: typeof RerunPipelineRequest.Type, step: string) => Effect.Effect<typeof RerunPipelineResult.Type, StepFailed>;
+    readonly report: (request: typeof ReportPipelineRequest.Type, step: string) => Effect.Effect<ReportPipelineResult, StepFailed>;
+    readonly approve: (request: typeof ApproveChangeRequestRequest.Type, step: string) => Effect.Effect<typeof ApproveChangeRequestResult.Type, StepFailed>;
 }>;
 /** Merges a ChangeRequest into its target branch through the external-effect ledger; a Step merges once. */
 export declare class MergeChangeRequestActivity extends MergeChangeRequestActivity_base {
@@ -304,6 +554,15 @@ declare const DraftUpdateActivity_base: Context.ServiceClass<DraftUpdateActivity
 /** Drafts a Project Update for the person the Run acts for; a Run drafts once. Nothing a Loop calls posts one. */
 export declare class DraftUpdateActivity extends DraftUpdateActivity_base {
 }
+declare const ChangeRequestReadActivity_base: Context.ServiceClass<ChangeRequestReadActivity, "@kitman-sh/sdk/loop/ChangeRequestReadActivity", {
+    readonly pipeline: (request: typeof ChangeRequestReadRequest.Type, step: string) => Effect.Effect<PipelineStatus, StepFailed>;
+    readonly reviewThreads: (request: typeof ChangeRequestReadRequest.Type, step: string) => Effect.Effect<ReviewThreads, StepFailed>;
+    readonly opened: (request: typeof OpenChangeRequestsRequest.Type, step: string) => Effect.Effect<OpenChangeRequests, StepFailed>;
+    readonly own: (step: string) => Effect.Effect<OwnChangeRequests, StepFailed>;
+}>;
+/** Reads what a ChangeRequest's Events point at, from its forge. */
+export declare class ChangeRequestReadActivity extends ChangeRequestReadActivity_base {
+}
 export declare const changeRequest: (name: string, request: typeof ChangeRequestRequest.Type) => Effect.Effect<{
     readonly id: string;
     readonly number: string;
@@ -325,6 +584,19 @@ export declare const createTasks: (name: string, request: typeof CreateTasksRequ
         readonly taskId: string;
     }[];
 }, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, CreateTasksActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/**
+ * Puts the Run on the Bug Task of the alert's fingerprint, made the first time. A repeat while another Run of it is
+ * open, or within `windowHours` of its last conclusion, is recorded on the Task as another occurrence and `joined`.
+ */
+export declare const alertTask: (name: string, request: typeof AlertTaskRequest.Type) => Effect.Effect<{
+    readonly taskId?: string;
+    readonly created: boolean;
+    readonly resolved?: boolean;
+    readonly joined?: {
+        readonly kind: "recent" | "run";
+        readonly runId: string;
+    };
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, AlertTaskActivity | 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;
@@ -336,6 +608,55 @@ export declare const mergeChangeRequest: (name: string, request: typeof MergeCha
     readonly revision: string;
 } | {
     readonly status: "conflict";
+} | {
+    readonly status: "moved";
+    readonly head: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | MergeChangeRequestActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/**
+ * Records Kitman's approval of a ChangeRequest's head, as Shepherd and readiness wait for. A Run cannot approve work it
+ * wrote: that is refused, not failed.
+ */
+export declare const approveChangeRequest: (name: string, request: typeof ApproveChangeRequestRequest.Type) => Effect.Effect<{
+    readonly approved: true;
+    readonly reviewId: string;
+} | {
+    readonly approved: false;
+    readonly reason: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | MergeChangeRequestActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/**
+ * Closes another's open ChangeRequest on the Run's repository, such as one a batch supersedes, after posting `note` on
+ * it once. Closing one already closed or merged succeeds with `closed: false`.
+ */
+export declare const closeChangeRequest: (name: string, request: typeof CloseChangeRequestRequest.Type) => Effect.Effect<{
+    readonly closed: boolean;
+    readonly head?: string;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | MergeChangeRequestActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/**
+ * Waits for the ChangeRequest's next pipeline Event after `read`, on any head: a push moves the head, and only the new
+ * head's pipeline reports. Events received before the read never settle it. A read with no `readAt` waits on its head.
+ */
+export declare const pipelineMoved: (name: string, changeRequestId: string, read: PipelineStatus, timeout?: Duration.Input) => Effect.Effect<{
+    readonly type: string;
+    readonly payload: {
+        readonly [x: string]: Schema.Json;
+    };
+}, import("./steps").CapabilityDenied | import("./steps").ChangeRequestClosed | import("./steps").DuplicateStep | StepFailed | import("./steps").WaitTimedOut, import("./steps").LoopHost | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/**
+ * Runs the failed jobs of the ChangeRequest's head pipeline, or of the newest pipeline of `ref`, again on the forge, as
+ * a person would for a flaky job or a failed deploy; with `all`, that pipeline runs again in full. The journal keeps the result, so a replayed Step runs nothing again.
+ */
+export declare const rerunPipeline: (name: string, request: typeof RerunPipelineRequest.Type) => Effect.Effect<{
+    readonly head: string;
+    readonly pipelines: number;
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | MergeChangeRequestActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/**
+ * Reports the Run's completed `verify` Step `verification` as the ChangeRequest's pipeline at the commit it checked:
+ * one job per check, a failed one with the end of its output as its log. `pipelineStatus` then reads it for that head,
+ * and `change_request.pipeline` fires as for a forge's pipeline.
+ */
+export declare const reportPipeline: (name: string, request: typeof ReportPipelineRequest.Type) => Effect.Effect<{
+    readonly head: string;
+    readonly status: "failed" | "success";
 }, 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;
@@ -346,8 +667,10 @@ export declare const transcripts: (name: string, request: typeof TranscriptsRequ
     readonly runs: readonly {
         readonly runId: string;
         readonly loopId: string;
+        readonly status?: "canceled" | "completed" | "expired" | "failed" | undefined;
         readonly teamId?: string | undefined;
         readonly failure?: string | undefined;
+        readonly retried?: boolean | undefined;
         readonly entries: readonly {
             readonly stepAttemptId: string;
             readonly sequence: number;
@@ -359,6 +682,7 @@ export declare const transcripts: (name: string, request: typeof TranscriptsRequ
 export declare const propose: (name: string, request: ProposeRequest) => Effect.Effect<{
     readonly kind: "memory" | "task";
     readonly id: string;
+    readonly matched?: boolean;
 }, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | ProposeActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
 export declare const projectActivity: (name: string, request: typeof ProjectActivityRequest.Type) => Effect.Effect<{
     readonly project: {
@@ -388,6 +712,62 @@ export declare const projectActivity: (name: string, request: typeof ProjectActi
         readonly at: string;
     }[];
 }, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopRun | ProjectActivityActivity | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/**
+ * The pipeline at a ChangeRequest's head, with a log tail per failed job. It is read when the Step runs, so read again
+ * under another name after waiting for `change_request.pipeline`.
+ */
+export declare const pipelineStatus: (name: string, request: typeof ChangeRequestReadRequest.Type) => Effect.Effect<{
+    readonly head: string;
+    readonly status: "canceled" | "failed" | "none" | "running" | "success";
+    readonly source: "forge" | "reported";
+    readonly jobs: readonly {
+        readonly name: string;
+        readonly status: "failed" | "running" | "skipped" | "success";
+        readonly url?: string | undefined;
+        readonly logTail?: string | undefined;
+    }[];
+    readonly readAt?: string;
+    readonly runnerChecks?: readonly string[];
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, ChangeRequestReadActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/** A ChangeRequest's unresolved review conversations, read when the Step runs. */
+export declare const reviewThreads: (name: string, request: typeof ChangeRequestReadRequest.Type) => Effect.Effect<{
+    readonly threads: readonly {
+        readonly id: string;
+        readonly path?: string | undefined;
+        readonly line?: number | undefined;
+        readonly outdated?: boolean | undefined;
+        readonly comments: readonly {
+            readonly author?: string | undefined;
+            readonly body: string;
+        }[];
+    }[];
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, ChangeRequestReadActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/** The open ChangeRequests on the Run's repository by any of `authors`, read when the Step runs. */
+export declare const openChangeRequests: (name: string, request: typeof OpenChangeRequestsRequest.Type) => Effect.Effect<{
+    readonly changeRequests: readonly {
+        readonly number: string;
+        readonly title: string;
+        readonly body: string;
+        readonly url: string;
+        readonly author: string;
+        readonly sourceBranch: string;
+        readonly head: string;
+    }[];
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, ChangeRequestReadActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/**
+ * The open ChangeRequests that Runs of this Loop in this Team opened on the Run's repository, newest first, read when
+ * the Step runs: a scheduled Loop finds the one its last Run left open.
+ */
+export declare const ownChangeRequests: (name: string) => Effect.Effect<{
+    readonly changeRequests: readonly {
+        readonly id: string;
+        readonly number: string;
+        readonly url: string;
+        readonly title: string;
+        readonly sourceBranch: string;
+        readonly body: string;
+    }[];
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, ChangeRequestReadActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
 export declare const draftUpdate: (name: string, request: DraftUpdateRequest) => Effect.Effect<{
     readonly id: string;
 }, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, DraftUpdateActivity | import("./steps").LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;

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

@@ -0,0 +1,57 @@
+import { ClaimResult } from '../../../core/src/resource-claim';
+import type * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import { DurableDeferred } from 'effect/workflow';
+import { LoopRun, StepFailed } from './steps';
+export { ClaimResult };
+/** A resource the Run holds until it lets go or settles. */
+export type Claim = Extract<ClaimResult, {
+    readonly status: 'granted';
+}>;
+export declare const claimDeferred: (step: string) => DurableDeferred.DurableDeferred<Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"granted">;
+    readonly resource: Schema.String;
+    readonly takenOverFrom: Schema.optionalKey<Schema.Struct<{
+        readonly runId: Schema.optionalKey<Schema.String>;
+        readonly loopId: Schema.optionalKey<Schema.String>;
+        readonly status: Schema.optionalKey<Schema.Literals<readonly ["pending", "running", "blocked", "completed", "failed", "canceled", "expired"]>>;
+        readonly reason: Schema.optionalKey<Schema.String>;
+        readonly private: Schema.optionalKey<Schema.Literal<true>>;
+        readonly sameLoop: Schema.Boolean;
+    }>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"kept">;
+    readonly resource: Schema.String;
+    readonly holder: Schema.Struct<{
+        readonly runId: Schema.optionalKey<Schema.String>;
+        readonly loopId: Schema.optionalKey<Schema.String>;
+        readonly status: Schema.optionalKey<Schema.Literals<readonly ["pending", "running", "blocked", "completed", "failed", "canceled", "expired"]>>;
+        readonly reason: Schema.optionalKey<Schema.String>;
+        readonly private: Schema.optionalKey<Schema.Literal<true>>;
+        readonly sameLoop: Schema.Boolean;
+    }>;
+}>]>, typeof StepFailed>;
+export declare const letGoDeferred: (step: string) => DurableDeferred.DurableDeferred<Schema.Null, typeof StepFailed>;
+/**
+ * Holds `resource`, such as a deploy target, for the Run, which lets go when it completes. A resource another Run
+ * holds is waited for with no Step running. One kept by a Run that settled without completing is offered as a
+ * takeover: asked when the Loop may ask, by default taken when the holder is the same Loop on the same repository.
+ */
+export declare const claim: (name: string, request: {
+    readonly resource: string;
+    readonly timeout?: Duration.Input;
+}) => Effect.Effect<{
+    readonly status: "granted";
+    readonly resource: string;
+    readonly takenOverFrom?: {
+        readonly runId?: string;
+        readonly loopId?: string;
+        readonly status?: "blocked" | "canceled" | "completed" | "expired" | "failed" | "pending" | "running";
+        readonly reason?: string;
+        readonly private?: true;
+        readonly sameLoop: boolean;
+    };
+}, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | import("./steps").QuestionRefused | StepFailed, import("./steps").LoopHost | LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;
+/** Lets go of a claim before the Run settles, so the oldest waiting Run gets it. */
+export declare const letGo: (name: string, held: Claim) => Effect.Effect<void, import("./steps").CapabilityDenied | import("./steps").DuplicateStep | StepFailed, import("./steps").LoopHost | LoopRun | import("effect/workflow/WorkflowEngine").WorkflowEngine | import("effect/workflow/WorkflowEngine").WorkflowInstance>;