@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/prompts/collaboration-workflow/issue-template.en.md

@@ -71,55 +71,59 @@ The `en` column of `issue-template.md`'s template; its rules and label table →
 
 ### Correspondence table
 
-| Kind    | ja             | en                     |
-| ------- | -------------- | ---------------------- |
-| key     | 種別           | Type                   |
-| key     | 目的           | Purpose                |
-| key     | 互換性         | Compatibility          |
-| key     | リリース分類   | Release classification |
-| key     | 人の判断       | Human judgement        |
-| key     | 判定規則       | Decision rule          |
-| key     | 中止条件       | Close condition        |
-| key     | 優先度         | Priority               |
-| key     | セキュリティ   | Security               |
-| key     | 原因の park    | Cause park             |
-| key     | 原因のレーン   | Cause lane             |
-| key     | 原因の損失     | Cause loss             |
-| key     | 実施順         | Order                  |
-| key     | 原因           | Cause                  |
-| key     | 規模見積もり   | Size estimate          |
-| key     | 分割しない理由 | No-split reason        |
-| key     | 行を増やさない | No added lines         |
-| key     | 先行リファクタ | Refactor first         |
-| key     | 強制           | Enforcement            |
-| key     | 計測           | Measurement            |
-| key     | 計測宣言       | Measure declaration    |
-| key     | 前提           | Premise                |
-| key     | 計測宣言なし   | No measure declaration |
-| key     | 実施可能条件   | Sample gate            |
-| key     | 実施可能日     | Not before             |
-| key     | 出どころ       | Source                 |
-| value   | 不具合         | defect                 |
-| value   | 非不具合       | non-defect             |
-| value   | 振る舞い変更   | behavior change        |
-| value   | 機能追加       | feature                |
-| value   | 機能改善       | improvement            |
-| value   | 時間短縮       | time saving            |
-| value   | 不具合修正     | bug fix                |
-| value   | 破壊的変更     | breaking change        |
-| value   | 不要           | not needed             |
-| value   | 要             | needed                 |
-| value   | 通常           | normal                 |
-| value   | 高             | high                   |
-| value   | 緊急           | critical               |
-| value   | 最後           | last                   |
-| value   | 不明           | unknown                |
-| value   | なし           | none                   |
-| heading | 背景           | Background             |
-| heading | 現象           | Symptom                |
-| heading | 期待結果       | Expected result        |
-| heading | 受け入れ条件   | Acceptance criteria    |
-| heading | 発火点         | Trigger                |
-| heading | ベースライン   | Baseline               |
-| heading | 再現           | Reproduction           |
-| heading | 期待効果       | Expected effect        |
+| Kind    | ja             | en                             |
+| ------- | -------------- | ------------------------------ |
+| key     | 種別           | Type                           |
+| key     | 目的           | Purpose                        |
+| key     | 互換性         | Compatibility                  |
+| key     | リリース分類   | Release classification         |
+| key     | 人の判断       | Human judgement                |
+| key     | 判定規則       | Decision rule                  |
+| key     | 中止条件       | Close condition                |
+| key     | 優先度         | Priority                       |
+| key     | セキュリティ   | Security                       |
+| key     | 原因の park    | Cause park                     |
+| key     | 原因のレーン   | Cause lane                     |
+| key     | 原因の損失     | Cause loss                     |
+| key     | 実施順         | Order                          |
+| key     | 原因           | Cause                          |
+| key     | 規模見積もり   | Size estimate                  |
+| key     | 分割しない理由 | No-split reason                |
+| key     | 行を増やさない | No added lines                 |
+| key     | 先行リファクタ | Refactor first                 |
+| key     | 強制           | Enforcement                    |
+| key     | 計測           | Measurement                    |
+| key     | 計測宣言       | Measure declaration            |
+| key     | 前提           | Premise                        |
+| key     | 計測宣言なし   | No measure declaration         |
+| key     | 実施可能条件   | Sample gate                    |
+| key     | 実施可能日     | Not before                     |
+| key     | 出どころ       | Source                         |
+| key     | 出所           | Constraint source              |
+| key     | 参照           | Constraint reference           |
+| key     | 指示           | Constraint instruction         |
+| value   | 不具合         | defect                         |
+| value   | 非不具合       | non-defect                     |
+| value   | 振る舞い変更   | behavior change                |
+| value   | 機能追加       | feature                        |
+| value   | 機能改善       | improvement                    |
+| value   | 時間短縮       | time saving                    |
+| value   | 不具合修正     | bug fix                        |
+| value   | 破壊的変更     | breaking change                |
+| value   | 不要           | not needed                     |
+| value   | 要             | needed                         |
+| value   | 通常           | normal                         |
+| value   | 高             | high                           |
+| value   | 緊急           | critical                       |
+| value   | 最後           | last                           |
+| value   | 不明           | unknown                        |
+| value   | なし           | none                           |
+| heading | 背景           | Background                     |
+| heading | 現象           | Symptom                        |
+| heading | 期待結果       | Expected result                |
+| heading | 受け入れ条件   | Acceptance criteria            |
+| heading | 発火点         | Trigger                        |
+| heading | ベースライン   | Baseline                       |
+| heading | 再現           | Reproduction                   |
+| heading | 期待効果       | Expected effect                |
+| heading | 自動実行の制約 | Automatic execution constraint |

package/scripts/agent/agent-argv.ts

@@ -7,6 +7,8 @@ import {
 	type AgentRole,
 	type ProfileResult,
 } from './agent-role-profile'
+import { agent_ship_cap } from './agent-ship-cap'
+import { agent_worker_profile } from './agent-worker-profile'
 import { claude_agent_argv } from './claude-agent-argv'
 import { codex_agent_argv } from './codex-agent-argv'
 
@@ -20,6 +22,12 @@ interface AgentArgv {
 type AgentArgvResult =
 	{ kind: 'argv'; argv: AgentArgv; profile: AgentProfile } | { kind: 'rejected'; note: string }
 
+// Where a cut relaunch runs, and how it reads its Issue's labels when `josh.worker` asks for them.
+interface ResumeSite {
+	cwd: string
+	labels: () => Promise<ReadonlyArray<string> | undefined>
+}
+
 // **`session_id` forces the fresh session's id, and only the Claude path can honour it**.
 // Codex has no such flag, and the run-state report reads Claude transcripts
 // alone, so an OpenAI scheduler simply builds as before; whiff attribution is a Claude-transcript
@@ -105,19 +113,25 @@ function profiled_in(invocation: string, resolved: ProfileResult, cwd: string):
 // **A cut relaunch's profile, resolved for the phase the resumed child is entering**.
 // A stored lane profile takes the phase's model where the phase has one (pre-gate: Sonnet, or
 // `JOSH_WORKER_SHIP_MODEL`) and the phase's effort; a lane without one resolves the worker for the
-// phase. An env override wins over the phase in either path.
-function resume_argv(
+// phase. An env override wins over the phase in either path. The phase's model is then capped at the
+// Issue's `josh.worker` profile, whose labels `site.labels` reads only when the setting exists.
+async function resume_argv(
 	invocation: string,
 	profile: AgentProfile | undefined,
 	phase: string,
-	cwd: string,
-): AgentArgvResult {
+	site: ResumeSite,
+): Promise<AgentArgvResult> {
 	const resolved =
 		profile === undefined
 			? agent_role_profile.resolve(agent_role_profile.WORKER, process.env, phase)
 			: agent_role_profile.with_phase(profile, phase)
+	const capped = await agent_ship_cap.capped(
+		resolved,
+		phase,
+		async () => await agent_worker_profile.resolve(site.cwd, site.labels),
+	)
 
-	return profiled_in(invocation, resolved, cwd)
+	return profiled_in(invocation, capped, site.cwd)
 }
 
 function resolve_in(
@@ -155,5 +169,5 @@ const agent_argv = {
 	with_resume_in,
 }
 
-export type { AgentArgv, AgentArgvResult }
+export type { AgentArgv, AgentArgvResult, ResumeSite }
 export { agent_argv }

package/scripts/agent/agent-phase-profile.ts

@@ -0,0 +1,89 @@
+import {
+	agent_profile_schema,
+	type AgentEffort,
+	type AgentPhase,
+	type AgentRole,
+} from './agent-profile-schema'
+import { agent_provider, type AgentEnvironment, type AgentProvider } from './agent-provider'
+
+const { OPENAI_PROVIDER, trimmed } = agent_provider
+const { PHASE_SCHEMA, PRE_GATE_PHASE } = agent_profile_schema
+
+interface PhaseModel {
+	key: string
+	value: string
+}
+
+type PhaseTable<Value> = Readonly<Partial<Record<AgentRole, Partial<Record<AgentPhase, Value>>>>>
+
+const SONNET_MODEL = 'claude-sonnet-5-5'
+
+// **Effort as a function of the run phase, not the role alone**. For the first
+// merge only the mechanical ship/bookkeeping region is lowered: the pre-gate resume drives the gate,
+// commit, PR and merge, applying fixes the gate has already named — work delegation.md calls the opposite
+// of judgement. The design-judgment implementation phases keep the role default, as does any role/phase
+// with no entry, and the review's own judgement is the reviewer role's, untouched by lowering
+// the worker here. The investigation phase — highest output density — is left for a later merge, once
+// the delegation half of this Issue has moved its reading out.
+const SHIP_EFFORT: AgentEffort = 'low'
+const PHASE_EFFORT: PhaseTable<AgentEffort> = {
+	worker: { [PRE_GATE_PHASE]: SHIP_EFFORT },
+}
+
+// **The ship phase may run on a model of its own** (joshuafolkken/kit#5343), read from its key ahead of
+// the role's and applied on the same cut relaunch as `SHIP_EFFORT`. Unset, the phase runs on its default:
+// Sonnet held the ship phase's duration and stop rates against Opus across a lane trial (joshuafolkken/kit#5346).
+const PHASE_MODELS: PhaseTable<PhaseModel> = {
+	worker: { [PRE_GATE_PHASE]: { key: 'JOSH_WORKER_SHIP_MODEL', value: SONNET_MODEL } },
+}
+
+function phase_model_keys(): ReadonlyArray<string> {
+	return Object.values(PHASE_MODELS).flatMap((phases) =>
+		Object.values(phases).map(({ key }) => key),
+	)
+}
+
+// A role's entry in a phase table; `undefined` for a phase-less or unrecognized phase, or no entry.
+function phase_entry<Value>(
+	table: PhaseTable<Value>,
+	role: AgentRole,
+	phase: string | undefined,
+): Value | undefined {
+	const parsed = PHASE_SCHEMA.safeParse(phase)
+
+	return parsed.success ? table[role]?.[parsed.data] : undefined
+}
+
+// The phase's own model — its key when set, else its default; `undefined` for a phase with no entry or
+// an OpenAI session, whose model is never read from env.
+function phase_model(
+	role: AgentRole,
+	provider: AgentProvider,
+	phase: string | undefined,
+	environment: AgentEnvironment,
+): PhaseModel | undefined {
+	const entry = provider === OPENAI_PROVIDER ? undefined : phase_entry(PHASE_MODELS, role, phase)
+	if (entry === undefined) return undefined
+
+	return { key: entry.key, value: trimmed(environment[entry.key]) ?? entry.value }
+}
+
+// The effort a phase resolves to before any env override: the phase's own value where the table names
+// one, otherwise the fallback. A phase-less or unrecognized call returns the
+// fallback unchanged, which is what keeps every existing caller reading the current default.
+function phase_effort(
+	role: AgentRole,
+	phase: string | undefined,
+	fallback: AgentEffort,
+): AgentEffort {
+	return phase_entry(PHASE_EFFORT, role, phase) ?? fallback
+}
+
+const agent_phase_profile = {
+	SONNET_MODEL,
+	phase_effort,
+	phase_model,
+	phase_model_keys,
+}
+
+export { agent_phase_profile }

package/scripts/agent/agent-role-profile.ts

@@ -1,8 +1,8 @@
 import { agent_consultation_model } from './agent-consultation-model'
+import { agent_phase_profile } from './agent-phase-profile'
 import {
 	agent_profile_schema,
 	type AgentEffort,
-	type AgentPhase,
 	type AgentProfile,
 	type AgentRole,
 } from './agent-profile-schema'
@@ -27,6 +27,7 @@ const {
 	warn_of_default,
 } = agent_provider
 const { consultation_provider } = agent_consultation_model
+const { SONNET_MODEL, phase_effort, phase_model, phase_model_keys } = agent_phase_profile
 
 const {
 	DEFAULT_PROFILES,
@@ -34,7 +35,6 @@ const {
 	IMPLEMENTATION_PHASE,
 	OPENAI_MODEL,
 	OPENAI_PROFILES,
-	PHASE_SCHEMA,
 	PRE_GATE_PHASE,
 	REVIEWER,
 	SCHEDULER,
@@ -52,13 +52,6 @@ interface Override {
 	value: string | undefined
 }
 
-interface PhaseModel {
-	key: string
-	value: string
-}
-
-type PhaseTable<Value> = Readonly<Partial<Record<AgentRole, Partial<Record<AgentPhase, Value>>>>>
-
 // What a resolution is keyed on beyond the role: the run phase (effort) and the review round (profile).
 interface AgentStage {
 	phase?: string | undefined
@@ -73,7 +66,6 @@ const PROVIDER_PROFILES = { anthropic: DEFAULT_PROFILES, openai: OPENAI_PROFILES
 // first only checks that the first round's findings were fixed, so its model and effort are set apart:
 // its own keys win, then the reviewer's, then its own default.
 const FIRST_REVIEW_ROUND = 1
-const SONNET_MODEL = 'claude-sonnet-5-5'
 const VERIFICATION_PROFILES: Readonly<Record<AgentProvider, AgentProfile>> = {
 	anthropic: {
 		...DEFAULT_PROFILES.reviewer,
@@ -99,25 +91,6 @@ const INVESTIGATION_MODELS: Readonly<Record<AgentProvider, string>> = {
 }
 const INVESTIGATION_MODEL_KEY = 'JOSH_INVESTIGATION_MODEL'
 
-// **Effort as a function of the run phase, not the role alone**. For the first
-// merge only the mechanical ship/bookkeeping region is lowered: the pre-gate resume drives the gate,
-// commit, PR and merge, applying fixes the gate has already named — work delegation.md calls the opposite
-// of judgement. The design-judgment implementation phases keep the role default, as does any role/phase
-// with no entry, and the review's own judgement is the reviewer role's, untouched by lowering
-// the worker here. The investigation phase — highest output density — is left for a later merge, once
-// the delegation half of this Issue has moved its reading out.
-const SHIP_EFFORT: AgentEffort = 'low'
-const PHASE_EFFORT: PhaseTable<AgentEffort> = {
-	worker: { [PRE_GATE_PHASE]: SHIP_EFFORT },
-}
-
-// **The ship phase may run on a model of its own** (joshuafolkken/kit#5343), read from its key ahead of
-// the role's and applied on the same cut relaunch as `SHIP_EFFORT`. Unset, the phase runs on its default:
-// Sonnet held the ship phase's duration and stop rates against Opus across a lane trial (joshuafolkken/kit#5346).
-const PHASE_MODELS: PhaseTable<PhaseModel> = {
-	worker: { [PRE_GATE_PHASE]: { key: 'JOSH_WORKER_SHIP_MODEL', value: SONNET_MODEL } },
-}
-
 const ENV_KEYS: Readonly<Record<AgentRole, { model: string; effort: string }>> = {
 	scheduler: { model: 'JOSH_SCHEDULER_MODEL', effort: 'JOSH_SCHEDULER_EFFORT' },
 	worker: { model: 'JOSH_WORKER_MODEL', effort: 'JOSH_WORKER_EFFORT' },
@@ -126,12 +99,6 @@ const ENV_KEYS: Readonly<Record<AgentRole, { model: string; effort: string }>> =
 
 const LEGACY_WORKER_KEYS = { model: 'JOSH_LANE_MODEL', effort: 'JOSH_LANE_EFFORT' }
 
-function phase_model_keys(): ReadonlyArray<string> {
-	return Object.values(PHASE_MODELS).flatMap((phases) =>
-		Object.values(phases).map(({ key }) => key),
-	)
-}
-
 // Every env key a profile is read from. The unit suite blanks them so a lane's model and effort never
 // reach its fixtures (joshuafolkken/kit#5863); its test pins each to the pattern its config blanks.
 const PROFILE_KEYS: ReadonlyArray<string> = [
@@ -175,31 +142,6 @@ function override_value(
 		: { key, value: trimmed(environment[key]) }
 }
 
-// A role's entry in a phase table; `undefined` for a phase-less or unrecognized phase, or no entry.
-function phase_entry<Value>(
-	table: PhaseTable<Value>,
-	role: AgentRole,
-	phase: string | undefined,
-): Value | undefined {
-	const parsed = PHASE_SCHEMA.safeParse(phase)
-
-	return parsed.success ? table[role]?.[parsed.data] : undefined
-}
-
-// The phase's own model — its key when set, else its default; `undefined` for a phase with no entry or
-// an OpenAI session, whose model is never read from env.
-function phase_model(
-	role: AgentRole,
-	provider: AgentProvider,
-	phase: string | undefined,
-	environment: AgentEnvironment,
-): PhaseModel | undefined {
-	const entry = provider === OPENAI_PROVIDER ? undefined : phase_entry(PHASE_MODELS, role, phase)
-	if (entry === undefined) return undefined
-
-	return { key: entry.key, value: trimmed(environment[entry.key]) ?? entry.value }
-}
-
 function model_override(
 	role: AgentRole,
 	environment: AgentEnvironment,
@@ -237,17 +179,6 @@ function validate(profile: AgentProfile, model_key: string): ProfileResult {
 	return { kind: 'profile', profile }
 }
 
-// The effort a phase resolves to before any env override: the phase's own value where the table names
-// one, otherwise the fallback. A phase-less or unrecognized call returns the
-// fallback unchanged, which is what keeps every existing caller reading the current default.
-function phase_effort(
-	role: AgentRole,
-	phase: string | undefined,
-	fallback: AgentEffort,
-): AgentEffort {
-	return phase_entry(PHASE_EFFORT, role, phase) ?? fallback
-}
-
 // The effort a stored profile takes in a phase: an env override wins, then the phase value, then the
 // profile's own effort. A cut relaunch that keeps a lane's stored model resolves
 // the effort through this so a person's `JOSH_WORKER_EFFORT` is never overwritten by the phase value.
@@ -374,6 +305,7 @@ const agent_role_profile = {
 	resolve,
 	resolve_provider,
 	resolve_review,
+	validate,
 	warn_of_default,
 	with_phase,
 }

package/scripts/agent/agent-ship-cap.ts

@@ -0,0 +1,44 @@
+import { agent_phase_profile } from './agent-phase-profile'
+import type { AgentProfile, ProfileResult } from './agent-role-profile'
+import type { WorkerResult } from './agent-worker-profile'
+
+// **The ship phase never runs above the Issue's `josh.worker` profile** (joshuafolkken/kit#7354): a
+// phase with a model of its own takes the weaker of that model and the Issue's, ranked by the order of
+// `profiles`, weakest first. A ship model no profile names cannot be ranked, so it is kept: a cap never
+// raises the phase above its own model. A repository without the setting, and a phase
+// without a model of its own, keep the resolved profile and never read the setting or the labels.
+
+type ResolvedWorker = Extract<WorkerResult, { kind: 'worker' }>
+
+function has_phase_model(profile: AgentProfile, phase: string): boolean {
+	return agent_phase_profile.phase_model(profile.role, profile.provider, phase, {}) !== undefined
+}
+
+function weaker(profile: AgentProfile, resolved: ResolvedWorker): AgentProfile {
+	const { worker, settings } = resolved
+	const rank = settings.profiles.findIndex((entry) => entry.agent.model === profile.model)
+	const limit = settings.profiles.findIndex((entry) => entry.name === worker.name)
+
+	return rank <= limit ? profile : { ...profile, model: worker.agent.model }
+}
+
+function capped_by(profile: AgentProfile, result: WorkerResult): ProfileResult {
+	if (result.kind === 'unset') return { kind: 'profile', profile }
+
+	return result.kind === 'rejected' ? result : { kind: 'profile', profile: weaker(profile, result) }
+}
+
+// `worker` is called only for a phase with a model of its own, so every other relaunch reads nothing.
+async function capped(
+	resolved: ProfileResult,
+	phase: string,
+	worker: () => Promise<WorkerResult>,
+): Promise<ProfileResult> {
+	if (resolved.kind === 'rejected' || !has_phase_model(resolved.profile, phase)) return resolved
+
+	return capped_by(resolved.profile, await worker())
+}
+
+const agent_ship_cap = { capped }
+
+export { agent_ship_cap }

package/scripts/agent/agent-worker-profile.ts

@@ -0,0 +1,154 @@
+import { json_value } from '#scripts/lib/json-value'
+import {
+	package_manifest,
+	type WorkerConfig,
+	type WorkerProfileDefinition,
+} from '#scripts/lib/package-manifest'
+import { file_reader } from '#scripts/lib/read-file'
+import type { z } from 'zod'
+import { agent_profile_schema, type AgentProfile } from './agent-profile-schema'
+import type { Rejected } from './agent-provider'
+import { agent_role_profile } from './agent-role-profile'
+
+// The per-Issue worker profile a repository opts into with `josh.worker` in its `package.json`: the
+// Issue's `worker:<name>` label picks a profile, else the configured default. A repository without the
+// setting answers `unset` before any label is fetched, so it keeps today's launch unchanged.
+const { EFFORT_SCHEMA, PROFILE_SCHEMA, WORKER } = agent_profile_schema
+const CONFIG_KEY = 'josh.worker'
+const LABEL_PREFIX = 'worker:'
+
+interface WorkerProfile {
+	name: string
+	when: string
+	agent: AgentProfile
+}
+
+interface WorkerSettings {
+	default: string
+	escalate: boolean
+	profiles: ReadonlyArray<WorkerProfile>
+}
+
+interface Unset {
+	kind: 'unset'
+}
+
+type SettingsResult = Rejected | Unset | { kind: 'settings'; settings: WorkerSettings }
+type WorkerResult =
+	Rejected | Unset | { kind: 'worker'; worker: WorkerProfile; settings: WorkerSettings }
+type ProfileCheck = Rejected | { kind: 'profile'; worker: WorkerProfile }
+
+const UNSET: Unset = { kind: 'unset' }
+
+function rejected(note: string): Rejected {
+	return { kind: 'rejected', note: `${CONFIG_KEY} ${note}` }
+}
+
+// A schema rejection: its issue path already starts at `josh.worker`, so it is not prefixed again.
+function schema_rejection(error: z.ZodError): Rejected {
+	const [issue] = error.issues
+	if (issue === undefined) return rejected('is invalid')
+
+	return { kind: 'rejected', note: `${issue.path.join('.')}: ${issue.message}` }
+}
+
+function checked_profile(definition: WorkerProfileDefinition): ProfileCheck {
+	const { name, model, effort, when } = definition
+	const parsed = PROFILE_SCHEMA.safeParse({ role: WORKER, model, effort })
+
+	if (!parsed.success) {
+		return rejected(
+			`profile ${name}: effort ${effort} is not one of ${EFFORT_SCHEMA.options.join(', ')}`,
+		)
+	}
+
+	const checked = agent_role_profile.validate(parsed.data, `${CONFIG_KEY} profile ${name} model`)
+
+	return checked.kind === 'rejected'
+		? checked
+		: { kind: 'profile', worker: { name, when, agent: checked.profile } }
+}
+
+function checked_settings(config: WorkerConfig): SettingsResult {
+	const profiles: Array<WorkerProfile> = []
+
+	for (const definition of config.profiles) {
+		const checked = checked_profile(definition)
+		if (checked.kind === 'rejected') return checked
+		profiles.push(checked.worker)
+	}
+
+	return {
+		kind: 'settings',
+		settings: { default: config.default, escalate: config.escalate, profiles },
+	}
+}
+
+// A manifest that cannot be read or parsed names no setting, so it reads as an empty object.
+function manifest_value(directory: string): unknown {
+	const text = file_reader.read_if_readable(package_manifest.manifest_path(directory))
+	if (text === undefined) return {}
+
+	return json_value.parse_or_undefined(text) ?? {}
+}
+
+// The repository's `josh.worker`: `unset` when the manifest names none (or cannot be read), a rejection
+// with its reason when the setting breaks a rule, otherwise the checked profiles.
+function read(directory: string): SettingsResult {
+	const parsed = package_manifest.josh_schemas.worker.safeParse(manifest_value(directory))
+	if (!parsed.success) return schema_rejection(parsed.error)
+
+	const config = parsed.data.josh?.worker
+
+	return config === undefined ? UNSET : checked_settings(config)
+}
+
+function profile_named(settings: WorkerSettings, name: string): WorkerProfile | undefined {
+	return settings.profiles.find((profile) => profile.name === name)
+}
+
+function for_labels(settings: WorkerSettings, labels: ReadonlyArray<string>): WorkerResult {
+	const names = labels
+		.filter((label) => label.startsWith(LABEL_PREFIX))
+		.map((label) => label.slice(LABEL_PREFIX.length))
+
+	if (names.length > 1) {
+		return rejected(`allows one ${LABEL_PREFIX}<name> label, got ${names.join(', ')}`)
+	}
+
+	const [name = settings.default] = names
+	const worker = profile_named(settings, name)
+	if (worker === undefined) return rejected(`has no profile for the label ${LABEL_PREFIX}${name}`)
+
+	return { kind: 'worker', worker, settings }
+}
+
+// The profile an Issue's worker runs on. `fetch_labels` is called only once a setting exists, so a
+// repository without one never asks GitHub for the Issue's labels. A label read that fails answers
+// `undefined` and is refused: falling back to the default could run a `worker:<name>` Issue on the
+// wrong model.
+async function resolve(
+	directory: string,
+	fetch_labels: () => Promise<ReadonlyArray<string> | undefined>,
+): Promise<WorkerResult> {
+	const result = read(directory)
+	if (result.kind !== 'settings') return result
+
+	const labels = await fetch_labels()
+	if (labels === undefined) return rejected('could not read the Issue labels')
+
+	return for_labels(result.settings, labels)
+}
+
+// The profile one step above `worker` in the escalation order, or `undefined` at the top.
+function next(settings: WorkerSettings, worker: WorkerProfile): WorkerProfile | undefined {
+	const index = settings.profiles.findIndex((profile) => profile.name === worker.name)
+	if (index === -1) return undefined
+
+	return settings.profiles[index + 1]
+}
+
+const agent_worker_profile = { LABEL_PREFIX, for_labels, next, read, resolve }
+
+export type { SettingsResult, WorkerProfile, WorkerResult, WorkerSettings }
+export { agent_worker_profile }

package/scripts/agent/claude-agent-argv.ts

@@ -110,7 +110,7 @@ function tool_flags(role: AgentRole, cwd: string = process.cwd()): ReadonlyArray
 function instruction_flags(profile: AgentProfile, cwd?: string): ReadonlyArray<string> {
 	if (profile.role === agent_role_profile.SCHEDULER) return []
 
-	return lane_instructions.flags(cwd)
+	return lane_instructions.flags(cwd, profile.role === agent_role_profile.WORKER)
 }
 
 function build(