orizu 0.5.20 → 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,9 +44,13 @@ 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';
@@ -54,8 +62,10 @@ import { reportCommentsCommand, throwDeprecatedPromptCommentsCommand, } from './
 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);
@@ -1174,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;
     }
@@ -1185,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);
@@ -1263,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];
@@ -1845,11 +1819,15 @@ async function runGepaOptimization() {
             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;
-        result = spawnSync(python, ['-m', dispatch.module, ...dispatch.args], {
-            stdio: 'inherit',
-            env: dispatch.environment,
-        });
+        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();
@@ -4453,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);
@@ -4471,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',
@@ -4490,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];
@@ -4500,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) {
@@ -4511,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()}`);
@@ -4608,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',
@@ -4643,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,
@@ -4839,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')) {
@@ -4850,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') {
@@ -4899,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');
@@ -4969,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' ||
@@ -5135,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"}

package/dist/instruction-set-manifest.js

@@ -0,0 +1,162 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+// Keep file-backed component reads within the same text budget used by prompt
+// tooling; request assembly never asks Node to allocate an unbounded body.
+export const MAX_INSTRUCTION_SET_COMPONENT_BYTES = 512 * 1024;
+const fail = (code) => { throw new Error(code); };
+const sha256 = (value) => createHash('sha256').update(value, 'utf8').digest('hex');
+function hasPinnedComponents(material) {
+    if (!material || typeof material !== 'object')
+        return false;
+    const pinned = material.pinnedComponents;
+    return Boolean(pinned && typeof pinned === 'object' && Object.keys(pinned).length > 0);
+}
+export function loadInstructionSetManifest(path) {
+    let value;
+    let source;
+    try {
+        source = readFileSync(path, 'utf8');
+    }
+    catch {
+        return fail('instruction_set_path_not_found');
+    }
+    try {
+        value = JSON.parse(source);
+    }
+    catch {
+        return fail('instruction_set_manifest_invalid_json');
+    }
+    if (!value || typeof value !== 'object')
+        return fail('instruction_set_manifest_invalid');
+    const input = value;
+    if (typeof input.name !== 'string' || input.name.trim() === '')
+        return fail('instruction_set_manifest_invalid_name');
+    const hasDescription = Object.hasOwn(input, 'description');
+    if (hasDescription && input.description !== null && typeof input.description !== 'string')
+        return fail('instruction_set_manifest_invalid_description');
+    const description = hasDescription
+        ? input.description === '' ? null : input.description
+        : undefined;
+    if (hasPinnedComponents(input.default))
+        return fail('instruction_set_component_unavailable');
+    if (!Array.isArray(input.shape) || input.shape.length === 0 || input.shape.some(key => typeof key !== 'string' || key === '') || new Set(input.shape).size !== input.shape.length)
+        return fail('instruction_set_manifest_invalid_shape');
+    if (!Array.isArray(input.components))
+        return fail('instruction_set_manifest_invalid_components');
+    let root;
+    try {
+        root = realpathSync(dirname(path));
+    }
+    catch {
+        return fail('instruction_set_path_not_found');
+    }
+    const seen = new Set();
+    const loadedComponents = [];
+    for (const raw of input.components) {
+        if (!raw || typeof raw !== 'object')
+            return fail('instruction_set_manifest_invalid_component');
+        const component = raw;
+        if (typeof component.key !== 'string' || component.key === '' || !input.shape.includes(component.key))
+            return fail(component.key && !input.shape.includes(component.key) ? 'instruction_set_key_outside_shape' : 'instruction_set_manifest_invalid_component');
+        const modelConfig = component.modelConfig === undefined ? undefined : component.modelConfig;
+        if (modelConfig !== undefined && (typeof modelConfig !== 'string' || modelConfig === ''))
+            return fail('instruction_set_manifest_invalid_component');
+        const identity = `${component.key}\u0000${modelConfig ?? ''}`;
+        if (seen.has(identity))
+            return fail('instruction_set_duplicate_component');
+        seen.add(identity);
+        let text;
+        if (typeof component.text === 'string' && component.path === undefined)
+            text = component.text;
+        else if (typeof component.path === 'string' && component.text === undefined) {
+            if (isAbsolute(component.path))
+                return fail('instruction_set_path_escape');
+            const candidate = resolve(root, component.path);
+            if (relative(root, candidate).startsWith('..'))
+                return fail('instruction_set_path_escape');
+            if (!existsSync(candidate))
+                return fail('instruction_set_path_not_found');
+            let target;
+            try {
+                target = realpathSync(candidate);
+            }
+            catch {
+                return fail('instruction_set_path_not_found');
+            }
+            if (relative(root, target).startsWith('..'))
+                return fail('instruction_set_path_escape');
+            try {
+                text = readFileSync(target, 'utf8');
+            }
+            catch {
+                return fail('instruction_set_path_not_found');
+            }
+            if (Buffer.byteLength(text, 'utf8') > MAX_INSTRUCTION_SET_COMPONENT_BYTES)
+                return fail('instruction_set_component_too_large');
+        }
+        else
+            return fail('instruction_set_manifest_invalid_component');
+        if (Buffer.byteLength(text, 'utf8') > MAX_INSTRUCTION_SET_COMPONENT_BYTES)
+            return fail('instruction_set_component_too_large');
+        const hasSyncBaseline = typeof component.syncedContentSha256 === 'string';
+        if (component.syncedContentSha256 !== undefined && (!hasSyncBaseline || !/^[a-f0-9]{64}$/u.test(component.syncedContentSha256)))
+            return fail('instruction_set_manifest_invalid_component');
+        loadedComponents.push({
+            key: component.key,
+            ...(modelConfig === undefined ? {} : { modelConfig }),
+            text,
+            hasSyncBaseline,
+            changedSinceSync: hasSyncBaseline && sha256(text) !== component.syncedContentSha256,
+        });
+    }
+    for (const key of input.shape)
+        if (!loadedComponents.some(component => component.key === key))
+            return fail('instruction_set_missing_shape_key');
+    const defaultIdentity = input.default && typeof input.default === 'object'
+        && typeof input.default.modelConfigIdentity === 'string'
+        ? input.default.modelConfigIdentity
+        : null;
+    let components = loadedComponents;
+    if (defaultIdentity) {
+        if (input.manifestVersion === 1 && input.shape.some(key => {
+            const bare = loadedComponents.find(component => component.key === key && component.modelConfig === undefined);
+            const tagged = loadedComponents.find(component => component.key === key && component.modelConfig === defaultIdentity);
+            return bare && tagged && (!bare.hasSyncBaseline || !tagged.hasSyncBaseline);
+        }))
+            return fail('instruction_set_sync_baseline_missing');
+        const changedDefaultKeys = new Set(loadedComponents.flatMap(component => (component.modelConfig === undefined && component.hasSyncBaseline && component.changedSinceSync
+            ? [component.key]
+            : [])));
+        const changedSameIdentityKeys = new Set(loadedComponents.flatMap(component => (component.modelConfig === defaultIdentity && component.hasSyncBaseline && component.changedSinceSync
+            ? [component.key]
+            : [])));
+        if ([...changedDefaultKeys].some(key => changedSameIdentityKeys.has(key)))
+            return fail('instruction_set_conflicting_synced_edits');
+        if (changedDefaultKeys.size > 0) {
+            components = loadedComponents.filter(component => (component.modelConfig !== defaultIdentity || !changedDefaultKeys.has(component.key)));
+        }
+    }
+    const namedProfiles = new Set([
+        ...(components.some(component => component.modelConfig === undefined) && defaultIdentity
+            ? [defaultIdentity]
+            : []),
+        ...components.flatMap(component => component.modelConfig ? [component.modelConfig] : []),
+    ]);
+    const namedProfileHasPins = Array.isArray(input.profiles) && input.profiles.some(profile => {
+        if (!profile || typeof profile !== 'object')
+            return false;
+        const value = profile;
+        return typeof value.modelConfigIdentity === 'string'
+            && namedProfiles.has(value.modelConfigIdentity)
+            && hasPinnedComponents(value.production);
+    });
+    if (namedProfileHasPins)
+        return fail('instruction_set_component_unavailable');
+    return {
+        name: input.name,
+        ...(hasDescription ? { description } : {}),
+        shape: input.shape,
+        components: components.map(({ key, modelConfig, text }) => ({ key, ...(modelConfig === undefined ? {} : { modelConfig }), text })),
+    };
+}

package/dist/instruction-sets-cli.d.ts

@@ -0,0 +1,40 @@
+import { renameSync, writeFileSync } from 'node:fs';
+export interface InstructionSetsCommandIo {
+    json: boolean;
+    print: (line: string) => void;
+    resolveProjectSlug: (provided: string | null) => Promise<string>;
+}
+export interface SyncComponent {
+    body?: string;
+    repoPath?: string;
+    contentSha?: string;
+    commitSha?: string;
+}
+export interface SyncMaterial {
+    profileVersionId: string;
+    versionNumber: number;
+    modelConfigIdentity: string;
+    resolvedFrom: string;
+    components: Record<string, SyncComponent>;
+}
+export interface SyncProfile {
+    modelConfigIdentity: string;
+    resolvedFrom: string;
+    production: SyncMaterial | null;
+}
+export interface SyncSet {
+    name: string;
+    slug?: string;
+    description?: string | null;
+    shape: string[];
+    default: SyncMaterial;
+    profiles: SyncProfile[];
+    filteredTo?: string[];
+}
+export interface SyncFileOps {
+    writeFileSync: typeof writeFileSync;
+    renameSync?: typeof renameSync;
+}
+export declare function syncToDisk(out: string, set: SyncSet, fileOps?: SyncFileOps): void;
+export declare function instructionSetsCommand(args: string[], io: InstructionSetsCommandIo): Promise<number>;
+//# sourceMappingURL=instruction-sets-cli.d.ts.map

package/dist/instruction-sets-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-sets-cli.d.ts","sourceRoot":"","sources":["../src/instruction-sets-cli.ts"],"names":[],"mappings":"AAGA,OAAO,EAAuC,UAAU,EAAoB,aAAa,EAAE,MAAM,SAAS,CAAA;AAI1G,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7B,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;CACjE;AA+BD,MAAM,WAAW,aAAa;IAAG,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE;AAC5G,MAAM,WAAW,YAAY;IAAG,gBAAgB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CAAE;AAC/K,MAAM,WAAW,WAAW;IAAG,mBAAmB,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,YAAY,GAAG,IAAI,CAAA;CAAE;AACnH,MAAM,WAAW,OAAO;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,WAAW,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE;AAM7K,MAAM,WAAW,WAAW;IAAG,aAAa,EAAE,OAAO,aAAa,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,UAAU,CAAA;CAAE;AAoCpG,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,WAA+B,QAyC7F;AAED,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,wBAAwB,GAAG,OAAO,CAAC,MAAM,CAAC,CA+K1G"}