@usine/orchestrator 0.1.0 → 0.2.1

package/dist/operator/need.d.ts

@@ -0,0 +1,66 @@
+import { CycleBudgetAsk } from "@usine/core/cycle-budget";
+import { Schema } from "effect";
+import { LabelPreflightFinding } from "../label-reconciler.ts";
+import { RepositoryPollFailure } from "../polling-triggers.ts";
+import { BoardProjectionError } from "./board.ts";
+declare const ApprovalNeed_base: Schema.Class<ApprovalNeed, Schema.TaggedStruct<"ApprovalNeed", {
+    readonly id: Schema.String;
+    readonly repository: Schema.brand<Schema.String, "RepositoryName">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "RunId">;
+    readonly loop: Schema.brand<Schema.NonEmptyString, "LoopName">;
+}>, {}>;
+/** An operator approval is required before this Run can proceed. */
+export declare class ApprovalNeed extends ApprovalNeed_base {
+}
+declare const RunFailureNeed_base: Schema.Class<RunFailureNeed, Schema.TaggedStruct<"RunFailureNeed", {
+    readonly id: Schema.String;
+    readonly repository: Schema.brand<Schema.String, "RepositoryName">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "RunId">;
+    readonly loop: Schema.brand<Schema.NonEmptyString, "LoopName">;
+    readonly failure: Schema.Union<readonly [typeof import("./attempt.ts").InfraFailureView, typeof import("./attempt.ts").DefectFailureView, typeof import("./attempt.ts").AgentFailureView, typeof import("./attempt.ts").RunawayFailureView, typeof import("./attempt.ts").ChildSessionBudgetFailureView]>;
+}>, {}>;
+/** A failed Run requires an operator decision, with its displayable failure details. */
+export declare class RunFailureNeed extends RunFailureNeed_base {
+}
+declare const PollFailureNeed_base: Schema.Class<PollFailureNeed, Schema.TaggedStruct<"PollFailureNeed", {
+    readonly id: Schema.String;
+    readonly failure: typeof RepositoryPollFailure;
+}>, {}>;
+/** Repository polling failed and needs operator attention. */
+export declare class PollFailureNeed extends PollFailureNeed_base {
+}
+declare const PreflightFindingNeed_base: Schema.Class<PreflightFindingNeed, Schema.TaggedStruct<"PreflightFindingNeed", {
+    readonly id: Schema.String;
+    readonly finding: typeof LabelPreflightFinding;
+}>, {}>;
+/** A declared repository label could not be provisioned or confirmed. */
+export declare class PreflightFindingNeed extends PreflightFindingNeed_base {
+}
+declare const BoardProjectionNeed_base: Schema.Class<BoardProjectionNeed, Schema.TaggedStruct<"BoardProjectionNeed", {
+    readonly id: Schema.String;
+    readonly failure: typeof BoardProjectionError;
+}>, {}>;
+/** An Item could not be displayed on its Board and needs operator attention. */
+export declare class BoardProjectionNeed extends BoardProjectionNeed_base {
+}
+declare const ScheduleFailureNeed_base: Schema.Class<ScheduleFailureNeed, Schema.TaggedStruct<"ScheduleFailureNeed", {
+    readonly id: Schema.String;
+    readonly failure: Schema.Union<readonly [typeof import("../schedule-triggers.ts").ScheduleAgentFailure, typeof import("../schedule-triggers.ts").ScheduleCronFailure, typeof import("../schedule-triggers.ts").ScheduleTickFailure]>;
+}>, {}>;
+/** A scheduled Loop could not evaluate or submit its work. */
+export declare class ScheduleFailureNeed extends ScheduleFailureNeed_base {
+}
+declare const CycleBudgetNeed_base: Schema.Class<CycleBudgetNeed, Schema.TaggedStruct<"CycleBudgetNeed", {
+    readonly id: Schema.String;
+    readonly ask: typeof CycleBudgetAsk;
+    readonly itemLabel: Schema.String;
+    readonly itemUrl: Schema.NullOr<Schema.String>;
+}>, {}>;
+/** An Item stopped opening Runs and requires an explicit reset of its shared cycle budget. */
+export declare class CycleBudgetNeed extends CycleBudgetNeed_base {
+}
+/** One reason the factory asks for operator attention in the overview. */
+export declare const NeedView: Schema.Union<readonly [typeof CycleBudgetNeed, typeof ApprovalNeed, typeof BoardProjectionNeed, typeof RunFailureNeed, typeof PollFailureNeed, typeof PreflightFindingNeed, typeof ScheduleFailureNeed]>;
+export type NeedView = typeof NeedView.Type;
+export {};
+//# sourceMappingURL=need.d.ts.map

package/dist/operator/need.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"need.d.ts","sourceRoot":"","sources":["../../src/operator/need.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG1D,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;;;;;;;AAElD,oEAAoE;AACpE,qBAAa,YAAa,SAAQ,iBAOhC;CAAG;;;;;;;;AAEL,wFAAwF;AACxF,qBAAa,cAAe,SAAQ,mBAQlC;CAAG;;;;;AAEL,8DAA8D;AAC9D,qBAAa,eAAgB,SAAQ,oBAKnC;CAAG;;;;;AAEL,yEAAyE;AACzE,qBAAa,oBAAqB,SAAQ,yBAKxC;CAAG;;;;;AAEL,gFAAgF;AAChF,qBAAa,mBAAoB,SAAQ,wBAKvC;CAAG;;;;;AAEL,8DAA8D;AAC9D,qBAAa,mBAAoB,SAAQ,wBAKvC;CAAG;;;;;;;AAEL,8FAA8F;AAC9F,qBAAa,eAAgB,SAAQ,oBAQpC;CAAG;AAEJ,0EAA0E;AAC1E,eAAO,MAAM,QAAQ,0MAQnB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAC"}

package/dist/operator/need.js

@@ -0,0 +1,70 @@
+import { LoopName } from "@usine/core/loop";
+import { CycleBudgetAsk } from "@usine/core/cycle-budget";
+import { RepositoryName } from "@usine/core/repository";
+import { RunId } from "@usine/core/run";
+import { Schema } from "effect";
+import { LabelPreflightFinding } from "../label-reconciler.js";
+import { RepositoryPollFailure } from "../polling-triggers.js";
+import { ScheduleFailure } from "../schedule-triggers.js";
+import { FailureView } from "./attempt.js";
+import { BoardProjectionError } from "./board.js";
+/** An operator approval is required before this Run can proceed. */
+export class ApprovalNeed extends Schema.TaggedClass("@usine/orchestrator/ApprovalNeed")("ApprovalNeed", {
+    id: Schema.String,
+    repository: RepositoryName,
+    runId: RunId,
+    loop: LoopName,
+}) {
+}
+/** A failed Run requires an operator decision, with its displayable failure details. */
+export class RunFailureNeed extends Schema.TaggedClass("@usine/orchestrator/RunFailureNeed")("RunFailureNeed", {
+    id: Schema.String,
+    repository: RepositoryName,
+    runId: RunId,
+    loop: LoopName,
+    failure: FailureView,
+}) {
+}
+/** Repository polling failed and needs operator attention. */
+export class PollFailureNeed extends Schema.TaggedClass("@usine/orchestrator/PollFailureNeed")("PollFailureNeed", {
+    id: Schema.String,
+    failure: RepositoryPollFailure,
+}) {
+}
+/** A declared repository label could not be provisioned or confirmed. */
+export class PreflightFindingNeed extends Schema.TaggedClass("@usine/orchestrator/PreflightFindingNeed")("PreflightFindingNeed", {
+    id: Schema.String,
+    finding: LabelPreflightFinding,
+}) {
+}
+/** An Item could not be displayed on its Board and needs operator attention. */
+export class BoardProjectionNeed extends Schema.TaggedClass("@usine/orchestrator/BoardProjectionNeed")("BoardProjectionNeed", {
+    id: Schema.String,
+    failure: BoardProjectionError,
+}) {
+}
+/** A scheduled Loop could not evaluate or submit its work. */
+export class ScheduleFailureNeed extends Schema.TaggedClass("@usine/orchestrator/ScheduleFailureNeed")("ScheduleFailureNeed", {
+    id: Schema.String,
+    failure: ScheduleFailure,
+}) {
+}
+/** An Item stopped opening Runs and requires an explicit reset of its shared cycle budget. */
+export class CycleBudgetNeed extends Schema.TaggedClass("CycleBudgetNeed")("CycleBudgetNeed", {
+    id: Schema.String,
+    ask: CycleBudgetAsk,
+    itemLabel: Schema.String,
+    itemUrl: Schema.NullOr(Schema.String),
+}) {
+}
+/** One reason the factory asks for operator attention in the overview. */
+export const NeedView = Schema.Union([
+    CycleBudgetNeed,
+    ApprovalNeed,
+    BoardProjectionNeed,
+    RunFailureNeed,
+    PollFailureNeed,
+    PreflightFindingNeed,
+    ScheduleFailureNeed,
+]);
+//# sourceMappingURL=need.js.map

package/dist/operator/need.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"need.js","sourceRoot":"","sources":["../../src/operator/need.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAElD,oEAAoE;AACpE,MAAM,OAAO,YAAa,SAAQ,MAAM,CAAC,WAAW,CAClD,kCAAkC,CACnC,CAAC,cAAc,EAAE;IAChB,EAAE,EAAE,MAAM,CAAC,MAAM;IACjB,UAAU,EAAE,cAAc;IAC1B,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,QAAQ;CACf,CAAC;CAAG;AAEL,wFAAwF;AACxF,MAAM,OAAO,cAAe,SAAQ,MAAM,CAAC,WAAW,CACpD,oCAAoC,CACrC,CAAC,gBAAgB,EAAE;IAClB,EAAE,EAAE,MAAM,CAAC,MAAM;IACjB,UAAU,EAAE,cAAc;IAC1B,KAAK,EAAE,KAAK;IACZ,IAAI,EAAE,QAAQ;IACd,OAAO,EAAE,WAAW;CACrB,CAAC;CAAG;AAEL,8DAA8D;AAC9D,MAAM,OAAO,eAAgB,SAAQ,MAAM,CAAC,WAAW,CACrD,qCAAqC,CACtC,CAAC,iBAAiB,EAAE;IACnB,EAAE,EAAE,MAAM,CAAC,MAAM;IACjB,OAAO,EAAE,qBAAqB;CAC/B,CAAC;CAAG;AAEL,yEAAyE;AACzE,MAAM,OAAO,oBAAqB,SAAQ,MAAM,CAAC,WAAW,CAC1D,0CAA0C,CAC3C,CAAC,sBAAsB,EAAE;IACxB,EAAE,EAAE,MAAM,CAAC,MAAM;IACjB,OAAO,EAAE,qBAAqB;CAC/B,CAAC;CAAG;AAEL,gFAAgF;AAChF,MAAM,OAAO,mBAAoB,SAAQ,MAAM,CAAC,WAAW,CACzD,yCAAyC,CAC1C,CAAC,qBAAqB,EAAE;IACvB,EAAE,EAAE,MAAM,CAAC,MAAM;IACjB,OAAO,EAAE,oBAAoB;CAC9B,CAAC;CAAG;AAEL,8DAA8D;AAC9D,MAAM,OAAO,mBAAoB,SAAQ,MAAM,CAAC,WAAW,CACzD,yCAAyC,CAC1C,CAAC,qBAAqB,EAAE;IACvB,EAAE,EAAE,MAAM,CAAC,MAAM;IACjB,OAAO,EAAE,eAAe;CACzB,CAAC;CAAG;AAEL,8FAA8F;AAC9F,MAAM,OAAO,eAAgB,SAAQ,MAAM,CAAC,WAAW,CAAkB,iBAAiB,CAAC,CACzF,iBAAiB,EACjB;IACE,EAAE,EAAE,MAAM,CAAC,MAAM;IACjB,GAAG,EAAE,cAAc;IACnB,SAAS,EAAE,MAAM,CAAC,MAAM;IACxB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;CACtC,CACF;CAAG;AAEJ,0EAA0E;AAC1E,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC;IACnC,eAAe;IACf,YAAY;IACZ,mBAAmB;IACnB,cAAc;IACd,eAAe;IACf,oBAAoB;IACpB,mBAAmB;CACpB,CAAC,CAAC"}

package/dist/operator/operator.d.ts

@@ -0,0 +1,68 @@
+import type { LoadedInstance } from "@usine/config/instance";
+import { CycleBudgetAskId } from "@usine/core/cycle-budget";
+import { CycleBudgets, type CycleBudgetResetRejectedError } from "@usine/engine/cycle-budget";
+import { LoopName } from "@usine/core/loop";
+import { RunId } from "@usine/core/run";
+import { RunEngine, type EnginePersistenceError, type RunEngineError, type RunStoreError } from "@usine/engine/engine";
+import { ItemProjectionReader } from "@usine/engine/item-projection";
+import { LoopControl, type LoopRuntimeState } from "@usine/engine/loop-control";
+import { RunReader } from "@usine/engine/run-reader";
+import { RepositoryLabelProjectionReader } from "@usine/engine/repository-label-projection";
+import { GitHubItemWriter } from "@usine/github/item-writer";
+import type { GitHubAppError } from "@usine/github/github-app";
+import { Context, Effect, Layer } from "effect";
+import { PollingTriggers } from "../polling-triggers.ts";
+import { ScheduleTriggers } from "../schedule-triggers.ts";
+import { type BoardItemNotFoundError, type BoardLaneNotFoundError, type BoardLaneReadOnlyError, type BoardMove, type BoardProjectNotFoundError } from "./board.ts";
+import { type TranscriptAttemptNotFoundError, type TranscriptRequest } from "./transcript.ts";
+import { ReadyOverview } from "./overview.ts";
+import { RunDetailView, EditAndRetry, SessionIntervention, RosterAgentNotFoundError } from "./run.ts";
+export type BoardMoveError = BoardItemNotFoundError | BoardLaneNotFoundError | BoardLaneReadOnlyError | BoardProjectNotFoundError | EnginePersistenceError | GitHubAppError;
+export type OperatorError = RosterAgentNotFoundError | RunEngineError | TranscriptAttemptNotFoundError | BoardMoveError | CycleBudgetResetRejectedError;
+export type OperatorObservationError = RunStoreError | TranscriptAttemptNotFoundError;
+declare const OperatorObservation_base: Context.ServiceClass<OperatorObservation, "@usine/orchestrator/OperatorObservation", {
+    /** Builds the supplied instance's Projects, Boards, Runs, and items needing operator attention. */
+    readonly overview: (instance: LoadedInstance) => Effect.Effect<ReadyOverview, OperatorObservationError>;
+    /** Reads one Run and a bounded transcript page; `request` selects the latest, newer, or earlier activity. */
+    readonly detail: (runId: RunId, request?: TranscriptRequest) => Effect.Effect<RunDetailView, OperatorObservationError>;
+}>;
+/** The read-only operator surface. It needs no trigger execution to build. */
+export declare class OperatorObservation extends OperatorObservation_base {
+    static readonly layer: Layer.Layer<OperatorObservation, never, CycleBudgets | ItemProjectionReader | LoopControl | PollingTriggers | RepositoryLabelProjectionReader | RunReader | ScheduleTriggers>;
+}
+declare const Operator_base: Context.ServiceClass<Operator, "@usine/orchestrator/Operator", {
+    /** Builds the supplied instance's Projects, Boards, Runs, and items needing operator attention. */
+    readonly overview: (instance: LoadedInstance) => Effect.Effect<ReadyOverview, OperatorObservationError>;
+    /** Reads one Run and a bounded transcript page; `request` selects the latest, newer, or earlier activity. */
+    readonly detail: (runId: RunId, request?: TranscriptRequest) => Effect.Effect<RunDetailView, OperatorObservationError>;
+} & {
+    /** Answers the Item's current cycle Ask; polling refreshes its state before more Runs open. */
+    readonly resetCycleBudget: (askId: CycleBudgetAskId) => Effect.Effect<void, OperatorError>;
+    /** Records approval for a waiting Run; execution still waits for Worker capacity. */
+    readonly approve: (runId: RunId) => Effect.Effect<void, OperatorError>;
+    /** Requests a new Attempt for a failed Run using its effective task and Agent. */
+    readonly retry: (runId: RunId) => Effect.Effect<void, OperatorError>;
+    /** Atomically amends a failed Run before requesting its next Attempt. */
+    readonly editAndRetry: (instance: LoadedInstance, runId: RunId, edit: EditAndRetry) => Effect.Effect<void, OperatorError>;
+    /** Delivers an attributed action through a live session's Attempt channel. */
+    readonly intervene: (instance: LoadedInstance, runId: RunId, input: SessionIntervention) => Effect.Effect<void, OperatorError>;
+    /** Cancels an open Run and interrupts its current Attempt; an already closed Run is unchanged. */
+    readonly cancel: (runId: RunId) => Effect.Effect<void, OperatorError>;
+    /** Swaps lane labels on GitHub and hints an authoritative refresh of its Board position and Loop matches. */
+    readonly moveBoardItem: (instance: LoadedInstance, move: BoardMove) => Effect.Effect<void, BoardMoveError>;
+    /** Pauses new work for a Loop while its existing Runs continue. */
+    readonly pause: (loop: LoopName) => Effect.Effect<LoopRuntimeState, EnginePersistenceError>;
+    /** Allows the Loop's triggers to open new Runs again. */
+    readonly unpause: (loop: LoopName) => Effect.Effect<LoopRuntimeState, EnginePersistenceError>;
+}>;
+/** The operator's view of the factory and actions for approving, retrying, canceling, and directing work. */
+export declare class Operator extends Operator_base {
+    static readonly layer: Layer.Layer<Operator, never, CycleBudgets | GitHubItemWriter | ItemProjectionReader | LoopControl | PollingTriggers | RepositoryLabelProjectionReader | RunEngine | RunReader | ScheduleTriggers>;
+}
+export { ProjectStatus, ProjectView, LoopView, ReadyOverview, NeedsSetupOverview, FactoryOverview, } from "./overview.ts";
+export { RunStateTag, RunView, RunDetailView, EditAndRetry, SessionIntervention, RosterAgentNotFoundError, } from "./run.ts";
+export { InfraFailureView, DefectFailureView, AgentFailureView, RunawayFailureView, ChildSessionBudgetFailureView, FailureView, SucceededAttemptView, FailedAttemptView, CanceledAttemptView, AttemptOutcomeView, AttemptView, } from "./attempt.ts";
+export { BoardLaneId, BoardLaneOrigin, BoardItemLink, BoardTaskView, WritableBoardLaneView, ReadOnlyBoardLaneView, BoardLaneView, BoardProjectionError, BoardView, LabelView, BoardMove, BoardProjectNotFoundError, BoardItemNotFoundError, BoardLaneNotFoundError, BoardLaneReadOnlyError, } from "./board.ts";
+export { ApprovalNeed, CycleBudgetNeed, RunFailureNeed, PollFailureNeed, PreflightFindingNeed, BoardProjectionNeed, ScheduleFailureNeed, NeedView, } from "./need.ts";
+export { FailedTranscriptView, TranscriptPayload, TranscriptEventView, TranscriptPageCursor, ColdTranscriptRequest, TailTranscriptRequest, EarlierTranscriptRequest, TranscriptRequest, TranscriptAttemptNotFoundError, } from "./transcript.ts";
+//# sourceMappingURL=operator.d.ts.map

package/dist/operator/operator.d.ts.map

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

package/dist/operator/operator.js

@@ -0,0 +1,402 @@
+import { transcriptEvent } from "./projection.js";
+import { TranscriptSessionsQuery } from "@usine/engine/transcript";
+import { GitHubLabelName } from "@usine/config/label";
+import { resolveParentModel } from "@usine/core/agent";
+import { AttemptContext } from "@usine/core/attempt";
+import { Intervention } from "@usine/core/attempt/channel";
+import { Event, DedupKey, EventId } from "@usine/core/event";
+import { CycleBudgetAskId } from "@usine/core/cycle-budget";
+import { CycleBudgets } from "@usine/engine/cycle-budget";
+import { LoopName } from "@usine/core/loop";
+import { RunId } from "@usine/core/run";
+import { RunEngine, RunOperationRejectedError, } from "@usine/engine/engine";
+import { ItemProjectionReader } from "@usine/engine/item-projection";
+import { LoopControl } from "@usine/engine/loop-control";
+import { RunReader } from "@usine/engine/run-reader";
+import { RepositoryLabelProjectionReader } from "@usine/engine/repository-label-projection";
+import { GitHubItemWriter } from "@usine/github/item-writer";
+import { ChangedIssue, ChangedPullRequest } from "@usine/github/polling";
+import { Context, DateTime, Effect, Exit, Layer, Option, Schema, SynchronizedRef } from "effect";
+import { labelMutationForBoardMove, projectBoard } from "../board/projection.js";
+import { GitHubItemKey, PollingTriggers } from "../polling-triggers.js";
+import { ScheduleTriggers } from "../schedule-triggers.js";
+import { ApprovalNeed, CycleBudgetNeed, BoardProjectionNeed, PollFailureNeed, PreflightFindingNeed, RunFailureNeed, ScheduleFailureNeed, } from "./need.js";
+import { BoardItemNotFoundError as BoardItemNotFound, BoardLaneNotFoundError as BoardLaneNotFound, BoardLaneReadOnlyError as BoardLaneReadOnly, BoardProjectNotFoundError as BoardProjectNotFound, LabelView, } from "./board.js";
+import { ColdTranscriptRequest, } from "./transcript.js";
+import { LoopView, ProjectView, ReadyOverview } from "./overview.js";
+import { RunDetailView, EditAndRetry, SessionIntervention, RosterAgentNotFoundError, } from "./run.js";
+import { readTranscript, runView } from "./projection.js";
+/** How many settled Runs the overview keeps beside the open ones. */
+const OVERVIEW_CLOSED_RUNS = 100;
+/** How many newest Items a Board shows; older ones drop off. */
+const OVERVIEW_BOARD_ITEMS = 500;
+const makeOperatorObservation = Effect.gen(function* () {
+    const budgets = yield* CycleBudgets;
+    const reader = yield* RunReader;
+    const controls = yield* LoopControl;
+    const itemReader = yield* ItemProjectionReader;
+    const repositoryLabels = yield* RepositoryLabelProjectionReader;
+    const polling = yield* PollingTriggers;
+    const schedules = yield* ScheduleTriggers;
+    const cache = yield* SynchronizedRef.make(Option.none());
+    const projectOverview = Effect.fn("Operator.projectOverview")(function* (instance, pollFailures, preflightFindings, scheduleFailures, revision) {
+        const [snapshots, states, cycleAsks] = yield* Effect.all([
+            reader.list({ closedLimit: OVERVIEW_CLOSED_RUNS }),
+            controls.states,
+            budgets.asks(),
+        ], { concurrency: "unbounded" });
+        const paused = new Set(states.filter((state) => state.paused).map((state) => state.loop));
+        const views = snapshots.map((snapshot) => runView(snapshot, paused));
+        const runsByRepository = new Map();
+        for (const view of views) {
+            const projectRuns = runsByRepository.get(view.repository) ?? [];
+            projectRuns.push(view);
+            runsByRepository.set(view.repository, projectRuns);
+        }
+        const projects = yield* Effect.forEach(instance.config.repos, (repository) => Effect.gen(function* () {
+            const { name } = repository;
+            const projectFindings = preflightFindings.filter(({ repository: findingRepository }) => findingRepository === name);
+            const [boardItems, labelProjection] = yield* Effect.all([
+                itemReader.list(name, { limit: OVERVIEW_BOARD_ITEMS }),
+                repositoryLabels.get(name),
+            ], { concurrency: "unbounded" });
+            const history = yield* reader.forItems(boardItems.map(({ itemKey }) => itemKey));
+            const merged = new Map((runsByRepository.get(name) ?? []).map((run) => [run.id, run]));
+            for (const saved of history) {
+                const view = runView(saved, paused);
+                merged.set(view.id, view);
+            }
+            const projectRuns = [...merged.values()].sort((a, b) => b.openedAt.localeCompare(a.openedAt) || b.id.localeCompare(a.id));
+            const catalog = Option.match(labelProjection, {
+                onNone: () => [],
+                onSome: ({ labels }) => labels,
+            });
+            const board = yield* projectBoard(repository, catalog.map(({ name }) => name), boardItems, projectRuns, cycleAsks.map(({ itemKey }) => itemKey));
+            const status = cycleAsks.some((ask) => ask.repository === name) ||
+                board.failures.length > 0 ||
+                projectFindings.length > 0 ||
+                projectRuns.some((run) => run.state === "Waiting" || run.state === "Failed")
+                ? "needs-you"
+                : projectRuns.some((run) => run.canCancel)
+                    ? "active"
+                    : "clear";
+            return new ProjectView({
+                repository: name,
+                status,
+                runs: projectRuns,
+                board,
+                labels: catalog.map(({ name: label, color, description }) => new LabelView({
+                    name: GitHubLabelName.make(label),
+                    color: Option.getOrNull(color),
+                    description: Option.getOrNull(description),
+                })),
+                preflightFindings: projectFindings,
+            });
+        }), { concurrency: 4 });
+        const loops = instance.loops.map((loop) => new LoopView({
+            name: loop.name,
+            trigger: loop.trigger.on,
+            agent: loop.agent,
+            paused: paused.has(loop.name),
+        }));
+        const needsYou = [];
+        for (const ask of cycleAsks) {
+            const item = Schema.decodeUnknownOption(GitHubItemKey)(ask.itemKey);
+            needsYou.push(new CycleBudgetNeed({
+                id: `cycle-budget:${ask.id}`,
+                ask,
+                itemLabel: Option.match(item, {
+                    onNone: () => ask.itemKey,
+                    onSome: ([, repository, number]) => `${repository}#${number}`,
+                }),
+                itemUrl: Option.match(item, {
+                    onNone: () => null,
+                    onSome: ([, repository, number]) => `https://github.com/${repository}/issues/${number}`,
+                }),
+            }));
+        }
+        const allRuns = new Map(views.map((run) => [run.id, run]));
+        for (const project of projects)
+            for (const run of project.runs)
+                allRuns.set(run.id, run);
+        for (const run of allRuns.values()) {
+            if (run.state === "Waiting") {
+                needsYou.push(new ApprovalNeed({
+                    id: `approval:${run.id}`,
+                    repository: run.repository,
+                    runId: run.id,
+                    loop: run.loop,
+                }));
+            }
+            else if (run.state === "Failed") {
+                const attempt = run.attempts.at(-1);
+                if (attempt?.outcome?._tag !== "Failed") {
+                    return yield* Effect.die(new Error(`Failed Run ${run.id} has no failed Attempt`));
+                }
+                needsYou.push(new RunFailureNeed({
+                    id: `run-failure:${run.id}`,
+                    repository: run.repository,
+                    runId: run.id,
+                    loop: run.loop,
+                    failure: attempt.outcome.failure,
+                }));
+            }
+        }
+        for (const project of projects) {
+            for (const failure of project.board.failures) {
+                needsYou.push(new BoardProjectionNeed({
+                    id: `board-projection:${failure.repository}:${failure.itemKey}`,
+                    failure,
+                }));
+            }
+        }
+        pollFailures.forEach((failure, index) => {
+            needsYou.push(new PollFailureNeed({
+                id: `poll-failure:${failure.repository}:${failure.errorTag}:${index}`,
+                failure,
+            }));
+        });
+        preflightFindings.forEach((finding) => {
+            needsYou.push(new PreflightFindingNeed({
+                id: `preflight:${finding.repository}:${finding.label}`,
+                finding,
+            }));
+        });
+        scheduleFailures.forEach((failure, index) => {
+            needsYou.push(new ScheduleFailureNeed({
+                id: `schedule-failure:${failure.loop}:${failure._tag}:${index}`,
+                failure,
+            }));
+        });
+        const projected = new ReadyOverview({ projects, loops, needsYou });
+        yield* Effect.logDebug("Refreshed operator overview", {
+            revision,
+            runs: views.length,
+            needsYou: needsYou.length,
+        });
+        return projected;
+    });
+    const overview = Effect.fn("Operator.overview")((instance) => SynchronizedRef.modifyEffect(cache, (cached) => Effect.gen(function* () {
+        const [revision, latestPoll, latestSchedule] = yield* Effect.all([reader.revision(), polling.latest, schedules.latest], { concurrency: "unbounded" });
+        const pollFailures = Option.match(latestPoll, {
+            onNone: () => [],
+            onSome: ({ failures }) => failures,
+        });
+        const preflightFindings = Option.match(latestPoll, {
+            onNone: () => [],
+            onSome: ({ preflightFindings }) => preflightFindings,
+        });
+        const scheduleFailures = Option.match(latestSchedule, {
+            onNone: () => [],
+            onSome: ({ failures }) => failures,
+        });
+        // Without the invalidation singleton staleness cannot be detected, so the
+        // cache is bypassed.
+        const token = Option.map(revision, (value) => JSON.stringify([
+            value,
+            instance.config.repos.map(({ name, lanes }) => [name, lanes]),
+            instance.loops.map(({ name, agent, trigger }) => [name, agent, trigger.on]),
+            pollFailures,
+            preflightFindings,
+            scheduleFailures,
+        ]));
+        if (Option.isNone(token)) {
+            yield* Effect.logWarning("Projection revision singleton is missing; the overview cache is bypassed");
+            const projected = yield* projectOverview(instance, pollFailures, preflightFindings, scheduleFailures, revision);
+            return [projected, Option.none()];
+        }
+        if (Option.isSome(cached) && cached.value.token === token.value) {
+            yield* Effect.logDebug("Reusing unchanged operator overview", {
+                revision,
+            });
+            return [cached.value.overview, cached];
+        }
+        const projected = yield* projectOverview(instance, pollFailures, preflightFindings, scheduleFailures, revision);
+        return [projected, Option.some({ token: token.value, overview: projected })];
+    })));
+    const detail = Effect.fn("Operator.detail")(function* (runId, request = new ColdTranscriptRequest()) {
+        yield* Effect.annotateCurrentSpan({ runId });
+        const [snapshot, states] = yield* Effect.all([reader.inspect(runId), controls.states], { concurrency: "unbounded" });
+        const paused = new Set(states.filter((state) => state.paused).map((state) => state.loop));
+        const [transcript, sessionState] = yield* Effect.all([
+            readTranscript(reader, snapshot, request),
+            Effect.forEach(snapshot.attempts.filter((attempt) => Option.isNone(attempt.outcome)), (attempt) => reader.transcript(new TranscriptSessionsQuery({ attemptId: attempt.id })), { concurrency: "unbounded" }),
+        ], { concurrency: "unbounded" });
+        return new RunDetailView({
+            run: runView(snapshot, paused),
+            eventDedupKey: snapshot.event.dedupKey,
+            eventPayload: snapshot.event.payload,
+            transcript: transcript.events,
+            sessionState: sessionState.flat().map(transcriptEvent),
+            earlierTranscript: transcript.earlier,
+        });
+    });
+    return { detail, overview };
+});
+/** The read-only operator surface. It needs no trigger execution to build. */
+export class OperatorObservation extends Context.Service()("@usine/orchestrator/OperatorObservation") {
+    static layer = Layer.effect(OperatorObservation, makeOperatorObservation);
+}
+const makeOperator = Effect.gen(function* () {
+    const budgets = yield* CycleBudgets;
+    const observation = yield* OperatorObservation;
+    const runs = yield* RunEngine;
+    const controls = yield* LoopControl;
+    const items = yield* ItemProjectionReader;
+    const repositoryLabels = yield* RepositoryLabelProjectionReader;
+    const github = yield* GitHubItemWriter;
+    const polling = yield* PollingTriggers;
+    const approve = Effect.fn("Operator.approve")(function* (runId) {
+        yield* Effect.annotateCurrentSpan({ runId });
+        const current = yield* runs.inspect(runId);
+        if (current.run.state._tag !== "Waiting") {
+            yield* Effect.logInfo("Operator approval rejected; the Run is past its gate", {
+                runId,
+                state: current.run.state._tag,
+            });
+            return yield* new RunOperationRejectedError({
+                runId,
+                operation: "approve",
+                state: current.run.state._tag,
+            });
+        }
+        const receivedAt = yield* DateTime.now;
+        const dedupKey = DedupKey.make(JSON.stringify(["operator-approval", runId]));
+        yield* runs.approve(runId, new Event({
+            id: EventId.make(dedupKey),
+            dedupKey,
+            payload: { runId, decision: "approved" },
+            receivedAt,
+        }));
+        yield* Effect.logInfo("Operator approved Run", { runId });
+    });
+    const retry = Effect.fn("Operator.retry")(function* (runId) {
+        yield* Effect.annotateCurrentSpan({ runId });
+        yield* runs.retry(runId);
+        yield* Effect.logInfo("Operator retried Run", { runId });
+    });
+    const editAndRetry = Effect.fn("Operator.editAndRetry")(function* (instance, runId, edit) {
+        yield* Effect.annotateCurrentSpan({ runId, agent: edit.agent });
+        const file = instance.agents.find(({ name }) => name === edit.agent);
+        if (file === undefined)
+            return yield* new RosterAgentNotFoundError({
+                agent: edit.agent,
+                message: `Agent ${edit.agent} is not in the roster`,
+            });
+        const agent = file.agent;
+        yield* runs.retry(runId, Option.some(new AttemptContext({
+            task: edit.task,
+            agent,
+            parentModel: resolveParentModel(agent, instance.config.settings.parentModel),
+        })));
+        yield* Effect.logInfo("Operator amended and retried Run", { runId, agent: agent.name });
+    });
+    const intervene = Effect.fn("Operator.intervene")(function* (instance, runId, input) {
+        yield* Effect.annotateCurrentSpan({
+            runId,
+            attemptId: input.attemptId,
+            action: input.action._tag,
+        });
+        yield* runs.intervene(runId, input.attemptId, new Intervention({
+            operator: Option.getOrElse(instance.config.operator, () => "local operator"),
+            target: input.target,
+            action: input.action,
+        }));
+    });
+    const cancel = Effect.fn("Operator.cancel")(function* (runId) {
+        yield* Effect.annotateCurrentSpan({ runId });
+        yield* runs.cancel(runId);
+        yield* Effect.logInfo("Operator canceled Run", { runId });
+    });
+    const pause = Effect.fn("Operator.pause")(function* (loop) {
+        yield* Effect.annotateCurrentSpan({ loop });
+        return yield* controls.pause(loop);
+    });
+    const unpause = Effect.fn("Operator.unpause")(function* (loop) {
+        yield* Effect.annotateCurrentSpan({ loop });
+        return yield* controls.unpause(loop);
+    });
+    const moveBoardItem = Effect.fn("Operator.moveBoardItem")(function* (instance, move) {
+        yield* Effect.annotateCurrentSpan({
+            repository: move.repository,
+            item: move.item,
+            lane: move.toLane,
+        });
+        const repository = instance.config.repos.find(({ name }) => name === move.repository);
+        if (repository === undefined) {
+            return yield* new BoardProjectNotFound({ repository: move.repository });
+        }
+        const [storedItems, labelProjection] = yield* Effect.all([
+            items.list(move.repository, { limit: OVERVIEW_BOARD_ITEMS }),
+            repositoryLabels.get(move.repository),
+        ], { concurrency: "unbounded" });
+        const board = yield* projectBoard(repository, Option.match(labelProjection, {
+            onNone: () => [],
+            onSome: ({ labels }) => labels.map(({ name }) => name),
+        }), storedItems, []);
+        const source = board.lanes.find(({ items: laneItems }) => laneItems.some(({ items }) => items.some(({ number }) => number === move.item)));
+        const movedItem = storedItems.find(({ number }) => number === move.item);
+        if (source === undefined || movedItem === undefined) {
+            return yield* new BoardItemNotFound({ repository: move.repository, item: move.item });
+        }
+        const target = board.lanes.find(({ id }) => id === move.toLane);
+        if (target === undefined) {
+            return yield* new BoardLaneNotFound({ repository: move.repository, lane: move.toLane });
+        }
+        if (target._tag === "ReadOnlyBoardLane") {
+            return yield* new BoardLaneReadOnly({ repository: move.repository, lane: move.toLane });
+        }
+        const mutation = labelMutationForBoardMove(board, target);
+        const changed = { number: move.item, updatedAt: yield* DateTime.now };
+        const item = movedItem.source === "pr" ? new ChangedPullRequest(changed) : new ChangedIssue(changed);
+        const applied = yield* github.updateLabels(move.repository, move.item, mutation).pipe(
+        // A failed or interrupted request may have applied part of the label
+        // swap. Reconcile it without replacing the writer's original outcome.
+        Effect.onExit((exit) => polling.hint(move.repository, item, Option.flatMap(Exit.findErrorOption(exit), (error) => error._tag === "GitHubRateLimitError" ? Option.some(error.retryAt) : Option.none()))));
+        yield* Effect.logInfo("Operator moved a Board card and queued its authoritative refresh", {
+            repository: move.repository,
+            item: move.item,
+            fromLane: source.id,
+            toLane: target.id,
+            addedLabels: mutation.add.join(", "),
+            removedLabels: mutation.remove.join(", "),
+            labels: applied.join(", "),
+        });
+    }, Effect.tapError((error) => Effect.logWarning("Board move rejected", {
+        errorTag: error._tag,
+        message: error.message,
+    })));
+    const resetCycleBudget = Effect.fn("Operator.resetCycleBudget")(function* (askId) {
+        yield* Effect.annotateCurrentSpan({ askId });
+        const key = `cycle-budget-reset:${askId}`;
+        yield* budgets.reset(askId, new Event({
+            id: EventId.make(key),
+            dedupKey: DedupKey.make(key),
+            payload: { action: "reset-cycle-budget", askId },
+            receivedAt: yield* DateTime.now,
+        }));
+    });
+    return {
+        ...observation,
+        approve,
+        cancel,
+        moveBoardItem,
+        pause,
+        retry,
+        editAndRetry,
+        intervene,
+        unpause,
+        resetCycleBudget,
+    };
+});
+/** The operator's view of the factory and actions for approving, retrying, canceling, and directing work. */
+export class Operator extends Context.Service()("@usine/orchestrator/Operator") {
+    static layer = Layer.effect(Operator, makeOperator).pipe(Layer.provide(OperatorObservation.layer));
+}
+export { ProjectStatus, ProjectView, LoopView, ReadyOverview, NeedsSetupOverview, FactoryOverview, } from "./overview.js";
+export { RunStateTag, RunView, RunDetailView, EditAndRetry, SessionIntervention, RosterAgentNotFoundError, } from "./run.js";
+export { InfraFailureView, DefectFailureView, AgentFailureView, RunawayFailureView, ChildSessionBudgetFailureView, FailureView, SucceededAttemptView, FailedAttemptView, CanceledAttemptView, AttemptOutcomeView, AttemptView, } from "./attempt.js";
+export { BoardLaneId, BoardLaneOrigin, BoardItemLink, BoardTaskView, WritableBoardLaneView, ReadOnlyBoardLaneView, BoardLaneView, BoardProjectionError, BoardView, LabelView, BoardMove, BoardProjectNotFoundError, BoardItemNotFoundError, BoardLaneNotFoundError, BoardLaneReadOnlyError, } from "./board.js";
+export { ApprovalNeed, CycleBudgetNeed, RunFailureNeed, PollFailureNeed, PreflightFindingNeed, BoardProjectionNeed, ScheduleFailureNeed, NeedView, } from "./need.js";
+export { FailedTranscriptView, TranscriptPayload, TranscriptEventView, TranscriptPageCursor, ColdTranscriptRequest, TailTranscriptRequest, EarlierTranscriptRequest, TranscriptRequest, TranscriptAttemptNotFoundError, } from "./transcript.js";
+//# sourceMappingURL=operator.js.map