orizu 0.5.19 → 0.5.21

package/dist/index.js

@@ -28,11 +28,15 @@ import { formatTaskCreateError } from './task-create-error.js';
 import { renderAgentSetupPrompt } from './setup-prompt.js';
 import { getWorkspaceRoot, initOrizuWorkspace, workspaceExists, } from './workspace.js';
 import { connectorsCommand } from './connectors-cli.js';
+import { modelConfigsCommand } from './model-configs-cli.js';
 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 { listOptimizationRunsCommand } from './optimizations-list-cli.js';
+import { promoteOptimizationCommand } from './optimizations-promote-cli.js';
+import { scorersCommand } from './scorers-cli.js';
+import { verifyScorerParityCommand } from './scorers-verify-parity.js';
 import { archiveArtifactCommand, listAssignmentsCommand, printAppSummaries, printDatasetSummaries, printScorerSummaries, printTaskSummaries, } from './archive-artifacts-cli.js';
 import { teamConnectorsCommand } from './team-connectors-cli.js';
 import { manifestsCommand } from './manifests-cli.js';
@@ -40,18 +44,28 @@ import { workbenchCommand } from './workbench-cli.js';
 import { hostedCommand } from './hosted-session-cli.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';
+import { runnerInputInstructionSet, runnerInputPrompt, runnerInstructionSetSyncSet } from './runner-instruction-set-contract.js';
 import { pushPromptDraft } from './prompt-draft-push.js';
 import { readMarkdownReportInput } from './markdown-report-input.js';
 import { promptPushErrorMessage, promptReportCommand } from './prompt-report-cli.js';
+import { setPromptLabel } from './prompt-label-cli.js';
 import { printPromptSummaryTable } from './prompt-summary-table.js';
 import { assertSnapshotManifestConfined, verifyGepaRunnerDirsFromArgs, verifyRunnerDirRegistered } from './runner-dir-verify.js';
 import { runScorersRegister } from './scorer-draft-push.js';
 import { runZipArtifactPush } from './zip-draft-push.js';
 import { runGithubLink, runInteractiveHostedSetup } from './github-setup.js';
 import { parseJsonResponse, sanitizeTerminalText } from './json-response.js';
+import { reportReplacementWarning } from './report-replacement-warning.js';
 import { reportCommentsCommand, throwDeprecatedPromptCommentsCommand, } from './report-comments-cli.js';
 import { diffCommentsCommand } from './diff-comments-cli.js';
 import { exportOptimizationRunCommand } from './optimization-export-cli.js';
+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';
 export { parseJsonResponse, sanitizeTerminalText } from './json-response.js';
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -185,6 +199,14 @@ export function createCodeChallenge(verifier) {
 function printError(message) {
     console.error(sanitizeTerminalText(message));
 }
+function printPushDisclosures(data) {
+    const warning = reportReplacementWarning(data);
+    if (warning)
+        printError(warning);
+    if (data.metadata_updated === true) {
+        printError('Updated prompt metadata on the identical existing version');
+    }
+}
 export function validateBrowserUrl(url, expectedOrigin) {
     let parsed;
     try {
@@ -1014,8 +1036,10 @@ async function pushPromptArtifact(kind) {
         });
         if (hasJsonFlag())
             printJson(data);
-        else
+        else {
+            printPushDisclosures(data);
             printLine(message);
+        }
         return;
     }
     // LEGACY SESSIONLESS PATH (no branch to commit to; the server dual-writes
@@ -1061,6 +1085,7 @@ async function pushPromptArtifact(kind) {
         printJson(data);
         return;
     }
+    printPushDisclosures(data);
     printLine(`Pushed ${kind} ${sanitizeTerminalText(String(manifest.name || promptDir))} (${sanitizeTerminalText(String(data.prompt_version_id || 'unknown version'))})`);
 }
 async function pullPromptArtifact(kind) {
@@ -1159,6 +1184,7 @@ async function pullPromptArtifact(kind) {
             scorer_version_id: data.scorerVersionId || undefined,
             scorer_version_ids: scorerVersions.map(item => item.id),
             path: targetDir,
+            owner: data.owner || undefined,
         });
         return;
     }
@@ -1170,55 +1196,14 @@ async function pullPromptArtifact(kind) {
     else if (!data.scorerVersionId && kind === 'judge') {
         printLine(`Warning: prompt version ${sanitizeTerminalText(data.version.id)} does not map to an executable scorer version.`);
     }
-}
-async function setPromptLabel() {
-    const promptName = getPositionalArg(3);
-    const label = getPositionalArg(4);
-    const project = getArg('--project') || await resolveProjectSlug(null);
-    const promptVersionId = getArg('--version');
-    if (!promptName || !label || !promptVersionId) {
-        throw new Error('Usage: orizu prompts labels set <prompt-name> <label> --version <prompt-version-id> [--project <team/project>] [--json]');
-    }
-    const response = await authedFetch(`/api/cli/prompts/labels?project=${encodeURIComponent(project)}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            promptName,
-            label,
-            promptVersionId,
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to set prompt label: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Prompt label set');
-    if (hasJsonFlag()) {
-        printJson(data);
-        return;
+    if (kind === 'prompt' && data.owner) {
+        printLine(`Owner: ${sanitizeTerminalText(data.prompt.name)} (${sanitizeTerminalText(data.prompt.id)}) -> ` +
+            `${sanitizeTerminalText(data.owner.instructionSetSlug)} / ${sanitizeTerminalText(data.owner.componentKey)}`);
     }
-    printLine(`Moved ${sanitizeTerminalText(label)} to ${sanitizeTerminalText(promptVersionId)}`);
 }
-async function setPromptArchivedState(archived) {
-    const promptRef = getPositionalArg(2);
-    const project = getArg('--project') || await resolveProjectSlug(null);
-    const command = archived ? 'archive' : 'restore';
-    if (!promptRef) {
-        throw new Error(`Usage: orizu prompts ${command} <prompt-id-or-name> --project <team/project> [--json]`);
-    }
-    const response = await authedFetch(`/api/cli/prompts/${encodeURIComponent(promptRef)}?project=${encodeURIComponent(project)}`, {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ archived }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to ${command} prompt: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, `Prompt ${command}`);
-    if (hasJsonFlag()) {
-        printJson(data);
-        return;
-    }
-    printLine(`${archived ? 'Archived' : 'Restored'} prompt ${sanitizeTerminalText(data.prompt.name)} (${sanitizeTerminalText(data.prompt.id)})`);
+function refusePromptMutation(replacement) {
+    process.exitCode = 1;
+    throw new Error(`Use: orizu instructions ${replacement}`);
 }
 async function bindPromptScorer(role) {
     const promptId = getPositionalArg(3);
@@ -1248,6 +1233,10 @@ async function bindPromptScorer(role) {
         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) {
     const value = cliArgs[index];
@@ -1795,30 +1784,12 @@ async function updateOptimizationRunLifecycle(action) {
 }
 // ALI-1073 list moved to optimizations-list-cli.ts (line ratchet, ALI-976);
 // ALI-1175 labels its best scores as agent-reported evidence there.
-function removeFlagWithValue(args, flag) {
-    const filtered = [];
-    for (let index = 0; index < args.length; index += 1) {
-        if (args[index] === flag) {
-            index += 1;
-            continue;
-        }
-        filtered.push(args[index]);
-    }
-    return filtered;
-}
-function bundledOrizuGepaPythonPath() {
-    const candidates = [
-        fileURLToPath(new URL('../vendor/orizu-gepa-python/src', import.meta.url)),
-        fileURLToPath(new URL('../../orizu-gepa-python/src', import.meta.url)),
-    ];
-    return candidates.find(candidate => existsSync(candidate)) ?? null;
-}
 async function runGepaOptimization() {
     const project = getArg('--project') || await resolveProjectSlug(null);
     const baseUrl = getBaseUrl();
-    const python = getArg('--python') || process.env.PYTHON || 'python3';
-    const bundledPythonPath = bundledOrizuGepaPythonPath();
-    let forwardedArgs = removeFlagWithValue(cliArgs.slice(2), '--python');
+    const runGepa = getGepaPythonCommand(cliArgs.slice(2), process.env);
+    const python = runGepa.python;
+    let forwardedArgs = runGepa.args;
     // ALI-1159 (ADR-007): GEPA executes ad-hoc local runner dirs while
     // attributing records to registered runner version ids — verify the bytes
     // ARE those versions before the optimizer spawns. Scans the forwarded argv
@@ -1828,6 +1799,7 @@ async function runGepaOptimization() {
     const verified = await verifyGepaRunnerDirsFromArgs(forwardedArgs);
     forwardedArgs = verified.args;
     let result;
+    let selectedEngine = 'official';
     try {
         // Uniform resolution (ALI-1090): honors ORIZU_TOKEN / ORIZU_TOKEN_FILE before
         // credentials.json so hosted sandboxes can run optimizations. Read at spawn
@@ -1838,33 +1810,33 @@ async function runGepaOptimization() {
         if (!forwardedArgs.includes('--project')) {
             forwardedArgs = ['--project', project, ...forwardedArgs];
         }
-        const pythonPathEntries = [
-            bundledPythonPath,
-            process.env.PYTHONPATH,
-        ].filter((entry) => Boolean(entry));
-        result = spawnSync(python, ['-m', 'orizu_gepa.cli', ...forwardedArgs], {
-            stdio: 'inherit',
-            env: {
-                ...process.env,
-                ORIZU_API_URL: baseUrl,
-                ORIZU_TOKEN: token,
-                ORIZU_PROJECT: project,
-                // Integrity handshake (ALI-1159): the Python entrypoint refuses
-                // runner dirs that are not in this wrapper-verified list.
-                ORIZU_VERIFIED_RUNNER_DIRS: JSON.stringify(verified.verifiedDirs),
-                PYTHONPATH: pythonPathEntries.join(delimiter),
-                PYTHONUNBUFFERED: process.env.PYTHONUNBUFFERED || '1',
-            },
+        const dispatch = dispatchGepaEngine(forwardedArgs, project, {
+            ...process.env,
+            ORIZU_API_URL: baseUrl,
+            ORIZU_TOKEN: token,
+            ORIZU_PROJECT: project,
+            ORIZU_VERIFIED_RUNNER_DIRS: JSON.stringify(verified.verifiedDirs),
+            PYTHONPATH: getGepaPythonPathEntries(process.env.PYTHONPATH).join(delimiter),
+            PYTHONUNBUFFERED: process.env.PYTHONUNBUFFERED || '1',
         });
+        const instructionSetName = dispatch.environment.ORIZU_INSTRUCTION_SET_NAME;
+        const modelConfigIdentity = dispatch.environment.ORIZU_MODEL_CONFIG_IDENTITY;
+        const instructionSetProfileVersionId = instructionSetName && modelConfigIdentity
+            ? await resolveGepaInstructionSetProfileVersion(instructionSetName, modelConfigIdentity, project) : undefined;
+        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 result.error;
+        throw new Error(`${selectedEngine} GEPA engine failed: ${result.error.message}`, { cause: result.error });
     }
     if (result.status !== 0) {
-        throw new Error(`orizu-gepa failed with exit code ${result.status}`);
+        throw new Error(`${selectedEngine} GEPA engine failed with exit code ${result.status}`);
     }
     if (hasJsonFlag()) {
         printJson({ status: 'completed', exitCode: 0 });
@@ -4459,7 +4431,7 @@ async function downloadAnnotations() {
     }
     printLine(`Saved ${format.toUpperCase()} export to ${sanitizeTerminalText(filename)}`);
 }
-function readRunnerManifest(runnerDir) {
+export function readRunnerManifest(runnerDir) {
     const manifestPath = join(runnerDir, 'manifest.json');
     const raw = readSourceFile(manifestPath);
     const manifest = JSON.parse(raw);
@@ -4477,9 +4449,9 @@ function readRunnerManifest(runnerDir) {
         supports_body_kind: supportedBodyKinds,
     };
 }
-const RUNNER_TIMEOUT_MS = 120_000;
-const RUNNER_OUTPUT_MAX_BYTES = 2 * 1024 * 1024;
-const RUNNER_ENV_ALLOWLIST = new Set([
+export const RUNNER_TIMEOUT_MS = 120_000;
+export const RUNNER_OUTPUT_MAX_BYTES = 2 * 1024 * 1024;
+export const RUNNER_ENV_ALLOWLIST = new Set([
     'PATH',
     'SystemRoot',
     'WINDIR',
@@ -4496,7 +4468,7 @@ const RUNNER_ENV_ALLOWLIST = new Set([
     'GEMINI_API_KEY',
     'GOOGLE_API_KEY',
 ]);
-function runnerSubprocessEnv(inputPath, outputPath) {
+export function runnerSubprocessEnv(inputPath, outputPath, instructionSetDir) {
     const env = {};
     for (const key of RUNNER_ENV_ALLOWLIST) {
         const value = process.env[key];
@@ -4506,6 +4478,9 @@ function runnerSubprocessEnv(inputPath, outputPath) {
     }
     env.ORIZU_RUNNER_INPUT_PATH = inputPath;
     env.ORIZU_RUNNER_OUTPUT_PATH = outputPath;
+    delete env.ORIZU_INSTRUCTION_SET_DIR;
+    if (instructionSetDir)
+        env.ORIZU_INSTRUCTION_SET_DIR = instructionSetDir;
     return env;
 }
 function boundedRunnerOutput(value) {
@@ -4517,7 +4492,7 @@ function boundedRunnerOutput(value) {
     }
     return `${buffer.subarray(0, RUNNER_OUTPUT_MAX_BYTES).toString('utf8')}\n[truncated]`;
 }
-async function materializeRunnerVersion(runnerVersionId) {
+export async function materializeRunnerVersion(runnerVersionId) {
     const response = await authedFetch(`/api/cli/runner-versions/${encodeURIComponent(runnerVersionId)}/download`);
     if (!response.ok) {
         throw new Error(`Failed to download runner version: ${await response.text()}`);
@@ -4614,15 +4589,15 @@ async function runnersExec() {
             const tempDir = mkdtempSync(join(tmpdir(), 'orizu-runner-'));
             const inputPath = join(tempDir, 'input.json');
             const outputPath = join(tempDir, 'output.json');
+            const instructionSetDir = context.instructionSet ? join(tempDir, 'instruction-set') : undefined;
             try {
                 const modelOutput = row.row.model_output ?? row.row.modelOutput ?? row.row.output ?? null;
+                if (instructionSetDir && context.instructionSet)
+                    syncToDisk(instructionSetDir, runnerInstructionSetSyncSet(context.instructionSet));
                 writeFileSync(inputPath, JSON.stringify({
                     row: row.row,
-                    prompt: {
-                        body: context.prompt.body,
-                        body_kind: context.prompt.bodyKind,
-                        provider_settings: context.prompt.providerSettings,
-                    },
+                    prompt: runnerInputPrompt(context.prompt),
+                    ...(context.instructionSet ? { instruction_set: runnerInputInstructionSet(context.instructionSet) } : {}),
                     subject: scorerVersion
                         ? {
                             type: 'scorer_row',
@@ -4649,7 +4624,7 @@ async function runnersExec() {
                 }));
                 const result = spawnSync(manifest.command[0], manifest.command.slice(1), {
                     cwd: runnerDir,
-                    env: runnerSubprocessEnv(inputPath, outputPath),
+                    env: runnerSubprocessEnv(inputPath, outputPath, instructionSetDir),
                     encoding: 'utf8',
                     maxBuffer: RUNNER_OUTPUT_MAX_BYTES,
                     timeout: RUNNER_TIMEOUT_MS,
@@ -4845,8 +4820,11 @@ export async function main(rawArgs = process.argv.slice(2)) {
         return;
     }
     if (command === 'prompts' && subcommand === 'push') {
-        await pushPromptArtifact('prompt');
-        return;
+        if (getArg('--session')) {
+            await pushPromptArtifact('prompt');
+            return;
+        }
+        refusePromptMutation('push <manifest> --project <team/project>');
     }
     if (command === 'prompts' && subcommand === 'report' &&
         (cliArgs[2] === 'set' || cliArgs[2] === 'upload')) {
@@ -4856,15 +4834,23 @@ export async function main(rawArgs = process.argv.slice(2)) {
         return;
     }
     if (command === 'prompts' && subcommand === 'archive') {
-        await setPromptArchivedState(true);
-        return;
+        refusePromptMutation('archive <slug-or-exact-name> --project <team/project>');
     }
     if (command === 'prompts' && subcommand === 'restore') {
-        await setPromptArchivedState(false);
-        return;
+        refusePromptMutation('restore <slug-or-exact-name> --project <team/project>');
     }
     if (command === 'prompts' && subcommand === 'labels' && cliArgs[2] === 'set') {
-        await setPromptLabel();
+        if (getPositionalArg(4) === 'production') {
+            refusePromptMutation('profiles promote <set> --project <team/project> --model-config <identity> --version <n>');
+        }
+        await setPromptLabel({
+            getArg,
+            getPositionalArg,
+            json: hasJsonFlag(),
+            printJson,
+            printLine,
+            resolveProjectSlug,
+        });
         return;
     }
     if (command === 'prompts' && subcommand === 'scorers' && cliArgs[2] === 'set-headline') {
@@ -4905,25 +4891,20 @@ export async function main(rawArgs = process.argv.slice(2)) {
         });
         return;
     }
-    if (command === 'scorers' && subcommand === 'list') {
-        await listScorers();
-        return;
-    }
-    if (command === 'scorers' && subcommand === 'register') {
-        await registerScorer();
-        return;
-    }
-    if (command === 'scorers' && subcommand === 'detail') {
-        await showScorerDetail();
-        return;
-    }
-    if (command === 'scorers' && subcommand === 'labels' && cliArgs[2] === 'set') {
-        await setScorerLabel();
-        return;
-    }
-    if (command === 'scorers' && subcommand === 'exec') {
-        await execScorer();
-        return;
+    if (command === 'scorers') {
+        const scorersExit = await scorersCommand(cliArgs, {
+            list: listScorers, register: registerScorer, detail: showScorerDetail,
+            labelsSet: setScorerLabel, exec: execScorer,
+            verifyParity: args => verifyScorerParityCommand(args, {
+                json: hasJsonFlag(), print: printLine, printErr: printError,
+                materializeRunnerVersion, readRunnerManifest, runnerSubprocessEnv,
+                timeoutMs: RUNNER_TIMEOUT_MS, maxOutputBytes: RUNNER_OUTPUT_MAX_BYTES,
+            }),
+        });
+        if (scorersExit !== null) {
+            process.exitCode = scorersExit;
+            return;
+        }
     }
     if ((command === 'runners' || command === 'optimizers') && subcommand === 'push') {
         await pushRunnerArtifact(command === 'runners' ? 'runner' : 'optimizer');
@@ -4975,6 +4956,12 @@ export async function main(rawArgs = process.argv.slice(2)) {
         await listOptimizationRunsCommand(cliArgs.slice(2), { json: hasJsonFlag(), print: printLine, resolveProjectSlug });
         return;
     }
+    if (command === 'optimizations' && subcommand === 'promote') {
+        await promoteOptimizationCommand(cliArgs.slice(2), {
+            json: hasJsonFlag(), print: printLine, resolveProjectSlug, fetcher: authedFetch,
+        });
+        return;
+    }
     if (command === 'optimizations' &&
         (subcommand === 'pause' ||
             subcommand === 'resume' ||
@@ -5141,9 +5128,12 @@ export async function main(rawArgs = process.argv.slice(2)) {
         await runGithubLink(team, { print: printLine, fetcher: authedFetch, openUrl: openInBrowser, confirm: (org) => askYesNo(`Connect this team to GitHub org '${org}'?`, true) });
         return;
     }
-    if (command === 'connectors' || command === 'manifests') {
-        const moduleCommand = command === 'connectors' ? connectorsCommand : manifestsCommand;
-        process.exitCode = await moduleCommand(cliArgs.slice(1), { json: hasJsonFlag(), print: printLine, resolveProjectSlug });
+    if (command === 'connectors' || command === 'manifests' || command === 'model-configs') {
+        process.exitCode = await (command === 'connectors' ? connectorsCommand : command === 'manifests' ? manifestsCommand : modelConfigsCommand)(cliArgs.slice(1), { json: hasJsonFlag(), print: printLine, resolveProjectSlug });
+        return;
+    }
+    if (command === 'instructions' || command === 'instruction-sets') {
+        process.exitCode = await instructionSetsCommand(cliArgs.slice(1), { json: hasJsonFlag(), print: printLine, resolveProjectSlug });
         return;
     }
     if (command === 'team' && (subcommand === 'kill-agents' || subcommand === 'release-agents')) {

package/dist/instruction-set-gepa-launch.d.ts

@@ -0,0 +1,3 @@
+/** Resolve the same production-or-default tuple served for a model identity. */
+export declare function resolveGepaInstructionSetProfileVersion(instructionSetName: string, modelConfigIdentity: string, project: string): Promise<string>;
+//# sourceMappingURL=instruction-set-gepa-launch.d.ts.map

package/dist/instruction-set-gepa-launch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-set-gepa-launch.d.ts","sourceRoot":"","sources":["../src/instruction-set-gepa-launch.ts"],"names":[],"mappings":"AAaA,gFAAgF;AAChF,wBAAsB,uCAAuC,CAC3D,kBAAkB,EAAE,MAAM,EAC1B,mBAAmB,EAAE,MAAM,EAC3B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/dist/instruction-set-gepa-launch.js

@@ -0,0 +1,15 @@
+import { authedFetch } from './http.js';
+import { parseJsonResponse } from './json-response.js';
+/** Resolve the same production-or-default tuple served for a model identity. */
+export async function resolveGepaInstructionSetProfileVersion(instructionSetName, modelConfigIdentity, project) {
+    const response = await authedFetch(`/api/cli/instruction-sets/${encodeURIComponent(instructionSetName)}?project=${encodeURIComponent(project)}`);
+    if (!response.ok)
+        throw new Error(`Instruction set resolution failed: ${await response.text()}`);
+    const payload = await parseJsonResponse(response, 'Instruction set resolution');
+    const instructionSet = payload.instructionSet;
+    const profile = instructionSet?.profiles?.find(candidate => candidate.modelConfigIdentity === modelConfigIdentity);
+    const profileVersionId = profile?.production?.profileVersionId || instructionSet?.default?.profileVersionId;
+    if (!profileVersionId)
+        throw new Error('instruction_set_profile_version_unresolvable');
+    return profileVersionId;
+}

package/dist/instruction-set-loader.d.ts

@@ -0,0 +1,6 @@
+export declare class InstructionSetLoaderError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+export declare function loadInstructionSet(directory: string, name: string, modelConfigIdentity: string): Record<string, string>;
+//# sourceMappingURL=instruction-set-loader.d.ts.map

package/dist/instruction-set-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-set-loader.d.ts","sourceRoot":"","sources":["../src/instruction-set-loader.ts"],"names":[],"mappings":"AAGA,qBAAa,yBAA0B,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAClC;AAOD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAwBvH"}

package/dist/instruction-set-loader.js

@@ -0,0 +1,59 @@
+import { existsSync, realpathSync, readFileSync, statSync } from 'node:fs';
+import { resolve, sep } from 'node:path';
+export class InstructionSetLoaderError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'InstructionSetLoaderError';
+    }
+}
+function inside(root, candidate) { return candidate === root || candidate.startsWith(`${root}${sep}`); }
+export function loadInstructionSet(directory, name, modelConfigIdentity) {
+    const unresolvedRoot = resolve(directory, name);
+    if (!existsSync(unresolvedRoot) || !statSync(unresolvedRoot).isDirectory())
+        throw new InstructionSetLoaderError('instruction_set_not_synced');
+    const setRoot = realpathSync(unresolvedRoot);
+    const manifestPath = resolve(setRoot, 'manifest.json');
+    if (!existsSync(manifestPath))
+        throw new InstructionSetLoaderError('instruction_set_manifest_missing');
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    }
+    catch {
+        throw new InstructionSetLoaderError('instruction_set_manifest_missing');
+    }
+    if (manifest.manifestVersion !== 1)
+        throw new InstructionSetLoaderError('instruction_set_manifest_version_unsupported');
+    if (manifest.filteredTo && !manifest.filteredTo.includes(modelConfigIdentity))
+        throw new InstructionSetLoaderError('instruction_set_profile_not_synced');
+    const selected = manifest.profiles.find(profile => profile.modelConfigIdentity === modelConfigIdentity)?.production || manifest.default;
+    const result = {};
+    for (const key of manifest.shape) {
+        if (selected.pinnedComponents?.[key])
+            throw new InstructionSetLoaderError('instruction_set_component_unavailable');
+        const relativePath = selected.files?.[key];
+        if (!relativePath)
+            throw new InstructionSetLoaderError('instruction_set_profile_key_missing');
+        const unresolvedPath = resolve(setRoot, relativePath);
+        if (!inside(setRoot, unresolvedPath))
+            throw new InstructionSetLoaderError('instruction_set_path_unsafe');
+        let path;
+        try {
+            path = realpathSync(unresolvedPath);
+        }
+        catch {
+            throw new InstructionSetLoaderError('instruction_set_component_unreadable');
+        }
+        if (!inside(setRoot, path))
+            throw new InstructionSetLoaderError('instruction_set_path_unsafe');
+        try {
+            result[key] = readFileSync(path, 'utf8');
+        }
+        catch {
+            throw new InstructionSetLoaderError('instruction_set_component_unreadable');
+        }
+    }
+    return result;
+}

package/dist/instruction-set-manifest.d.ts

@@ -0,0 +1,14 @@
+export interface InstructionSetComponent {
+    key: string;
+    modelConfig?: string;
+    text: string;
+}
+export interface InstructionSetManifest {
+    name: string;
+    description?: string | null;
+    shape: string[];
+    components: InstructionSetComponent[];
+}
+export declare const MAX_INSTRUCTION_SET_COMPONENT_BYTES: number;
+export declare function loadInstructionSetManifest(path: string): InstructionSetManifest;
+//# sourceMappingURL=instruction-set-manifest.d.ts.map

package/dist/instruction-set-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-set-manifest.d.ts","sourceRoot":"","sources":["../src/instruction-set-manifest.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,uBAAuB;IAAG,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAC5F,MAAM,WAAW,sBAAsB;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,uBAAuB,EAAE,CAAA;CAAE;AAI7I,eAAO,MAAM,mCAAmC,QAAa,CAAA;AAW7D,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,sBAAsB,CAmG/E"}