codex-toys 0.140.2 → 0.140.4

package/dist/cli/workspace-autonomy.js

@@ -125,6 +125,7 @@ export async function collectWorkspaceDoctorInfo(context, options = {}) {
     const now = new Date();
     const latestDeferredRun = deferredRuns
         .toSorted((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
+    const deferredDueFlags = await Promise.all(deferredRuns.map(async (intent) => await isDeferredIntentDue(context, intent, now)));
     const failingCount = countFailingTasks(config?.tasks ?? [], runs);
     const includeRunner = options.includeRunner === true || options.runnerProbe !== undefined;
     const runner = includeRunner
@@ -149,7 +150,7 @@ export async function collectWorkspaceDoctorInfo(context, options = {}) {
         dueCount: dueTasks(config?.tasks ?? [], runs, new Date()).length,
         failingCount,
         deferredCount: deferredRuns.length,
-        deferredDueCount: deferredRuns.filter((intent) => isDeferredIntentDue(intent, now)).length,
+        deferredDueCount: deferredDueFlags.filter(Boolean).length,
         deferredRunningCount: deferredRuns.filter((intent) => intent.status === "running").length,
         deferredFailedCount: deferredRuns.filter((intent) => intent.status === "failed").length,
         latestRun,
@@ -292,6 +293,7 @@ export async function createDeferredRunIntent(context, params) {
         createdBy: input.createdBy,
         reason: input.reason,
         source: input.source,
+        dependsOn: input.dependsOn,
         attemptIds: [],
     });
     await writeNewJsonFile(deferredIntentPath(context, intent.id), intent);
@@ -329,12 +331,141 @@ export async function readDeferredRun(context, intentId, options = {}) {
         : undefined;
     return compactUndefined({ intent, attempts, outputs });
 }
+export async function enqueuePromptQueueIntent(context, params) {
+    const input = parsePromptQueueEnqueueParams(params);
+    const after = input.afterIntentId
+        ? {
+            kind: "deferred-run",
+            intentId: input.afterIntentId,
+            status: input.afterStatus,
+        }
+        : undefined;
+    return await createDeferredRunIntent(context, {
+        id: input.id,
+        runAt: input.runAt,
+        target: compactUndefined({
+            kind: "turn",
+            prompt: input.prompt,
+            threadId: input.threadId,
+            cwd: input.cwd,
+            model: input.model,
+            serviceTier: input.serviceTier,
+            effort: input.effort,
+            sandbox: input.sandbox,
+            approvalPolicy: input.approvalPolicy,
+            permissions: input.permissions,
+            responsesapiClientMetadata: input.responsesapiClientMetadata,
+            outputSchema: input.outputSchema,
+        }),
+        createdBy: input.createdBy ?? "workspace-prompt-queue",
+        reason: input.reason ?? input.title,
+        source: promptQueueSource(input, after),
+        dependsOn: after ? [after] : undefined,
+    });
+}
+export async function listPromptQueueIntents(context, options = {}) {
+    const intents = await listDeferredRunIntents(context, {
+        status: options.status,
+    });
+    return intents
+        .filter((intent) => isPromptQueueIntent(intent, options.queue))
+        .slice(0, clampLimit(options.limit, 500));
+}
+export async function collectPromptQueueRuns(context, options = {}) {
+    return await collectDeferredRuns(context, {
+        cursor: options.cursor,
+        defaultCursor: "prompt-queue",
+        now: options.now,
+        filter: (intent) => isPromptQueueIntent(intent, options.queue),
+    });
+}
+export async function runDuePromptQueueIntents(context, options) {
+    return await runDueDeferredRuns(context, {
+        ...options,
+        filter: (intent) => isPromptQueueIntent(intent, options.queue),
+    });
+}
+export async function enqueueLocalHandoffIntent(context, params) {
+    const input = parseLocalHandoffEnqueueParams(params);
+    const after = input.afterIntentId
+        ? {
+            kind: "deferred-run",
+            intentId: input.afterIntentId,
+            status: input.afterStatus,
+        }
+        : undefined;
+    return await createDeferredRunIntent(context, {
+        id: input.id,
+        runAt: input.runAt,
+        target: compactUndefined({
+            kind: "turn",
+            prompt: input.prompt,
+            threadId: input.threadId,
+            cwd: input.cwd,
+            model: input.model,
+            serviceTier: input.serviceTier,
+            effort: input.effort,
+            sandbox: input.sandbox,
+            approvalPolicy: input.approvalPolicy,
+            permissions: input.permissions,
+            responsesapiClientMetadata: input.responsesapiClientMetadata,
+            outputSchema: input.outputSchema,
+        }),
+        createdBy: input.createdBy ?? "workspace-local-handoff",
+        reason: input.reason ?? input.title,
+        source: localHandoffSource(input, after),
+        dependsOn: after ? [after] : undefined,
+    });
+}
+export async function listLocalHandoffIntents(context, options = {}) {
+    const intents = await listDeferredRunIntents(context, {
+        status: options.status,
+    });
+    return intents
+        .filter((intent) => isLocalHandoffIntent(intent, options))
+        .slice(0, clampLimit(options.limit, 500));
+}
+export async function collectLocalHandoffRuns(context, options = {}) {
+    return await collectDeferredRuns(context, {
+        cursor: options.cursor,
+        defaultCursor: "local-handoff",
+        now: options.now,
+        filter: (intent) => isLocalHandoffIntent(intent, options),
+    });
+}
+export async function drainLocalHandoffQueue(context, options) {
+    const action = options.action ?? "run";
+    const result = await runDueDeferredRuns(context, {
+        ...options,
+        includeLocalHandoffs: true,
+        localHandoffMaterialize: action === "materialize"
+            ? { queue: options.promptQueue }
+            : undefined,
+        filter: (intent) => isLocalHandoffIntent(intent, {
+            queue: options.queue,
+            targetHost: options.hostId ? undefined : "local-controller",
+            hostId: options.hostId,
+            capabilities: options.capabilities ?? [],
+        }),
+    });
+    return {
+        mode: result.mode,
+        action,
+        executions: result.executions,
+    };
+}
 export async function collectDeferredRuns(context, options = {}) {
     await ensureDeferredRunDirs(context);
-    const cursor = deferredCollectCursorName(options.cursor);
+    const cursor = deferredCollectCursorName(options.cursor, options.defaultCursor);
     const previousCursor = await readDeferredRunCollectCursor(context, cursor);
     const collectedAt = (options.now ?? new Date()).toISOString();
-    const terminalIntents = (await listDeferredRunIntents(context))
+    const filteredIntents = [];
+    for (const intent of await listDeferredRunIntents(context)) {
+        if (!options.filter || await options.filter(intent)) {
+            filteredIntents.push(intent);
+        }
+    }
+    const terminalIntents = filteredIntents
         .filter((intent) => isTerminalDeferredRunStatus(intent.status))
         .toSorted((left, right) => left.updatedAt.localeCompare(right.updatedAt) || left.id.localeCompare(right.id))
         .filter((intent) => isAfterDeferredRunCollectCursor(intent, previousCursor));
@@ -371,13 +502,59 @@ export async function cancelDeferredRunIntent(context, intentId) {
     await writeJsonFileAtomic(deferredIntentPath(context, intentId), canceled);
     return canceled;
 }
+export async function retryDeferredRunIntent(context, intentId, params = {}, options = {}) {
+    await ensureDeferredRunDirs(context);
+    const originalIntent = await readDeferredRunIntent(context, intentId);
+    if (!isTerminalDeferredRunStatus(originalIntent.status)) {
+        throw new Error(`Only terminal deferred runs can be retried: ${intentId} is ${originalIntent.status}`);
+    }
+    const input = parseDeferredRunRetryParams(params);
+    const now = (options.now ?? new Date()).toISOString();
+    const retrySource = retryDeferredRunSource(originalIntent, input.source);
+    let id = input.id ?? deferredRetryRunId(originalIntent.id, now);
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+        const intent = compactUndefined({
+            id,
+            status: "pending",
+            mode: context.mode,
+            runAt: input.runAt ?? now,
+            target: originalIntent.target,
+            createdAt: now,
+            updatedAt: now,
+            createdBy: input.createdBy ?? "workspace-deferred-retry",
+            reason: input.reason ?? `Retry deferred run ${originalIntent.id}`,
+            source: retrySource,
+            dependsOn: originalIntent.dependsOn,
+            attemptIds: [],
+        });
+        try {
+            await writeNewJsonFile(deferredIntentPath(context, intent.id), intent);
+            return { intent, originalIntent };
+        }
+        catch (error) {
+            if (!isAlreadyExistsError(error)) {
+                throw error;
+            }
+            id = deferredRetryRunId(originalIntent.id, now);
+        }
+    }
+    throw new Error(`Could not allocate retry deferred run id for ${intentId}`);
+}
 export async function runDueDeferredRuns(context, options) {
     await ensureStateDirs(context);
     await ensureDeferredRunDirs(context);
     const now = options.now ?? new Date();
-    const due = (await listDeferredRunIntents(context))
-        .filter((intent) => isDeferredIntentDue(intent, now))
-        .slice(0, clampLimit(options.limit, 100));
+    const due = [];
+    for (const intent of await listDeferredRunIntents(context)) {
+        if (await isDeferredIntentDue(context, intent, now) &&
+            (options.includeLocalHandoffs === true || !isLocalHandoffIntent(intent)) &&
+            (!options.filter || await options.filter(intent))) {
+            due.push(intent);
+        }
+        if (due.length >= clampLimit(options.limit, 100)) {
+            break;
+        }
+    }
     const executions = [];
     for (const intent of due) {
         const claim = await claimDeferredRunIntent(context, intent, {
@@ -393,6 +570,7 @@ export async function runDueDeferredRuns(context, options) {
             const result = await executeDeferredRunTarget(context, claim.intent, {
                 callToybox: options.callToybox,
                 automationCwd: options.automationCwd,
+                localHandoffMaterialize: options.localHandoffMaterialize,
             });
             await writeJsonFileAtomic(outputPath, result.output);
             const finishedAt = new Date().toISOString();
@@ -535,6 +713,13 @@ async function runAutomationTask(context, config, task, runId, startedAt, option
 async function executeDeferredRunTarget(context, intent, options) {
     try {
         const target = intent.target;
+        if (options.localHandoffMaterialize && isLocalHandoffIntent(intent)) {
+            const materialized = await materializeLocalHandoffIntent(context, intent, options.localHandoffMaterialize);
+            return {
+                status: "completed",
+                output: { localHandoff: materialized },
+            };
+        }
         if (target.kind === "workspace-task") {
             const config = await loadWorkspaceConfig(context);
             const task = config.tasks.find((item) => item.id === target.taskId);
@@ -580,6 +765,42 @@ async function executeDeferredRunTarget(context, intent, options) {
         };
     }
 }
+async function materializeLocalHandoffIntent(context, intent, options) {
+    if (intent.target.kind !== "turn") {
+        throw new Error(`Local handoff can only materialize turn targets: ${intent.id}`);
+    }
+    const source = recordOrUndefined(intent.source) ?? {};
+    const queue = options.queue ?? optionalString(source.queue) ?? "local";
+    const promptIntent = await enqueuePromptQueueIntent(context, {
+        prompt: intent.target.prompt,
+        title: optionalString(source.title) ?? intent.reason,
+        queue,
+        labels: stringArray(source.labels),
+        threadId: intent.target.threadId,
+        cwd: intent.target.cwd,
+        model: intent.target.model,
+        serviceTier: intent.target.serviceTier,
+        effort: intent.target.effort,
+        sandbox: intent.target.sandbox,
+        approvalPolicy: intent.target.approvalPolicy,
+        permissions: intent.target.permissions,
+        responsesapiClientMetadata: intent.target.responsesapiClientMetadata,
+        outputSchema: intent.target.outputSchema,
+        createdBy: "workspace-local-handoff-drain",
+        reason: intent.reason,
+        source: compactUndefined({
+            kind: "local-handoff-materialized",
+            handoffIntentId: intent.id,
+            handoffSource: source,
+        }),
+    });
+    return {
+        action: "materialized",
+        handoffIntentId: intent.id,
+        promptIntentId: promptIntent.id,
+        queue,
+    };
+}
 async function runAutomationDeferredTarget(context, config, intent, options) {
     const target = await resolveTurnAutomationTarget(intent.target.automation, {
         cwd: context.repoRoot,
@@ -889,7 +1110,7 @@ async function readDeferredRunCollectCursor(context, cursor) {
 }
 async function claimDeferredRunIntent(context, intent, options) {
     const current = await readDeferredRunIntent(context, intent.id);
-    if (!isDeferredIntentDue(current, options.now)) {
+    if (!await isDeferredIntentDue(context, current, options.now)) {
         return undefined;
     }
     const claimPath = deferredClaimPath(context, current.id);
@@ -972,8 +1193,185 @@ function parseDeferredRunCreateParams(value) {
         createdBy: optionalString(input.createdBy),
         reason: optionalString(input.reason),
         source,
+        dependsOn: parseDeferredRunDependencies(input.dependsOn),
+    });
+}
+function parsePromptQueueEnqueueParams(value) {
+    const input = record(value);
+    const runAt = optionalString(input.runAt);
+    if (runAt && Number.isNaN(Date.parse(runAt))) {
+        throw new Error(`Prompt queue runAt must be an ISO-compatible date: ${runAt}`);
+    }
+    const afterStatus = deferredDependencyStatusValue(input.afterStatus, "prompt queue afterStatus");
+    return compactUndefined({
+        id: optionalString(input.id),
+        runAt,
+        prompt: requiredString(input.prompt, "prompt queue prompt"),
+        title: optionalString(input.title),
+        queue: optionalString(input.queue),
+        labels: stringArray(input.labels),
+        threadId: optionalString(input.threadId),
+        cwd: optionalString(input.cwd),
+        model: optionalString(input.model),
+        serviceTier: optionalString(input.serviceTier),
+        effort: reasoningEffortValue(input.effort, "prompt queue effort"),
+        sandbox: sandboxValue(input.sandbox, "prompt queue sandbox"),
+        approvalPolicy: approvalPolicyValue(input.approvalPolicy, "prompt queue approvalPolicy"),
+        permissions: optionalString(input.permissions),
+        responsesapiClientMetadata: stringRecord(input.responsesapiClientMetadata),
+        outputSchema: input.outputSchema,
+        afterIntentId: optionalString(input.afterIntentId),
+        afterStatus,
+        createdBy: optionalString(input.createdBy),
+        reason: optionalString(input.reason),
+        source: recordOrUndefined(input.source),
     });
 }
+function parseLocalHandoffEnqueueParams(value) {
+    const input = record(value);
+    const runAt = optionalString(input.runAt);
+    if (runAt && Number.isNaN(Date.parse(runAt))) {
+        throw new Error(`Local handoff runAt must be an ISO-compatible date: ${runAt}`);
+    }
+    const afterStatus = deferredDependencyStatusValue(input.afterStatus, "local handoff afterStatus");
+    return compactUndefined({
+        id: optionalString(input.id),
+        runAt,
+        prompt: requiredString(input.prompt, "local handoff prompt"),
+        title: optionalString(input.title),
+        queue: optionalString(input.queue),
+        labels: stringArray(input.labels),
+        targetHost: optionalString(input.targetHost),
+        requiredCapabilities: stringArray(input.requiredCapabilities),
+        requesterHost: optionalString(input.requesterHost),
+        requesterThreadId: optionalString(input.requesterThreadId),
+        threadId: optionalString(input.threadId),
+        cwd: optionalString(input.cwd),
+        model: optionalString(input.model),
+        serviceTier: optionalString(input.serviceTier),
+        effort: reasoningEffortValue(input.effort, "local handoff effort"),
+        sandbox: sandboxValue(input.sandbox, "local handoff sandbox"),
+        approvalPolicy: approvalPolicyValue(input.approvalPolicy, "local handoff approvalPolicy"),
+        permissions: optionalString(input.permissions),
+        responsesapiClientMetadata: stringRecord(input.responsesapiClientMetadata),
+        outputSchema: input.outputSchema,
+        afterIntentId: optionalString(input.afterIntentId),
+        afterStatus,
+        createdBy: optionalString(input.createdBy),
+        reason: optionalString(input.reason),
+        source: recordOrUndefined(input.source),
+    });
+}
+function parseDeferredRunDependencies(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const dependencies = value.map(parseDeferredRunDependency);
+    return dependencies.length > 0 ? dependencies : undefined;
+}
+function parseDeferredRunDependency(value) {
+    const input = record(value);
+    const kind = requiredString(input.kind, "deferred run dependency kind");
+    if (kind !== "deferred-run") {
+        throw new Error(`Invalid deferred run dependency kind: ${kind}`);
+    }
+    return compactUndefined({
+        kind: "deferred-run",
+        intentId: requiredString(input.intentId, "deferred run dependency intentId"),
+        status: deferredDependencyStatusValue(input.status, "deferred run dependency status"),
+    });
+}
+function parseDeferredRunRetryParams(value) {
+    const input = record(value);
+    const runAt = optionalString(input.runAt);
+    if (runAt && Number.isNaN(Date.parse(runAt))) {
+        throw new Error(`Deferred run retry runAt must be an ISO-compatible date: ${runAt}`);
+    }
+    return compactUndefined({
+        id: optionalString(input.id),
+        runAt,
+        createdBy: optionalString(input.createdBy),
+        reason: optionalString(input.reason),
+        source: recordOrUndefined(input.source),
+    });
+}
+function retryDeferredRunSource(originalIntent, source) {
+    const originalSource = recordOrUndefined(originalIntent.source) ?? {};
+    return compactUndefined({
+        ...originalSource,
+        kind: optionalString(originalSource.kind) ?? "deferred-retry",
+        retry: compactUndefined({
+            kind: "deferred-retry",
+            originalIntentId: originalIntent.id,
+            originalStatus: originalIntent.status,
+            originalRunAt: originalIntent.runAt,
+            originalUpdatedAt: originalIntent.updatedAt,
+            details: source,
+        }),
+    });
+}
+function promptQueueSource(input, after) {
+    return compactUndefined({
+        kind: "prompt-queue",
+        queue: input.queue ?? "default",
+        title: input.title,
+        labels: input.labels,
+        after,
+        details: input.source,
+    });
+}
+function localHandoffSource(input, after) {
+    const requester = compactUndefined({
+        host: input.requesterHost,
+        threadId: input.requesterThreadId,
+    });
+    return compactUndefined({
+        kind: "local-handoff",
+        queue: input.queue ?? "local",
+        title: input.title,
+        labels: input.labels,
+        targetHost: input.targetHost ?? "local-controller",
+        requiredCapabilities: input.requiredCapabilities,
+        requester: Object.keys(requester).length > 0 ? requester : undefined,
+        after,
+        details: input.source,
+    });
+}
+function isPromptQueueIntent(intent, queue) {
+    if (intent.target.kind !== "turn") {
+        return false;
+    }
+    const source = recordOrUndefined(intent.source);
+    if (source?.kind !== "prompt-queue") {
+        return false;
+    }
+    return !queue || source.queue === queue;
+}
+function isLocalHandoffIntent(intent, options = {}) {
+    if (intent.target.kind !== "turn") {
+        return false;
+    }
+    const source = recordOrUndefined(intent.source);
+    if (source?.kind !== "local-handoff") {
+        return false;
+    }
+    if (options.queue && source.queue !== options.queue) {
+        return false;
+    }
+    const targetHost = optionalString(source.targetHost) ?? "local-controller";
+    if (options.targetHost && targetHost !== options.targetHost) {
+        return false;
+    }
+    if (options.hostId && targetHost !== "local-controller" && targetHost !== options.hostId) {
+        return false;
+    }
+    if (options.capabilities) {
+        const requiredCapabilities = stringArray(source.requiredCapabilities) ?? [];
+        const availableCapabilities = new Set(options.capabilities);
+        return requiredCapabilities.every((capability) => availableCapabilities.has(capability));
+    }
+    return true;
+}
 function parseDeferredRunTarget(value) {
     const target = record(value);
     const kind = requiredString(target.kind, "deferred run target kind");
@@ -1005,6 +1403,7 @@ function parseDeferredRunTarget(value) {
             cwd: optionalString(target.cwd),
             model: optionalString(target.model),
             serviceTier: optionalString(target.serviceTier),
+            effort: reasoningEffortValue(target.effort, "deferred run turn target effort"),
             sandbox: sandboxValue(target.sandbox, "deferred run turn target sandbox"),
             approvalPolicy: approvalPolicyValue(target.approvalPolicy, "deferred run turn target approvalPolicy"),
             permissions: optionalString(target.permissions),
@@ -1027,6 +1426,7 @@ function normalizeDeferredRunIntent(value) {
         createdBy: optionalString(input.createdBy),
         reason: optionalString(input.reason),
         source: recordOrUndefined(input.source),
+        dependsOn: parseDeferredRunDependencies(input.dependsOn),
         attemptIds: Array.isArray(input.attemptIds)
             ? input.attemptIds.filter((entry) => typeof entry === "string")
             : [],
@@ -1110,15 +1510,44 @@ function hasScheduledIntentForDate(taskId, intents, now) {
             intent.source?.kind === "workspace-task-schedule" &&
             intent.source.date === now.toISOString().slice(0, 10)));
 }
-function isDeferredIntentDue(intent, now) {
+async function isDeferredIntentDue(context, intent, now) {
     if (intent.status === "pending") {
-        return intent.runAt <= now.toISOString();
+        return intent.runAt <= now.toISOString() &&
+            await areDeferredRunDependenciesSatisfied(context, intent.dependsOn);
     }
     if (intent.status === "running" && intent.lease?.expiresAt) {
         return intent.lease.expiresAt <= now.toISOString();
     }
     return false;
 }
+async function areDeferredRunDependenciesSatisfied(context, dependencies) {
+    if (!dependencies || dependencies.length === 0) {
+        return true;
+    }
+    for (const dependency of dependencies) {
+        if (dependency.kind !== "deferred-run") {
+            return false;
+        }
+        let intent;
+        try {
+            intent = await readDeferredRunIntent(context, dependency.intentId);
+        }
+        catch {
+            return false;
+        }
+        const status = dependency.status ?? "completed";
+        if (status === "terminal") {
+            if (!isTerminalDeferredRunStatus(intent.status)) {
+                return false;
+            }
+            continue;
+        }
+        if (intent.status !== status) {
+            return false;
+        }
+    }
+    return true;
+}
 function isTerminalDeferredRunStatus(status) {
     return status === "completed" || status === "failed" || status === "canceled";
 }
@@ -1395,8 +1824,8 @@ function deferredClaimPath(context, intentId) {
 function deferredCollectCursorPath(context, cursor) {
     return path.join(deferredCollectCursorDir(context), `${safeFileSegment(cursor)}.json`);
 }
-function deferredCollectCursorName(value) {
-    const cursor = value?.trim() || "default";
+function deferredCollectCursorName(value, defaultCursor = "default") {
+    const cursor = value?.trim() || defaultCursor;
     if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(cursor)) {
         throw new Error(`Invalid deferred collect cursor: ${cursor}`);
     }
@@ -1405,6 +1834,9 @@ function deferredCollectCursorName(value) {
 function deferredRunId(createdAt) {
     return `deferred-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
 }
+function deferredRetryRunId(originalIntentId, createdAt) {
+    return `retry-${safeFileSegment(originalIntentId).slice(0, 40)}-${createdAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+}
 function deferredAttemptId(intentId, startedAt) {
     return `${startedAt.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}-${safeFileSegment(intentId).slice(0, 48)}`;
 }
@@ -1664,6 +2096,13 @@ function stringRecord(value) {
     const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
     return entries.length > 0 ? Object.fromEntries(entries) : undefined;
 }
+function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = value.filter((entry) => typeof entry === "string" && entry.length > 0);
+    return entries.length > 0 ? entries : undefined;
+}
 function sandboxValue(value, label) {
     if (value === "danger-full-access" ||
         value === "read-only" ||
@@ -1687,6 +2126,32 @@ function approvalPolicyValue(value, label) {
     }
     return undefined;
 }
+function reasoningEffortValue(value, label) {
+    if (value === "none" ||
+        value === "minimal" ||
+        value === "low" ||
+        value === "medium" ||
+        value === "high" ||
+        value === "xhigh") {
+        return value;
+    }
+    if (value !== undefined) {
+        throw new Error(`${label} must be none, minimal, low, medium, high, or xhigh`);
+    }
+    return undefined;
+}
+function deferredDependencyStatusValue(value, label) {
+    if (value === "completed" ||
+        value === "failed" ||
+        value === "canceled" ||
+        value === "terminal") {
+        return value;
+    }
+    if (value !== undefined) {
+        throw new Error(`${label} must be completed, failed, canceled, or terminal`);
+    }
+    return undefined;
+}
 function deferredRunStatus(value) {
     if (value === "pending" ||
         value === "running" ||