@oisincoveney/pipeline 3.11.19 → 3.12.0

package/dist/argo-workflow.js

@@ -21,6 +21,9 @@ const RUNNER_RETRY_STRATEGY = {
 const RUNNER_OPENCODE_ENV = [{
 	name: "CODEX_AUTH_PER_PROJECT_ACCOUNTS",
 	value: "0"
+}, {
+	name: "PIPELINE_AGENT_TIMEOUT_MS",
+	value: "1200000"
 }];
 const DEFAULT_RUNNER_RESOURCES = {
 	limits: {
@@ -32,7 +35,7 @@ const DEFAULT_RUNNER_RESOURCES = {
 		memory: "5Gi"
 	}
 };
-const DEFAULT_RUNNER_DEADLINE_SECONDS = 3600;
+const DEFAULT_RUNNER_DEADLINE_SECONDS = 5400;
 const kubernetesNameSchema = z.string().min(1);
 const labelValueSchema = z.string().min(1);
 const stringMapSchema = z.record(z.string().min(1), z.string().min(1));

package/dist/cli/program.js

@@ -15,6 +15,9 @@ import { registerRunnerCommandCommand } from "../commands/runner-command-command
 import { MOKA_RUN_EFFORTS, MOKA_RUN_TARGETS, resolveMokaRun } from "./run-resolver.js";
 import { registerTicketCommand } from "../commands/ticket-command.js";
 import { formatConfigLintWarning, lintPipelineConfig } from "../config/lint.js";
+import { parseLoopFlags, runLoopSubmit } from "../loop/loop-command.js";
+import { runLoopControllerEntrypoint } from "../loop/loop-controller-entrypoint.js";
+import { loadMokaGlobalConfig } from "../moka-global-config.js";
 import { formatPipelineInitResult, initPipelineProject } from "../pipeline-init.js";
 import { createRun, runControlStatusPaths, updateRunController } from "../run-control/store.js";
 import { registerRunControlCommands } from "../run-control/commands.js";
@@ -357,6 +360,7 @@ function createCliProgram(options = {}) {
 	].join("\n")).argument("[input...]", "task description, or command argv with --command")).action(async (input, flags) => {
 		printMokaSubmitResult(await runMokaSubmitFromCli(input, flags));
 	});
+	registerLoopCommand(program);
 	registerRunnerCommandCommand(program);
 	registerBenchCommand(program);
 	registerTicketCommand(program, {
@@ -372,6 +376,51 @@ function createCliProgram(options = {}) {
 	} });
 	return program;
 }
+/**
+* Register `moka loop` (submit the cloud controller) and the hidden
+* `moka loop-controller` (the in-cluster process that drives the loop). The
+* public command validates the backlog and submits; a cyclic or empty backlog
+* refuses to start with a non-zero exit.
+*/
+function registerLoopCommand(program) {
+	program.command("loop").description("Submit a long-running cloud controller that drains the backlog ticket-by-ticket").addOption(new Option$1("--strategy <strategy>", "ready-ticket selection strategy").choices([
+		"priority",
+		"bfs",
+		"dfs"
+	]).default("priority")).option("--root <epic-id>", "restrict traversal to this epic subtree").option("--max-remediation-attempts <n>", "bounded fix-up submits before a PR is declared blocked").option("--merge-timeout <n>", "bounded merge polls before an indeterminate PR is declared blocked").action(async (options) => {
+		const result = await runLoopSubmit(buildLoopSubmitInput(options));
+		console.log(`Loop controller submitted: ${result.workflowName} in ${result.namespace}`);
+	});
+	program.command("loop-controller", { hidden: true }).description("Internal in-cluster loop controller process").requiredOption("--payload-file <path>", "Path to the runner payload JSON").addOption(new Option$1("--strategy <strategy>", "ready-ticket selection strategy").choices([
+		"priority",
+		"bfs",
+		"dfs"
+	]).default("priority")).option("--root <epic-id>", "restrict traversal to this epic subtree").option("--max-remediation-attempts <n>", "bounded fix-up submits").option("--merge-timeout <n>", "bounded merge polls").action(async (flags) => {
+		await runLoopControllerEntrypoint({
+			flags: parseLoopFlags(flags),
+			payloadFile: flags.payloadFile,
+			worktreePath: process.env.PIPELINE_TARGET_PATH ?? process.cwd()
+		});
+	});
+}
+function buildLoopSubmitInput(options) {
+	const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+	const config = loadPipelineConfig(cwd, { allowMissingLintFileReferences: true });
+	const momokaya = loadMokaGlobalConfig()?.momokaya;
+	return {
+		config,
+		eventUrl: momokaya?.submit.eventUrl,
+		flags: parseLoopFlags(options),
+		gitCredentialsSecretName: momokaya?.submit.gitCredentialsSecretName,
+		githubAuthSecretName: momokaya?.submit.githubAuthSecretName,
+		kubeconfigPath: momokaya?.kubernetes.kubeconfig,
+		namespace: momokaya?.kubernetes.namespace,
+		opencodeAuthSecretName: momokaya?.submit.opencodeAuthSecretName,
+		opencodeOpenaiAccountsSecretName: momokaya?.submit.opencodeOpenaiAccountsSecretName,
+		serviceAccountName: momokaya?.submit.serviceAccountName,
+		worktreePath: cwd
+	};
+}
 function runLocalResolvedTask(task, execution, runControl) {
 	return execute(task, {
 		entrypoint: execution.entrypoint,

package/dist/cli/run-command.d.ts

@@ -6,6 +6,7 @@ interface RunCommandCall {
   readonly flags: RunResolverFlags;
   readonly resolution: RunResolution;
   readonly task: string;
+  readonly ticketId?: string;
 }
 type RunCommand = (call: RunCommandCall) => Promise<void> | void;
 //#endregion

package/dist/cli/submit-options.js

@@ -1,7 +1,7 @@
 import { loadPipelineConfig } from "../config/load.js";
 import "../config.js";
-import { loadMokaGlobalConfig } from "../moka-global-config.js";
 import { submitMoka } from "../moka-submit.js";
+import { loadMokaGlobalConfig } from "../moka-global-config.js";
 import { Option } from "commander";
 //#region src/cli/submit-options.ts
 function addMokaSubmitOptions(command) {

package/dist/commands/ticket-command.js

@@ -4,11 +4,11 @@ import "../config.js";
 import { RepoIoServiceLive } from "../runtime/services/repo-io-service.js";
 import { createRunnerLaunchPlan, runLaunchPlan } from "../runner.js";
 import { normalizeRunnerOutput } from "../runner-output.js";
+import { buildTicketGraphEffect, scopedTicketIds, sequenceTicketBatchesEffect } from "../tickets/ticket-graph.js";
 import { MOKA_RUN_EFFORTS, MOKA_RUN_TARGETS, resolveMokaRun } from "../cli/run-resolver.js";
 import { BacklogService, BacklogServiceLive } from "../runtime/services/backlog-service.js";
 import { applyTicketPlanEffect } from "../tickets/apply-ticket-plan.js";
 import { loadBacklogTaskStoreEffect } from "../tickets/backlog-task-store.js";
-import { buildTicketGraphEffect, scopedTicketIds, sequenceTicketBatchesEffect } from "../tickets/ticket-graph.js";
 import { renderTicketPlanDryRun } from "../tickets/ticket-plan-render.js";
 import { selectNextTicket, selectReadyTickets } from "../tickets/ticket-selection.js";
 import { Data, Effect } from "effect";
@@ -47,7 +47,7 @@ function startTicketEffect(worktreePath, flags, runCommand) {
 	return Effect.gen(function* () {
 		const { loaded, selectionOptions } = yield* loadTicketSelectionEffect(worktreePath, flags);
 		const selected = yield* readyTicketEffect(selectNextTicket(loaded.graph, selectionOptions));
-		const task = ticketRunTask(selected);
+		const { task, ticketId } = ticketRunTask(selected);
 		const descriptionParts = [task];
 		const runFlags = yield* ticketStartRunFlagsEffect(flags);
 		const resolution = yield* Effect.try({
@@ -71,16 +71,31 @@ function startTicketEffect(worktreePath, flags, runCommand) {
 					descriptionParts,
 					flags: runFlags,
 					resolution,
-					task
+					task,
+					ticketId
 				});
 			}
 		});
 	});
 }
+const BACKLOG_STATUS_DIRECTIVE = `\
+## Backlog ticket management
+
+Your first action must be to set this ticket to "In Progress":
+  backlog task edit <TICKET_ID> --status "In Progress" --plain
+
+Your final action on completion must be to set this ticket to "Done" and update \
+its acceptance criteria through the backlog tools:
+  backlog task edit <TICKET_ID> --status "Done" --plain
+
+Use backlog tools on your working branch. Do not hand-edit the task markdown file.`;
 function ticketRunTask(ticket) {
 	const title = formatNextTicket(ticket);
 	const description = ticket.description?.trim();
-	return description ? `${title}\n\n${description}` : title;
+	return {
+		task: `${description ? `${title}\n\n${description}` : title}\n\n${BACKLOG_STATUS_DIRECTIVE.replaceAll("<TICKET_ID>", ticket.id)}`,
+		ticketId: ticket.id
+	};
 }
 function ticketStartRunFlagsEffect(flags) {
 	return Effect.gen(function* () {

package/dist/config/schemas.d.ts

@@ -536,7 +536,12 @@ declare const configSchema: z.ZodObject<{
   delivery: z.ZodOptional<z.ZodObject<{
     pull_request: z.ZodOptional<z.ZodObject<{
       enabled: z.ZodDefault<z.ZodBoolean>;
+      head_branch: z.ZodOptional<z.ZodString>;
       label: z.ZodDefault<z.ZodString>;
+      mode: z.ZodDefault<z.ZodEnum<{
+        "create-new-pr": "create-new-pr";
+        "update-existing-pr": "update-existing-pr";
+      }>>;
     }, z.core.$strict>>;
   }, z.core.$strict>>;
   durability: z.ZodOptional<z.ZodObject<{

package/dist/config/schemas.js

@@ -488,7 +488,9 @@ const repoMapSchema = z.object({
 }).strict();
 const deliverySchema = z.object({ pull_request: z.object({
 	enabled: z.boolean().default(false),
-	label: z.string().min(1).default("preview")
+	head_branch: z.string().min(1).optional(),
+	label: z.string().min(1).default("preview"),
+	mode: z.enum(["create-new-pr", "update-existing-pr"]).default("create-new-pr")
 }).strict().optional() }).strict();
 const pipelineFileSchema = z.object({
 	default_workflow: z.string(),

package/dist/loop/argo-poll.d.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+
+//#region src/loop/argo-poll.d.ts
+/**
+ * Minimal slice of CustomObjectsApi needed to read an Argo Workflow.
+ * Kept narrow so tests can inject a trivial fake without constructing a full
+ * KubeConfig or hitting a real cluster.
+ */
+interface WorkflowReadApi {
+  getNamespacedCustomObject(param: {
+    group: string;
+    name: string;
+    namespace: string;
+    plural: string;
+    version: string;
+  }): Promise<unknown>;
+}
+//#endregion
+export { WorkflowReadApi };

package/dist/loop/argo-poll.js

@@ -0,0 +1,124 @@
+import { isRecord } from "../safe-json.js";
+import { Duration, Effect } from "effect";
+import { CustomObjectsApi, KubeConfig } from "@kubernetes/client-node";
+//#region src/loop/argo-poll.ts
+const TERMINAL_PHASES = new Set([
+	"Succeeded",
+	"Failed",
+	"Error"
+]);
+const KNOWN_RUNNING_PHASES = new Set([
+	"Running",
+	"Pending",
+	""
+]);
+function isTerminal(phase) {
+	return TERMINAL_PHASES.has(phase);
+}
+/** Exported for reuse in KubernetesArgoService. */
+function classifyArgoPhase(raw) {
+	return classifyPhase(raw);
+}
+function classifyPhase(raw) {
+	if (TERMINAL_PHASES.has(raw)) {
+		if (raw === "Succeeded") return "Succeeded";
+		if (raw === "Failed") return "Failed";
+		return "Error";
+	}
+	if (KNOWN_RUNNING_PHASES.has(raw)) {
+		if (raw === "Running") return "Running";
+		if (raw === "Pending") return "Pending";
+		return "";
+	}
+	return "Running";
+}
+function buildWorkflowReadApi(options) {
+	const kc = new KubeConfig();
+	if (options.kubeconfigPath) kc.loadFromFile(options.kubeconfigPath);
+	else kc.loadFromDefault();
+	return kc.makeApiClient(CustomObjectsApi);
+}
+/**
+* Fetch the Argo Workflow object and extract `.status.phase`.
+* Unknown phase values are mapped to Running so the poll loop continues
+* until Argo reports a known terminal phase.
+*/
+function getWorkflowPhase(options) {
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => options.workflowReadApi.getNamespacedCustomObject({
+			group: "argoproj.io",
+			name: options.workflowName,
+			namespace: options.namespace,
+			plural: "workflows",
+			version: "v1alpha1"
+		})
+	}).pipe(Effect.map((resource) => classifyPhase(extractRawPhase(resource))));
+}
+/**
+* Walk the k8s response record with isRecord guards and pull out the raw phase string.
+* Returns "" (Argo pending) when the field is absent or not a string.
+* Exported for reuse in KubernetesArgoService.
+*/
+function extractArgoRawPhase(resource) {
+	return extractRawPhase(resource);
+}
+function extractRawPhase(resource) {
+	if (!isRecord(resource)) return "";
+	const status = resource.status;
+	if (!isRecord(status)) return "";
+	const phase = status.phase;
+	return typeof phase === "string" ? phase : "";
+}
+const DEFAULT_POLL_INTERVAL_MS = 5e3;
+const DEFAULT_MAX_RETRIES = 10;
+const RETRY_BASE_DELAY_MS = 250;
+/**
+* Poll an Argo Workflow until it reaches a terminal phase (Succeeded/Failed/Error).
+*
+* Transient k8s API errors are retried with exponential backoff up to maxRetries
+* times, and reported via onTransientError on each attempt. Exhausted budget
+* fails the Effect with the last error — never silently resolves to a fake terminal.
+*
+* Uses in-cluster service-account auth by default (loadFromDefault()); pass
+* kubeconfigPath to override, or inject workflowReadApi directly for testing.
+*/
+function pollWorkflowPhaseUntilTerminal(options) {
+	const api = options.workflowReadApi ?? buildWorkflowReadApi({ kubeconfigPath: options.kubeconfigPath });
+	const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	return pollLoop({
+		namespace: options.namespace,
+		workflowName: options.workflowName,
+		workflowReadApi: api,
+		pollIntervalMs,
+		maxRetries,
+		onTransientError: options.onTransientError,
+		errorCount: 0
+	});
+}
+function pollLoop(state) {
+	return getWorkflowPhase({
+		namespace: state.namespace,
+		workflowName: state.workflowName,
+		workflowReadApi: state.workflowReadApi
+	}).pipe(Effect.flatMap((phase) => {
+		if (isTerminal(phase)) return Effect.succeed(phase);
+		return Effect.sleep(Duration.millis(state.pollIntervalMs)).pipe(Effect.zipRight(pollLoop({
+			...state,
+			errorCount: 0
+		})));
+	}), Effect.catchAll((error) => handlePollError(state, error)));
+}
+function handlePollError(state, error) {
+	const nextErrorCount = state.errorCount + 1;
+	state.onTransientError?.(error, nextErrorCount);
+	if (nextErrorCount > state.maxRetries) return Effect.fail(error);
+	const delay = Duration.millis(RETRY_BASE_DELAY_MS * 2 ** (nextErrorCount - 1));
+	return Effect.sleep(delay).pipe(Effect.zipRight(pollLoop({
+		...state,
+		errorCount: nextErrorCount
+	})));
+}
+//#endregion
+export { classifyArgoPhase, extractArgoRawPhase, pollWorkflowPhaseUntilTerminal };

package/dist/loop/backlog-records.js

@@ -0,0 +1,9 @@
+import { RepoIoServiceLive } from "../runtime/services/repo-io-service.js";
+import { loadBacklogTaskStoreEffect } from "../tickets/backlog-task-store.js";
+import { Effect } from "effect";
+//#region src/loop/backlog-records.ts
+function loadBacklogRecords(worktreePath) {
+	return loadBacklogTaskStoreEffect(worktreePath).pipe(Effect.map((store) => store.tasks), Effect.mapError((error) => new Error(error.message)), Effect.provide(RepoIoServiceLive));
+}
+//#endregion
+export { loadBacklogRecords };

package/dist/loop/controller-deps.js

@@ -0,0 +1,227 @@
+import { runAuthenticatedGit } from "../run-state/git-refs.js";
+import { RunnerEventSinkHttpService, RunnerEventSinkHttpServiceLive } from "../runtime/services/runner-event-sink-http-service.js";
+import { pollWorkflowPhaseUntilTerminal } from "./argo-poll.js";
+import { ticketGraphDtoSchema } from "../tickets/ticket-graph-dto.js";
+import { submitMoka } from "../moka-submit.js";
+import { loadBacklogRecords } from "./backlog-records.js";
+import { classifyRequiredChecks, resolvePrForRun } from "./gh-checks.js";
+import { createGhRunner } from "./gh-runner.js";
+import { mergeForClassification } from "./merge.js";
+import { Effect } from "effect";
+import { randomBytes } from "node:crypto";
+//#region src/loop/controller-deps.ts
+/**
+* Build the production `ControllerDeps`. `context` carries the static run
+* context; `seams` overrides any external boundary (used by tests to avoid
+* GitHub / k8s / git).
+*/
+function buildControllerDeps(context, seams = {}) {
+	const gh = seams.gh ?? createGhRunner();
+	const generateRunId = seams.generateRunId ?? defaultRunId;
+	const submit = seams.submitRun ?? defaultSubmitRun(context, seams.submitMoka ?? submitMoka);
+	const loadTasks = seams.loadTasks ?? loadBacklogRecords;
+	const gitRefresh = seams.gitRefresh ?? defaultGitRefresh;
+	const pollPhase = seams.pollPhase ?? defaultPollPhase;
+	return {
+		classifyChecks: (pr, runner) => classifyMergeSignal(pr, runner),
+		emit: buildEmit(context, seams.postEvent),
+		gh,
+		loadGraph: () => loadTasks(context.worktreePath),
+		maxMergePolls: context.maxMergePolls,
+		maxRemediationAttempts: context.maxRemediationAttempts,
+		merge: ({ classification, pr }) => mergeForClassification({
+			classification,
+			gh,
+			pr
+		}),
+		pollPhase: (input) => pollPhase({
+			namespace: context.namespace,
+			runId: input.runId,
+			workflowName: input.workflowName
+		}),
+		refreshBacklog: () => Effect.tryPromise({
+			catch: refreshError,
+			try: () => gitRefresh(context.worktreePath)
+		}).pipe(Effect.flatMap(() => loadTasks(context.worktreePath))),
+		resolvePr: (runId, runner) => resolvePrForRun(runId, runner),
+		rootId: context.rootId,
+		sleep: (ms) => Effect.sleep(ms),
+		strategy: context.strategy,
+		submitRun: (input) => adaptSubmit(submit, generateRunId, input)
+	};
+}
+/**
+* Return "merged" when GitHub reports the PR landed; otherwise delegate to the
+* required-check classifier. The PR-state read is a single `gh pr view` json
+* call; an unparsable response is surfaced (never silently treated as merged).
+*/
+function classifyMergeSignal(pr, gh) {
+	return gh.json([
+		"pr",
+		"view",
+		String(pr.number),
+		"--json",
+		"state"
+	]).pipe(Effect.flatMap((raw) => parsePrState(raw)), Effect.flatMap((state) => state === "MERGED" ? Effect.succeed("merged") : classifyRequiredChecks(pr, gh)));
+}
+function parsePrState(raw) {
+	if (typeof raw === "object" && raw !== null && "state" in raw && typeof raw.state === "string") return Effect.succeed(raw.state);
+	return Effect.fail(/* @__PURE__ */ new Error("gh pr view response missing string `state`"));
+}
+function adaptSubmit(submit, generateRunId, input) {
+	const runId = generateRunId();
+	return submit({
+		deliveryMode: input.deliveryMode,
+		headBranch: input.headBranch,
+		repositorySha: input.repositorySha,
+		runId,
+		task: input.ticketId
+	}).pipe(Effect.map((result) => ({
+		runId,
+		workflowName: result.workflowName
+	})));
+}
+/**
+* Default submit seam: shape a graph submitMoka call. For remediation
+* (`update-existing-pr`) it forwards `delivery.mode`, the PR head sha
+* (`repository.sha`) and the PR branch (`repository.headBranch` =
+* `moka/run/<originalRunId>`) so fix-commits APPEND to the existing PR branch.
+*/
+function defaultSubmitRun(context, submit) {
+	return (request) => Effect.tryPromise({
+		catch: submitError,
+		try: () => submit({
+			config: context.config,
+			delivery: {
+				mode: request.deliveryMode,
+				pullRequest: true
+			},
+			eventUrl: context.eventUrl,
+			gitCredentialsSecretName: context.gitCredentialsSecretName,
+			githubAuthSecretName: context.githubAuthSecretName,
+			mode: "full",
+			namespace: context.namespace,
+			opencodeAuthSecretName: context.opencodeAuthSecretName,
+			opencodeOpenaiAccountsSecretName: context.opencodeOpenaiAccountsSecretName,
+			repository: submitRepository(context, request),
+			run: {
+				id: request.runId,
+				project: context.project
+			},
+			serviceAccountName: context.serviceAccountName,
+			task: request.task,
+			type: "graph"
+		})
+	}).pipe(Effect.map((result) => ({ workflowName: result.workflowName })));
+}
+/**
+* Repository context for a child submit. Remediation overrides the head sha and
+* head branch so the workspace IS the PR branch; the create path leaves them
+* absent (the runner cuts a fresh `moka/run/<runId>` branch from baseBranch).
+*/
+function submitRepository(context, request) {
+	return {
+		baseBranch: context.baseBranch,
+		...request.headBranch ? { headBranch: request.headBranch } : {},
+		...request.repositorySha ? { sha: request.repositorySha } : {},
+		url: context.url
+	};
+}
+/** One owner of LoopControllerEvent → RunnerEventRecord, keyed on event type. */
+const RECORD_BUILDER = {
+	"loop.start": (event, envelope) => event.type === "loop.start" ? {
+		...envelope,
+		loopStart: { strategy: event.strategy },
+		type: "loop.start"
+	} : unreachable(event),
+	"loop.graph.snapshot": (event, envelope) => event.type === "loop.graph.snapshot" ? {
+		...envelope,
+		loopGraphSnapshot: ticketGraphDtoSchema.parse(event.snapshot),
+		type: "loop.graph.snapshot"
+	} : unreachable(event),
+	"loop.node.transition": (event, envelope) => event.type === "loop.node.transition" ? {
+		...envelope,
+		loopNodeTransition: {
+			loopState: event.loopState,
+			ticketId: event.ticketId
+		},
+		type: "loop.node.transition"
+	} : unreachable(event),
+	"loop.finish": (event, envelope) => event.type === "loop.finish" ? {
+		...envelope,
+		loopFinish: {
+			blocked: event.blocked,
+			passed: event.passed
+		},
+		type: "loop.finish"
+	} : unreachable(event)
+};
+function unreachable(event) {
+	throw new Error(`unexpected loop event for builder: ${event.type}`);
+}
+function buildEmit(context, postEvent) {
+	const post = postEvent ?? defaultPostEvent(context);
+	let sequence = 0;
+	return (event) => Effect.promise(() => {
+		sequence += 1;
+		return post(RECORD_BUILDER[event.type](event, {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			runId: context.runId,
+			sequence
+		}));
+	});
+}
+/**
+* Default sink: POST the single loop.* record through the authenticated runner
+* event-sink batch endpoint (the same path runtime records use). The records
+* carry the loop.* shapes the console consumes; sequence is monotonic per run.
+*/
+function defaultPostEvent(context) {
+	const fetchImpl = globalThis.fetch?.bind(globalThis);
+	if (!fetchImpl) throw new Error("Loop controller event sink requires fetch support");
+	return (record) => Effect.runPromise(Effect.provide(Effect.flatMap(RunnerEventSinkHttpService, (service) => service.postBatch({
+		authHeader: context.eventAuthHeader,
+		authToken: context.eventAuthToken,
+		events: [record],
+		fetch: fetchImpl,
+		maxRetries: 0,
+		retryDelayMs: 250,
+		url: context.eventUrl
+	})), RunnerEventSinkHttpServiceLive));
+}
+async function defaultGitRefresh(worktreePath) {
+	await runAuthenticatedGit(worktreePath, [
+		"fetch",
+		"origin",
+		"main"
+	]);
+	await runAuthenticatedGit(worktreePath, [
+		"pull",
+		"--ff-only",
+		"origin",
+		"main"
+	]);
+}
+function defaultPollPhase(input) {
+	return pollWorkflowPhaseUntilTerminal({
+		namespace: input.namespace,
+		workflowName: input.workflowName
+	}).pipe(Effect.mapError(toError));
+}
+function defaultRunId() {
+	return `loop-${randomBytes(8).toString("hex")}`;
+}
+function refreshError(error) {
+	return /* @__PURE__ */ new Error(`backlog refresh failed: ${messageOf(error)}`);
+}
+function submitError(error) {
+	return /* @__PURE__ */ new Error(`child run submit failed: ${messageOf(error)}`);
+}
+function toError(error) {
+	return error instanceof Error ? error : new Error(messageOf(error));
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+export { buildControllerDeps };