@aiwg/cli 2026.10.9 → 2026.10.11

package/dist/src/models/worker-selection-policy.js

@@ -0,0 +1,217 @@
+// Validates and merges worker selection restrictions and constrained role aliases.
+import { z } from 'zod';
+import { validLocalOnlyPath } from './conductor-data-policy.mjs';
+import { integer } from '../schema/zod-validation.mjs';
+const uniqueStrings = z.array(z.string().min(1)).refine(values => new Set(values).size === values.length, 'Duplicate entries');
+const WorkerDataPolicySchema = z.strictObject({
+    localOnlyPaths: uniqueStrings.refine(values => values.every(validLocalOnlyPath), 'Expected literal project-relative paths').optional(),
+    allowedProcessing: z.array(z.enum(['local', 'remote'])).refine(values => new Set(values).size === values.length).optional(),
+    allowProductImprovement: z.boolean().optional(),
+    allowUnknown: z.boolean().optional(),
+    maxRetentionDays: integer().nonnegative().optional(),
+});
+const baseRoles = ['efficiency', 'coding', 'reasoning'];
+const WorkerRoleSchema = z.strictObject({
+    baseRole: z.enum(baseRoles).optional(),
+    groups: uniqueStrings.refine(values => values.length > 0),
+    tier: z.enum(['economy', 'standard', 'premium', 'max-quality']),
+    initialEffort: z.string().min(1).nullable(),
+    effortLadder: uniqueStrings,
+    escalateAfter: integer().positive().optional(),
+    maxEscalations: integer().nonnegative().optional(),
+    deescalateAfter: integer().positive().optional(),
+    allowNotApplicableEffort: z.boolean().optional(),
+});
+const reservedRoleKey = (key) => key === 'prototype' || Object.hasOwn(Object.prototype, key);
+const roleGuidanceSchema = z.preprocess((input, context) => {
+    if (input !== null && typeof input === 'object')
+        for (const role of Object.keys(input)) {
+            if (reservedRoleKey(role))
+                context.addIssue({ code: 'custom', path: [role], message: `Reserved worker role alias key: ${role}` });
+        }
+    return input;
+}, z.record(z.string().regex(/^[a-z][a-z0-9-]{0,62}$/), WorkerRoleSchema));
+/** Inherited object members never constitute configured role guidance. */
+export function ownWorkerRoleGuidance(policy, role) {
+    return policy?.roleGuidance && Object.hasOwn(policy.roleGuidance, role) ? policy.roleGuidance[role] : undefined;
+}
+export const WorkerSelectionPolicySchema = z.strictObject({
+    roleGuidance: roleGuidanceSchema.optional(),
+    guards: z.strictObject({
+        deniedEfforts: uniqueStrings.optional(),
+        deniedModels: uniqueStrings.optional(),
+        denySelfDelegation: z.boolean().optional(),
+        requireExactModel: z.boolean().optional(),
+        allowedVisibility: z.array(z.enum(['listed', 'hidden'])).refine(v => new Set(v).size === v.length).optional(),
+        allowedLifecycle: z.array(z.enum(['active', 'deprecated'])).refine(v => new Set(v).size === v.length).optional(),
+        minimumIdentityEvidence: z.enum(['runtime-configured', 'backend-attested']).optional(),
+    }).optional(),
+    dataPolicy: WorkerDataPolicySchema.optional(),
+    dataClasses: z.record(z.string().regex(/^[a-z][a-z0-9-]{0,62}$/), WorkerDataPolicySchema).optional(),
+    freshness: z.strictObject({
+        warnHours: integer().positive().optional(),
+        blockHours: integer().positive().optional(),
+        policyDays: integer().positive().optional(),
+    }).optional(),
+    taskClasses: z.record(z.string().regex(/^[a-z][a-z0-9-]{0,62}$/), z.string().min(1)).optional(),
+}).superRefine((policy, context) => {
+    for (const [role, guidance] of Object.entries(policy.roleGuidance ?? {})) {
+        if (baseRoles.includes(role) ? guidance.baseRole !== undefined : guidance.baseRole === undefined)
+            context.addIssue({ code: 'custom', path: ['roleGuidance', role], message: 'Unknown worker role requires a baseRole; base roles cannot be aliases' });
+        const base = guidance.baseRole && ownWorkerRoleGuidance(policy, guidance.baseRole);
+        if (base)
+            for (const message of aliasRestrictionErrors(guidance, base))
+                context.addIssue({ code: 'custom', path: ['roleGuidance', role], message });
+        if (guidance.effortLadder.includes('none') || (guidance.initialEffort === 'none' ? guidance.effortLadder.length !== 0 : guidance.initialEffort !== null && !guidance.effortLadder.includes(guidance.initialEffort))) {
+            context.addIssue({ code: 'custom', path: ['roleGuidance', role], message: 'Initial effort must belong to the ladder; real none requires an empty ladder' });
+        }
+        if (guidance.initialEffort === null && (guidance.allowNotApplicableEffort !== true || guidance.effortLadder.length !== 0)) {
+            context.addIssue({ code: 'custom', path: ['roleGuidance', role], message: 'Null effort requires an empty ladder and allowNotApplicableEffort=true' });
+        }
+    }
+    for (const key of policy.guards?.deniedModels ?? []) {
+        if (!isCanonicalWorkerModelKey(key))
+            context.addIssue({ code: 'custom', path: ['guards', 'deniedModels'], message: 'Noncanonical inference model key' });
+    }
+    if (policy.freshness?.warnHours !== undefined && policy.freshness.blockHours !== undefined && policy.freshness.warnHours > policy.freshness.blockHours) {
+        context.addIssue({ code: 'custom', path: ['freshness'], message: 'warnHours must not exceed blockHours' });
+    }
+    for (const role of Object.values(policy.taskClasses ?? {})) {
+        if (!baseRoles.includes(role) && !ownWorkerRoleGuidance(policy, role)?.baseRole)
+            context.addIssue({ code: 'custom', path: ['taskClasses'], message: 'Unknown worker role' });
+    }
+});
+/** Aliases may reorder/subset choices, never change base authority or escalation controls. */
+function aliasRestrictionErrors(alias, base) {
+    const errors = [];
+    if (alias.groups.some(group => !base.groups.includes(group)))
+        errors.push('Alias groups widen base role');
+    if (alias.effortLadder.some(effort => !base.effortLadder.includes(effort))
+        || alias.initialEffort === 'none' && base.initialEffort !== 'none'
+        || alias.initialEffort === null && base.initialEffort !== null
+        || alias.allowNotApplicableEffort === true && base.allowNotApplicableEffort !== true)
+        errors.push('Alias effort choices widen base role');
+    if (alias.tier !== base.tier)
+        errors.push('Alias tier must retain base role authority');
+    if ((alias.maxEscalations ?? base.maxEscalations ?? 2) > (base.maxEscalations ?? 2))
+        errors.push('Alias maxEscalations widens base role');
+    for (const key of ['escalateAfter', 'deescalateAfter']) {
+        if (alias[key] !== undefined && alias[key] !== (base[key] ?? 2))
+            errors.push(`Alias ${key} must retain base role control`);
+    }
+    return errors;
+}
+/** Canonical RFC3986 identity; installation and account never enter the key. */
+export function workerModelKey(inferenceProvider, apiModelId) {
+    if (!/^[a-z][a-z0-9-]{0,62}$/.test(inferenceProvider) || !apiModelId)
+        throw new Error('OG_CONFIG_REFERENCE: invalid inference model identity');
+    return `${inferenceProvider}/${encodeURIComponent(apiModelId).replace(/[!'()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`)}`;
+}
+export function isCanonicalWorkerModelKey(key) {
+    const slash = key.indexOf('/');
+    try {
+        return slash > 0 && workerModelKey(key.slice(0, slash), decodeURIComponent(key.slice(slash + 1))) === key;
+    }
+    catch {
+        return false;
+    }
+}
+export const DEFAULT_WORKER_SELECTION = {
+    guards: { deniedEfforts: ['ultra'], deniedModels: [], denySelfDelegation: true, requireExactModel: true, allowedVisibility: ['listed'], allowedLifecycle: ['active'], minimumIdentityEvidence: 'runtime-configured' },
+    dataPolicy: { allowedProcessing: ['local', 'remote'], allowProductImprovement: false, allowUnknown: false },
+    freshness: { warnHours: 24, blockHours: 168, policyDays: 30 },
+    taskClasses: { inventory: 'efficiency', implementation: 'coding', architecture: 'reasoning', review: 'reasoning' },
+};
+/** Merge leaves, preserving pre-merge explicit origins and attempted relaxations. */
+export function mergeWorkerSelection(layers) {
+    const policy = Object.create(null);
+    const origins = Object.create(null);
+    const diagnostics = [];
+    const visit = (target, input, parts, layer) => {
+        for (const [key, value] of Object.entries(input)) {
+            const path = [...parts, key];
+            const pointer = `/defaults/workerSelection/${path.map(p => p.replace(/~/g, '~0').replace(/\//g, '~1')).join('/')}`;
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                if (!Object.hasOwn(target, key))
+                    target[key] = Object.create(null);
+                visit(target[key], value, path, layer);
+                continue;
+            }
+            const origin = { source: layer.source, authority: layer.authority, digest: layer.digest, pointer, contribution: structuredClone(value) };
+            const prior = origins[pointer] ?? [];
+            const explicit = prior.filter(o => o.authority !== 'builtin');
+            let effective = structuredClone(value);
+            let relaxation = false;
+            if (layer.authority !== 'builtin' && explicit.length > 0) {
+                const previous = target[key];
+                if (['deniedEfforts', 'deniedModels', 'localOnlyPaths'].includes(key))
+                    effective = [...new Set([...previous, ...value])];
+                else if (['allowedVisibility', 'allowedLifecycle', 'allowedProcessing'].includes(key)) {
+                    relaxation = value.some((v) => !previous.includes(v));
+                    effective = previous.filter((v) => value.includes(v));
+                }
+                else if (['denySelfDelegation', 'requireExactModel'].includes(key)) {
+                    relaxation = previous === true && value === false;
+                    effective = previous || value;
+                }
+                else if (['allowUnknown', 'allowProductImprovement'].includes(key)) {
+                    relaxation = previous === false && value === true;
+                    effective = previous && value;
+                }
+                else if (['maxRetentionDays', 'warnHours', 'blockHours', 'policyDays'].includes(key)) {
+                    relaxation = value > previous;
+                    effective = Math.min(previous, value);
+                }
+                else if (key === 'minimumIdentityEvidence') {
+                    relaxation = previous === 'backend-attested' && value !== previous;
+                    effective = previous === 'backend-attested' ? previous : value;
+                }
+            }
+            if (relaxation)
+                diagnostics.push({ code: 'OG_POLICY_RELAXATION', pointer, message: 'Explicit restriction cannot relax an inherited restriction', origins: [...explicit, origin] });
+            target[key] = effective;
+            origins[pointer] = [...prior, origin];
+        }
+    };
+    for (const layer of layers)
+        if (layer.policy) {
+            for (const [role, guidance] of Object.entries(layer.policy.roleGuidance ?? {})) {
+                if (!guidance.baseRole)
+                    continue;
+                const previous = ownWorkerRoleGuidance(policy, role);
+                if (layer.authority !== 'project' || previous?.baseRole && previous.baseRole !== guidance.baseRole)
+                    diagnostics.push({
+                        code: 'OG_POLICY_RELAXATION', pointer: `/defaults/workerSelection/roleGuidance/${role}/baseRole`,
+                        message: 'Only project layers may declare constrained aliases; inherited aliases cannot change baseRole',
+                    });
+            }
+            visit(policy, layer.policy, [], layer);
+        }
+    for (const [role, guidance] of Object.entries(policy.roleGuidance ?? {})) {
+        const base = guidance.baseRole && ownWorkerRoleGuidance(policy, guidance.baseRole);
+        if (base)
+            for (const field of ['maxEscalations', 'escalateAfter', 'deescalateAfter'])
+                guidance[field] ??= base[field];
+        if (guidance.baseRole && !base)
+            diagnostics.push({
+                code: 'OG_CONFIG_REFERENCE', pointer: `/defaults/workerSelection/roleGuidance/${role}/baseRole`, message: 'Alias base role has no guidance',
+            });
+    }
+    const validation = WorkerSelectionPolicySchema.safeParse(policy);
+    if (!validation.success)
+        for (const issue of validation.error.issues)
+            diagnostics.push({ code: 'OG_CONFIG_REFERENCE', pointer: `/defaults/workerSelection/${issue.path.join('/')}`, message: issue.message });
+    // Data classes are applied as further restrictions to the base path.
+    for (const dataClass of Object.values(policy.dataClasses ?? {})) {
+        const base = policy.dataPolicy ?? {};
+        if (dataClass.allowedProcessing)
+            dataClass.allowedProcessing = dataClass.allowedProcessing.filter(p => !base.allowedProcessing || base.allowedProcessing.includes(p));
+        for (const key of ['allowUnknown', 'allowProductImprovement'])
+            if (base[key] === false)
+                dataClass[key] = false;
+        if (base.maxRetentionDays !== undefined)
+            dataClass.maxRetentionDays = Math.min(dataClass.maxRetentionDays ?? base.maxRetentionDays, base.maxRetentionDays);
+    }
+    return { policy, origins, diagnostics };
+}
+//# sourceMappingURL=worker-selection-policy.js.map

package/dist/src/models/wrapper-deployment.js

@@ -156,7 +156,7 @@ export async function verifyModelWrapperDeployment(agentsPath, expectation = {})
     const missing = [];
     const mismatches = [];
     for (const [role, wrapper] of expected) {
-        const matches = files.filter(file => path.basename(file).replace(/\.(?:md|toml|json|yaml|yml)$/i, '') === wrapper);
+        const matches = files.filter(file => path.basename(file).replace(/(?:\.agent)?\.(?:md|toml|json|yaml|yml)$/i, '') === wrapper);
         if (matches.length === 0) {
             missing.push(wrapper);
             continue;

package/dist/src/policy/authorization.js

@@ -170,13 +170,41 @@ const LEGACY_MANIFESTS = [
     '.aiwg/ops/security/repo-access.manifest.yaml',
     '.aiwg/security/repo-access.manifest.yaml',
 ];
+/**
+ * Factory delivery defaults written by `aiwg init`/`aiwg use`
+ * (emptyConfig in src/config/aiwg-config.ts). Kept as a literal here —
+ * rather than importing the config module — because aiwg-config already
+ * imports this module for authorization validation, so a value import
+ * would be a cycle. A unit test pins this literal against
+ * emptyConfig().delivery (#3635).
+ */
+const DEFAULT_DELIVERY_POLICY = {
+    mode: 'pr-required',
+    default_branch: 'main',
+    require_ci_green: true,
+    auto_close_issues: true,
+    issue_comment_on_cycle: true,
+    force_push_policy: 'never',
+};
+/** True when the delivery block is exactly what the tool writes for a fresh project. */
+export function isDefaultDeliveryPolicy(delivery) {
+    if (!delivery || typeof delivery !== 'object')
+        return false;
+    const actual = delivery;
+    const actualKeys = Object.keys(actual);
+    return actualKeys.length === Object.keys(DEFAULT_DELIVERY_POLICY).length
+        && actualKeys.every((key) => actual[key] === DEFAULT_DELIVERY_POLICY[key]);
+}
 export async function auditLegacyPermissions(projectDir, config) {
     const out = validateAuthorization(config?.authorization);
     if (!config?.authorization && config?.repos?.some(repo => repo.allowed?.length))
         out.push({ severity: 'warning', code: 'legacy-repos-allowed', source: '.aiwg/aiwg.config', message: 'repos[].allowed should be normalized into authorization roles and assignments.' });
     if (!config?.authorization && Object.keys(config?.repo_maintainer?.tiers ?? {}).length)
         out.push({ severity: 'warning', code: 'legacy-maintainer-tiers', source: '.aiwg/aiwg.config', message: 'repo_maintainer.tiers should be represented by normalized role assignments.' });
-    if (!config?.authorization && config?.delivery)
+    // Tool-written delivery defaults are not operator legacy input: a fresh
+    // `aiwg use` must not produce something that needs migration (#3635).
+    // Operator-edited delivery (any key added, removed, or changed) still flags.
+    if (!config?.authorization && config?.delivery && !isDefaultDeliveryPolicy(config.delivery))
         out.push({ severity: 'warning', code: 'legacy-delivery-policy', source: '.aiwg/aiwg.config', message: 'delivery and signing operations should be normalized into scoped role assignments.' });
     for (const path of LEGACY_MANIFESTS) {
         try {

package/dist/src/process/aiwg-probe-command.d.mts

@@ -0,0 +1,15 @@
+export interface AiwgProbeCommand {
+  file: string;
+  prefix: string[];
+  via: 'aiwg-bin' | 'entrypoint' | 'package' | 'path';
+}
+
+export function resolveAiwgProbeCommand(options?: {
+  env?: NodeJS.ProcessEnv;
+  argv1?: string | undefined;
+  execPath?: string;
+  cwd?: string;
+  packageRoot?: string | null;
+}): AiwgProbeCommand;
+
+export function probeNotOnPathDetail(): string;

package/dist/src/process/aiwg-probe-command.mjs

@@ -0,0 +1,37 @@
+// Resolves the aiwg invocation for doctor's discovery self-probes so they
+// run the current entrypoint instead of failing when aiwg is not on PATH.
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+export function resolveAiwgProbeCommand({
+  env = process.env,
+  argv1 = process.argv[1],
+  execPath = process.execPath,
+  cwd = process.cwd(),
+  packageRoot = null,
+} = {}) {
+  const override = env?.AIWG_BIN;
+  if (typeof override === 'string' && override.length > 0) {
+    return { file: override, prefix: [], via: 'aiwg-bin' };
+  }
+  const entry = typeof argv1 === 'string' && argv1.length > 0
+    ? (path.isAbsolute(argv1) ? argv1 : path.resolve(cwd, argv1))
+    : null;
+  // Only the aiwg launcher itself is a usable entrypoint; doctor also runs as
+  // `node tools/cli/doctor.mjs`, where argv[1] is doctor, not aiwg.
+  const isLauncher = entry && ['aiwg', 'aiwg.mjs'].includes(path.basename(entry));
+  if (entry && isLauncher && existsSync(entry)) {
+    return { file: execPath, prefix: [entry], via: 'entrypoint' };
+  }
+  if (typeof packageRoot === 'string' && packageRoot.length > 0) {
+    const bin = path.join(packageRoot, 'bin', 'aiwg.mjs');
+    if (existsSync(bin)) {
+      return { file: execPath, prefix: [bin], via: 'package' };
+    }
+  }
+  return { file: 'aiwg', prefix: [], via: 'path' };
+}
+
+export function probeNotOnPathDetail() {
+  return 'aiwg not on PATH (spawn ENOENT) — add the npm global bin to PATH or invoke doctor via the install entrypoint';
+}

package/dist/src/serve/shared-host-admission-checks.js

@@ -0,0 +1,116 @@
+export function attemptBlock(snapshot, candidate, policy, now) {
+    const accounting = candidate.accounting;
+    const deny = (cause, kind = 'policy-exclusion') => ({ kind, cause, terminal: true });
+    const attempts = Object.values(snapshot.records).filter(record => record.accounting?.attemptNumber !== undefined);
+    const taskAttempts = attempts.filter(record => record.accounting.taskKey === accounting.taskKey);
+    if (taskAttempts.length) {
+        const previous = taskAttempts.sort((a, b) => a.accounting.attemptNumber - b.accounting.attemptNumber).at(-1);
+        if (candidate.allowance?.previousRequestId !== previous.requestId)
+            return deny('new attempt must reference the latest task attempt');
+        if (previous.state !== 'settled')
+            return deny('previous attempt requires proof-checked reconciliation before replacement');
+        const failure = previous.accounting.failure;
+        const purpose = candidate.allowance?.purpose ?? 'retry';
+        if (purpose === 'retry' || purpose === 'fallback' || failure?.class === 'rate-limit') {
+            if (!failure || !failure.retryable || !['rate-limit', 'unavailable', 'timeout'].includes(failure.class))
+                return deny('previous failure does not permit automatic retry');
+            if (!(policy.managed.retry?.on ?? ['rate-limit', 'unavailable', 'timeout']).includes(failure.class))
+                return deny(`${failure.class} retries are disabled`);
+        }
+    }
+    else if (candidate.allowance?.previousRequestId)
+        return deny('unknown previous task attempt');
+    for (const key of [accounting.runKey, accounting.taskKey]) {
+        const scope = snapshot.allowances[key];
+        if (Date.parse(scope.deadlineAt ?? '') <= now)
+            return deny('cumulative allowance deadline elapsed');
+        const prior = attempts.filter(record => record.accounting.runKey === key || record.accounting.taskKey === key);
+        if (scope.limits.maxAttempts !== undefined && prior.reduce((sum, record) => sum + record.accounting.attemptCount, 0) + accounting.attemptCount > scope.limits.maxAttempts)
+            return deny('cumulative attempt allowance exhausted', 'budget-denial');
+        for (const [dimension, limit] of [['tokens', scope.limits.maxTokens], ['costUsd', scope.limits.maxCostUsd]]) {
+            if (limit === undefined)
+                continue;
+            let used = 0;
+            for (const record of prior) {
+                const value = chargedUsage(record, dimension);
+                if (value === null)
+                    return deny(`unknown ${dimension} charge has no finite reservation`, 'budget-denial');
+                used += value;
+            }
+            const reserved = accounting.reservation[dimension];
+            if (reserved === null || reserved === 0 || used + reserved > limit)
+                return deny(`cumulative ${dimension} reservation exceeds allowance`, 'budget-denial');
+        }
+    }
+    if (taskAttempts.some(record => Date.parse(record.accounting.notBefore ?? '') > now))
+        return { kind: 'policy-exclusion', cause: 'retry-backoff', terminal: false };
+    if (policy.managed.budgets?.unknownCost === 'deny' && accounting.reservation.costUsd === null)
+        return deny('unknown cost is denied by policy', 'budget-denial');
+    const quotaScope = candidate.managed?.cli && snapshot.hostBinding
+        ? policy.managed.upstream[candidate.managed.cli].quotaScope : candidate.managed?.quotaScope;
+    const quotas = quotaScope ? [`quota/${encodeURIComponent(quotaScope)}`]
+        : Object.keys(snapshot.cooldowns ?? {});
+    if (quotas.some(key => Date.parse(snapshot.cooldowns?.[key]?.until ?? '') > now))
+        return { kind: 'policy-exclusion', cause: 'quota-cooldown', terminal: false };
+    return undefined;
+}
+function chargedUsage(record, dimension) {
+    const accounting = record.accounting;
+    const usage = accounting.usage;
+    const measured = !usage || usage.quality === 'unknown' ? null : dimension === 'costUsd' ? usage.costUsd
+        : usage.inputTokens === null || usage.outputTokens === null || usage.cacheTokens === null || usage.reasoningTokens === null ? null
+            : usage.inputTokens + usage.outputTokens + usage.cacheTokens + usage.reasoningTokens;
+    const reservation = accounting.reservation[dimension];
+    // Uncertain execution can still accrue spend; estimates never refund a reserve.
+    if (record.state !== 'settled' || usage?.quality !== 'reported') {
+        return reservation === null || measured === null ? reservation : Math.max(reservation, measured);
+    }
+    return measured ?? reservation;
+}
+export function capacityBlock(snapshot, candidate, policy, now = -Infinity) {
+    const slots = policy.managed ? candidate.reservedSlots ?? 1 : 1;
+    const active = Object.values(snapshot.records).filter(record => record.state === 'admitted' || (policy.managed && record.state === 'uncertain'));
+    const limits = [
+        { dimension: 'global', cap: policy.maxConcurrent, matches: () => true },
+    ];
+    if (policy.managed)
+        for (const key of candidate.dimensions ?? []) {
+            const cap = policy.managed.dimensionCaps[key];
+            if (cap !== undefined)
+                limits.push({ dimension: key, cap, matches: record => !record.dimensions || record.dimensions.includes(key) });
+        }
+    for (const [field, quotas] of [
+        ['environment', policy.environmentQuotas], ['provider', policy.providerQuotas],
+        ['runtimeKind', { host: policy.defaultHostQuota ?? 1, ...policy.runtimeQuotas }],
+    ]) {
+        const cap = quotas?.[candidate[field]];
+        if (cap !== undefined)
+            limits.push({ dimension: `${field}/${candidate[field]}`, cap: policy.managed ? cap : Math.ceil(cap), matches: record => record[field] === candidate[field] });
+    }
+    const impossible = limits.find(limit => slots > limit.cap);
+    if (impossible)
+        return { kind: 'policy-exclusion', cause: 'request-exceeds-cap', dimension: impossible.dimension, terminal: false };
+    const used = (records, limit) => records.filter(limit.matches)
+        .reduce((sum, record) => sum + (policy.managed ? record.reservedSlots ?? 1 : 1), 0);
+    const blocked = limits.filter(limit => used(active, limit) + slots > limit.cap);
+    if (!blocked.length)
+        return undefined;
+    const dimensions = blocked.map(limit => limit.dimension);
+    const certain = active.filter(record => record.state === 'admitted' && !(Date.parse(record.leaseExpiresAt ?? '') <= now));
+    if (policy.managed && blocked.some(limit => used(certain, limit) + slots <= limit.cap)) {
+        return { kind: 'safety-blocked', cause: 'uncertain-lease', dimension: dimensions[0], dimensions, terminal: false };
+    }
+    return { kind: 'capacity-wait', cause: 'capacity-cap', dimension: dimensions[0], dimensions, terminal: false };
+}
+/** Past retry/cooldown exclusion does not count toward an eligible service gap. */
+export function attemptReadyAt(snapshot, candidate, policy) {
+    const retry = Object.values(snapshot.records).filter(record => record.accounting?.attemptNumber !== undefined
+        && record.accounting.taskKey === candidate.accounting?.taskKey)
+        .reduce((latest, record) => Math.max(latest, Date.parse(record.accounting.notBefore ?? '') || 0), 0);
+    const quota = candidate.managed?.cli && snapshot.hostBinding
+        ? policy.managed.upstream[candidate.managed.cli].quotaScope : candidate.managed?.quotaScope;
+    const cooldown = Object.entries(snapshot.cooldowns ?? {}).filter(([key]) => !quota || key === `quota/${encodeURIComponent(quota)}`)
+        .reduce((latest, [, value]) => Math.max(latest, Date.parse(value.until) || 0), 0);
+    return Math.max(retry, cooldown);
+}
+//# sourceMappingURL=shared-host-admission-checks.js.map