cloving 1.3.0 → 1.4.0

package/dist/src/daemon/worktree-processes.js

@@ -0,0 +1,151 @@
+import { execFile } from "node:child_process";
+import { readdir, readlink, realpath } from "node:fs/promises";
+import { resolve, sep } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+import { writeRecord } from "./operation-journal.js";
+const execute = promisify(execFile);
+async function output(command, arguments_) {
+    return (await execute(command, arguments_, {
+        encoding: "utf8",
+        timeout: 5000,
+        maxBuffer: 8 * 1024 * 1024,
+    })).stdout;
+}
+async function directories() {
+    if (process.platform === "linux") {
+        const entries = await readdir("/proc");
+        const links = await Promise.all(entries
+            .filter((entry) => /^\d+$/.test(entry))
+            .map(async (entry) => {
+            const directory = await readlink(`/proc/${entry}/cwd`).catch(() => undefined);
+            return [Number(entry), directory];
+        }));
+        return new Map(links.filter((entry) => entry[1] !== undefined));
+    }
+    const text = await output("lsof", ["-d", "cwd", "-Fpn", "-n", "-P"]);
+    const found = new Map();
+    let processId = 0;
+    for (const line of text.split("\n")) {
+        if (line.startsWith("p"))
+            processId = Number(line.slice(1));
+        if (line.startsWith("n"))
+            found.set(processId, line.slice(1));
+    }
+    return found;
+}
+async function processes() {
+    try {
+        const text = await output("ps", ["-axo", "pid=,pgid=,uid="]);
+        const entries = text
+            .trim()
+            .split("\n")
+            .map((line) => {
+            const [processId = 0, group = 0, user = -1] = line
+                .trim()
+                .split(/\s+/)
+                .map(Number);
+            return { processId, group, user };
+        });
+        const working = await directories();
+        return entries.map((entry) => {
+            const directory = working.get(entry.processId);
+            return { ...entry, ...(directory === undefined ? {} : { directory }) };
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function inTree(entry, directory) {
+    if (entry.processId <= 1 ||
+        entry.processId === process.pid ||
+        entry.directory === undefined)
+        return false;
+    const root = resolve(directory);
+    return entry.directory === root || entry.directory.startsWith(root + sep);
+}
+export async function recordedProcessDirectory(processId) {
+    return (await processes())?.find((entry) => entry.processId === processId)
+        ?.directory;
+}
+function terminate(entries, request) {
+    const { directory, signal } = request;
+    const maySignal = (entry) => entry.user === process.getuid?.() && inTree(entry, directory);
+    const found = entries.filter(maySignal);
+    const groups = new Set();
+    for (const entry of found) {
+        const safeGroup = entry.group > 1 &&
+            entries.filter((other) => other.group === entry.group).every(maySignal);
+        const target = safeGroup ? -entry.group : entry.processId;
+        if (groups.has(target))
+            continue;
+        groups.add(target);
+        try {
+            process.kill(target, signal);
+        }
+        catch {
+            continue;
+        }
+    }
+    return found.map((entry) => entry.processId);
+}
+async function treeSnapshot(directory) {
+    const entries = await processes();
+    return entries?.some((entry) => inTree(entry, directory)) === false
+        ? processes()
+        : entries;
+}
+async function waitForTree(request, deadline) {
+    while (!request.signal.aborted) {
+        const entries = await treeSnapshot(request.directory);
+        if (entries === undefined ||
+            !entries.some((entry) => inTree(entry, request.directory)) ||
+            performance.now() >= deadline)
+            return entries;
+        await delay(Math.min(250, Math.max(0, deadline - performance.now())));
+    }
+    return undefined;
+}
+export async function stopTreeProcesses(request) {
+    const directory = await realpath(request.directory).catch(() => undefined);
+    return directory === undefined
+        ? false
+        : stopCanonicalTree({ ...request, directory });
+}
+async function stopCanonicalTree(request) {
+    const entries = await treeSnapshot(request.directory);
+    const aborted = () => request.signal.aborted;
+    if (entries === undefined || aborted())
+        return false;
+    const processIds = terminate(entries, {
+        directory: request.directory,
+        signal: "SIGTERM",
+    });
+    let remaining = processIds.length === 0
+        ? entries
+        : await waitForTree(request, performance.now() + (request.stopMilliseconds ?? 15_000));
+    if (remaining === undefined || aborted())
+        return recordCleanup(request, { processIds, remaining });
+    const killed = terminate(remaining, {
+        directory: request.directory,
+        signal: "SIGKILL",
+    });
+    processIds.push(...killed);
+    if (killed.length > 0)
+        remaining = await waitForTree(request, performance.now() + 1000);
+    return recordCleanup(request, { processIds, remaining });
+}
+async function recordCleanup(request, cleanup) {
+    const remainingProcessIds = cleanup.remaining
+        ?.filter((entry) => inTree(entry, request.directory))
+        .map((entry) => entry.processId);
+    await writeRecord(request.folder, {
+        name: "resume-processes.json",
+        value: {
+            processIds: [...new Set(cleanup.processIds)],
+            remainingProcessIds,
+        },
+    });
+    return !request.signal.aborted && remainingProcessIds?.length === 0;
+}

package/dist/src/doctor-report.d.ts

@@ -1,5 +1,5 @@
 import { type SubmissionContract } from "./submission.ts";
-export declare const doctorCodes: readonly ["git-repository", "node-version", "harnesses", "default-harness", "gh-login", "github-origin", "greptile-review", "settings-files", "runtime-directory", "service", "ticket-command", "next-command", "check-command", "queue-interval", "private-texts"];
+export declare const doctorCodes: readonly ["git-repository", "node-version", "harnesses", "default-harness", "gh-login", "github-origin", "greptile-review", "settings-files", "no-workflow", "runtime-directory", "service", "ticket-command", "next-command", "check-command", "queue-interval", "private-texts"];
 export type DoctorCode = (typeof doctorCodes)[number];
 export interface DoctorObservation {
     readonly result: "ok" | "fail" | "skip";
@@ -14,11 +14,9 @@ export declare const doctorFixes: Readonly<Record<DoctorCode, string>>;
 export declare function doctorExitCode(checks: readonly DoctorCheck[]): number;
 export interface DoctorWorkflow {
     readonly queue?: boolean;
-    readonly scope: "bundled" | "project" | "user";
+    readonly scope: "project" | "user";
     readonly workflowId: string;
     readonly capabilities: readonly string[];
     readonly input?: SubmissionContract;
 }
-export declare function requiredDoctorCodes(workflows: readonly DoctorWorkflow[], options: {
-    readonly queueSeconds: string | undefined;
-}): readonly DoctorCode[];
+export declare function requiredDoctorCodes(workflows: readonly DoctorWorkflow[]): readonly DoctorCode[];

package/dist/src/doctor-report.js

@@ -8,6 +8,7 @@ export const doctorCodes = [
     "github-origin",
     "greptile-review",
     "settings-files",
+    "no-workflow",
     "runtime-directory",
     "service",
     "ticket-command",
@@ -25,6 +26,7 @@ export const doctorFixes = {
     "github-origin": "Set a GitHub origin: git remote add origin git@github.com:OWNER/REPO.git || git remote set-url origin git@github.com:OWNER/REPO.git",
     "greptile-review": "Install the Greptile app at https://github.com/apps/greptile, then open a first pull request: gh pr create",
     "settings-files": "Fix the project JSON: ${EDITOR:-vi} .cloving/config.json; for private JSON, edit <config>/cloving/projects/<repository-id>.json",
+    "no-workflow": "cloving init",
     "runtime-directory": 'Select a private writable runtime: CLOVING_RUNTIME_DIR="$HOME/.local/state/cloving/doctor/run" cloving doctor',
     service: "Start the service: cloving start",
     "ticket-command": "Set tickets.command to an executable list: ${EDITOR:-vi} .cloving/config.json",
@@ -38,33 +40,24 @@ export function doctorExitCode(checks) {
         ? 1
         : 0;
 }
-export function requiredDoctorCodes(workflows, options) {
+export function requiredDoctorCodes(workflows) {
     const codes = new Set([
         "git-repository",
         "node-version",
         "default-harness",
         "settings-files",
+        "no-workflow",
         "runtime-directory",
     ]);
     if (workflows.some((workflow) => workflow.capabilities.includes("github"))) {
         codes.add("gh-login");
         codes.add("github-origin");
     }
-    const bundled = workflows
-        .filter((workflow) => workflow.scope === "bundled")
-        .map((workflow) => workflow.workflowId);
-    const issue = bundled.includes("develop-issue");
-    if (issue)
-        codes.add("check-command");
-    if (workflows.some((workflow) => workflow.queue === true) ||
-        (issue && options.queueSeconds !== undefined)) {
+    if (workflows.some((workflow) => workflow.queue === true)) {
         codes.add("next-command");
         codes.add("queue-interval");
     }
-    if (workflows.some((workflow) => hasTicketField(workflow.input)) ||
-        bundled.some((name) => ["develop-ticket", "develop-issue"].includes(name)))
+    if (workflows.some((workflow) => hasTicketField(workflow.input)))
         codes.add("ticket-command");
-    if (bundled.includes("develop-prd"))
-        codes.add("private-texts");
     return [...codes];
 }

package/dist/src/harness-start.d.ts

@@ -0,0 +1,15 @@
+import { type ShellMode } from "./agent-harness-shell.ts";
+import type { HarnessSelection } from "./configuration-change.ts";
+export interface HarnessStartRequest {
+    readonly executable: string;
+    readonly arguments: readonly string[];
+    readonly directory: string;
+    readonly environment: Readonly<Record<string, string | undefined>>;
+}
+export declare function harnessStartRequest(entry: HarnessSelection & {
+    readonly shellMode?: ShellMode;
+}, context: {
+    readonly repository: string;
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly message: string;
+}): HarnessStartRequest;

package/dist/src/harness-start.js

@@ -0,0 +1,37 @@
+import { shellArguments, shellRunScript, } from "./agent-harness-shell.js";
+const shellStartScript = `
+set +m
+kind=
+if [ -n "\${ZSH_VERSION-}" ]; then
+  kind=$(builtin whence -w -- "$1" 2>/dev/null) || kind=
+  kind="\${kind##*: }"
+elif [ -n "\${BASH_VERSION-}" ]; then
+  kind=$(builtin type -t -- "$1" 2>/dev/null) || kind=
+fi
+case "$kind" in
+  function|alias) ;;
+  *) printf '%s\\n' 'Open your agent in this repository and tell it: run \`cloving init-prompt\`.' >&2; exit 1 ;;
+esac
+${shellRunScript}
+`;
+export function harnessStartRequest(entry, context) {
+    const argumentsList = entry.name === "opencode"
+        ? ["--prompt", context.message]
+        : [context.message];
+    const executable = entry.kind === "shell" ? (context.environment["SHELL"] ?? "") : entry.path;
+    const args = entry.kind === "shell"
+        ? [
+            ...shellArguments(entry.shellMode ?? "login"),
+            shellStartScript,
+            "cloving-init",
+            entry.path,
+            ...argumentsList,
+        ]
+        : argumentsList;
+    return {
+        executable,
+        arguments: args,
+        directory: context.repository,
+        environment: context.environment,
+    };
+}

package/dist/src/host/command-wait.d.ts

@@ -0,0 +1,38 @@
+import type { CommandWaitState } from "../authority/command-waits.ts";
+import type { CommandWaitRequest, CommandWaitProgress } from "../step-bridge.ts";
+interface WaitName {
+    readonly runId: string;
+    readonly name: string;
+}
+interface WaitCall extends WaitName {
+    readonly commandId: string;
+}
+interface WaitReceipt {
+    readonly kind: string;
+    readonly reason?: string;
+}
+export interface CommandWaitPorts {
+    readonly open: (request: WaitCall & {
+        readonly input: string;
+    }) => Promise<WaitReceipt>;
+    readonly check: (request: WaitCall) => Promise<WaitReceipt>;
+    readonly read: (request: WaitName) => Promise<CommandWaitState | undefined>;
+}
+interface WaitHost {
+    readonly commandWait?: CommandWaitPorts;
+    readonly runStatus: (runId: string) => Promise<string | undefined>;
+    readonly subject: () => Promise<{
+        readonly runId: string;
+        readonly commandId: string;
+    } | undefined>;
+    readonly stopped: AbortSignal;
+    readonly pollMilliseconds: number;
+    readonly retryMilliseconds: number;
+}
+export declare function commandWaitBridge(host: WaitHost): {
+    openCommandWait: (request: CommandWaitRequest) => Promise<CommandWaitProgress>;
+    checkCommandWait: (request: {
+        readonly name: string;
+    }) => Promise<CommandWaitProgress>;
+};
+export {};

package/dist/src/host/command-wait.js

@@ -0,0 +1,115 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { commandWaitValue, isCommandWaitRequest } from "../command-wait.js";
+function progress(wait) {
+    if (wait === undefined)
+        return { kind: "refused", reason: "unknown-command-wait" };
+    if (wait.state === "waiting")
+        return waiting(wait);
+    if (wait.state === "timed-out")
+        return { kind: "timed-out", reason: "command-wait-timeout" };
+    if (wait.state !== "completed")
+        return { kind: "failed", reason: wait.reason ?? "command-wait-failed" };
+    const value = JSON.parse(wait.result ?? "null");
+    return commandWaitValue(value)
+        ? { kind: "ready", value }
+        : { kind: "failed", reason: "command-wait-invalid-output" };
+}
+function refused(receipt) {
+    if (["accepted", "duplicate"].includes(receipt.kind))
+        return undefined;
+    return {
+        kind: receipt.kind === "failed" ? "failed" : "refused",
+        reason: receipt.reason ?? receipt.kind,
+    };
+}
+async function requested(context, send) {
+    const { host, call, retryReasons = ["service-busy"] } = context;
+    for (;;) {
+        if (host.stopped.aborted)
+            await new Promise(() => undefined);
+        const receipt = await send();
+        if (receipt.kind !== "rejected" ||
+            !retryReasons.includes(receipt.reason ?? ""))
+            return receipt;
+        if (receipt.reason === "command-wait-run-not-running" &&
+            !["queued", "running", "waiting_gate", "paused"].includes((await host.runStatus(call.runId)) ?? ""))
+            return receipt;
+        await delay(host.retryMilliseconds, undefined, {
+            signal: host.stopped,
+        }).catch(() => undefined);
+    }
+}
+async function settled(context, request) {
+    const { host, port } = context;
+    for (;;) {
+        if (host.stopped.aborted)
+            await new Promise(() => undefined);
+        const wait = await port.read(request);
+        if (wait?.state !== "waiting" || wait.checkOperation === null)
+            return progress(wait);
+        await delay(host.pollMilliseconds, undefined, {
+            signal: host.stopped,
+        }).catch(() => undefined);
+    }
+}
+export function commandWaitBridge(host) {
+    return {
+        openCommandWait: async (request) => {
+            if (!isCommandWaitRequest(request))
+                return { kind: "refused", reason: "invalid-command-wait-request" };
+            const subject = await host.subject();
+            const port = host.commandWait;
+            if (subject === undefined || port === undefined)
+                return { kind: "unavailable", reason: "cloving-host-unavailable" };
+            const call = {
+                ...subject,
+                name: request.name,
+                input: JSON.stringify(request.input),
+            };
+            const receipt = await requested({
+                host,
+                call,
+                retryReasons: ["service-busy", "command-wait-run-not-running"],
+            }, () => port.open(call));
+            return (refused(receipt) ??
+                progress(await port.read({ ...subject, name: request.name })));
+        },
+        checkCommandWait: async (request) => {
+            const subject = await host.subject();
+            const port = host.commandWait;
+            if (subject === undefined || port === undefined)
+                return { kind: "unavailable", reason: "cloving-host-unavailable" };
+            const call = { ...subject, name: request.name };
+            const wait = await port.read(call);
+            if (wait?.state !== "waiting")
+                return progress(wait);
+            if (wait.checkOperation !== null)
+                return await settled({ host, port }, call);
+            if (wait.nextCheckAt !== null &&
+                Date.now() < Math.min(wait.nextCheckAt, wait.deadline))
+                return progress(wait);
+            const receipt = await requested({ host, call }, () => port.check(call));
+            return checkReply(receipt, wait) ?? (await settled({ host, port }, call));
+        },
+    };
+}
+function checkReply(receipt, wait) {
+    if (receipt.reason === "command-wait-timeout")
+        return { kind: "timed-out", reason: receipt.reason };
+    if (receipt.reason === "command-wait-run-not-running")
+        return waiting(wait, Date.now() + 1000);
+    if ([
+        "command-wait-check-in-flight",
+        "command-wait-check-not-due",
+        "command-wait-ended",
+    ].includes(receipt.reason ?? ""))
+        return undefined;
+    return refused(receipt);
+}
+function waiting(wait, nextCheckAt = wait.nextCheckAt ?? wait.deadline) {
+    return {
+        kind: "pending",
+        deadline: wait.deadline,
+        nextCheckAt,
+    };
+}

package/dist/src/host/start-delivery.d.ts

@@ -1,11 +1,9 @@
 import { type TaggedRun } from "./world-runs.ts";
-export type WorkflowFunction = (input: unknown, continuation?: Continuation) => Promise<unknown>;
-export interface Continuation {
-    readonly gateId: string;
-    readonly decision: string;
-    readonly answer: string | null;
-}
-export interface RunIntent extends Partial<Continuation> {
+export type WorkflowFunction = (input: unknown) => Promise<unknown>;
+export interface RunIntent {
+    readonly gateId?: string;
+    readonly decision?: string;
+    readonly answer?: string | null;
     readonly kind: string;
     readonly runId: string;
     readonly operationId: string;

package/dist/src/host/start-delivery.js

@@ -17,27 +17,15 @@ async function reconciled(parts, intent) {
         evidence: found.map((run) => `world-run:${run.receipt}`).join(" "),
     };
 }
-async function continuation(parts, intent) {
-    const { kind, gateId, decision, answer } = intent;
-    if (kind === "start-run")
-        return undefined;
-    if (kind !== "continue-run" || gateId === undefined || decision === undefined)
-        throw new Error(`unsupported-intent: ${kind}`);
-    if (answer === undefined || answer === null)
-        return { gateId, decision, answer: null };
-    const text = await parts.document(answer);
-    if (text === undefined)
-        throw new Error(`answer-not-available: ${gateId}`);
-    return { gateId, decision, answer: text };
-}
 async function delivered(parts, intent) {
-    const continued = await continuation(parts, intent);
+    if (intent.kind !== "start-run")
+        throw new Error(`unsupported-intent: ${intent.kind}`);
     const workflow = await parts.workflow(intent);
     const input = await parts.input(intent.runId);
     if (workflow === undefined || input === undefined)
         throw new Error(`start-not-available: ${intent.runId}`);
     const argument = JSON.parse(input);
-    const started = await start(workflow, [argument, continued], {
+    const started = await start(workflow, [argument], {
         attributes: {
             [runTag]: intent.runId,
             [operationTag]: intent.operationId,

package/dist/src/host/step-bridge-host.d.ts

@@ -1,3 +1,4 @@
+import { type CommandWaitPorts } from "./command-wait.ts";
 import { type GateOpening, type GateReceipt, type WaitRegistration } from "./gate-bridge.ts";
 export type { GateOpening, GateReceipt, WaitRegistration, } from "./gate-bridge.ts";
 import { type RunWaitPorts } from "./run-wait.ts";
@@ -41,6 +42,7 @@ export interface BridgeTiming {
 }
 export declare const bridgeTiming: BridgeTiming;
 export interface BridgePorts {
+    readonly commandWait?: CommandWaitPorts;
     readonly decisionReceived?: (runId: string, gateId: string) => Promise<boolean>;
     readonly runWait?: RunWaitPorts;
     readonly call: () => StepCall;

package/dist/src/host/step-bridge-host.js

@@ -1,3 +1,4 @@
+import { commandWaitBridge } from "./command-wait.js";
 import { createHash } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
 import { getStepMetadata, getWorkflowMetadata } from "workflow";
@@ -155,9 +156,29 @@ async function gate(hold, request) {
         return { kind: "unavailable", reason: "unknown-world-run" };
     return await openBridgeGate(hold.ports, subject);
 }
+function hostCommandWait(hold) {
+    return commandWaitBridge({
+        ...(hold.ports.commandWait === undefined
+            ? {}
+            : { commandWait: hold.ports.commandWait }),
+        stopped: hold.ports.stopped,
+        pollMilliseconds: hold.timing.pollMilliseconds,
+        retryMilliseconds: hold.timing.retryMilliseconds,
+        runStatus: async (runId) => (await hold.ports.state()).runs[runId]?.status,
+        subject: async () => {
+            const call = hold.ports.call();
+            const world = await located(hold, call.worldRunId);
+            if (world === undefined)
+                return undefined;
+            await inWork(hold, world.runId);
+            return { runId: world.runId, commandId: transportOf(call) };
+        },
+    });
+}
 export function stepBridge(ports) {
     const hold = { ports, timing: ports.timing ?? bridgeTiming };
     return {
+        ...hostCommandWait(hold),
         effect: (request) => effect(hold, request),
         gate: (request) => gate(hold, request),
         waitForDecision: async (request) => {

package/dist/src/operation-identity.d.ts

@@ -5,3 +5,4 @@ export interface OperationScope {
     readonly operation: string;
 }
 export declare function operationScope(operationId: string): OperationScope | null;
+export declare function operationPhase(operationId: string): string | null;

package/dist/src/operation-identity.js

@@ -48,6 +48,10 @@ export function operationScope(operationId) {
         return null;
     return { run, operation };
 }
+export function operationPhase(operationId) {
+    const [marker, , , phase] = parsedList(operationId);
+    return marker === "cloving-operation" && isComponent(phase) ? phase : null;
+}
 function parsedList(text) {
     try {
         const value = JSON.parse(text);

package/dist/src/private-config.schema.json

@@ -19,6 +19,42 @@
                         "type": "string",
                         "pattern": "\\S"
                     }
+                },
+                "redGreen": {
+                    "type": "object",
+                    "properties": {
+                        "test": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "testFiles": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "prepare": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "assertionPattern": {
+                            "type": "string"
+                        },
+                        "skipPattern": {
+                            "type": "string"
+                        }
+                    },
+                    "required": ["test", "testFiles"],
+                    "additionalProperties": false
                 }
             },
             "additionalProperties": false
@@ -49,6 +85,10 @@
                     "minimum": 10,
                     "maximum": 3600
                 },
+                "dailySpendLimitUsd": {
+                    "type": "number",
+                    "exclusiveMinimum": 0
+                },
                 "lanes": {
                     "type": "integer",
                     "minimum": 1,

package/dist/src/project-config.schema.json

@@ -19,6 +19,42 @@
                         "type": "string",
                         "pattern": "\\S"
                     }
+                },
+                "redGreen": {
+                    "type": "object",
+                    "properties": {
+                        "test": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "testFiles": {
+                            "type": "array",
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "prepare": {
+                            "type": "array",
+                            "minItems": 1,
+                            "items": {
+                                "type": "string",
+                                "pattern": "^[^\\u0000]+$"
+                            }
+                        },
+                        "assertionPattern": {
+                            "type": "string"
+                        },
+                        "skipPattern": {
+                            "type": "string"
+                        }
+                    },
+                    "required": ["test", "testFiles"],
+                    "additionalProperties": false
                 }
             },
             "additionalProperties": false
@@ -49,6 +85,10 @@
                     "minimum": 10,
                     "maximum": 3600
                 },
+                "dailySpendLimitUsd": {
+                    "type": "number",
+                    "exclusiveMinimum": 0
+                },
                 "lanes": {
                     "type": "integer",
                     "minimum": 1,

package/dist/src/project-settings.d.ts

@@ -1,8 +1,8 @@
-import { type Configuration } from "./configuration-schema.ts";
+import { type Configuration, type RedGreenSettings } from "./configuration-schema.ts";
 import type { TurnProfiles } from "./turn-profile.ts";
 import type { TokenPrices } from "./token-prices.ts";
 export type SettingSource = "environment" | "private" | "project";
-export type SettingValue = string | number | readonly string[] | TurnProfiles | TokenPrices;
+export type SettingValue = string | number | readonly string[] | TurnProfiles | TokenPrices | RedGreenSettings;
 export declare const settingVariables: Readonly<Record<string, string>>;
 export declare function absoluteWorkflowFolder(folder: string | undefined): string | undefined;
 export declare function configurationRoot(environment: Readonly<NodeJS.ProcessEnv>, home: string): string;