orizu 0.5.21 → 0.5.23

package/src/hosted-gepa-numeric-values.ts

@@ -0,0 +1,60 @@
+interface NumericRule {
+  field: string
+  flag: string
+  grammar: string
+  accepts: (value: unknown) => boolean
+}
+
+const isFiniteNumber = (value: unknown): value is number =>
+  typeof value === 'number' && Number.isFinite(value)
+const isInteger = (value: unknown): value is number =>
+  isFiniteNumber(value) && Number.isInteger(value)
+const isPositiveInteger = (value: unknown): value is number =>
+  isInteger(value) && value > 0
+
+const rules: NumericRule[] = [
+  ...[
+    ['proposalMaxCalls', '--proposal-max-calls'],
+    ['proposalMaxTokens', '--proposal-max-tokens'],
+    ['maxIterations', '--max-iterations'],
+    ['maxCandidateProposals', '--max-candidate-proposals'],
+    ['maxFullEvals', '--max-full-evals'],
+    ['maxMetricCalls', '--max-metric-calls'],
+    ['minibatchSize', '--minibatch-size'],
+    ['reflectionMaxTokens', '--reflection-max-tokens'],
+    ['reflectionRetryAttempts', '--reflection-retry-attempts'],
+    ['reflectionHttpTimeoutSeconds', '--reflection-http-timeout-seconds'],
+  ].map(([field, flag]) => ({ field, flag, grammar: 'positive integer', accepts: isPositiveInteger })),
+  {
+    field: 'numThreads', flag: '--num-threads', grammar: 'auto or positive integer',
+    accepts: value => value === 'auto' || isPositiveInteger(value),
+  },
+  ...[
+    ['epsilon', '--epsilon'],
+    ['reflectionTemperature', '--reflection-temperature'],
+  ].map(([field, flag]) => ({ field, flag, grammar: 'finite number', accepts: isFiniteNumber })),
+  { field: 'seed', flag: '--seed', grammar: 'integer', accepts: isInteger },
+]
+
+const integerPattern = /^[+-]?\d+$/
+const floatPattern = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i
+
+export function parseHostedGepaNumericValue(field: string, rawValue: string): number | 'auto' {
+  const rule = rules.find(candidate => candidate.field === field)
+  if (!rule) throw new Error(`Unknown hosted numeric field ${field}`)
+  const trimmed = rawValue.trim()
+  if (field === 'numThreads' && trimmed.toLowerCase() === 'auto') return 'auto'
+  const lexicalPattern = rule.grammar === 'finite number' ? floatPattern : integerPattern
+  const parsed = lexicalPattern.test(trimmed) ? Number(trimmed) : Number.NaN
+  if (!rule.accepts(parsed)) throw new Error(`${rule.flag} must be ${rule.grammar}`)
+  return parsed
+}
+
+export function hostedGepaNumericError(values: Record<string, unknown>): string | null {
+  for (const rule of rules) {
+    if (values[rule.field] !== undefined && !rule.accepts(values[rule.field])) {
+      return `${rule.field} must be ${rule.grammar}`
+    }
+  }
+  return null
+}

package/src/hosted-provider-settings.ts

@@ -0,0 +1,69 @@
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function hasOnlyKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+  return Object.keys(value).every(key => keys.includes(key))
+}
+
+function isChoice(value: unknown, choices: readonly string[]): boolean {
+  return typeof value === 'string' && choices.includes(value)
+}
+
+function isProviderObject(value: unknown, keys: readonly string[], choices: Readonly<Record<string, readonly string[]>>): boolean {
+  return isRecord(value) && hasOnlyKeys(value, keys)
+    && Object.entries(value).every(([key, nested]) => isChoice(nested, choices[key] ?? []))
+}
+
+function isCredentialKey(key: string): boolean {
+  const tokens = key.replaceAll(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)
+  return tokens.some(token => ['auth', 'authorization', 'token', 'secret', 'password', 'passwd', 'credential', 'credentials', 'key'].includes(token))
+    || /(?:authorization|authheader|bearer|token|secret|password|passwd|credential|credentials|apikey|accesskey(?:id)?|privatekey|clientkey|secretkey|connection(?:string|url)|dsn)$/.test(tokens.join(''))
+}
+
+function containsCredential(value: unknown, root = true): boolean {
+  if (Array.isArray(value)) return root || value.some(nested => containsCredential(nested, false))
+  if (!isRecord(value)) return root ? value !== undefined
+    : typeof value === 'string' && (/(?:authorization|bearer|x-api-key|x-auth-token)\s*[: ]/i.test(value)
+      || /^[a-z]+:\/\/[^/@]*:[^/@]*@/i.test(value))
+  return Object.entries(value).some(([key, nested]) => isCredentialKey(key) || containsCredential(nested, false))
+}
+
+function unsupportedHostedSetting(value: unknown, model: string): string | null {
+  if (value === undefined) return null
+  if (!isRecord(value)) return '<root>'
+  const providerKeys = model.startsWith('openai/') ? ['reasoning']
+    : model.startsWith('anthropic/') ? ['thinking', 'output_config'] : []
+  const unknown = Object.keys(value).find(key => !['top_p', ...providerKeys].includes(key))
+  if (unknown) return unknown
+  if (value.top_p !== undefined && (typeof value.top_p !== 'number'
+    || !Number.isFinite(value.top_p) || value.top_p < 0 || value.top_p > 1)) return 'top_p'
+  if (value.thinking !== undefined && (!isRecord(value.thinking) || value.thinking.type === undefined)) return 'thinking.type'
+  for (const [key, nested, keys, choices] of [
+    ['thinking', value.thinking, ['type'], { type: ['adaptive'] }],
+    ['output_config', value.output_config, ['effort'], { effort: ['low', 'medium', 'high', 'max'] }],
+    ['reasoning', value.reasoning, ['effort', 'summary'], { effort: ['minimal', 'low', 'medium', 'high', 'xhigh'], summary: ['auto', 'concise', 'detailed'] }],
+  ] as Array<[string, unknown, readonly string[], Readonly<Record<string, readonly string[]>>]>) if (nested !== undefined && !isProviderObject(nested, keys, choices)) {
+    if (!isRecord(nested)) return key
+    return `${key}.${Object.keys(nested).find(child => !keys.includes(child)
+      || !isChoice(nested[child], choices[child] ?? [])) ?? key}`
+  }
+  return null
+}
+
+export function hostedSettingsContainCredentials(value: unknown): boolean { return containsCredential(value) }
+
+export function hostedProviderSettingsError(
+  value: unknown, model = 'anthropic/', temperature?: unknown
+): string | null {
+  if (hostedSettingsContainCredentials(value)) {
+    return 'Hosted reflection provider settings must not contain credential-bearing fields.'
+  }
+  const unsupported = unsupportedHostedSetting(value, model)
+  if (unsupported) return `Unsupported hosted setting "${unsupported}".`
+  if (model.startsWith('anthropic/') && temperature !== undefined && temperature !== null
+    && isRecord(value) && value.thinking !== undefined) {
+    return 'reflection_temperature cannot be combined with Anthropic thinking'
+  }
+  return null
+}

package/src/hosted-session-cli.ts

@@ -57,6 +57,7 @@ import { buildEgressPolicy, DEFAULT_EGRESS_CANARY_HOST } from './egress-policy.j
 import { DEFAULT_HOSTED_MODEL, hostedLoopCommand, type HostedLoopContext } from './hosted-loop.js'
 import { hostedBootCommand } from './hosted-boot.js'
 import { mergeJobCommand } from './merge-job.js'
+import { skilledProposerBakeCommand } from './skilled-proposer-launch.js'
 import { authedFetch } from './http.js'
 import { resolveBaseUrl } from './http.js'
 import { findUnknownOption } from './option-validation.js'
@@ -1568,7 +1569,9 @@ export async function hostedCommand(
     if (positional[1] === 'merge-job') {
       return mergeJobCommand(io)
     }
-    io.printErr?.('Usage: orizu internal <hosted-loop --context <path> | hosted-boot | merge-job>')
+    if (positional[1] === 'bake-skilled-proposer-venv') return skilledProposerBakeCommand(io)
+    if (positional[1] === 'verify-skilled-proposer-bake') return skilledProposerBakeCommand(io, true)
+    io.printErr?.('Usage: orizu internal <hosted-loop --context <path> | hosted-boot | merge-job | bake-skilled-proposer-venv | verify-skilled-proposer-bake>')
     return 1
   }
 

package/src/http.ts

@@ -93,6 +93,10 @@ function isExpired(expiresAt: number): boolean {
   return expiresAt <= nowUnix + 30
 }
 
+export function credentialRequestRedirectPolicy(): Pick<RequestInit, 'redirect'> {
+  return process.env.ORIZU_CLI_AUTH_REDIRECT === 'error' ? { redirect: 'error' } : {}
+}
+
 async function refreshCredentials(baseUrl: string, credentials: ServerCredentials): Promise<ServerCredentials> {
   if (!isSessionCredentials(credentials)) {
     throw new Error('API key credentials do not refresh. Run `orizu login` again if access fails.')
@@ -103,6 +107,7 @@ async function refreshCredentials(baseUrl: string, credentials: ServerCredential
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ refreshToken: credentials.refreshToken }),
+    ...credentialRequestRedirectPolicy(),
   })
 
   if (!response.ok) {
@@ -141,6 +146,7 @@ export async function authedFetch(path: string, init: RequestInit = {}) {
         ...(init.headers || {}),
         Authorization: `Bearer ${envBearer}`,
       },
+      ...credentialRequestRedirectPolicy(),
     })
   }
 
@@ -160,6 +166,7 @@ export async function authedFetch(path: string, init: RequestInit = {}) {
       ...(init.headers || {}),
       Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
     },
+    ...credentialRequestRedirectPolicy(),
   })
 
   if (response.status === 401 && isSessionCredentials(activeCredentials)) {
@@ -170,6 +177,7 @@ export async function authedFetch(path: string, init: RequestInit = {}) {
         ...(init.headers || {}),
         Authorization: `Bearer ${getAuthorizationToken(activeCredentials)}`,
       },
+      ...credentialRequestRedirectPolicy(),
     })
   }
 

package/src/index.ts

@@ -36,7 +36,14 @@ import { parseGlobalFlags } from './global-flags.js'
 import { getCapabilities, renderHelpForArgs, renderRootHelp } from './help.js'
 import { runLocalAppPreview } from './preview-runtime.js'
 import { readAssignmentManifestJsonlFile } from './task-assignment-manifest.js'
-import { assertSecureTokenTransport, authedFetch, getBaseUrl, resolveLoginBaseUrl, setGlobalFlags } from './http.js'
+import {
+  assertSecureTokenTransport,
+  authedFetch,
+  credentialRequestRedirectPolicy,
+  getBaseUrl,
+  resolveLoginBaseUrl,
+  setGlobalFlags,
+} from './http.js'
 import {
   computeSkillContentHash,
   getSkillInstallPath,
@@ -71,6 +78,7 @@ import { ARTIFACT_MAX_BYTES, runnerOptimizerCommand } from './artifact-pull.js'
 import { killSwitchCommand } from './kill-switch-cli.js'
 import { egressAllowlistCommand } from './egress-allowlist-cli.js'
 import { acceptScoreRunCommand } from './scores-accept-cli.js'
+import { cleanupAll, throwWithCleanup } from './cleanup.js'
 import { listOptimizationRunsCommand } from './optimizations-list-cli.js'
 import { promoteOptimizationCommand } from './optimizations-promote-cli.js'
 import { scorersCommand } from './scorers-cli.js'
@@ -86,7 +94,7 @@ import {
 import { teamConnectorsCommand } from './team-connectors-cli.js'
 import { manifestsCommand } from './manifests-cli.js'
 import { workbenchCommand } from './workbench-cli.js'
-import { hostedCommand } from './hosted-session-cli.js'
+import { dispatchHostedCommands } from './hosted-commands.js'
 import { workspaceSyncCommand } from './workspace-sync.js'
 import { runGitCredentialInvocation } from './git-credential.js'
 import { instructionSetsCommand, syncToDisk } from './instruction-sets-cli.js'; export { loadInstructionSet } from './instruction-set-loader.js'
@@ -100,7 +108,13 @@ import type {
   CliLengthMeasurementUnavailableReason,
   CliLengthStats,
 } from './prompt-length-wire.js'
-import { assertSnapshotManifestConfined, verifyGepaRunnerDirsFromArgs, verifyRunnerDirRegistered } from './runner-dir-verify.js'
+import {
+  assertSnapshotManifestConfined,
+  extractFlagValue,
+  type GepaVerifiedArgs,
+  verifyGepaRunnerDirsFromArgs,
+  verifyRunnerDirRegistered,
+} from './runner-dir-verify.js'
 import { runScorersRegister } from './scorer-draft-push.js'
 import { runZipArtifactPush } from './zip-draft-push.js'
 import { type GithubLinkResult, runGithubLink, runInteractiveHostedSetup } from './github-setup.js'
@@ -117,7 +131,7 @@ import { dispatchGepaEngine } from './gepa-engine-dispatch.js'
 import { resolveGepaInstructionSetProfileVersion } from './instruction-set-gepa-launch.js'
 import { getGepaPythonCommand } from './gepa-python-command.js'
 import { getGepaPythonPathEntries } from './gepa-python-paths.js'
-import { prepareSkilledProposerLaunch } from './skilled-proposer-launch.js'
+import { prepareSkilledProposerLaunch, spawnSkilledProposerChild } from './skilled-proposer-launch.js'
 
 export { parseJsonResponse, sanitizeTerminalText } from './json-response.js'
 
@@ -1287,6 +1301,7 @@ async function logout() {
       body: 'refreshToken' in credentials
         ? JSON.stringify({ refreshToken: credentials.refreshToken })
         : undefined,
+      ...credentialRequestRedirectPolicy(),
     })
 
     if (!response.ok) {
@@ -1767,53 +1782,6 @@ function refusePromptMutation(replacement: string): never {
   throw new Error(`Use: orizu instructions ${replacement}`)
 }
 
-async function bindPromptScorer(role: 'headline' | 'tracked') {
-  const promptId = getPositionalArg(3)
-  const project = getArg('--project') || await resolveProjectSlug(null)
-  const scorerVersionId = getArg('--scorer-version')
-
-  if (!promptId || !scorerVersionId) {
-    throw new Error(`Usage: orizu prompts scorers ${role === 'headline' ? 'set-headline' : 'add'} <prompt-id> --scorer-version <id> [--dataset-version <id> --split-set <id> --split <name>] [--project <team/project>] [--json]`)
-  }
-
-  const response = await authedFetch(`/api/cli/prompts/scorers?project=${encodeURIComponent(project)}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      promptId,
-      scorerVersionId,
-      role,
-      datasetVersionId: getArg('--dataset-version') || undefined,
-      splitSetId: getArg('--split-set') || undefined,
-      splitName: getArg('--split') || undefined,
-    }),
-  })
-
-  if (!response.ok) {
-    throw new Error(`Failed to bind prompt scorer: ${await response.text()}`)
-  }
-
-  const data = await parseJsonResponse<{
-    promptScorer: Record<string, unknown>
-    owner?: {
-      instructionSetSlug: string
-      componentKey: string
-    }
-  }>(response, 'Prompt scorer bind')
-  if (hasJsonFlag()) {
-    printJson(data)
-    return
-  }
-
-  printLine(`${role === 'headline' ? 'Set headline' : 'Added'} scorer ${sanitizeTerminalText(scorerVersionId)} for ${sanitizeTerminalText(promptId)}`)
-  if (data.owner) {
-    printLine(
-      `Owner: ${sanitizeTerminalText(promptId)} -> ` +
-      `${sanitizeTerminalText(data.owner.instructionSetSlug)} / ${sanitizeTerminalText(data.owner.componentKey)}`
-    )
-  }
-}
-
 function getPositionalArg(index: number): string | null {
   const value = cliArgs[index]
   return value && !value.startsWith('--') ? value : null
@@ -2497,6 +2465,43 @@ async function updateOptimizationRunLifecycle(action: OptimizationLifecycleActio
 
 // ALI-1073 list moved to optimizations-list-cli.ts (line ratchet, ALI-976);
 // ALI-1175 labels its best scores as agent-reported evidence there.
+const GEPA_RUNNER_MATERIALIZATION_PAIRS = [
+  { versionFlag: '--runner-version-id', dirFlag: '--candidate-runner-dir' },
+  { versionFlag: '--scorer-runner-version-id', dirFlag: '--scorer-runner-dir' },
+] as const
+
+async function materializeMissingGepaRunnerDirs(args: string[]): Promise<{
+  args: string[]
+  cleanup: () => void
+}> {
+  const rewritten = [...args]
+  const cleanups: Array<() => void> = []
+  const cleanup = () => cleanupAll(
+    cleanups,
+    'Failed to clean materialized runner directories'
+  )
+
+  try {
+    for (const pair of GEPA_RUNNER_MATERIALIZATION_PAIRS) {
+      const runnerVersionId = extractFlagValue(rewritten, pair.versionFlag)
+      const runnerDir = extractFlagValue(rewritten, pair.dirFlag)
+      if (!runnerVersionId || runnerDir) continue
+
+      const materialized = await materializeRunnerVersion(runnerVersionId)
+      cleanups.push(materialized.cleanup)
+      rewritten.push(pair.dirFlag, materialized.runnerDir)
+    }
+  } catch (error) {
+    throwWithCleanup(
+      error,
+      cleanups,
+      'Runner materialization failed and cleanup also failed'
+    )
+  }
+
+  return { args: rewritten, cleanup }
+}
+
 async function runGepaOptimization() {
   const project = getArg('--project') || await resolveProjectSlug(null)
   const baseUrl = getBaseUrl()
@@ -2509,11 +2514,12 @@ async function runGepaOptimization() {
   // itself (both argparse flag forms), fail-closed on half-populated pairs,
   // and REWRITES the dir flags to verified snapshots (the exact hashed bytes)
   // so a post-hash mutation of the original dirs cannot change what runs.
-  const verified = await verifyGepaRunnerDirsFromArgs(forwardedArgs)
-  forwardedArgs = verified.args
-  let result
+  const materialized = await materializeMissingGepaRunnerDirs(forwardedArgs)
+  let verified: GepaVerifiedArgs | undefined
   let selectedEngine = 'official'
   try {
+    verified = await verifyGepaRunnerDirsFromArgs(materialized.args)
+    forwardedArgs = verified.args
     // Uniform resolution (ALI-1090): honors ORIZU_TOKEN / ORIZU_TOKEN_FILE before
     // credentials.json so hosted sandboxes can run optimizations. Read at spawn
     // time — AFTER the verification awaits above, so a hosted token-file
@@ -2539,18 +2545,29 @@ async function runGepaOptimization() {
     if (instructionSetProfileVersionId) dispatch.environment.ORIZU_INSTRUCTION_SET_PROFILE_VERSION_ID = instructionSetProfileVersionId
     selectedEngine = dispatch.engine
     const launch = prepareSkilledProposerLaunch(python, dispatch.engine, dispatch.environment)
-    result = spawnSync(launch.python, ['-m', dispatch.module, ...dispatch.args], { stdio: 'inherit', env: launch.environment })
-  } finally {
-    verified.cleanup()
-  }
-  if (result.error) {
-    throw new Error(`${selectedEngine} GEPA engine failed: ${result.error.message}`, { cause: result.error })
-  }
-
-  if (result.status !== 0) {
-    throw new Error(`${selectedEngine} GEPA engine failed with exit code ${result.status}`)
+    const result = await spawnSkilledProposerChild(
+      launch.python, ['-m', dispatch.module, ...dispatch.args], dispatch.engine, launch.environment,
+    )
+    if (result.error) {
+      throw new Error(`${selectedEngine} GEPA engine failed: ${result.error.message}`, { cause: result.error })
+    }
+    if (result.status !== 0) {
+      throw new Error(`${selectedEngine} GEPA engine failed with exit code ${result.status}`)
+    }
+  } catch (error) {
+    throwWithCleanup(
+      error,
+      [
+        ...(verified ? [verified.cleanup] : []),
+        materialized.cleanup,
+      ],
+      'GEPA launch failed and runner cleanup also failed'
+    )
   }
-
+  cleanupAll(
+    [verified.cleanup, materialized.cleanup],
+    'Failed to clean GEPA runner directories'
+  )
   if (hasJsonFlag()) {
     printJson({ status: 'completed', exitCode: 0 })
   }
@@ -5829,26 +5846,33 @@ export async function materializeRunnerVersion(runnerVersionId: string): Promise
   const tempDir = mkdtempSync(join(tmpdir(), 'orizu-runner-version-'))
   const zipPath = join(tempDir, 'runner.zip')
   const runnerDir = join(tempDir, 'runner')
-  const zipBytes = new Uint8Array(await response.arrayBuffer())
-  if (zipBytes.byteLength > ARTIFACT_MAX_BYTES) {
-    rmSync(tempDir, { recursive: true, force: true })
-    throw new Error(`Runner artifact exceeds ${ARTIFACT_MAX_BYTES} bytes`)
-  }
-  writeFileSync(zipPath, zipBytes)
+  const cleanup = () => rmSync(tempDir, { recursive: true, force: true })
 
-  const result = spawnSync('unzip', ['-q', zipPath, '-d', runnerDir], {
-    encoding: 'utf8',
-  })
-  if (result.error) {
-    rmSync(tempDir, { recursive: true, force: true })
-    throw result.error
-  }
-  if (result.status !== 0) {
-    rmSync(tempDir, { recursive: true, force: true })
-    throw new Error(`unzip failed: ${sanitizeTerminalText(result.stderr || result.stdout || '')}`)
-  }
+  try {
+    const zipBytes = new Uint8Array(await response.arrayBuffer())
+    if (zipBytes.byteLength > ARTIFACT_MAX_BYTES) {
+      throw new Error(`Runner artifact exceeds ${ARTIFACT_MAX_BYTES} bytes`)
+    }
+    writeFileSync(zipPath, zipBytes)
 
-  return { runnerDir, cleanup: () => rmSync(tempDir, { recursive: true, force: true }) }
+    const result = spawnSync('unzip', ['-q', zipPath, '-d', runnerDir], {
+      encoding: 'utf8',
+    })
+    if (result.error) {
+      throw result.error
+    }
+    if (result.status !== 0) {
+      throw new Error(`unzip failed: ${sanitizeTerminalText(result.stderr || result.stdout || '')}`)
+    }
+
+    return { runnerDir, cleanup }
+  } catch (error) {
+    throwWithCleanup(
+      error,
+      [cleanup],
+      `Runner ${runnerVersionId} materialization failed and cleanup also failed`
+    )
+  }
 }
 
 async function runnersExec() {
@@ -6236,13 +6260,11 @@ export async function main(rawArgs = process.argv.slice(2)) {
   }
 
   if (command === 'prompts' && subcommand === 'scorers' && cliArgs[2] === 'set-headline') {
-    await bindPromptScorer('headline')
-    return
+    refusePromptMutation('scorers set-headline <set> --key <component-key> --scorer-version <id> --project <team/project>')
   }
 
   if (command === 'prompts' && subcommand === 'scorers' && cliArgs[2] === 'add') {
-    await bindPromptScorer('tracked')
-    return
+    refusePromptMutation('scorers add <set> --key <component-key> --scorer-version <id> --project <team/project>')
   }
 
   if (command === 'judges' && subcommand === 'list') {
@@ -6324,6 +6346,7 @@ export async function main(rawArgs = process.argv.slice(2)) {
     return
   }
 
+  if (await dispatchHostedCommands(cliArgs, { environment: process.env, getArg, json: hasJsonFlag(), printJson, printLine, printErr: printError, resolveProjectSlug, setExitCode: code => { process.exitCode = code } })) return
   if (command === 'optimizations' && subcommand === 'start') {
     await startOptimizationRun()
     return
@@ -6355,7 +6378,8 @@ export async function main(rawArgs = process.argv.slice(2)) {
   }
   if (command === 'optimizations' && subcommand === 'promote') {
     await promoteOptimizationCommand(cliArgs.slice(2), {
-      json: hasJsonFlag(), print: printLine, resolveProjectSlug, fetcher: authedFetch,
+      json: hasJsonFlag(), origin: parsed.flags, print: printLine, printErr: printError,
+      resolveProjectSlug, fetcher: authedFetch,
     })
     return
   }
@@ -6511,7 +6535,6 @@ export async function main(rawArgs = process.argv.slice(2)) {
   if (command === 'datasets' && subcommand === 'lock') { await lockDataset(); return }
   if (command === 'datasets' && subcommand === 'clone') { await cloneDataset(); return }
   if (command === 'tasks' && subcommand === 'export') { await downloadAnnotations(); return }
-  if (command === 'internal' || (command === 'session' && subcommand === 'start' && hasArg('--hosted'))) { process.exitCode = await hostedCommand(cliArgs, { json: hasJsonFlag(), print: printLine, printErr: printError }); return }
   if (command === 'session' || command === 'run') {
     process.exitCode = await workbenchCommand(cliArgs, { json: hasJsonFlag(), print: printLine })
     return

package/src/instruction-set-loader.ts

@@ -1,4 +1,4 @@
-import { existsSync, realpathSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, realpathSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { resolve, sep } from 'node:path'
 
 export class InstructionSetLoaderError extends Error {
@@ -6,14 +6,64 @@ export class InstructionSetLoaderError extends Error {
 }
 
 interface Material { files: Record<string, string>; pinnedComponents?: Record<string, unknown> }
-interface Manifest { manifestVersion: number; name: string; shape: string[]; default: Material; profiles: Array<{ modelConfigIdentity: string; production: Material | null }>; filteredTo?: string[] }
+interface Manifest { manifestVersion: number; projectId?: string; instructionSetId?: string; name: string; slug?: string; shape: string[]; default: Material; profiles: Array<{ modelConfigIdentity: string; production: Material | null }>; filteredTo?: string[] }
 
 function inside(root: string, candidate: string) { return candidate === root || candidate.startsWith(`${root}${sep}`) }
 
+function manifestMatchesReference(candidate: string, reference: string): boolean {
+  try {
+    const manifest = JSON.parse(
+      readFileSync(resolve(candidate, 'manifest.json'), 'utf8')
+    ) as Pick<Manifest, 'name' | 'slug'>
+    return manifest.name === reference || manifest.slug === reference
+  } catch {
+    return false
+  }
+}
+
+function resolveSetRoot(directory: string, reference: string): string {
+  let directoryRoot: string
+  try { directoryRoot = realpathSync(directory) } catch { throw new InstructionSetLoaderError('instruction_set_not_synced') }
+  const direct = resolve(directoryRoot, reference)
+  try {
+    if (inside(directoryRoot, direct) && existsSync(direct) && statSync(direct).isDirectory()) {
+      const realDirect = realpathSync(direct)
+      if (inside(directoryRoot, realDirect)) {
+        try {
+          const manifest = JSON.parse(
+            readFileSync(resolve(realDirect, 'manifest.json'), 'utf8')
+          ) as Pick<Manifest, 'name' | 'slug'>
+          if (manifest.name === reference || manifest.slug === reference) {
+            return realDirect
+          }
+        } catch {
+          // Preserve the exact-path loader's specific missing/invalid manifest error.
+          return realDirect
+        }
+      }
+    }
+  } catch {
+    // A stale or unreadable direct-path candidate must not shadow a valid set.
+  }
+  const matches = readdirSync(directoryRoot, { withFileTypes: true }).flatMap(entry => {
+    try {
+      if (entry.name.startsWith('.') || !entry.isDirectory()) return []
+      const candidate = realpathSync(resolve(directoryRoot, entry.name))
+      return inside(directoryRoot, candidate) && manifestMatchesReference(candidate, reference)
+        ? [candidate]
+        : []
+    } catch {
+      return []
+    }
+  })
+  if (matches.length !== 1) throw new InstructionSetLoaderError(
+    matches.length > 1 ? 'instruction_set_reference_ambiguous' : 'instruction_set_not_synced'
+  )
+  return matches[0]!
+}
+
 export function loadInstructionSet(directory: string, name: string, modelConfigIdentity: string): Record<string, string> {
-  const unresolvedRoot = resolve(directory, name)
-  if (!existsSync(unresolvedRoot) || !statSync(unresolvedRoot).isDirectory()) throw new InstructionSetLoaderError('instruction_set_not_synced')
-  const setRoot = realpathSync(unresolvedRoot)
+  const setRoot = resolveSetRoot(directory, name)
   const manifestPath = resolve(setRoot, 'manifest.json')
   if (!existsSync(manifestPath)) throw new InstructionSetLoaderError('instruction_set_manifest_missing')
   let manifest: Manifest