@aiwg/cli 2026.10.9 → 2026.10.11

package/dist/src/models/worker-installation.mjs

@@ -1,5 +1,6 @@
 /** Shared installed-worker qualification owner, also used by the Ralph compatibility facade. */
 import { spawn } from 'node:child_process';
+import { buildInstalledWorkerTransport } from './worker-artifact-binding.mjs';
 import { constants } from 'node:fs';
 import { open, realpath, lstat, mkdir, rename, writeFile, unlink } from 'node:fs/promises';
 import path from 'node:path';
@@ -207,11 +208,11 @@ export async function prepareInstalledWorkerInvocation(instance, invocation, qua
         || result.stdin !== qualification.adapter.invocation.stdin) {
         throw new WorkerPolicyError('OG_PIN_MISMATCH', 'Worker argv/stdin differs from the authorized driver mapping');
       }
-      // Shell plans contain names, never credential values. Recheck the named
-      // launch environment now; the conductor must repeat preparation if it
-      // changes before copying the command into its shell.
+      // Shell plans contain names, never values. PATH is host plumbing; its
+      // allowlisted name stays bound, while the executable is pinned separately.
+      // Other launch values must still match qualification.
       if (JSON.stringify([...result.envNames].sort()) !== JSON.stringify(Object.keys(installation.environment ?? {}).sort())
-        || result.envNames.some(name => process.env[name] !== installation.environment[name])) {
+        || result.envNames.some(name => name !== 'PATH' && process.env[name] !== installation.environment[name])) {
         throw new WorkerPolicyError('OG_PIN_MISMATCH', 'Worker launch environment differs from qualification');
       }
     }
@@ -345,13 +346,13 @@ export async function inspectWorkerInstallation(instance, request) {
   return { binary, cwd: canonicalCwd, inputRoots, outputRoots, scopeDigest: qualificationDigest({ metadata, profileId, cliVersion, platform, binary, modules, runtimeFiles,
     permissionRequirements, controlArgv, fixtureDigest: await workerNegativeFixtureDigest(),
     requiredControls: [...requiredControls].sort(), effectiveConfigDigest, accountScope, boundary, cwd: canonicalCwd,
-    workerWritableRoots: canonicalWritableRoots, inputRoots, outputRoots, environmentDigest: qualificationDigest(environment), endpoints, mcp: request.mcp ?? null,
+    workerWritableRoots: canonicalWritableRoots, inputRoots, outputRoots, environmentDigest: qualificationDigest(Object.fromEntries(Object.entries(environment).filter(([name]) => name !== 'PATH'))), endpoints, mcp: request.mcp ?? null,
     mcpServerDigest: request.mcpServerDigest ?? null }) };
 }
 
 /** Restricted whole-banner regex: one capture, no branching, assertions,
  * backreferences, wildcards, unbounded repetition or repeated groups. Bounded
- * at most two atom repetitions, each capped at 128; banners are capped at 4096 bytes. */
+ * at most two atom repetitions capped at 128, or a final [\s\S] banner tail capped at 4096 bytes. */
 export function compileWorkerVersionPattern(pattern) {
   if (typeof pattern !== 'string' || pattern.length > 256 || !pattern.startsWith('^') || !pattern.endsWith('$')) throw new Error('Invalid worker version pattern');
   let captures = 0, depth = 0, repetitions = 0, atom = false;
@@ -376,7 +377,7 @@ export function compileWorkerVersionPattern(pattern) {
       depth--; atom = false; // groups cannot be repeated
     } else if (c === '{') {
       const match = /^\{([0-9]+),([0-9]+)\}/.exec(pattern.slice(i));
-      if (++repetitions > 2 || !atom || !match || +match[1] < 1 || +match[2] < +match[1] || +match[2] > 128) throw new Error('Unsafe worker version repetition');
+      if (++repetitions > 2 || !atom || !match || +match[1] < 1 || +match[2] < +match[1] || +match[2] > (captures === 1 && depth === 0 && pattern.slice(i - 6) === '[\\s\\S]{1,4096}$' ? 4096 : 128)) throw new Error('Unsafe worker version repetition');
       i += match[0].length - 1; atom = false;
     } else {
       if ('.*+?|^$}'.includes(c)) throw new Error('Unsafe worker version pattern');
@@ -1141,13 +1142,10 @@ export async function loadRecordedWorkerInstallations({ registry, cwd, policy, p
           platform: process.platform, installation, stdinFramerBinding: { storePath: filename, storeDigest: digest },
           ...(profile.transport === 'mcp' ? { mcp: binding.mcp, mcpSchemas: record.mcpSchemas } : {}) },
         ...(typeof instance.buildWorkerStdinFrame === 'function'
-          ? { buildWorkerStdinFrame: brief => instance.buildWorkerStdinFrame(brief) } : {}),
-        buildInvocation: async input => profile.transport === 'shell' ? {
-          argv: [scope.binary.realpath, ...instance.buildWorkerArgs(input, profile, input.permissions)],
-          stdin: adapter.invocation.stdin, envNames: Object.keys(installation.environment),
-          ...(typeof instance.buildWorkerArtifacts === 'function'
-            ? { artifacts: instance.buildWorkerArtifacts(input) } : {}),
-        } : instance.buildInvocation(input),
+          ? { buildWorkerStdinFrame: (brief, invocation) => instance.buildWorkerStdinFrame(brief, invocation) } : {}),
+        buildInvocation: async input => profile.transport === 'shell'
+          ? buildInstalledWorkerTransport(instance, input, profile, adapter.invocation, scope.binary.realpath, installation.environment)
+          : instance.buildInvocation(input),
         prepareWorkerInvocation: (invocation, qualification) => prepareInstalledWorkerInvocation(instance, invocation, qualification),
         ...(mcpRegistry ? { mcpRegistry, mcpProfile: record.mcpProfile } : {}),
       };

package/dist/src/models/worker-member-references.js

@@ -0,0 +1,64 @@
+import { expandWorkerGroupTemplates } from '../config/worker-group-templates.js';
+/** Every group member referencing this cli, including disabled ones (for context). */
+export function memberReferences(parallelism, cli) {
+    parallelism = expandWorkerGroupTemplates(parallelism).parallelism;
+    const refs = [];
+    for (const [groupId, group] of Object.entries(parallelism.groups ?? {})) {
+        for (const member of group?.members ?? []) {
+            if (member.cli !== cli)
+                continue;
+            refs.push({ groupId, memberId: member.id, member,
+                enabled: member.enabled !== false && parallelism.clis?.[cli]?.enabled !== false });
+        }
+    }
+    return refs.sort((a, b) => `${a.groupId}/${a.memberId}`.localeCompare(`${b.groupId}/${b.memberId}`));
+}
+export function memberLabels(refs) {
+    return refs.map(ref => `${ref.groupId}/${ref.memberId}${ref.enabled ? '' : ' (disabled)'}`);
+}
+export function describeConfigContext(members) {
+    return members.length ? `members: ${members.join(', ')}` : 'members: no group member references this cli';
+}
+/**
+ * Union of every cli id a readiness pass must consider: explicit
+ * `parallelism.clis` entries plus any cli id referenced only implicitly by a
+ * group member (canonical default binding, no explicit installation entry).
+ */
+export function allConfiguredCliIds(parallelism, cli) {
+    parallelism = expandWorkerGroupTemplates(parallelism).parallelism;
+    const ids = new Set(Object.keys(parallelism.clis ?? {}));
+    for (const group of Object.values(parallelism.groups ?? {})) {
+        for (const member of group?.members ?? [])
+            ids.add(member.cli);
+    }
+    return [...ids].filter(id => cli === undefined || id === cli).sort();
+}
+/**
+ * A cli is "required" only when an enabled group member referencing it also
+ * covers a role its group lists in `requiredRoles`. Every other configured
+ * cli is optional: installation failures stay advisory (never 'error', so
+ * they never flip doctor's exit code) until something actually requires it.
+ */
+export function isCliRequired(parallelism, cli) {
+    parallelism = expandWorkerGroupTemplates(parallelism).parallelism;
+    for (const group of Object.values(parallelism.groups ?? {})) {
+        const required = new Set(group?.requiredRoles ?? []);
+        if (!required.size)
+            continue;
+        for (const member of group?.members ?? []) {
+            if (member.cli !== cli || member.enabled === false)
+                continue;
+            if (parallelism.clis?.[cli]?.enabled === false)
+                continue;
+            if (member.roles.some(role => required.has(role)))
+                return true;
+        }
+    }
+    return false;
+}
+/** Cap a status at 'warn' for optional (non-required) clis so an unreferenced
+ * or not-yet-wired profile never flips doctor's exit code. */
+export function advisoryStatus(status, required) {
+    return required || status !== 'error' ? status : 'warn';
+}
+//# sourceMappingURL=worker-member-references.js.map

package/dist/src/models/worker-plan.js

@@ -0,0 +1,317 @@
+// Resolves eligible worker tuples against current config, catalog and installation snapshots.
+import { ownWorkerRoleGuidance } from './worker-selection-policy.js';
+import { mergeGroupWorkerPolicy } from '../config/worker-group-templates.js';
+import { WORKER_DISPATCH_ENABLE_COMMAND, WORKER_DISPATCH_READINESS_COMMAND } from './worker-dispatch-offer.js';
+import { resolveWorkerGroupInstallation, resolveParallelism, validateWorkerGroupQualifications, validateWorkerGroupReferences, validateWorkerBudgetEnforcement, workerActivationDigests, workerConfigDigest, } from '../config/aiwg-config.js';
+import { qualifyWorkerInvocationProfile, validateWorkerPolicyRoute, validateWorkerModelObservation, assertWorkerLaunchMode, hasOperatorWorkerNativeRenderer, hasSelectionRelevantConflicts, workerContextHeadroom, workerModelKey, isCanonicalWorkerModelKey, WorkerSelectionPolicySchema, validateWorkerCatalogDiscovery, } from './provider-policy.js';
+import { MODEL_WRAPPERS } from './provider-models.js';
+import { routeModelTier } from './router.js';
+const matchesChoice = (tuple, choice) => tuple.group === choice.group && tuple.member === choice.member && tuple.model === choice.model && tuple.effort === choice.effort;
+function findWorkerModelRow(rows, model) {
+    const matches = rows?.filter(row => row.id === model || row.apiModelId === model) ?? [];
+    return matches.length === 1 ? matches[0] : undefined;
+}
+function workerCatalogDigest(catalog) {
+    if (!catalog.discovery)
+        return workerConfigDigest(catalog);
+    // Offline loads synthesize fetchedAt. Keep catalog facts and persisted
+    // observation/qualification times pinned, independent of the load clock.
+    const { fetchedAt, ...discovery } = catalog.discovery;
+    return workerConfigDigest({ ...catalog, discovery });
+}
+/** Pure S1 resolution. No probing, launch, activation, admission, or writes.
+ * Recheck against freshly loaded snapshots before preparing an invocation. */
+export function resolveWorkerPlan(snapshot, request) {
+    let parallelism = snapshot.config.parallelism ?? {};
+    const policy = snapshot.models.defaults.workerSelection;
+    const digests = {
+        ...snapshot.modelDigests,
+        configDigest: workerActivationDigests(snapshot.config).configDigest,
+        resolvedModelsDigest: workerConfigDigest(snapshot.models),
+        catalogDigest: workerCatalogDigest(snapshot.catalog),
+        profileDigest: workerConfigDigest([snapshot.registry, snapshot.installations]),
+        constraintsDigest: workerConfigDigest(snapshot.constraints),
+    };
+    const plan = {
+        mode: parallelism.worker_mode ?? 'direct', status: 'blocked', role: null, selected: null,
+        eligible: [], alternatives: [], exclusions: [], diagnostics: [], digests,
+        policy: structuredClone(policy), origins: structuredClone(snapshot.models.workerPolicyOrigins),
+        choice: null, capacity: 'conductor-guidance-only', ceilings: {},
+    };
+    const diagnostic = (code, pointer, message) => ({ code, pointer, message });
+    const block = (code, pointer, message) => {
+        plan.diagnostics.push(diagnostic(code, pointer, message));
+    };
+    if (!parallelism.worker_dispatch) {
+        plan.status = 'disabled';
+        block('OG_CONFIG_REFERENCE', '/parallelism/worker_dispatch', `Direct worker dispatch is off (parallelism.worker_dispatch). Enable with \`${WORKER_DISPATCH_ENABLE_COMMAND}\` `
+            + `(then check readiness with \`${WORKER_DISPATCH_READINESS_COMMAND}\`).`);
+        return plan;
+    }
+    const now = new Date(request.now);
+    if (!Number.isFinite(now.getTime()))
+        block('OG_CONFIG_REFERENCE', '/request/now', 'A valid current clock is required');
+    if (!request.context || typeof request.context.estimator !== 'string')
+        block('OG_CONFIG_REFERENCE', '/request/context', 'A named, bounded context estimate is required');
+    if (snapshot.constraints?.revokedModels?.some(key => !isCanonicalWorkerModelKey(key)))
+        block('OG_CONFIG_REFERENCE', '/constraints/revokedModels', 'Revocations require canonical inference model keys');
+    if (request.expectedDigests && (Object.keys(request.expectedDigests).length !== Object.keys(digests).length
+        || Object.entries(digests).some(([key, value]) => request.expectedDigests[key] !== value))) {
+        block('OG_CONFIG_REFERENCE', '/request/expectedDigests', 'Current input digests changed; resolve again');
+    }
+    if (Object.values(snapshot.modelDigests).length !== 3 || Object.values(digests).some(value => !/^sha256:[a-f0-9]{64}$/.test(value))) {
+        block('OG_CONFIG_REFERENCE', '/models', 'Current loader input digests are required');
+    }
+    if (plan.mode === 'managed') {
+        const activation = parallelism.activation;
+        if (!activation || ['configDigest', 'projectModelsDigest', 'userModelsDigest', 'builtinModelsDigest'].some(key => activation[key] !== digests[key])) {
+            block('OG_CONFIG_REFERENCE', '/parallelism/activation', 'Managed activation is missing or stale');
+        }
+    }
+    if (!policy)
+        block('OG_CONFIG_REFERENCE', '/defaults/workerSelection', 'Current merged worker policy is required');
+    const catalogErrors = validateWorkerCatalogDiscovery(snapshot.catalog.discovery);
+    if (catalogErrors.length)
+        block('OG_ADAPTER_UNQUALIFIED', '/catalog/discovery', catalogErrors.join('; '));
+    if (plan.diagnostics.length || !policy)
+        return plan;
+    const policyShape = WorkerSelectionPolicySchema.safeParse(policy);
+    if (!policyShape.success) {
+        block('OG_CONFIG_REFERENCE', '/defaults/workerSelection', policyShape.error.message);
+        return plan;
+    }
+    for (const message of validateWorkerGroupReferences(parallelism, policy))
+        block('OG_CONFIG_REFERENCE', '/parallelism', message);
+    if (plan.diagnostics.length)
+        return plan;
+    parallelism = resolveParallelism(parallelism, snapshot.config.providers?.[0]);
+    const ceilingLayers = [parallelism.budgets?.perRun, parallelism.budgets?.perTask,
+        { maxAttempts: parallelism.retry?.maxAttempts ?? 3 }, snapshot.constraints?.ceilings, request.ceilings];
+    for (const key of ['tokens', 'costUsd', 'wallSeconds', 'maxAttempts']) {
+        const values = ceilingLayers.map(layer => layer?.[key]).filter((value) => value !== undefined);
+        if (values.some(value => !Number.isFinite(value) || value < 0 || key !== 'costUsd' && !Number.isSafeInteger(value))) {
+            block('OG_CONFIG_REFERENCE', `/request/ceilings/${key}`, 'Ceilings must be finite nonnegative values; counts must be integers');
+        }
+        else if (values.length)
+            plan.ceilings[key] = Math.min(...values);
+    }
+    if (plan.ceilings.maxAttempts === 0)
+        block('OG_BUDGET_UNMEASURABLE', '/request/ceilings/maxAttempts', 'No task attempts remain');
+    const qualifiedRoles = {};
+    for (const [groupId, group] of Object.entries(parallelism.groups ?? {})) {
+        for (const member of group.members ?? []) {
+            const observed = findWorkerModelRow(snapshot.catalog.discovery?.instances?.[member.cli]?.models, member.model)?.worker;
+            qualifiedRoles[`${groupId}/${member.id}`] = observed?.qualification.status === 'qualified'
+                ? observed.qualification.roles.filter(role => ownWorkerRoleGuidance(policy, role)?.groups.includes(groupId)) : [];
+        }
+    }
+    // Qualification gaps are group-scoped: an unqualified group must not block a
+    // request that never considers it. Gaps are applied once the candidates are known.
+    const qualificationGaps = validateWorkerGroupQualifications(parallelism, qualifiedRoles).map(diagnostic => ({
+        ...diagnostic, message: `${diagnostic.message}. Run aiwg doctor --probe-workers --qualify.`,
+    }));
+    const gapGroup = (diagnostic) => diagnostic.pointer.split('/')[3] ?? '';
+    const taskRole = request.taskClass && policy.taskClasses && Object.hasOwn(policy.taskClasses, request.taskClass) ? policy.taskClasses[request.taskClass] : undefined;
+    const role = request.role ?? taskRole;
+    plan.role = role ?? null;
+    if (request.taskClass && (!taskRole || request.role && taskRole !== request.role))
+        block('OG_CONFIG_REFERENCE', '/request/taskClass', 'Unknown task class or conflicting role');
+    const guidance = role ? ownWorkerRoleGuidance(policy, role) : undefined;
+    if (!role || !guidance)
+        block('OG_CONFIG_REFERENCE', '/defaults/workerSelection/roleGuidance', 'Requested role has no guidance');
+    if (request.member && !request.group)
+        block('OG_CONFIG_REFERENCE', '/request/member', 'Group-local member pins require a group');
+    if (request.group && !guidance?.groups.includes(request.group))
+        block('OG_CONFIG_REFERENCE', '/request/group', 'Group is outside role guidance');
+    if ([request.maxParallel, snapshot.constraints?.maxParallel].some(value => value !== undefined && (!Number.isSafeInteger(value) || value < 0)))
+        block('OG_CONFIG_REFERENCE', '/request/maxParallel', 'Capacity ceilings must be nonnegative integers');
+    if (request.requireDifferentFamily && (!request.reviewOf || validateWorkerModelObservation(request.reviewOf).length
+        || hasSelectionRelevantConflicts(request.reviewOf) || !request.reviewOf.family || request.reviewOf.family === 'unknown')) {
+        block('OG_MODEL_UNAPPROVED', '/request/reviewOf', 'Required review needs unambiguous observed source lineage');
+    }
+    const candidateGroups = request.group ? [request.group] : guidance?.groups ?? [];
+    const unqualifiedGroups = new Set(qualificationGaps.map(gapGroup));
+    const qualifiedGroups = candidateGroups.filter(groupId => !unqualifiedGroups.has(groupId));
+    if (!qualifiedGroups.length) {
+        plan.diagnostics.push(...qualificationGaps.filter(gap => candidateGroups.includes(gapGroup(gap))));
+    }
+    else {
+        // Unpinned requests skip an unqualified guidance group visibly instead of failing the role.
+        for (const groupId of candidateGroups.filter(groupId => unqualifiedGroups.has(groupId))) {
+            const gaps = qualificationGaps.filter(gap => gapGroup(gap) === groupId);
+            for (const member of parallelism.groups?.[groupId]?.members ?? []) {
+                plan.exclusions.push({ group: groupId, member: member.id, model: member.model, effort: null, diagnostics: gaps });
+            }
+        }
+    }
+    if (plan.diagnostics.length || !role || !guidance)
+        return plan;
+    const baseRole = guidance.baseRole ?? role;
+    const wrapperPin = snapshot.models.agentOverrides[MODEL_WRAPPERS[baseRole]]?.['model-override'];
+    const groupPolicies = new Map();
+    const groups = qualifiedGroups;
+    for (const groupId of groups) {
+        const group = parallelism.groups[groupId];
+        const narrowed = mergeGroupWorkerPolicy(policy, group);
+        groupPolicies.set(groupId, narrowed.policy);
+        if (narrowed.diagnostics.length) {
+            plan.diagnostics.push(...narrowed.diagnostics);
+            continue;
+        }
+        const groupPolicy = narrowed.policy;
+        const permissions = { ...group.execution, transport: group.execution?.transport ?? 'shell' };
+        const transport = permissions.transport;
+        if (request.transport === 'mcp' && permissions.launchMode === 'native-sandbox') {
+            const reason = diagnostic('OG_POLICY_RELAXATION', `/parallelism/groups/${groupId}/execution/launchMode`, 'MCP worker-invoke does not support native-sandbox isolation. Use models resolve --transport shell and the shell launcher, or select a group with systemd-unit isolation.');
+            for (const member of group.members ?? [])
+                plan.exclusions.push({ group: groupId, member: member.id, model: member.model, effort: null, diagnostics: [reason] });
+            if (request.group === groupId)
+                plan.diagnostics.push(reason);
+            continue;
+        }
+        // Priority is guidance only. Preserve declaration order for ties; fallback order stays explicit.
+        const members = (group.members ?? []).map((member, index) => ({ member, index })).sort((a, b) => (a.member.priority ?? 100) - (b.member.priority ?? 100) || a.index - b.index);
+        for (const { member } of members) {
+            const binding = snapshot.installations[member.cli];
+            const discovery = snapshot.catalog.discovery?.instances?.[member.cli];
+            const row = findWorkerModelRow(discovery?.models, member.model);
+            const observation = row?.worker;
+            const efforts = request.effort !== undefined ? [request.effort]
+                : [...new Set([guidance.initialEffort, ...guidance.effortLadder])];
+            for (const effort of efforts) {
+                const tuple = { group: groupId, member: member.id, model: member.model, effort };
+                const reasons = [];
+                const deny = (code, pointer, message) => { reasons.push(diagnostic(code, pointer, message)); };
+                const pointer = `/parallelism/groups/${groupId}/members/${member.id}`;
+                if (request.transport !== undefined && request.transport !== transport)
+                    deny('OG_POLICY_RELAXATION', '/request/transport', 'Requested transport differs from resolved group permissions');
+                if (member.enabled === false || parallelism.clis?.[member.cli]?.enabled === false)
+                    deny('OG_CONFIG_REFERENCE', pointer, 'Member or installation is disabled');
+                if (!member.roles.includes(baseRole))
+                    deny('OG_CONFIG_REFERENCE', pointer, 'Member does not cover requested role');
+                const pinMismatch = request.member && request.member !== member.id || request.model && request.model !== member.model || wrapperPin && wrapperPin !== member.model;
+                const substitution = request.substitution && matchesChoice(tuple, request.substitution) && request.substitution.rationale.trim();
+                if (pinMismatch && !substitution)
+                    deny('OG_PIN_MISMATCH', pointer, 'Exact request or wrapper pin requires explicit substitution');
+                if (!observation || !binding || !row?.llmProvider || !row.apiModelId)
+                    deny('OG_ADAPTER_UNQUALIFIED', pointer, 'Missing exact model, inference provider, observation or current installation evidence. Run aiwg doctor --probe-workers --qualify.');
+                if (observation && binding && row?.llmProvider && row.apiModelId) {
+                    const shapeErrors = validateWorkerModelObservation(observation);
+                    if (shapeErrors.length) {
+                        deny('OG_ADAPTER_UNQUALIFIED', '/worker', shapeErrors.join('; '));
+                        plan.exclusions.push({ ...tuple, diagnostics: reasons });
+                        continue;
+                    }
+                    if (observation.cliId !== member.cli || observation.runtimeVersion !== binding.cliVersion
+                        || observation.accountScope !== binding.accountScope || observation.endpointFingerprint !== binding.endpointFingerprint
+                        || discovery?.accountBinding !== binding.accountScope || discovery?.runtimeVersion !== binding.cliVersion
+                        || parallelism.clis?.[member.cli]?.accountScope && parallelism.clis[member.cli].accountScope !== binding.accountScope) {
+                        deny('OG_ADAPTER_UNQUALIFIED', pointer, 'Catalog and current installation scope differ');
+                    }
+                    if (group.efforts && (effort === null || !group.efforts.includes(effort)))
+                        deny('OG_EFFORT_DENIED', pointer, 'Effort is outside group ceiling');
+                    reasons.push(...validateWorkerPolicyRoute({ policy: groupPolicy, role, inferenceProvider: row.llmProvider, apiModelId: row.apiModelId,
+                        selectedModel: member.model, effort, identityEvidence: binding.identityEvidence, observation,
+                        wrapperPin, ...(substitution ? { substitution: request.substitution } : {}), dataClass: request.dataClass, now, context: request.context }));
+                    if (request.requireDifferentFamily && (observation.family === 'unknown' || observation.family === request.reviewOf.family))
+                        deny('OG_MODEL_UNAPPROVED', '/worker/family', 'Required review must use a different observed family');
+                    try {
+                        const { adapter } = resolveWorkerGroupInstallation(parallelism, member.cli, snapshot.registry);
+                        const configuredProfile = parallelism.clis?.[member.cli]?.invocationProfile;
+                        const profilePointer = `/parallelism/clis/${member.cli}/invocationProfile`;
+                        if (configuredProfile && !Object.hasOwn(adapter.invocationProfiles ?? {}, configuredProfile)) {
+                            deny('OG_CONFIG_REFERENCE', profilePointer, 'Configured invocation profile is not registered for this adapter; select a registered profile.');
+                        }
+                        else if (configuredProfile && configuredProfile !== binding.profile) {
+                            deny('OG_PIN_MISMATCH', profilePointer, 'Configured invocation profile differs from installation qualification; qualify the selected profile again.');
+                        }
+                        const configuredServer = parallelism.clis?.[member.cli]?.mcpServerRef;
+                        if (transport === 'mcp' && configuredServer && configuredServer !== binding.mcp?.serverRef)
+                            throw new Error('Configured MCP server changed');
+                        if (!hasOperatorWorkerNativeRenderer(adapter) && (adapter.capabilities.modelPin === 'unsupported' || !adapter.capabilities.nativeFallbackControllable))
+                            throw new Error('Exact model or fallback control is unqualified; qualify an adapter with these controls');
+                        if (policy.guards?.denySelfDelegation !== false && !adapter.capabilities.nestedAgentsControllable)
+                            throw new Error('Child-agent control is unqualified. Review models.json defaults.workerSelection.guards.denySelfDelegation; false permits uncontrolled child agents without qualifying their behavior.');
+                        if (binding.identityEvidence === 'backend-attested' && adapter.capabilities.modelPin !== 'observed')
+                            throw new Error('Requested-only mapping cannot attest backend identity');
+                        if (!hasOperatorWorkerNativeRenderer(adapter) && group.execution?.sandbox && !adapter.capabilities.sandboxModes.includes(group.execution.sandbox))
+                            throw new Error('Requested sandbox mode is unqualified');
+                        assertWorkerLaunchMode(adapter, permissions);
+                        qualifyWorkerInvocationProfile(adapter, { profile: binding.profile, transport, cliVersion: binding.cliVersion,
+                            policy, permissions, effort, boundary: binding.boundary,
+                            requiredControls: request.requiredControls, mcp: binding.mcp });
+                        if (hasOperatorWorkerNativeRenderer(adapter) && transport === 'shell' && permissions.sandbox === 'external') {
+                            reasons.push({ code: 'OG_SANDBOX_EXTERNAL', blocking: false,
+                                pointer: `/parallelism/groups/${groupId}/execution/sandbox`,
+                                message: `${adapter.provider} CLI's own sandbox is disabled by explicit external policy; isolation relies on the per-task worktree and launcher resource scope.` });
+                        }
+                        const { maxAttempts: _maxAttempts, ...budgetLimits } = plan.ceilings;
+                        const budgetDimensions = { tokens: 'tokens', cost: 'costUsd', 'wall-time': 'wallSeconds' };
+                        const enforceable = adapter.capabilities.hardBudget.map(key => budgetDimensions[key]);
+                        for (const message of validateWorkerBudgetEnforcement({ ...parallelism.budgets, perTask: budgetLimits }, enforceable))
+                            deny('OG_BUDGET_UNMEASURABLE', '/parallelism/budgets', message);
+                    }
+                    catch (error) {
+                        deny('OG_ADAPTER_UNQUALIFIED', pointer, String(error));
+                    }
+                    let key;
+                    try {
+                        key = workerModelKey(row.llmProvider, row.apiModelId);
+                    }
+                    catch {
+                        plan.exclusions.push({ ...tuple, diagnostics: reasons });
+                        continue;
+                    }
+                    if (snapshot.constraints?.revokedModels?.includes(key))
+                        deny('OG_MODEL_UNAPPROVED', '/constraints/revokedModels', 'Current model revocation');
+                    if (snapshot.constraints?.unavailableMembers?.includes(`${groupId}/${member.id}`))
+                        deny('OG_ADAPTER_UNQUALIFIED', pointer, 'Member is currently unavailable');
+                    const premium = ['premium', 'max-quality'].includes(guidance.tier) || observation.pricing.costClass === 'premium';
+                    // Worker candidates always invoke a model; deterministic/routine hints must not bypass premium authority.
+                    const authority = routeModelTier({ ...request.authority, deterministic: false, routine: false,
+                        defaultTier: guidance.tier === 'economy' ? 1 : 2, requestedPremium: premium || request.authority?.requestedPremium });
+                    if (authority.requiresConfirmation)
+                        deny('OG_MODEL_UNAPPROVED', '/request/authority', `${authority.rationale.join('; ')}; agents may pass --authorize-premium only after the human explicitly confirmed the premium escalation (escalation-discipline rule)`);
+                    const installation = parallelism.clis?.[member.cli];
+                    const caps = [parallelism.max_parallel_subagents, group.maxParallel, parallelism.admission?.groupCaps?.[groupId],
+                        parallelism.admission?.memberCaps?.[`${groupId}/${member.id}`], parallelism.admission?.cliCaps?.[member.cli],
+                        parallelism.admission?.modelCaps?.[key], installation && parallelism.admission?.quotaCaps?.[installation.quotaScope],
+                        snapshot.constraints?.maxParallel, request.maxParallel].filter((value) => value !== undefined);
+                    const effectiveMaxParallel = caps.length ? Math.min(...caps) : null;
+                    if (effectiveMaxParallel === 0)
+                        deny('OG_ADAPTER_UNQUALIFIED', '/constraints/maxParallel', 'Current capacity ceiling is zero');
+                    if (!reasons.some(reason => reason.blocking !== false))
+                        plan.eligible.push({ ...tuple, cli: member.cli,
+                            inferenceProvider: row.llmProvider, modelKey: key, family: observation.family, identityEvidence: binding.identityEvidence,
+                            profile: binding.profile, transport,
+                            permissions: structuredClone(permissions), context: workerContextHeadroom(request.context, observation),
+                            observedAt: observation.observedAt, verifiedAt: observation.verifiedAt, observationRef: observation.recordId,
+                            effectiveMaxParallel, diagnostics: reasons });
+                }
+                if (reasons.some(reason => reason.blocking !== false))
+                    plan.exclusions.push({ ...tuple, diagnostics: reasons });
+            }
+        }
+    }
+    if (request.choice) {
+        if (!request.choice.rationale.trim())
+            block('OG_CONFIG_REFERENCE', '/request/choice/rationale', 'Conductor choice requires a rationale');
+        plan.selected = plan.eligible.find(tuple => matchesChoice(tuple, request.choice)) ?? null;
+        if (!plan.selected)
+            block('OG_MODEL_UNAPPROVED', '/request/choice', 'Conductor choice is outside the eligible set');
+    }
+    else
+        plan.selected = plan.eligible[0] ?? null;
+    if (plan.diagnostics.length)
+        plan.selected = null;
+    if (plan.selected) {
+        plan.policy = groupPolicies.get(plan.selected.group);
+        plan.status = 'eligible';
+        plan.diagnostics.push(...plan.selected.diagnostics.filter(item => item.code === 'OG_SANDBOX_EXTERNAL'));
+        plan.choice = { source: request.choice ? 'conductor' : 'default', rationale: request.choice?.rationale ?? 'Role group order, member priority/declaration order, then qualified effort ladder',
+            ...(request.substitution && matchesChoice(plan.selected, request.substitution) ? { substitution: structuredClone(request.substitution) } : {}) };
+    }
+    plan.alternatives = plan.eligible.filter(tuple => tuple !== plan.selected);
+    return plan;
+}
+//# sourceMappingURL=worker-plan.js.map