@juangcarmona/lighthouse-sdlc 0.16.3 → 0.17.0

package/model-profiles.md

@@ -19,7 +19,22 @@ Create `.lighthouse/models.json` in the consuming repository after verifying ide
 }
 ```
 
-The only profile names are `plan`, `build` and `fast`. Models must be OpenAI provider-qualified identifiers without an embedded variant. Effort is independent: `none`, `minimal`, `low`, `medium`, `high`, `xhigh` or `max`, but only values explicitly permitted for that model by the operator can run. The resolver rejects unknown configuration keys, providers, profile names, effort values and unsupported tier or transport fields. It never chooses an alternative on failure.
+Schema version 1 supports the profile names `plan`, `build` and `fast`. Schema version 2 also supports other lowercase names and direct `{ "model": "openai/model", "reasoningEffort": "high" }` assignments for workers and defaults. Models must be OpenAI provider-qualified identifiers without an embedded variant. Effort is independent: `none`, `minimal`, `low`, `medium`, `high`, `xhigh` or `max`, but only values explicitly permitted for that model by the operator can run. The resolver rejects unknown configuration keys, providers, profile names, effort values and unsupported tier or transport fields. It never chooses an alternative on failure.
+
+A version 2 project can configure four independent combinations, subject to operator capabilities:
+
+```json
+{
+  "schemaVersion": 2,
+  "workers": {
+    "triage": { "model": "openai/verified-model-a", "reasoningEffort": "medium" },
+    "refine": { "model": "openai/verified-model-a", "reasoningEffort": "high" },
+    "implement": { "model": "openai/verified-model-b", "reasoningEffort": "high" },
+    "review": "review-preset"
+  },
+  "profiles": { "review-preset": { "model": "openai/verified-model-b", "reasoningEffort": "medium" } }
+}
+```
 
 ## Operator opt-in and precedence
 
@@ -43,7 +58,7 @@ Merge these fields into the existing operator engine configuration. Retain `imag
 
 Selection precedence, highest first:
 
-1. A delegated task's explicit profile; this still requires operator opt-in and capability permission.
+1. A direct manual execution selection, when the operator permits it, or a delegated task's explicit profile. These selectors cannot be combined.
 2. Operator worker assignment.
 3. Project worker assignment.
 4. Operator default profile.
@@ -99,3 +114,7 @@ For every task/candidate record revision, exact prompt or fixture, model, effort
 Record the account route as operator-confirmed subscription, API or unknown; do not inspect credentials or switch routes. For API evaluations record uncached input, cached input, applicable cache writes, output/reasoning as actually billed, context regime and processing tier. Avoid counting reasoning twice when it is included in billed output. Record dated rate sources and compute API-equivalent estimates separately from actual charges. For subscriptions report only exposed usage; unknown is neither free nor unlimited. Flex and Batch are different transports and neither is implemented here.
 
 Choose the least costly setting that meets the declared bar only when comparable accepted-task and account evidence supports that decision. Otherwise report selection as unresolved. This delivery supplies deterministic configuration and scheduling tests; it does not claim live candidate results or preset acceptance.
+
+## Individual executions
+
+With operator schema version 2 and `allowExecutionSelection: true`, an owner can set the router's optional `model_selection` input to JSON such as `{"profile":"plan"}` or `{"model":"openai/verified-planning-model","reasoningEffort":"high"}`. The choice applies only to that direct manual stage dispatch. Automated continuations, recovery and Product Change workers do not inherit it. Operator capabilities still constrain the selection; an unavailable model or effort fails without fallback. Leave the input empty to use normal worker and default precedence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juangcarmona/lighthouse-sdlc",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "type": "module",
   "description": "Provider-neutral SDLC skills, commands and route contracts for Lighthouse adopters",
   "repository": {

package/src/completion-actions.mjs

@@ -1,4 +1,4 @@
-import { admitDispatch, checkDispatchClaim, finishDispatch, completedEvent, statusText } from './stage-dispatch.mjs';
+import { admitDispatch, checkDispatchClaim, finishDispatch, completedEvent, statusText, executionModelSelection } from './stage-dispatch.mjs';
 import { readFile, writeFile, mkdir, appendFile, access } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -42,7 +42,7 @@ async function main(command) {
     if (!completion.merged) assertChecks(completion);
     const postMerge = completion.merged ? await postMergeRuns(api, completion, completion.merge) : [];
     const id = fingerprint({ repository, stage, issue: authorization.issue, run: env.GITHUB_RUN_ID, attempt: env.GITHUB_RUN_ATTEMPT });
-    const request = { ...(dispatch ? { dispatch: { commentId: dispatch.commentId, requestId: dispatch.request.id, digest: dispatch.receipt.digest }, dispatchOrigin: { request: dispatch.request, receipt: dispatch.receipt } } : {}), runId: id, issue: authorization.issue, stage, title: completion.title, sourceRevision: completion.merged ? completion.merge : completion.binding.head, taskDigest: completion.binding.intent, workflowRunId: env.GITHUB_RUN_ID, attempt: env.GITHUB_RUN_ATTEMPT, observedAt: new Date().toISOString(), harnessRevision: execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).trim(), runUrl: `https://github.com/${repository}/actions/runs/${env.GITHUB_RUN_ID}`, authorization, completion, postMerge };
+    const request = { ...(dispatch && executionModelSelection(dispatch.request) ? { modelSelection: executionModelSelection(dispatch.request) } : {}), ...(dispatch ? { dispatch: { commentId: dispatch.commentId, requestId: dispatch.request.id, digest: dispatch.receipt.digest }, dispatchOrigin: { request: dispatch.request, receipt: dispatch.receipt } } : {}), runId: id, issue: authorization.issue, stage, title: completion.title, sourceRevision: completion.merged ? completion.merge : completion.binding.head, taskDigest: completion.binding.intent, workflowRunId: env.GITHUB_RUN_ID, attempt: env.GITHUB_RUN_ATTEMPT, observedAt: new Date().toISOString(), harnessRevision: execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).trim(), runUrl: `https://github.com/${repository}/actions/runs/${env.GITHUB_RUN_ID}`, authorization, completion, postMerge };
     request.priorIntegration = priorIntegration;
     if (Buffer.byteLength(JSON.stringify(request)) > 2 * 1024 * 1024) throw Error('Completion context exceeds bounds');
     await mkdir(dir, { recursive: true }); await save('request.json', request);

package/src/issue-actions.mjs

@@ -1,5 +1,5 @@
 import { refinementAfterRun, signalRefinementContinuation } from './stage-transition.mjs';
-import { dispatchId, dispatchArtifact, recordDispatch, sendDispatch, admitDispatch, checkDispatchClaim, finishDispatch, completedEvent, statusText, stages } from './stage-dispatch.mjs';
+import { dispatchId, dispatchArtifact, recordDispatch, sendDispatch, admitDispatch, checkDispatchClaim, finishDispatch, completedEvent, statusText, stages, executionModelSelection } from './stage-dispatch.mjs';
 import { readActionsJson } from './actions-artifact.mjs';
 import { deliveryAfterChecks, dispatchDeliveryChecks } from './delivery-events.mjs';
 import { readFile, writeFile, appendFile, mkdir } from 'node:fs/promises';
@@ -216,6 +216,7 @@ async function main(command) {
     // Only an explicit owner dispatch selects a workflow branch; native events use main.
     const manual = env.GITHUB_EVENT_NAME === 'workflow_dispatch';
     const request = { schemaVersion: 1, id: dispatchId(repo, feedbackIdentity ?? eventRunId ?? env.GITHUB_RUN_ID, stage), ...(worker ? { worker, ...(feedbackIdentity ? { feedbackKey: feedbackIdentity } : {}) } : {}), ...(route.productApproval?.approval ? { productApproval: { ...route.productApproval.approval, pullRequest: route.productApproval.pullRequest, head: route.productApproval.head, issue: route.productApproval.issue, changeName: route.productApproval.changeName } } : {}), ...(route.productFeedback ? { productFeedback: route.productFeedback } : {}), ...(route.productReview && !route.productApproval?.approval ? { productReview: { pullRequest: route.productReview.pullRequest, head: route.productReview.head, issue: route.productReview.issue, changeName: route.productReview.changeName } } : {}), repository: repo, issue: issueNumber, stage, routerRunId: env.GITHUB_RUN_ID, routerAttempt: Number(env.GITHUB_RUN_ATTEMPT), routerRevision: router.head_sha, routerRef: router.head_branch, workflowRevision: manual ? router.head_sha : revision, sourceRevision: revision, ref: manual ? router.head_branch : metadata.default_branch, eventName: env.GITHUB_EVENT_NAME, event, handoff, queue, ...(handoff ? { predecessor: route.predecessor } : {}), ...(eventRunId ? { eventRunId } : {}), autoImplement: stage === 'refine' && env.LIGHTHOUSE_AUTO_IMPLEMENT === 'true', taskDigest: taskDigest(issue, answers) };
+    executionModelSelection(request);
     const recorded = await recordDispatch(api, repo, request);
     await output('send', String(recorded.send));
     await output('artifact', dispatchArtifact(request));
@@ -316,7 +317,7 @@ async function main(command) {
     const productChangeName = productWorker ? dispatch.request.productFeedback?.changeName ?? dispatch.request.event.inputs?.change_name?.trim() ?? `issue-${issueNumber}-product-change` : undefined;
     if (productWorker && !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(productChangeName)) throw Error('Invalid Product Change name');
     const baselineDigest = productWorker ? await productModelDigest(process.cwd()) : undefined;
-    const snapshot = { autoImplement: env.LIGHTHOUSE_AUTO_IMPLEMENT === 'true', ...(dispatch ? { worker: dispatch.request.worker, workflowRevision: env.GITHUB_SHA, dispatch: { commentId: dispatch.commentId, requestId: dispatch.request.id, digest: dispatch.receipt.digest, routerRunId: dispatch.request.routerRunId, routerAttempt: dispatch.request.routerAttempt } } : {}), ...(productWorker ? { authorizationDigest, policyDigest, productChangeName, baselineDigest } : {}), ...(planningReference ? { planningReference } : {}), ...(implementationReview ? { implementationReview, baseRevision } : {}), ...(proposalReview ? { proposalReview } : {}), runId: id, issue: issueNumber, stage, title: issue.title, defaultBranch: repository.default_branch, sourceRevision: revision.sha, taskDigest: taskDigest(issue, answers), workflowRunId: env.GITHUB_RUN_ID, ...(predecessor ? { refinement: predecessor } : {}), ...(continuation ? { replyTo: continuation.request.runId, commentId: event.comment.id } : {}), ...(implementation ? { implementation } : {}), ...(seed ? { seedDigest: changesDigest(seed) } : {}) };
+    const snapshot = { ...(dispatch && executionModelSelection(dispatch.request) ? { modelSelection: executionModelSelection(dispatch.request) } : {}), autoImplement: env.LIGHTHOUSE_AUTO_IMPLEMENT === 'true', ...(dispatch ? { worker: dispatch.request.worker, workflowRevision: env.GITHUB_SHA, dispatch: { commentId: dispatch.commentId, requestId: dispatch.request.id, digest: dispatch.receipt.digest, routerRunId: dispatch.request.routerRunId, routerAttempt: dispatch.request.routerAttempt } } : {}), ...(productWorker ? { authorizationDigest, policyDigest, productChangeName, baselineDigest } : {}), ...(planningReference ? { planningReference } : {}), ...(implementationReview ? { implementationReview, baseRevision } : {}), ...(proposalReview ? { proposalReview } : {}), runId: id, issue: issueNumber, stage, title: issue.title, defaultBranch: repository.default_branch, sourceRevision: revision.sha, taskDigest: taskDigest(issue, answers), workflowRunId: env.GITHUB_RUN_ID, ...(predecessor ? { refinement: predecessor } : {}), ...(continuation ? { replyTo: continuation.request.runId, commentId: event.comment.id } : {}), ...(implementation ? { implementation } : {}), ...(seed ? { seedDigest: changesDigest(seed) } : {}) };
     if (stage === 'triage') snapshot.originalRequest = issue.body ?? '';
     if (triage) snapshot.triageEstimate = triage.envelope.result.output.estimate;
     await output('source_revision', revision.sha);

package/src/model-profiles.mjs

@@ -3,54 +3,80 @@ export const MODEL_PROFILES = Object.freeze(['plan', 'build', 'fast']);
 export const REASONING_EFFORTS = Object.freeze(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
 const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
 const own = (value, key) => Object.hasOwn(value ?? {}, key);
+const profileName = (name, version) => typeof name === 'string' && (version === 1 ? MODEL_PROFILES.includes(name) : /^[a-z][a-z0-9-]{0,63}$/.test(name));
 function keys(value, allowed, label) {
   if (!record(value) || Object.keys(value).some(key => !allowed.includes(key))) throw Error(`Invalid ${label}`);
 }
+function validatePair(value, complete = false) {
+  keys(value, ['model', 'reasoningEffort'], 'model profile settings');
+  if (complete && (!own(value, 'model') || !own(value, 'reasoningEffort'))) throw Error('Direct model selection must include model and reasoning effort');
+  if (own(value, 'model') && (typeof value.model !== 'string' || !/^openai\/[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(value.model))) throw Error('Profile model must be an OpenAI provider/model identifier without a variant');
+  if (own(value, 'reasoningEffort') && !REASONING_EFFORTS.includes(value.reasoningEffort)) throw Error('Invalid reasoning effort');
+}
+function selector(value, version) {
+  if (profileName(value, version)) return value;
+  if (version === 2 && record(value)) { validatePair(value, true); return value; }
+  throw Error('Invalid model selector');
+}
 function validateSettings(value, operator = false) {
-  keys(value, ['schemaVersion', 'profiles', 'workers', 'defaultProfile', ...(operator ? ['enabled'] : [])], 'model profile configuration');
-  if (value.schemaVersion !== 1) throw Error('Model profiles require schemaVersion 1');
+  keys(value, ['schemaVersion', 'profiles', 'workers', 'defaultProfile', ...(operator ? ['enabled', 'allowExecutionSelection'] : [])], 'model profile configuration');
+  if (![1, 2].includes(value.schemaVersion)) throw Error('Model profiles require schemaVersion 1 or 2');
   if (operator && typeof value.enabled !== 'boolean') throw Error('Operator model profiles require explicit enabled');
-  if (own(value, 'defaultProfile') && !MODEL_PROFILES.includes(value.defaultProfile)) throw Error('Invalid default model profile');
+  if (own(value, 'allowExecutionSelection') && (value.schemaVersion !== 2 || typeof value.allowExecutionSelection !== 'boolean')) throw Error('Execution selection requires version 2 and a boolean opt-in');
+  if (own(value, 'defaultProfile')) selector(value.defaultProfile, value.schemaVersion);
   if (own(value, 'profiles')) {
-    keys(value.profiles, MODEL_PROFILES, 'profile names');
-    for (const profile of Object.values(value.profiles)) {
-      keys(profile, ['model', 'reasoningEffort'], 'model profile settings');
-      if (own(profile, 'model') && !/^openai\/[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(profile.model)) throw Error('Profile model must be an OpenAI provider/model identifier without a variant');
-      if (own(profile, 'reasoningEffort') && !REASONING_EFFORTS.includes(profile.reasoningEffort)) throw Error('Invalid reasoning effort');
-    }
+    if (!record(value.profiles) || Object.keys(value.profiles).some(name => !profileName(name, value.schemaVersion))) throw Error('Invalid profile names');
+    for (const profile of Object.values(value.profiles)) validatePair(profile);
   }
   if (own(value, 'workers')) {
-    if (!record(value.workers) || Object.entries(value.workers).some(([worker, profile]) => !/^[a-z][a-z0-9-]{0,63}$/.test(worker) || !MODEL_PROFILES.includes(profile))) throw Error('Invalid worker profile assignments');
+    if (!record(value.workers)) throw Error('Invalid worker profile assignments');
+    for (const [worker, valueForWorker] of Object.entries(value.workers)) {
+      if (!/^[a-z][a-z0-9-]{0,63}$/.test(worker)) throw Error('Invalid worker profile assignments');
+      selector(valueForWorker, value.schemaVersion);
+    }
   }
   return value;
 }
 
-export function resolveModelProfile({ project = null, operator, worker, profile } = {}) {
+export function resolveModelProfile({ project = null, operator, worker, profile, executionSelection } = {}) {
   if (!record(operator)) throw Error('Operator model configuration required');
   if (project !== null) validateSettings(project);
   const local = operator.modelProfiles;
   if (local !== undefined) validateSettings(local, true);
+  if (local?.enabled && project?.schemaVersion === 2 && local.schemaVersion !== 2) throw Error('Version 2 model settings require operator version 2');
   if (!local?.enabled) {
-    if (profile !== undefined) throw Error('Delegated profiles require operator opt-in');
+    if (profile !== undefined || executionSelection !== undefined) throw Error('Delegated profiles require operator opt-in');
     if (typeof operator.model !== 'string' || !operator.model.trim() || /[\0\r\n]/.test(operator.model)) throw Error('Legacy operator model required');
     return { mode: 'legacy', profile: null, model: operator.model, reasoningEffort: null, engineModel: operator.model, source: 'operator.model', capabilityEvidence: 'not-checked-legacy' };
   }
-  if (profile !== undefined && !MODEL_PROFILES.includes(profile)) throw Error('Invalid requested model profile');
-  const choices = [[profile, 'task.profile'], [own(local.workers, worker) ? local.workers[worker] : undefined, 'operator.workers'], [own(project?.workers, worker) ? project.workers[worker] : undefined, 'project.workers'], [local.defaultProfile, 'operator.defaultProfile'], [project?.defaultProfile, 'project.defaultProfile']];
-  const choice = choices.find(([name]) => name !== undefined);
+  if (profile !== undefined && !profileName(profile, local.schemaVersion)) throw Error('Invalid requested model profile');
+  if (profile !== undefined && executionSelection !== undefined) throw Error('Conflicting model selections');
+  let execution;
+  if (executionSelection !== undefined) {
+    if (local.schemaVersion !== 2 || local.allowExecutionSelection !== true) throw Error('Execution selection requires operator opt-in');
+    keys(executionSelection, ['profile', 'model', 'reasoningEffort'], 'execution model selection');
+    if (own(executionSelection, 'profile')) {
+      if (Object.keys(executionSelection).length !== 1 || !profileName(executionSelection.profile, 2)) throw Error('Invalid execution model selection');
+      execution = executionSelection.profile;
+    } else { validatePair(executionSelection, true); execution = executionSelection; }
+  }
+  const choices = [[execution, 'execution'], [profile, 'task.profile'], [own(local.workers, worker) ? local.workers[worker] : undefined, 'operator.workers'], [own(project?.workers, worker) ? project.workers[worker] : undefined, 'project.workers'], [local.defaultProfile, 'operator.defaultProfile'], [project?.defaultProfile, 'project.defaultProfile']];
+  const choice = choices.find(([value]) => value !== undefined);
   if (!choice) throw Error('No model profile assigned to worker');
-  const [name, source] = choice;
-  const base = project?.profiles?.[name] ?? {}, override = local.profiles?.[name] ?? {};
-  const selected = { ...base, ...override };
+  const [value, source] = choice, name = typeof value === 'string' ? value : null;
+  const base = name && own(project?.profiles, name) ? project.profiles[name] : {};
+  const override = name && own(local.profiles, name) ? local.profiles[name] : {};
+  const selected = name ? { ...base, ...override } : value;
   if (!selected.model || !selected.reasoningEffort) throw Error(`Incomplete model profile: ${name}`);
   const capability = operator.modelCapabilities?.[selected.model];
-  if (!record(capability) || capability.available !== true || capability.tools !== true || !Array.isArray(capability.reasoningEfforts) || !capability.reasoningEfforts.includes(selected.reasoningEffort)) throw Error(`Model or reasoning unavailable in operator capabilities: ${name}`);
-  return { mode: 'profile', profile: name, ...selected, engineModel: `${selected.model}#${selected.reasoningEffort}`, source, fields: { model: own(override, 'model') ? 'operator' : 'project', reasoningEffort: own(override, 'reasoningEffort') ? 'operator' : 'project' }, capabilityEvidence: 'operator-configuration-only' };
+  if (!record(capability) || capability.available !== true || capability.tools !== true || !Array.isArray(capability.reasoningEfforts) || !capability.reasoningEfforts.includes(selected.reasoningEffort)) throw Error(`Model or reasoning unavailable in operator capabilities: ${name ?? source}`);
+  const directSource = source === 'execution' ? 'execution' : source.startsWith('operator.') ? 'operator' : 'project';
+  return { mode: name ? 'profile' : 'direct', profile: name, ...selected, engineModel: `${selected.model}#${selected.reasoningEffort}`, source, fields: name ? { model: own(override, 'model') ? 'operator' : 'project', reasoningEffort: own(override, 'reasoningEffort') ? 'operator' : 'project' } : { model: directSource, reasoningEffort: directSource }, capabilityEvidence: 'operator-configuration-only' };
 }
 
-export function modelExecutionReceipt(selection) {
+export function modelExecutionReceipt(selection, executionSelection) {
   return {
-    requested: { profile: selection.profile, model: selection.model, reasoningEffort: selection.reasoningEffort },
+    requested: { profile: selection.profile, model: selection.model, reasoningEffort: selection.reasoningEffort, ...(executionSelection ? { selector: executionSelection } : {}) },
     resolved: selection,
     providerReported: { model: null, reasoningEffort: null, status: 'unverified', reason: 'The current adapter has no authenticated provider-settings receipt' },
     billing: { route: 'unchanged', actualCost: null, estimatedApiEquivalentCost: null, subscriptionUsage: null },

package/src/opencode-execute.mjs

@@ -64,7 +64,7 @@ async function main() {
     projectModels = JSON.parse(await readFile(path, 'utf8'));
   }
   catch (error) { if (error.code !== 'ENOENT') throw error; }
-  const modelSelection = resolveModelProfile({ project: projectModels, operator: config, worker: env.LIGHTHOUSE_WORKER ?? request.stage, ...(env.LIGHTHOUSE_MODEL_PROFILE ? { profile: env.LIGHTHOUSE_MODEL_PROFILE } : {}) });
+  const modelSelection = resolveModelProfile({ project: projectModels, operator: config, worker: env.LIGHTHOUSE_WORKER ?? request.stage, ...(request.modelSelection ? { executionSelection: request.modelSelection } : {}), ...(env.LIGHTHOUSE_MODEL_PROFILE ? { profile: env.LIGHTHOUSE_MODEL_PROFILE } : {}) });
   const selected = request.stage === 'implement' ? selectEnvironment(config, request.implementation?.environment) : null;
   if (request.stage === 'implement') {
     if (selected) config.implementationImage = selected.image;
@@ -109,7 +109,7 @@ async function main() {
     await writeFile(prompt, await readFile(env.GH_AW_PROMPT, 'utf8') + completionBoundary, { mode: 0o444 });
     const harness = resolve(dirname(fileURLToPath(import.meta.url)), '..');
     const pkg = JSON.parse(await readFile(join(harness, 'package.json'), 'utf8'));
-    const runtimeReceipt = { package: { name: pkg.name, version: pkg.version }, harnessRevision: execFileSync('git', ['-C', harness, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim(), image: config.image, limits, environment: environmentReceipt(selected), model: modelSelection.model, modelExecution: modelExecutionReceipt(modelSelection), engine: 'OpenCode 2.1.0', isolation: 'Docker; no AWF egress filtering', skills: await readdir(join(harness, 'skills')), sourceRevision: request.sourceRevision, seed: request.implementation?.policy.seed ?? null, seedDigest: request.seedDigest ?? null };
+    const runtimeReceipt = { package: { name: pkg.name, version: pkg.version }, harnessRevision: execFileSync('git', ['-C', harness, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim(), image: config.image, limits, environment: environmentReceipt(selected), model: modelSelection.model, modelExecution: modelExecutionReceipt(modelSelection, request.modelSelection), engine: 'OpenCode 2.1.0', isolation: 'Docker; no AWF egress filtering', skills: await readdir(join(harness, 'skills')), sourceRevision: request.sourceRevision, seed: request.implementation?.policy.seed ?? null, seedDigest: request.seedDigest ?? null };
     await writeFile(join(runDir, 'runtime.json'), JSON.stringify(runtimeReceipt));
     const command = imageCommand(config.image);
     const args = ['run', '--rm', '--init', '--name', name, '--user', `${config.uid}:${config.uid}`, ...resourceArgs(limits), '--cap-drop', 'ALL', '--security-opt', 'no-new-privileges', '--read-only',

package/src/stage-dispatch.mjs

@@ -70,6 +70,18 @@ export async function sendDispatch(api, repository, request, commentId) {
   return api(`actions/workflows/lighthouse-sdlc-${workerFor(request)}.lock.yml/dispatches`, 'POST', { ref: request.ref, inputs: { issue: String(request.issue), 'dispatch-request': String(commentId), ...(workerFor(request) === 'apply-product-change' ? { 'pull-request': String(request.productApproval.pullRequest), head: request.productApproval.head } : {}) } });
 }
 
+// Called only for a dispatch whose router identity is authenticated by the host.
+export function executionModelSelection(request) {
+  const input = request?.event?.inputs?.model_selection;
+  if (input === undefined || input === '') return undefined;
+  if (request.eventName !== 'workflow_dispatch' || request.recovery || request.handoff || request.worker || request.event.inputs.after_run || (request.event.inputs.workflow && request.event.inputs.workflow !== 'stage')) throw Error('Model selection requires a direct owner stage dispatch');
+  if (typeof input !== 'string' || Buffer.byteLength(input) > 512) throw Error('Invalid execution model selection');
+  let value;
+  try { value = JSON.parse(input); } catch { throw Error('Invalid execution model selection JSON'); }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw Error('Invalid execution model selection');
+  return value;
+}
+
 export function verifyDispatchOrigin(request, receipt, parent, worker, repository, owner, issue) {
   const delegatedWorker = workerFor(request) === 'apply-review' && ['propose', 'implement'].includes(request.stage) || workerFor(request) === 'product-change' && ['propose', 'implement'].includes(request.stage);
   const applyProductWorker = workerFor(request) === 'apply-product-change' && ['propose', 'implement'].includes(request.stage);
@@ -88,6 +100,7 @@ export function verifyDispatchOrigin(request, receipt, parent, worker, repositor
   const originEvent = recovery ? request.routerEventName : request.eventName;
   const continuation = !recovery && isBotContinuation(request.event, parent.event, parent.actor?.login, parent.triggering_actor?.login) && request.stage === 'implement' && request.handoff && !request.worker && !request.feedbackKey && Number(request.event.inputs.issue) === issue && request.predecessor?.runId === request.event.inputs.after_run;
   if (String(parent.id) !== String(receipt.routerRunId) || parent.run_attempt !== receipt.routerAttempt || request.routerRunId !== receipt.routerRunId || request.routerAttempt !== receipt.routerAttempt || parent.path !== originPath || (parent.event !== 'workflow_run' && !continuation && (parent.actor?.login !== owner || parent.triggering_actor?.login !== owner)) || !(recovery ? ['schedule', 'workflow_dispatch'] : events).includes(parent.event) || parent.event !== originEvent || parent.head_sha !== (request.routerRevision ?? request.workflowRevision) || parent.head_branch !== (request.routerRef ?? request.ref) || parent.repository?.full_name !== repository) throw Error('Dispatch origin is not an authorized router execution');
+  executionModelSelection(request);
   const eventRunId = request.eventName === 'workflow_run' ? request.event?.workflow_run?.id : request.event?.inputs?.after_run;
   if (String(eventRunId ?? '') !== String(receipt.eventRunId ?? '') || String(request.eventRunId ?? '') !== String(receipt.eventRunId ?? '')) throw Error('Completion event identity mismatch');
   if (worker.path !== stagePath(workerFor(request)) || worker.event !== 'workflow_dispatch' || worker.head_sha !== request.workflowRevision || worker.head_branch !== request.ref || worker.repository?.full_name !== repository || ![owner, 'github-actions[bot]'].includes(worker.actor?.login) || ![owner, 'github-actions[bot]'].includes(worker.triggering_actor?.login)) throw Error('Dispatch worker identity mismatch');

package/workflows/lighthouse-sdlc-router.yml

@@ -35,6 +35,10 @@ on:
         default: stage
         type: choice
         options: [stage, product-change]
+      model_selection:
+        description: Optional JSON model selection for this execution
+        required: false
+        type: string
       after_run:
         description: Recheck a completed execution through the same continuation rules
         required: false