@aiwg/cli 2026.10.8 → 2026.10.10

package/dist/src/config/worker-adoption.js

@@ -0,0 +1,368 @@
+import { normalizeAiwgConfigCandidate } from './config-normalization.js';
+// Reviews and atomically activates the existing worker policy pair with full-copy recovery.
+import { readFile, rm, access } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { ConfigLoader } from '../models/config-loader.js';
+import { validateUserProjectModelConfig } from '../models/provider-policy.js';
+import { emptyConfig, getConfigPath, workerActivationDigests, workerConfigDigest, validateParallelismConfig } from './aiwg-config.js';
+import { projectControlPath, resolveProjectAiwgDir } from './project-artifacts.js';
+import { acquireWorkerWriteLock, reclaimWorkerWriteLock, atomicConfigWrite, runWorkerMaintenance } from './worker-write.js';
+const json = (input) => input.bytes === null ? null : JSON.parse(input.bytes);
+async function capture(file) {
+    let bytes = null;
+    try {
+        bytes = await readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    return { file: resolve(file), bytes, digest: workerConfigDigest(bytes) };
+}
+const revisionPath = (project) => projectControlPath(project, 'aiwg.config.apply-lock.revision.json');
+async function adoptionRevision(project, activationRevision = 0) {
+    const input = await capture(revisionPath(project));
+    const revision = input.bytes === null ? 0 : json(input).revision;
+    if (!Number.isSafeInteger(revision) || revision < 0 || revision >= Number.MAX_SAFE_INTEGER)
+        throw new Error('Invalid adoption revision');
+    return Math.max(revision, activationRevision);
+}
+async function inventory(project, options) {
+    const locations = new ConfigLoader(project, options).getLocations();
+    const compatibility = join(resolveProjectAiwgDir(project), 'aiwg.config');
+    const files = [getConfigPath(project), locations.projectConfig, locations.userConfig, locations.aiwgDefault];
+    if (!files.includes(compatibility)) {
+        // The config writer synchronizes a compatibility copy when its directory is reachable.
+        try {
+            await access(resolveProjectAiwgDir(project));
+            files.push(compatibility);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    return Promise.all([...new Set(files.map(file => resolve(file)))].map(capture));
+}
+const pair = (config, models) => {
+    const parallelism = structuredClone(config.parallelism ?? null);
+    if (parallelism)
+        delete parallelism.activation;
+    return { parallelism, workerSelection: structuredClone(models?.defaults?.workerSelection ?? null) };
+};
+function candidate(inputs, after) {
+    const configInput = [inputs[0], ...inputs.slice(4)].find(input => input.bytes !== null);
+    const config = normalizeAiwgConfigCandidate(configInput ? json(configInput) : emptyConfig());
+    const models = json(inputs[1]) ?? {};
+    if (after) {
+        config.parallelism = structuredClone(after.parallelism ?? undefined);
+        models.defaults ??= {};
+        if (after.workerSelection === null)
+            delete models.defaults.workerSelection;
+        else
+            models.defaults.workerSelection = structuredClone(after.workerSelection);
+    }
+    return { config, models };
+}
+async function validate(project, config, models, options) {
+    const errors = validateParallelismConfig(config.parallelism);
+    const validation = validateUserProjectModelConfig(models);
+    if (errors.length || !validation.valid)
+        throw new Error([...errors, ...validation.diagnostics.map(item => item.message)].join('; '));
+    const loader = new ConfigLoader(project, { aiwgHome: options.aiwgHome, workerCandidate: { projectModels: models } });
+    await loader.load(config.parallelism);
+    return { ...workerActivationDigests(config), ...loader.getInputDigests() };
+}
+async function adoptedCandidate(proposal, options) {
+    const next = candidate(proposal.inputs, proposal.after);
+    const digests = await validate(proposal.project, next.config, next.models, options);
+    const previous = candidate(proposal.inputs).config.parallelism?.activation;
+    if (next.config.parallelism?.worker_mode === 'managed') {
+        next.config.parallelism.activation = { ...digests, revision: proposal.baseRevision + 1,
+            snapshotRef: proposal.digest, ...(previous ? { previousRef: previous.snapshotRef } : {}) };
+    }
+    return { ...next, digests, configBytes: JSON.stringify(next.config, null, 2) + '\n', modelsBytes: JSON.stringify(next.models, null, 2) + '\n' };
+}
+export async function proposeWorkerAdoption(project, changes, options = {}) {
+    project = resolve(project);
+    const inputs = await inventory(project, options);
+    validateRetainedCopies(inputs);
+    const { config, models } = candidate(inputs);
+    await validate(project, config, models, options);
+    const before = pair(config, models);
+    const after = { ...before, ...structuredClone(changes) };
+    if (after.parallelism?.activation !== undefined)
+        throw new Error('Activation markers are produced by apply, never by proposals');
+    const next = candidate(inputs, after);
+    await validate(project, next.config, next.models, options);
+    const proposal = { project, baseRevision: await adoptionRevision(project, config.parallelism?.activation?.revision), inputs, before, after };
+    return { ...proposal, digest: workerConfigDigest(proposal) };
+}
+function changedFields(before, after, pointer = '') {
+    if (workerConfigDigest(before) === workerConfigDigest(after))
+        return [];
+    const present = [before, after].filter(value => value !== undefined && value !== null);
+    if (present.length && present.every(value => typeof value === 'object' && !Array.isArray(value))) {
+        const keys = [...new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})])];
+        if (!keys.length)
+            return [pointer];
+        return keys.flatMap(key => changedFields(before?.[key], after?.[key], `${pointer}/${key.replace(/~/g, '~0').replace(/\//g, '~1')}`));
+    }
+    return [pointer];
+}
+function authorize(proposal, authority) {
+    const { digest, ...body } = proposal;
+    if (workerConfigDigest(body) !== digest)
+        throw new Error('Proposal digest mismatch; review again');
+    if (authority && 'digest' in authority && authority.digest === digest)
+        return;
+    if (authority && 'fields' in authority && authority.project === proposal.project && authority.revision === proposal.baseRevision
+        && Array.isArray(authority.fields) && authority.fields.length && authority.fields.every(field => typeof field === 'string' && /^\/(parallelism|workerSelection)(\/[^/]+)*$/.test(field) && field !== '/parallelism/activation' && !field.startsWith('/parallelism/activation/'))
+        && changedFields(proposal.before, proposal.after).every(field => authority.fields.some(scope => field === scope || field.startsWith(`${scope}/`))))
+        return;
+    throw new Error('Worker adoption requires the exact proposal digest or standing authorization for every changed field and base revision');
+}
+function validateRetainedCopies(inputs) {
+    const canonical = [inputs[0], ...inputs.slice(4)].find(input => input.bytes !== null);
+    for (const copy of inputs.slice(4)) {
+        if (copy.bytes !== null && workerConfigDigest(json(copy)) !== workerConfigDigest(canonical && json(canonical)))
+            throw new Error(`Compatibility config diverges from the canonical validated copy: ${copy.file}`);
+    }
+}
+async function recheck(proposal, options, checkRevision = true) {
+    const current = await inventory(proposal.project, options);
+    if (workerConfigDigest(current) !== workerConfigDigest(proposal.inputs))
+        throw new Error('Stale proposal: input bytes/digests or participating copies changed');
+    const { config, models } = candidate(current);
+    if ((checkRevision && await adoptionRevision(proposal.project, config.parallelism?.activation?.revision) !== proposal.baseRevision) || workerConfigDigest(pair(config, models)) !== workerConfigDigest(proposal.before))
+        throw new Error('Stale proposal: base revision or reviewed pair changed');
+    return current;
+}
+export async function regenerateWorkerGuidance(project, config) {
+    const { generate, discoverDeployedArtifacts } = await import('../smiths/context-pipeline/index.js');
+    const { getProviderContextDiscoveryPathStrings } = await import('../providers/provider-definitions.js');
+    const providers = [...new Set([...(config.providers ?? []), ...Object.values(config.installed ?? {}).flatMap(entry => Object.keys(entry.deployedTo ?? {}))])];
+    if (!providers.length)
+        throw new Error('Cannot regenerate guidance: configure at least one provider');
+    for (const provider of providers) {
+        const paths = getProviderContextDiscoveryPathStrings(provider);
+        if (!paths)
+            throw new Error(`Cannot regenerate guidance for ${provider}`);
+        const sections = await discoverDeployedArtifacts(project, paths);
+        const result = await generate({ provider: provider, projectPath: project, sections, detectExistingFiles: true });
+        if (result.warnings.length)
+            throw new Error(`Guidance regeneration for ${provider}: ${result.warnings.join('; ')}`);
+    }
+}
+export async function applyWorkerAdoption(project, proposal, authority, options = {}) {
+    if (proposal.project !== resolve(project))
+        throw new Error('Proposal belongs to a different project');
+    authorize(proposal, authority);
+    if (proposal.after.parallelism?.activation !== undefined || workerConfigDigest(Object.keys(proposal.after).sort()) !== workerConfigDigest(['parallelism', 'workerSelection']))
+        throw new Error('Proposal exceeds the worker policy pair');
+    // Reject staleness before writing even the lock or recovery record.
+    await recheck(proposal, options);
+    const lock = await acquireWorkerWriteLock(project, true, proposal.digest);
+    const write = (file, content) => atomicConfigWrite(file, content, lock.assertOwned);
+    let keepBlocked = false;
+    let regenerationStarted = false;
+    try {
+        await options.checkpoint?.('locked');
+        lock.assertOwned();
+        await runWorkerMaintenance(async () => {
+            const inputs = await recheck(proposal, options);
+            validateRetainedCopies(inputs);
+            const previous = candidate(inputs);
+            await validate(project, previous.config, previous.models, options);
+            const next = await adoptedCandidate(proposal, options);
+            const { digests, configBytes, modelsBytes } = next;
+            const configCopies = [inputs[0], ...inputs.slice(4)];
+            // Keep the validated bytes durably before the first participating write.
+            await write(join(lock.path, 'recovery.json'), JSON.stringify({ proposal, inputs }, null, 2));
+            await options.checkpoint?.('blocked');
+            lock.assertOwned();
+            options.signal?.throwIfAborted();
+            await recheck(proposal, options);
+            let committed = false;
+            try {
+                await write(inputs[1].file, modelsBytes);
+                await options.checkpoint?.('models');
+                options.signal?.throwIfAborted();
+                for (const [index, input] of configCopies.entries()) {
+                    await write(input.file, configBytes);
+                    await options.checkpoint?.(`config:${index}`);
+                    options.signal?.throwIfAborted();
+                }
+                const check = async () => {
+                    lock.assertOwned();
+                    const current = await inventory(project, options);
+                    const expected = inputs.map(input => ({ ...input, bytes: input.file === inputs[1].file ? modelsBytes : configCopies.some(copy => copy.file === input.file) ? configBytes : input.bytes }));
+                    if (current.length !== expected.length || current.some((input, index) => input.file !== expected[index].file || input.bytes !== expected[index].bytes))
+                        throw new Error('Activation copies or model inputs changed during apply');
+                    const actual = await validate(project, next.config, next.models, options);
+                    if (workerConfigDigest(actual) !== workerConfigDigest(digests))
+                        throw new Error('Activation digest verification failed');
+                };
+                await check();
+                await options.checkpoint?.('activation');
+                options.signal?.throwIfAborted();
+                lock.assertOwned();
+                regenerationStarted = true;
+                await (options.regenerate ?? regenerateWorkerGuidance)(project, next.config);
+                await options.checkpoint?.('regenerated');
+                options.signal?.throwIfAborted();
+                await check();
+                await write(revisionPath(project), JSON.stringify({ revision: proposal.baseRevision + 1 }) + '\n');
+                committed = true;
+                await options.checkpoint?.('committed');
+                lock.assertOwned();
+            }
+            catch (error) {
+                if (committed) {
+                    keepBlocked = true;
+                    throw new Error(`Worker adoption committed: ${error}. Dispatch remains closed at ${lock.path}; finish with authorized recovery`);
+                }
+                const failures = [];
+                // Attempt EVERY owned copy, including a write that may have renamed then thrown.
+                for (const input of [inputs[1], ...configCopies]) {
+                    try {
+                        lock.assertOwned();
+                        if (input.bytes === null)
+                            await rm(input.file, { force: true });
+                        else
+                            await write(input.file, input.bytes);
+                    }
+                    catch (restoreError) {
+                        failures.push(`${input.file}: ${restoreError}`);
+                    }
+                }
+                try {
+                    await recheck(proposal, options);
+                    await validate(project, previous.config, previous.models, options);
+                }
+                catch (restoreError) {
+                    failures.push(`restored pair validation: ${restoreError}`);
+                }
+                // Regenerated guidance may be partial; keep submissions closed until explicit recovery.
+                keepBlocked = failures.length > 0 || regenerationStarted;
+                throw new Error(`Worker adoption failed: ${error}. ${keepBlocked ? `Dispatch remains closed at ${lock.path}; ${failures.join('; ') || 'guidance consistency requires recovery'}` : 'All participating copies restored and revalidated.'}`);
+            }
+        });
+    }
+    finally {
+        // A displaced owner must neither restore bytes nor remove a successor's exclusion.
+        let owned = true;
+        try {
+            lock.assertOwned();
+        }
+        catch {
+            owned = false;
+        }
+        if (owned)
+            await lock.release(keepBlocked);
+    }
+}
+/** Recover an interrupted apply from its retained, authorized bytes; never infer approval. */
+export async function recoverWorkerAdoption(project, authority, options = {}) {
+    const lock = await reclaimWorkerWriteLock(project);
+    const write = (file, content) => atomicConfigWrite(file, content, lock.assertOwned);
+    let recovered = false;
+    try {
+        await options.checkpoint?.('recovery:owned');
+        await runWorkerMaintenance(async () => {
+            lock.assertOwned();
+            const record = await capture(join(lock.path, 'recovery.json'));
+            if (record.bytes === null) {
+                // Publication precedes recovery.json, and recovery.json precedes every pair write.
+                // A missing record therefore needs validation, never speculative restoration.
+                const inputs = await inventory(project, options);
+                validateRetainedCopies(inputs);
+                const current = candidate(inputs);
+                await validate(project, current.config, current.models, options);
+                options.signal?.throwIfAborted();
+                lock.assertOwned();
+                await (options.regenerate ?? regenerateWorkerGuidance)(project, current.config);
+                if (workerConfigDigest(await inventory(project, options)) !== workerConfigDigest(inputs))
+                    throw new Error('Inputs changed during incomplete-initialization recovery');
+                await validate(project, current.config, current.models, options);
+            }
+            else {
+                const retained = json(record);
+                const proposal = retained.proposal;
+                if (proposal.project !== resolve(project))
+                    throw new Error('Recovery belongs to a different project');
+                authorize(proposal, authority);
+                if (workerConfigDigest(retained.inputs) !== workerConfigDigest(proposal.inputs))
+                    throw new Error('Recovery bytes do not match the reviewed inputs');
+                const inputs = await inventory(project, options);
+                if (workerConfigDigest(inputs.map(input => input.file)) !== workerConfigDigest(proposal.inputs.map(input => input.file)))
+                    throw new Error('Recovery copy inventory changed');
+                validateRetainedCopies(proposal.inputs);
+                options.signal?.throwIfAborted();
+                const previous = candidate(proposal.inputs);
+                await validate(project, previous.config, previous.models, options);
+                const next = await adoptedCandidate(proposal, options);
+                const expectedBytes = (index) => index === 1 ? next.modelsBytes : index === 0 || index >= 4 ? next.configBytes : proposal.inputs[index].bytes;
+                // The independent revision is the durable commit marker. Activation alone is
+                // insufficient: it is written before the pair has finished committing.
+                const committed = await adoptionRevision(project) > proposal.baseRevision;
+                if (committed) {
+                    validateRetainedCopies(inputs);
+                    const current = candidate(inputs);
+                    if (workerConfigDigest(pair(current.config, current.models)) !== workerConfigDigest(proposal.after)
+                        || inputs.some((input, index) => input.bytes !== expectedBytes(index)))
+                        throw new Error('Committed recovery pair does not match proposal.after; inspect the retained recovery record');
+                    await validate(project, current.config, current.models, options);
+                    lock.assertOwned();
+                    await (options.regenerate ?? regenerateWorkerGuidance)(project, current.config);
+                    if (workerConfigDigest(await inventory(project, options)) !== workerConfigDigest(inputs))
+                        throw new Error('Committed recovery pair changed during guidance regeneration');
+                    await validate(project, current.config, current.models, options);
+                }
+                else {
+                    if (inputs.some((input, index) => input.bytes !== proposal.inputs[index].bytes && input.bytes !== expectedBytes(index)))
+                        throw new Error('Recovery pair has unexpected input bytes matching neither before nor after; inspect the retained recovery record');
+                    const failures = [];
+                    for (const input of [proposal.inputs[1], proposal.inputs[0], ...proposal.inputs.slice(4)]) {
+                        try {
+                            lock.assertOwned();
+                            if (input.bytes === null)
+                                await rm(input.file, { force: true });
+                            else
+                                await write(input.file, input.bytes);
+                        }
+                        catch (error) {
+                            failures.push(`${input.file}: ${error}`);
+                        }
+                    }
+                    if (failures.length)
+                        throw new Error(failures.join('; '));
+                    await recheck(proposal, options, false);
+                    lock.assertOwned();
+                    await (options.regenerate ?? regenerateWorkerGuidance)(project, previous.config);
+                    await recheck(proposal, options, false);
+                }
+            }
+            options.signal?.throwIfAborted();
+            lock.assertOwned();
+            await options.checkpoint?.('recovery:verified');
+            lock.assertOwned();
+            recovered = true;
+        });
+    }
+    catch (error) {
+        throw new Error(`Recovery failed; dispatch remains closed at ${lock.path}: ${error}`);
+    }
+    finally {
+        let owned = true;
+        try {
+            lock.assertOwned();
+        }
+        catch {
+            owned = false;
+        }
+        if (owned)
+            await lock.release(!recovered);
+    }
+}
+//# sourceMappingURL=worker-adoption.js.map

package/dist/src/config/worker-config-digest.js

@@ -0,0 +1,14 @@
+// Hashes canonical worker configuration inputs for origins and replay checks.
+import { createHash } from 'node:crypto';
+/** Hash canonical JSON, treating absent optional model files as null. */
+export function workerConfigDigest(value) {
+    const canonical = (node) => {
+        if (Array.isArray(node))
+            return node.map(canonical);
+        if (node !== null && typeof node === 'object')
+            return Object.fromEntries(Object.keys(node).sort().filter(key => node[key] !== undefined).map(key => [key, canonical(node[key])]));
+        return node ?? null;
+    };
+    return `sha256:${createHash('sha256').update(JSON.stringify(canonical(value))).digest('hex')}`;
+}
+//# sourceMappingURL=worker-config-digest.js.map

package/dist/src/config/worker-group-templates.js

@@ -0,0 +1,150 @@
+import { mergeWorkerSelection } from '../models/worker-selection-policy.js';
+import { workerConfigDigest } from './worker-config-digest.js';
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const escape = (value) => value.replace(/~/g, '~0').replace(/\//g, '~1');
+export function expandWorkerGroupTemplates(input, source = 'parallelism') {
+    const origins = {};
+    const errors = [];
+    if (!object(input))
+        return { parallelism: input, origins, errors };
+    const parallelism = structuredClone(input);
+    const templates = input.groupTemplates ?? {};
+    if (parallelism.groups)
+        parallelism.groups = Object.assign(Object.create(null), parallelism.groups);
+    const fail = (pointer, message) => { errors.push(`OG_POLICY_RELAXATION ${pointer}: ${message}`); };
+    const merge = (base, own, pointer) => {
+        const result = { ...base, ...own, execution: { ...base.execution, ...own.execution } };
+        delete result.template;
+        if (base.maxParallel !== undefined && own.maxParallel !== undefined) {
+            if (own.maxParallel > base.maxParallel)
+                fail(pointer, 'Template concurrency ceiling cannot be widened');
+            result.maxParallel = Math.min(base.maxParallel, own.maxParallel);
+        }
+        if (base.efforts && own.efforts) {
+            if (own.efforts.some(effort => !base.efforts.includes(effort)))
+                fail(pointer, 'Template effort ceiling cannot be widened');
+            result.efforts = own.efforts.filter(effort => base.efforts.includes(effort));
+        }
+        if (base.members && own.members) {
+            for (const member of own.members) {
+                const prior = base.members.find(candidate => candidate.id === member.id);
+                if (!prior || prior.cli !== member.cli || prior.model !== member.model
+                    || member.roles.some(role => !prior.roles.includes(role)) || prior.enabled === false && member.enabled !== false) {
+                    fail(pointer, 'Template member ceiling cannot be widened or rebound');
+                }
+            }
+        }
+        result.requiredRoles = [...new Set([...(base.requiredRoles ?? []), ...(own.requiredRoles ?? [])])];
+        if (base.dataPolicy || own.dataPolicy) {
+            const merged = mergeWorkerSelection([
+                { source, authority: 'project', digest: workerConfigDigest(base), policy: base.dataPolicy ? { dataPolicy: base.dataPolicy } : undefined },
+                { source, authority: 'project', digest: workerConfigDigest(own), policy: own.dataPolicy ? { dataPolicy: own.dataPolicy } : undefined },
+            ]);
+            for (const diagnostic of merged.diagnostics)
+                fail(`${pointer}/dataPolicy`, diagnostic.message);
+            result.dataPolicy = merged.policy.dataPolicy;
+        }
+        for (const key of Object.keys(base.execution ?? {})) {
+            const before = base.execution[key];
+            const after = own.execution?.[key];
+            // Execution constraints have no universally safe cross-profile ordering.
+            if (after !== undefined && after !== before)
+                fail(`${pointer}/execution/${key}`, 'Inherited execution control cannot change');
+        }
+        return result;
+    };
+    const shape = (value, pointer) => {
+        if (!object(value) || value.template !== undefined && typeof value.template !== 'string'
+            || value.members !== undefined && (!Array.isArray(value.members) || value.members.some((member) => !object(member) || !Array.isArray(member.roles)))
+            || value.efforts !== undefined && !Array.isArray(value.efforts)
+            || value.execution !== undefined && !object(value.execution)) {
+            errors.push(`OG_CONFIG_REFERENCE ${pointer}: Invalid group template shape`);
+            return false;
+        }
+        return true;
+    };
+    const expanded = new Map();
+    const depths = new Map();
+    const failed = new Set();
+    const expand = (name) => {
+        const pending = [];
+        const active = new Set();
+        let next = name;
+        // Collect uncached ancestors iteratively, then expand from the root down.
+        while (!expanded.has(next) && !failed.has(next)) {
+            const pointer = `/parallelism/groupTemplates/${escape(next)}`;
+            if (active.has(next)) {
+                errors.push(`OG_CONFIG_REFERENCE ${pointer}: Cyclic or excessive template nesting`);
+                failed.add(next);
+                break;
+            }
+            if (!object(templates) || !Object.hasOwn(templates, next)) {
+                errors.push(`OG_CONFIG_REFERENCE ${pointer}: Unknown template`);
+                failed.add(next);
+                break;
+            }
+            const own = templates[next];
+            if (!shape(own, pointer)) {
+                failed.add(next);
+                break;
+            }
+            active.add(next);
+            pending.push(next);
+            if (!own.template)
+                break;
+            next = own.template;
+        }
+        for (const current of pending.reverse()) {
+            const own = templates[current];
+            if (failed.has(current) || own.template && failed.has(own.template)) {
+                failed.add(current);
+                continue;
+            }
+            const depth = (own.template ? depths.get(own.template) : 0) + 1;
+            if (depth > 64) {
+                errors.push(`OG_CONFIG_REFERENCE /parallelism/groupTemplates/${escape(current)}: Cyclic or excessive template nesting`);
+                failed.add(current);
+                continue;
+            }
+            const parent = own.template ? expanded.get(own.template) : {};
+            expanded.set(current, merge(parent, own, `/parallelism/groupTemplates/${escape(current)}`));
+            depths.set(current, depth);
+        }
+        return expanded.get(name) ?? {};
+    };
+    if (object(templates))
+        for (const name of Object.keys(templates))
+            expand(name);
+    if (object(input.groups)) {
+        for (const [id, own] of Object.entries(input.groups)) {
+            const pointer = `/parallelism/groups/${escape(id)}`;
+            if (!shape(own, pointer))
+                continue;
+            const base = own.template ? expand(own.template) : {};
+            const result = merge(base, own, pointer);
+            // Existing shape validation requires members on every fully expanded group.
+            parallelism.groups[id] = result;
+            if (own.template) {
+                const names = [];
+                for (let name = own.template; name && expanded.has(name); name = templates[name].template)
+                    names.push(name);
+                names.reverse();
+                origins[`${pointer}/template`] = names.map(name => ({ source, authority: 'project',
+                    digest: workerConfigDigest(templates[name]), pointer: `/parallelism/groupTemplates/${escape(name)}`,
+                    contribution: structuredClone(templates[name]),
+                }));
+                origins[`${pointer}/template`].push({ source, authority: 'project', digest: workerConfigDigest(own), pointer, contribution: structuredClone(own) });
+            }
+        }
+    }
+    // Keep raw declarations for stable provenance; the validator checks them separately.
+    return { parallelism, origins, errors };
+}
+/** Group data declarations are further restrictions on the already merged model policy. */
+export function mergeGroupWorkerPolicy(policy, group) {
+    return mergeWorkerSelection([
+        { source: 'models:effective', authority: 'project', digest: workerConfigDigest(policy), policy },
+        { source: 'parallelism:group', authority: 'project', digest: workerConfigDigest(group), policy: group.dataPolicy ? { dataPolicy: group.dataPolicy } : undefined },
+    ]);
+}
+//# sourceMappingURL=worker-group-templates.js.map

package/dist/src/config/worker-guidance-warning.js

@@ -0,0 +1,28 @@
+// Reports guidance refresh steps after direct parallelism edits.
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { normalizeProviderDefinitionId } from '../providers/provider-definitions.js';
+export function warnStaleParallelism(cfg, projectDir, key, before) {
+    if (key !== 'parallelism' && !key.startsWith('parallelism.'))
+        return;
+    if (isDeepStrictEqual(before, getDottedPath(cfg, key)))
+        return;
+    const configured = (cfg.providers ?? []).map(normalizeProviderDefinitionId).filter((id) => !!id);
+    const recorded = Object.values(cfg.installed ?? {}).flatMap(entry => Object.keys(entry.deployedTo ?? {}))
+        .map(normalizeProviderDefinitionId).filter((id) => !!id).sort();
+    const providers = [...new Set([...configured, ...recorded])];
+    const targets = providers.length ? providers : ['<provider>'];
+    const lines = [
+        `WARNING: ${key} changed project configuration; generated workspace/provider guidance may now be stale.`,
+        `From project root ${path.resolve(projectDir)}, preview and refresh every configured or recorded provider context:`,
+        ...targets.flatMap(provider => [
+            `  aiwg regenerate --workspace --provider ${provider} --dry-run`,
+            `  aiwg regenerate --workspace --provider ${provider}`,
+        ]),
+        '  aiwg workspace-context doctor',
+        `Shared parallelism defaults and labels use primary provider '${cfg.providers?.[0] ?? 'unknown'}' (providers[0]); --provider selects the adapter/context target.`,
+    ];
+    console.error(lines.join('\n'));
+}
+function getDottedPath(value, key) { return key.split('.').reduce((node, part) => node?.[part], value); }
+//# sourceMappingURL=worker-guidance-warning.js.map