@kya-os/cli 2.0.0 → 2.0.2

package/node_modules/@kya-os/contracts/dist/workbench/economics.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetSettlementSchema = exports.ReservationRequestSchema = exports.BudgetAccountSchema = exports.CostRecordSchema = exports.BillingBasisSchema = exports.CostPhaseSchema = exports.CostBasisSchema = exports.CostEstimateSchema = exports.CostQuantitiesSchema = exports.PriceScheduleSchema = exports.InputAccountingSchema = exports.CostDimensionSchema = void 0;
+const zod_1 = require("zod");
+const count = zod_1.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const id = zod_1.z.string().trim().min(1).max(1024);
+exports.CostDimensionSchema = zod_1.z.enum(['input', 'output', 'cache_read', 'cache_write_short', 'cache_write_long', 'cache_write_unspecified', 'cache_storage']);
+exports.InputAccountingSchema = zod_1.z.enum(['excludes_cache', 'includes_read_only', 'includes_read_and_write']);
+const dimensions = zod_1.z.object({
+    input: count.nullable(), output: count.nullable(), cache_read: count.nullable(),
+    cache_write_short: count.nullable(), cache_write_long: count.nullable(),
+    cache_write_unspecified: count.nullable(), cache_storage: count.nullable(),
+}).strict();
+/** Rates are micro-USD per million tokens (storage: million token-hours).
+ * Null is unpriced. Zero is explicitly free. Never infer subscription prices. */
+exports.PriceScheduleSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(1), currency: zod_1.z.literal('USD'), provider: id, model: id,
+    version: id, sourceUrl: zod_1.z.string().url().refine(value => /^https?:\/\//.test(value)),
+    inputAccounting: exports.InputAccountingSchema, rates: dimensions,
+}).strict();
+exports.CostQuantitiesSchema = zod_1.z.object({
+    /** Storage quantity is observed token-milliseconds, never idle session time. */
+    values: dimensions, telemetryComplete: zod_1.z.boolean(),
+}).strict();
+exports.CostEstimateSchema = zod_1.z.object({
+    pricing: exports.PriceScheduleSchema, quantities: exports.CostQuantitiesSchema, lines: dimensions,
+    pricedSubtotalMicroUsd: count, totalMicroUsd: count.nullable(),
+    missingDimensions: zod_1.z.array(exports.CostDimensionSchema),
+}).strict().superRefine((estimate, ctx) => {
+    const missing = [];
+    let subtotal = 0n;
+    for (const dimension of exports.CostDimensionSchema.options) {
+        const rate = estimate.pricing.rates[dimension];
+        const quantity = estimate.quantities.values[dimension];
+        let expected = null;
+        if (rate === 0 || quantity === 0)
+            expected = 0n;
+        else if (rate !== null && quantity !== null) {
+            const denominator = dimension === 'cache_storage' ? 3600000000000n : 1000000n;
+            expected = (BigInt(rate) * BigInt(quantity) + denominator - 1n) / denominator;
+        }
+        if (expected === null)
+            missing.push(dimension);
+        else
+            subtotal += expected;
+        if ((expected === null ? null : Number(expected)) !== estimate.lines[dimension])
+            ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, path: ['lines', dimension], message: 'Cost line does not match explicit price and usage' });
+    }
+    const total = missing.length === 0 && estimate.quantities.telemetryComplete ? Number(subtotal) : null;
+    if (subtotal > BigInt(Number.MAX_SAFE_INTEGER) || Number(subtotal) !== estimate.pricedSubtotalMicroUsd || total !== estimate.totalMicroUsd || JSON.stringify(missing) !== JSON.stringify(estimate.missingDimensions))
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Inconsistent cost total or coverage' });
+});
+exports.CostBasisSchema = zod_1.z.enum(['unknown', 'estimated', 'provider_reported', 'invoice_reconciled']);
+exports.CostPhaseSchema = zod_1.z.enum(['planning', 'execution', 'retry', 'review']);
+/** Metered usage is priced per unit; subscription-included usage is not billed per request. */
+exports.BillingBasisSchema = zod_1.z.enum(['metered', 'subscription_included', 'unknown']);
+exports.CostRecordSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.literal(1), recordId: id, chargeId: id, attemptId: id,
+    phase: exports.CostPhaseSchema, basis: exports.CostBasisSchema, currency: zod_1.z.literal('USD'),
+    amountMicroUsd: count.nullable(), knownSubtotalMicroUsd: count, coverageComplete: zod_1.z.boolean(),
+    sourceRef: id.nullable(), estimate: exports.CostEstimateSchema.nullable(), recordedAtMs: count,
+    /** Who billed or reported the charge; required for reported and invoice records. */
+    provider: id.optional(), model: id.optional(), billingBasis: exports.BillingBasisSchema.optional(),
+}).strict().superRefine((record, ctx) => {
+    if (record.coverageComplete !== (record.amountMicroUsd !== null) || (record.amountMicroUsd !== null && record.amountMicroUsd !== record.knownSubtotalMicroUsd))
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Total requires complete coverage and matching subtotal' });
+    if (record.basis === 'unknown' && (record.amountMicroUsd !== null || record.estimate !== null))
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Unknown cost cannot contain a known total' });
+    if (record.basis !== 'unknown' && record.sourceRef === null)
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Cost provenance is required' });
+    if (['provider_reported', 'invoice_reconciled'].includes(record.basis) && record.amountMicroUsd === null)
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Reported/reconciled amount is required' });
+    if (record.estimate !== null && (record.basis !== 'estimated' || record.estimate.totalMicroUsd !== record.amountMicroUsd || record.estimate.pricedSubtotalMicroUsd !== record.knownSubtotalMicroUsd))
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'Record does not match its estimate' });
+    if (['provider_reported', 'invoice_reconciled'].includes(record.basis) && record.provider === undefined)
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: 'A reported or reconciled amount must name its provider' });
+    if (record.estimate !== null && ((record.provider !== undefined && record.provider !== record.estimate.pricing.provider) || (record.model !== undefined && record.model !== record.estimate.pricing.model) || (record.billingBasis !== undefined && record.billingBasis !== 'metered')))
+        ctx.addIssue({ code: zod_1.z.ZodIssueCode.custom, message: "A record's provenance must match its estimate's price schedule" });
+});
+/** Local admission allowance; it does not impose a provider monetary cap. */
+exports.BudgetAccountSchema = zod_1.z.object({ id, parentId: id.nullable(), limitMicroUsd: count }).strict();
+exports.ReservationRequestSchema = zod_1.z.object({ id, attemptId: id, budgetId: id, amountMicroUsd: count, createdAtMs: count }).strict();
+exports.BudgetSettlementSchema = zod_1.z.discriminatedUnion('state', [
+    zod_1.z.object({ state: zod_1.z.literal('known'), costRecordId: id }).strict(),
+    zod_1.z.object({ state: zod_1.z.literal('unknown'), costRecordId: id.nullable() }).strict(),
+    zod_1.z.object({ state: zod_1.z.literal('not_started'), evidenceRef: id }).strict(),
+]);

package/node_modules/@kya-os/contracts/dist/workbench/execution.d.ts

@@ -0,0 +1,594 @@
+import { z } from 'zod';
+/** A local native sandbox does not establish OS credential or provider isolation. */
+export declare const WorkbenchExecutionCapabilitiesSchema: z.ZodObject<{
+    workspaceSandbox: z.ZodLiteral<"harness_workspace_write">;
+    childNetworkPolicy: z.ZodLiteral<"disabled_in_requested_harness_policy">;
+    isolatedSecrets: z.ZodLiteral<false>;
+    managedContainment: z.ZodLiteral<false>;
+    providerEgressEnforcement: z.ZodLiteral<false>;
+    brokeredExternalActions: z.ZodLiteral<false>;
+    limitation: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    workspaceSandbox: "harness_workspace_write";
+    childNetworkPolicy: "disabled_in_requested_harness_policy";
+    isolatedSecrets: false;
+    managedContainment: false;
+    providerEgressEnforcement: false;
+    brokeredExternalActions: false;
+    limitation: string;
+}, {
+    workspaceSandbox: "harness_workspace_write";
+    childNetworkPolicy: "disabled_in_requested_harness_policy";
+    isolatedSecrets: false;
+    managedContainment: false;
+    providerEgressEnforcement: false;
+    brokeredExternalActions: false;
+    limitation: string;
+}>;
+export declare const WorkbenchExecutionPolicySchema: z.ZodObject<{
+    persistHistory: z.ZodDefault<z.ZodBoolean>;
+    nativeResume: z.ZodOptional<z.ZodObject<{
+        attemptId: z.ZodString;
+        priorSegmentId: z.ZodString;
+        threadId: z.ZodString;
+        turnId: z.ZodString;
+        usageBaseline: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            cachedInputTokens: z.ZodNumber;
+            cacheWriteInputTokens: z.ZodNullable<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            inputTokens: number;
+            outputTokens: number;
+            cachedInputTokens: number;
+            cacheWriteInputTokens: number | null;
+        }, {
+            inputTokens: number;
+            outputTokens: number;
+            cachedInputTokens: number;
+            cacheWriteInputTokens: number | null;
+        }>;
+        workspaceSnapshotDigest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        attemptId: string;
+        priorSegmentId: string;
+        threadId: string;
+        turnId: string;
+        usageBaseline: {
+            inputTokens: number;
+            outputTokens: number;
+            cachedInputTokens: number;
+            cacheWriteInputTokens: number | null;
+        };
+        workspaceSnapshotDigest: string;
+    }, {
+        attemptId: string;
+        priorSegmentId: string;
+        threadId: string;
+        turnId: string;
+        usageBaseline: {
+            inputTokens: number;
+            outputTokens: number;
+            cachedInputTokens: number;
+            cacheWriteInputTokens: number | null;
+        };
+        workspaceSnapshotDigest: string;
+    }>>;
+    nativeFork: z.ZodOptional<z.ZodObject<{
+        parentTaskId: z.ZodString;
+        parentAttemptId: z.ZodString;
+        parentSegmentId: z.ZodString;
+        parentManifestDigest: z.ZodString;
+        parentThreadId: z.ZodString;
+        parentTurnId: z.ZodString;
+        workspaceSnapshotDigest: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        parentTaskId: string;
+        workspaceSnapshotDigest: string;
+        parentAttemptId: string;
+        parentSegmentId: string;
+        parentManifestDigest: string;
+        parentThreadId: string;
+        parentTurnId: string;
+    }, {
+        parentTaskId: string;
+        workspaceSnapshotDigest: string;
+        parentAttemptId: string;
+        parentSegmentId: string;
+        parentManifestDigest: string;
+        parentThreadId: string;
+        parentTurnId: string;
+    }>>;
+    budget: z.ZodNullable<z.ZodObject<{
+        budgetId: z.ZodString;
+        reservationMicroUsd: z.ZodNumber;
+        pricing: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            currency: z.ZodLiteral<"USD">;
+            provider: z.ZodString;
+            model: z.ZodString;
+            version: z.ZodString;
+            sourceUrl: z.ZodEffects<z.ZodString, string, string>;
+            inputAccounting: z.ZodEnum<["excludes_cache", "includes_read_only", "includes_read_and_write"]>;
+            rates: z.ZodObject<{
+                input: z.ZodNullable<z.ZodNumber>;
+                output: z.ZodNullable<z.ZodNumber>;
+                cache_read: z.ZodNullable<z.ZodNumber>;
+                cache_write_short: z.ZodNullable<z.ZodNumber>;
+                cache_write_long: z.ZodNullable<z.ZodNumber>;
+                cache_write_unspecified: z.ZodNullable<z.ZodNumber>;
+                cache_storage: z.ZodNullable<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                input: number | null;
+                output: number | null;
+                cache_read: number | null;
+                cache_write_short: number | null;
+                cache_write_long: number | null;
+                cache_write_unspecified: number | null;
+                cache_storage: number | null;
+            }, {
+                input: number | null;
+                output: number | null;
+                cache_read: number | null;
+                cache_write_short: number | null;
+                cache_write_long: number | null;
+                cache_write_unspecified: number | null;
+                cache_storage: number | null;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            version: string;
+            provider: string;
+            model: string;
+            schemaVersion: 1;
+            currency: "USD";
+            sourceUrl: string;
+            inputAccounting: "excludes_cache" | "includes_read_only" | "includes_read_and_write";
+            rates: {
+                input: number | null;
+                output: number | null;
+                cache_read: number | null;
+                cache_write_short: number | null;
+                cache_write_long: number | null;
+                cache_write_unspecified: number | null;
+                cache_storage: number | null;
+            };
+        }, {
+            version: string;
+            provider: string;
+            model: string;
+            schemaVersion: 1;
+            currency: "USD";
+            sourceUrl: string;
+            inputAccounting: "excludes_cache" | "includes_read_only" | "includes_read_and_write";
+            rates: {
+                input: number | null;
+                output: number | null;
+                cache_read: number | null;
+                cache_write_short: number | null;
+                cache_write_long: number | null;
+                cache_write_unspecified: number | null;
+                cache_storage: number | null;
+            };
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        pricing: {
+            version: string;
+            provider: string;
+            model: string;
+            schemaVersion: 1;
+            currency: "USD";
+            sourceUrl: string;
+            inputAccounting: "excludes_cache" | "includes_read_only" | "includes_read_and_write";
+            rates: {
+                input: number | null;
+                output: number | null;
+                cache_read: number | null;
+                cache_write_short: number | null;
+                cache_write_long: number | null;
+                cache_write_unspecified: number | null;
+                cache_storage: number | null;
+            };
+        } | null;
+        budgetId: string;
+        reservationMicroUsd: number;
+    }, {
+        pricing: {
+            version: string;
+            provider: string;
+            model: string;
+            schemaVersion: 1;
+            currency: "USD";
+            sourceUrl: string;
+            inputAccounting: "excludes_cache" | "includes_read_only" | "includes_read_and_write";
+            rates: {
+                input: number | null;
+                output: number | null;
+                cache_read: number | null;
+                cache_write_short: number | null;
+                cache_write_long: number | null;
+                cache_write_unspecified: number | null;
+                cache_storage: number | null;
+            };
+        } | null;
+        budgetId: string;
+        reservationMicroUsd: number;
+    }>>;
+    requiresIsolatedSecrets: z.ZodDefault<z.ZodBoolean>;
+    requiresManagedContainment: z.ZodDefault<z.ZodBoolean>;
+    requiresProviderEgressEnforcement: z.ZodDefault<z.ZodBoolean>;
+    requiresBrokeredExternalActions: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    budget: {
+        pricing: {
+            version: string;
+            provider: string;
+            model: string;
+            schemaVersion: 1;
+            currency: "USD";
+            sourceUrl: string;
+            inputAccounting: "excludes_cache" | "includes_read_only" | "includes_read_and_write";
+            rates: {
+                input: number | null;
+                output: number | null;
+                cache_read: number | null;
+                cache_write_short: number | null;
+                cache_write_long: number | null;
+                cache_write_unspecified: number | null;
+                cache_storage: number | null;
+            };
+        } | null;
+        budgetId: string;
+        reservationMicroUsd: number;
+    } | null;
+    persistHistory: boolean;
+    requiresIsolatedSecrets: boolean;
+    requiresManagedContainment: boolean;
+    requiresProviderEgressEnforcement: boolean;
+    requiresBrokeredExternalActions: boolean;
+    nativeResume?: {
+        attemptId: string;
+        priorSegmentId: string;
+        threadId: string;
+        turnId: string;
+        usageBaseline: {
+            inputTokens: number;
+            outputTokens: number;
+            cachedInputTokens: number;
+            cacheWriteInputTokens: number | null;
+        };
+        workspaceSnapshotDigest: string;
+    } | undefined;
+    nativeFork?: {
+        parentTaskId: string;
+        workspaceSnapshotDigest: string;
+        parentAttemptId: string;
+        parentSegmentId: string;
+        parentManifestDigest: string;
+        parentThreadId: string;
+        parentTurnId: string;
+    } | undefined;
+}, {
+    budget: {
+        pricing: {
+            version: string;
+            provider: string;
+            model: string;
+            schemaVersion: 1;
+            currency: "USD";
+            sourceUrl: string;
+            inputAccounting: "excludes_cache" | "includes_read_only" | "includes_read_and_write";
+            rates: {
+                input: number | null;
+                output: number | null;
+                cache_read: number | null;
+                cache_write_short: number | null;
+                cache_write_long: number | null;
+                cache_write_unspecified: number | null;
+                cache_storage: number | null;
+            };
+        } | null;
+        budgetId: string;
+        reservationMicroUsd: number;
+    } | null;
+    persistHistory?: boolean | undefined;
+    nativeResume?: {
+        attemptId: string;
+        priorSegmentId: string;
+        threadId: string;
+        turnId: string;
+        usageBaseline: {
+            inputTokens: number;
+            outputTokens: number;
+            cachedInputTokens: number;
+            cacheWriteInputTokens: number | null;
+        };
+        workspaceSnapshotDigest: string;
+    } | undefined;
+    nativeFork?: {
+        parentTaskId: string;
+        workspaceSnapshotDigest: string;
+        parentAttemptId: string;
+        parentSegmentId: string;
+        parentManifestDigest: string;
+        parentThreadId: string;
+        parentTurnId: string;
+    } | undefined;
+    requiresIsolatedSecrets?: boolean | undefined;
+    requiresManagedContainment?: boolean | undefined;
+    requiresProviderEgressEnforcement?: boolean | undefined;
+    requiresBrokeredExternalActions?: boolean | undefined;
+}>;
+export type WorkbenchExecutionPolicy = z.infer<typeof WorkbenchExecutionPolicySchema>;
+export type WorkbenchExecutionCapabilities = z.infer<typeof WorkbenchExecutionCapabilitiesSchema>;
+export declare const WorkbenchRepositoryBindingSchema: z.ZodObject<{
+    repositoryId: z.ZodString;
+    path: z.ZodString;
+    baseCommit: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    repositoryId: string;
+    baseCommit: string;
+}, {
+    path: string;
+    repositoryId: string;
+    baseCommit: string;
+}>;
+export declare const WorkbenchTaskRoutingSchema: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+    mode: z.ZodLiteral<"direct">;
+    leadId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    mode: "direct";
+    leadId: string;
+}, {
+    mode: "direct";
+    leadId: string;
+}>, z.ZodObject<{
+    mode: z.ZodLiteral<"pool">;
+    poolId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    mode: "pool";
+    poolId: string;
+}, {
+    mode: "pool";
+    poolId: string;
+}>]>;
+export declare const WorkbenchSourceBindingSchema: z.ZodObject<{
+    sourceId: z.ZodString;
+    sourceRevision: z.ZodNumber;
+    inputDigest: z.ZodString;
+    operationId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    sourceId: string;
+    sourceRevision: number;
+    inputDigest: string;
+    operationId: string;
+}, {
+    sourceId: string;
+    sourceRevision: number;
+    inputDigest: string;
+    operationId: string;
+}>;
+/** A specification is data. Receiving this object never authorizes execution. */
+export declare const WorkbenchTaskManifestSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    taskId: z.ZodString;
+    revision: z.ZodNumber;
+    objective: z.ZodString;
+    repository: z.ZodObject<{
+        repositoryId: z.ZodString;
+        path: z.ZodString;
+        baseCommit: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        repositoryId: string;
+        baseCommit: string;
+    }, {
+        path: string;
+        repositoryId: string;
+        baseCommit: string;
+    }>;
+    source: z.ZodOptional<z.ZodObject<{
+        sourceId: z.ZodString;
+        sourceRevision: z.ZodNumber;
+        inputDigest: z.ZodString;
+        operationId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sourceId: string;
+        sourceRevision: number;
+        inputDigest: string;
+        operationId: string;
+    }, {
+        sourceId: string;
+        sourceRevision: number;
+        inputDigest: string;
+        operationId: string;
+    }>>;
+    /** The reviewed dependency binding a dependent tracker task consumes; part of the manifest digest. */
+    dependencyBinding: z.ZodOptional<z.ZodString>;
+    acceptanceCriteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        text: string;
+    }, {
+        id: string;
+        text: string;
+    }>, "many">;
+    routing: z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"direct">;
+        leadId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mode: "direct";
+        leadId: string;
+    }, {
+        mode: "direct";
+        leadId: string;
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"pool">;
+        poolId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mode: "pool";
+        poolId: string;
+    }, {
+        mode: "pool";
+        poolId: string;
+    }>]>;
+    harness: z.ZodString;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    maxAttempts: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    taskId: string;
+    harness: string;
+    schemaVersion: 1;
+    objective: string;
+    acceptanceCriteria: {
+        id: string;
+        text: string;
+    }[];
+    revision: number;
+    repository: {
+        path: string;
+        repositoryId: string;
+        baseCommit: string;
+    };
+    routing: {
+        mode: "direct";
+        leadId: string;
+    } | {
+        mode: "pool";
+        poolId: string;
+    };
+    maxAttempts: number;
+    model?: string | null | undefined;
+    source?: {
+        sourceId: string;
+        sourceRevision: number;
+        inputDigest: string;
+        operationId: string;
+    } | undefined;
+    dependencyBinding?: string | undefined;
+}, {
+    taskId: string;
+    harness: string;
+    schemaVersion: 1;
+    objective: string;
+    acceptanceCriteria: {
+        id: string;
+        text: string;
+    }[];
+    revision: number;
+    repository: {
+        path: string;
+        repositoryId: string;
+        baseCommit: string;
+    };
+    routing: {
+        mode: "direct";
+        leadId: string;
+    } | {
+        mode: "pool";
+        poolId: string;
+    };
+    maxAttempts: number;
+    model?: string | null | undefined;
+    source?: {
+        sourceId: string;
+        sourceRevision: number;
+        inputDigest: string;
+        operationId: string;
+    } | undefined;
+    dependencyBinding?: string | undefined;
+}>, {
+    taskId: string;
+    harness: string;
+    schemaVersion: 1;
+    objective: string;
+    acceptanceCriteria: {
+        id: string;
+        text: string;
+    }[];
+    revision: number;
+    repository: {
+        path: string;
+        repositoryId: string;
+        baseCommit: string;
+    };
+    routing: {
+        mode: "direct";
+        leadId: string;
+    } | {
+        mode: "pool";
+        poolId: string;
+    };
+    maxAttempts: number;
+    model?: string | null | undefined;
+    source?: {
+        sourceId: string;
+        sourceRevision: number;
+        inputDigest: string;
+        operationId: string;
+    } | undefined;
+    dependencyBinding?: string | undefined;
+}, {
+    taskId: string;
+    harness: string;
+    schemaVersion: 1;
+    objective: string;
+    acceptanceCriteria: {
+        id: string;
+        text: string;
+    }[];
+    revision: number;
+    repository: {
+        path: string;
+        repositoryId: string;
+        baseCommit: string;
+    };
+    routing: {
+        mode: "direct";
+        leadId: string;
+    } | {
+        mode: "pool";
+        poolId: string;
+    };
+    maxAttempts: number;
+    model?: string | null | undefined;
+    source?: {
+        sourceId: string;
+        sourceRevision: number;
+        inputDigest: string;
+        operationId: string;
+    } | undefined;
+    dependencyBinding?: string | undefined;
+}>;
+export declare const WorkbenchExecutionLeaseSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    taskId: z.ZodString;
+    specRevision: z.ZodNumber;
+    attemptNumber: z.ZodNumber;
+    leadId: z.ZodString;
+    ownerEpoch: z.ZodNumber;
+    leaseUntilMs: z.ZodNumber;
+    manifestDigest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    taskId: string;
+    specRevision: number;
+    manifestDigest: string;
+    leadId: string;
+    operationId: string;
+    attemptNumber: number;
+    ownerEpoch: number;
+    leaseUntilMs: number;
+}, {
+    taskId: string;
+    specRevision: number;
+    manifestDigest: string;
+    leadId: string;
+    operationId: string;
+    attemptNumber: number;
+    ownerEpoch: number;
+    leaseUntilMs: number;
+}>;
+export type WorkbenchTaskManifest = z.infer<typeof WorkbenchTaskManifestSchema>;
+export type WorkbenchExecutionLease = z.infer<typeof WorkbenchExecutionLeaseSchema>;